Class IndexedDBCryptoStore

constructor

• new IndexedDBCryptoStore(
      indexedDB: IDBFactory,
      dbName: string,
  ): IndexedDBCryptoStore

  Create a new IndexedDBCryptoStore

  Parameters

  • indexedDB: IDBFactory

    global indexedDB instance
  • dbName: string

    name of db to connect to

  Returns IndexedDBCryptoStore

StaticSTORE_ACCOUNT

StaticSTORE_BACKUP

StaticSTORE_DEVICE_DATA

StaticSTORE_INBOUND_GROUP_SESSIONS

StaticSTORE_INBOUND_GROUP_SESSIONS_WITHHELD

StaticSTORE_PARKED_SHARED_HISTORY

StaticSTORE_ROOMS

StaticSTORE_SESSIONS

StaticSTORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS

containsData

• containsData(): Promise<boolean>
  Internal

  Returns true if this CryptoStore has ever been initialised (ie, it might contain data).

  Implementation of CryptoStore.containsData.

  Returns Promise<boolean>

countEndToEndInboundGroupSessions

• countEndToEndInboundGroupSessions(): Promise<number>
  Internal

  Count the number of Megolm sessions in the database.

  Implementation of CryptoStore.countEndToEndInboundGroupSessions.

  Returns Promise<number>

countEndToEndSessions

• countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void

  Returns the number of end-to-end sessions in the store

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (count: number) => void

    Called with the count of sessions

  Returns void

deleteAllData

• deleteAllData(): Promise<void>

  Delete all data from this store.

  Returns Promise<void>

  resolves when the store has been cleared.

deleteEndToEndInboundGroupSessionsBatch

• deleteEndToEndInboundGroupSessionsBatch(
      sessions: { senderKey: string; sessionId: string }[],
  ): Promise<void>
  Internal

  Delete a batch of Megolm sessions from the database.

  Implementation of CryptoStore.deleteEndToEndInboundGroupSessionsBatch.

  Parameters

  • sessions: { senderKey: string; sessionId: string }[]

  Returns Promise<void>

deleteEndToEndSessionsBatch

• deleteEndToEndSessionsBatch(
      sessions: { deviceKey: string; sessionId: string }[],
  ): Promise<void>
  Internal

  Delete a batch of Olm sessions from the database.

  Implementation of CryptoStore.deleteEndToEndSessionsBatch.

  Parameters

  • sessions: { deviceKey: string; sessionId: string }[]

  Returns Promise<void>

doTxn

• doTxn<T>(
      mode: Mode,
      stores: Iterable<string>,
      func: (txn: IDBTransaction) => T,
      log?: Logger,
  ): Promise<T>

  Perform a transaction on the crypto store. Any store methods that require a transaction (txn) object to be passed in may only be called within a callback of either this function or one of the store functions operating on the same transaction.

  Type Parameters

  • T

  Parameters

  • mode: Mode

    'readwrite' if you need to call setter functions with this transaction. Otherwise, 'readonly'.
  • stores: Iterable<string>

    List IndexedDBCryptoStore.STORE_* options representing all types of object that will be accessed or written to with this transaction.
  • func: (txn: IDBTransaction) => T

    Function called with the transaction object: an opaque object that should be passed to store functions.
  • Optionallog: Logger

    A possibly customised log

  Returns Promise<T>

  Promise that resolves with the result of the func when the transaction is complete. If the backend is async (ie. the indexeddb backend) any of the callback functions throwing an exception will cause this promise to reject with that exception. On synchronous backends, the exception will propagate to the caller of the getFoo method.

getAccount

• getAccount(
      txn: IDBTransaction,
      func: (accountPickle: null | string) => void,
  ): void

  Parameters

  • txn: IDBTransaction
  • func: (accountPickle: null | string) => void

  Returns void

getCrossSigningKeys

• getCrossSigningKeys(
      txn: IDBTransaction,
      func: (keys: null | Record<string, CrossSigningKeyInfo>) => void,
  ): void

  Get the public part of the cross-signing keys (eg. self-signing key, user signing key).

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (keys: null | Record<string, CrossSigningKeyInfo>) => void

    Called with the account keys object: { key_type: base64 encoded seed } where key type = user_signing_key_seed or self_signing_key_seed

  Returns void

getEndToEndInboundGroupSession

• getEndToEndInboundGroupSession(
      senderCurve25519Key: string,
      sessionId: string,
      txn: IDBTransaction,
      func: (
          groupSession: null | InboundGroupSessionData,
          groupSessionWithheld: null | IWithheld,
      ) => void,
  ): void

  Retrieve the end-to-end inbound group session for a given server key and session ID

  Parameters

  • senderCurve25519Key: string

    The sender's curve 25519 key
  • sessionId: string

    The ID of the session
  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (
        groupSession: null | InboundGroupSessionData,
        groupSessionWithheld: null | IWithheld,
    ) => void

    Called with A map from sessionId to Base64 end-to-end session.

  Returns void

getEndToEndInboundGroupSessionsBatch

• getEndToEndInboundGroupSessionsBatch(): Promise<null | SessionExtended[]>
  Internal

  Fetch a batch of Megolm sessions from the database.

  Implementation of CryptoStore.getEndToEndInboundGroupSessionsBatch.

  Returns Promise<null | SessionExtended[]>

getEndToEndRooms

• getEndToEndRooms(
      txn: IDBTransaction,
      func: (rooms: Record<string, IRoomEncryption>) => void,
  ): void

  Get an object of roomId->roomInfo for all e2e rooms in the store

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (rooms: Record<string, IRoomEncryption>) => void

    Function called with the end-to-end encrypted rooms

  Returns void

getEndToEndSession

• getEndToEndSession(
      deviceKey: string,
      sessionId: string,
      txn: IDBTransaction,
      func: (session: null | ISessionInfo) => void,
  ): void

  Retrieve a specific end-to-end session between the logged-in user and another device.

  Parameters

  • deviceKey: string

    The public key of the other device.
  • sessionId: string

    The ID of the session to retrieve
  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (session: null | ISessionInfo) => void

    Called with A map from sessionId to session information object with 'session' key being the Base64 end-to-end session and lastReceivedMessageTs being the timestamp in milliseconds at which the session last received a message.

  Returns void

getEndToEndSessions

• getEndToEndSessions(
      deviceKey: string,
      txn: IDBTransaction,
      func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
  ): void

  Retrieve the end-to-end sessions between the logged-in user and another device.

  Parameters

  • deviceKey: string

    The public key of the other device.
  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (sessions: { [sessionId: string]: ISessionInfo }) => void

    Called with A map from sessionId to session information object with 'session' key being the Base64 end-to-end session and lastReceivedMessageTs being the timestamp in milliseconds at which the session last received a message.

  Returns void

getEndToEndSessionsBatch

• getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]>
  Internal

  Fetch a batch of Olm sessions from the database.

  Implementation of CryptoStore.getEndToEndSessionsBatch.

  Returns Promise<null | ISessionInfo[]>

getMigrationState

• getMigrationState(): Promise<MigrationState>
  Internal

  Get data on how much of the libolm to Rust Crypto migration has been done.

  Implementation of CryptoStore.getMigrationState.

  Returns Promise<MigrationState>

getSecretStorePrivateKey

• getSecretStorePrivateKey<K extends "m.megolm_backup.v1">(
      txn: IDBTransaction,
      func: (key: null | SecretStorePrivateKeys[K]) => void,
      type: K,
  ): void

  Type Parameters

  • K extends "m.megolm_backup.v1"

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • func: (key: null | SecretStorePrivateKeys[K]) => void

    Called with the private key
  • type: K

    A key type

  Returns void

markSessionsNeedingBackup

• markSessionsNeedingBackup(
      sessions: ISession[],
      txn?: IDBTransaction,
  ): Promise<void>

  Mark sessions as needing to be backed up.

  Parameters

  • sessions: ISession[]

    The sessions that need to be backed up.
  • Optionaltxn: IDBTransaction

    An active transaction. See doTxn(). (optional)

  Returns Promise<void>

  resolves when the sessions are marked

setMigrationState

• setMigrationState(migrationState: MigrationState): Promise<void>
  Internal

  Set data on how much of the libolm to Rust Crypto migration has been done.

  Implementation of CryptoStore.setMigrationState.

  Parameters

  • migrationState: MigrationState

  Returns Promise<void>

startup

• startup(): Promise<CryptoStore>

  Ensure the database exists and is up-to-date, or fall back to a local storage or in-memory store.

  This must be called before the store can be used.

  Returns Promise<CryptoStore>

  resolves to either an IndexedDBCryptoStoreBackend.Backend, or a MemoryCryptoStore

storeAccount

• storeAccount(txn: IDBTransaction, accountPickle: string): void

  Write the account pickle to the store. This requires an active transaction. See doTxn().

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • accountPickle: string

    The new account pickle to store.

  Returns void

storeEndToEndInboundGroupSession

• storeEndToEndInboundGroupSession(
      senderCurve25519Key: string,
      sessionId: string,
      sessionData: InboundGroupSessionData,
      txn: IDBTransaction,
  ): void

  Writes an end-to-end inbound group session to the store. If there already exists an inbound group session with the same senderCurve25519Key and sessionID, it will be overwritten.

  Parameters

  • senderCurve25519Key: string

    The sender's curve 25519 key
  • sessionId: string

    The ID of the session
  • sessionData: InboundGroupSessionData

    The session data structure
  • txn: IDBTransaction

    An active transaction. See doTxn().

  Returns void

storeEndToEndSession

• storeEndToEndSession(
      deviceKey: string,
      sessionId: string,
      sessionInfo: ISessionInfo,
      txn: IDBTransaction,
  ): void

  Store a session between the logged-in user and another device

  Parameters

  • deviceKey: string

    The public key of the other device.
  • sessionId: string

    The ID for this end-to-end session.
  • sessionInfo: ISessionInfo

    Session information object
  • txn: IDBTransaction

    An active transaction. See doTxn().

  Returns void

storeSecretStorePrivateKey

• storeSecretStorePrivateKey<K extends "m.megolm_backup.v1">(
      txn: IDBTransaction,
      type: K,
      key: SecretStorePrivateKeys[K],
  ): void

  Write the cross-signing private keys back to the store

  Type Parameters

  • K extends "m.megolm_backup.v1"

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • type: K

    The type of cross-signing private key to store
  • key: SecretStorePrivateKeys[K]

    keys object as getCrossSigningKeys()

  Returns void

Staticexists

• exists(indexedDB: IDBFactory, dbName: string): Promise<boolean>

  Parameters

  • indexedDB: IDBFactory
  • dbName: string

  Returns Promise<boolean>

StaticexistsAndIsNotMigrated

• existsAndIsNotMigrated(indexedDb: IDBFactory, dbName: string): Promise<boolean>

  Utility to check if a legacy crypto store exists and has not been migrated. Returns true if the store exists and has not been migrated, false otherwise.

  Parameters

  • indexedDb: IDBFactory
  • dbName: string

  Returns Promise<boolean>