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

addEndToEndInboundGroupSession

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

• Adds an end-to-end inbound group session to the store. If there already exists an inbound group session with the same senderCurve25519Key and sessionID, the session will not be added.

  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

addParkedSharedHistory

• addParkedSharedHistory(
      roomId: string,
      parkedData: ParkedSharedHistory,
      txn?: IDBTransaction,
  ): void

• Park a shared-history group session for a room we may be invited to later.

  Parameters

  • roomId: string
  • parkedData: ParkedSharedHistory
  • Optionaltxn: IDBTransaction

  Returns void

addSharedHistoryInboundGroupSession

• addSharedHistoryInboundGroupSession(
      roomId: string,
      senderKey: string,
      sessionId: string,
      txn?: IDBTransaction,
  ): void

• Add a shared-history group session for a room.

  Parameters

  • roomId: string

    The room that the key belongs to
  • senderKey: string

    The sender's curve 25519 key
  • sessionId: string

    The ID of the session
  • Optionaltxn: IDBTransaction

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

  Returns void

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

countSessionsNeedingBackup

• countSessionsNeedingBackup(txn?: IDBTransaction): Promise<number>

• Count the inbound group sessions that need to be backed up.

  Parameters

  • Optionaltxn: IDBTransaction

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

  Returns Promise<number>

  resolves to the number of sessions

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>

deleteOutgoingRoomKeyRequest

• deleteOutgoingRoomKeyRequest(
      requestId: string,
      expectedState: number,
  ): Promise<null | OutgoingRoomKeyRequest>

• Look for an existing room key request by id and state, and delete it if found

  Parameters

  • requestId: string

    ID of request to update
  • expectedState: number

    state we expect to find the request in

  Returns Promise<null | OutgoingRoomKeyRequest>

  resolves once the operation is completed

doTxn

• doTxn<T>(
      mode: Mode,
      stores: Iterable<string, any, any>,
      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, any, any>

    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.

filterOutNotifiedErrorDevices

• filterOutNotifiedErrorDevices(
      devices: IOlmDevice<DeviceInfo>[],
  ): Promise<IOlmDevice<DeviceInfo>[]>

• Parameters

  • devices: IOlmDevice<DeviceInfo>[]

  Returns Promise<IOlmDevice<DeviceInfo>[]>

getAccount

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

• Parameters

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

  Returns void

getAllEndToEndInboundGroupSessions

• getAllEndToEndInboundGroupSessions(
      txn: IDBTransaction,
      func: (session: null | ISession) => void,
  ): void

• Fetches all inbound group sessions in the store

  Parameters

  • txn: IDBTransaction

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

    Called once for each group session in the store with an object having keys {senderKey, sessionId, sessionData}, then once with null to indicate the end of the list.

  Returns void

getAllEndToEndSessions

• getAllEndToEndSessions(
      txn: IDBTransaction,
      func: (session: null | ISessionInfo) => void,
  ): void

• Retrieve all end-to-end sessions

  Parameters

  • txn: IDBTransaction

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

    Called one for each session with an object with, deviceKey, lastReceivedMessageTs, sessionId and session keys.

  Returns void

getAllOutgoingRoomKeyRequestsByState

• getAllOutgoingRoomKeyRequestsByState(
      wantedState: number,
  ): Promise<OutgoingRoomKeyRequest[]>

• Look for room key requests by state – unlike above, return a list of all entries in one state.

  Parameters

  • wantedState: number

  Returns Promise<OutgoingRoomKeyRequest[]>

  Returns an array of requests in the given state

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

getEndToEndDeviceData

• getEndToEndDeviceData(
      txn: IDBTransaction,
      func: (deviceData: null | IDeviceData) => void,
  ): void

• Get the state of all tracked devices

  Parameters

  • txn: IDBTransaction

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

    Function called with the device data

  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

getEndToEndSessionProblem

• getEndToEndSessionProblem(
      deviceKey: string,
      timestamp: number,
  ): Promise<null | IProblem>

• Parameters

  • deviceKey: string
  • timestamp: number

  Returns Promise<null | IProblem>

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>

getOrAddOutgoingRoomKeyRequest

• getOrAddOutgoingRoomKeyRequest(
      request: OutgoingRoomKeyRequest,
  ): Promise<OutgoingRoomKeyRequest>

• Look for an existing outgoing room key request, and if none is found, add a new one

  Parameters

  • request: OutgoingRoomKeyRequest

  Returns Promise<OutgoingRoomKeyRequest>

  resolves to OutgoingRoomKeyRequest: either the same instance as passed in, or the existing one.

getOutgoingRoomKeyRequest

• getOutgoingRoomKeyRequest(
      requestBody: IRoomKeyRequestBody,
  ): Promise<null | OutgoingRoomKeyRequest>

• Look for an existing room key request

  Parameters

  • requestBody: IRoomKeyRequestBody

    existing request to look for

  Returns Promise<null | OutgoingRoomKeyRequest>

  resolves to the matching OutgoingRoomKeyRequest, or null if not found

getOutgoingRoomKeyRequestByState

• getOutgoingRoomKeyRequestByState(
      wantedStates: number[],
  ): Promise<null | OutgoingRoomKeyRequest>

• Look for room key requests by state

  Parameters

  • wantedStates: number[]

    list of acceptable states

  Returns Promise<null | OutgoingRoomKeyRequest>

  resolves to the a OutgoingRoomKeyRequest, or null if there are no pending requests in those states. If there are multiple requests in those states, an arbitrary one is chosen.

getOutgoingRoomKeyRequestsByTarget

• getOutgoingRoomKeyRequestsByTarget(
      userId: string,
      deviceId: string,
      wantedStates: number[],
  ): Promise<OutgoingRoomKeyRequest[]>

• Look for room key requests by target device and state

  Parameters

  • userId: string

    Target user ID
  • deviceId: string

    Target device ID
  • wantedStates: number[]

    list of acceptable states

  Returns Promise<OutgoingRoomKeyRequest[]>

  resolves to a list of all the OutgoingRoomKeyRequest

getSecretStorePrivateKey

• getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
      txn: IDBTransaction,
      func: (key: null | SecretStorePrivateKeys[K]) => void,
      type: K,
  ): void

• Type Parameters

  • K extends keyof SecretStorePrivateKeys

  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

getSessionsNeedingBackup

• getSessionsNeedingBackup(limit: number): Promise<ISession[]>

• Get the inbound group sessions that need to be backed up.

  Parameters

  • limit: number

    The maximum number of sessions to retrieve. 0 for no limit.

  Returns Promise<ISession[]>

  resolves to an array of inbound group sessions

getSharedHistoryInboundGroupSessions

• getSharedHistoryInboundGroupSessions(
      roomId: string,
      txn?: IDBTransaction,
  ): Promise<[senderKey: string, sessionId: string][]>

• Get the shared-history group session for a room.

  Parameters

  • roomId: string

    The room that the key belongs to
  • Optionaltxn: IDBTransaction

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

  Returns Promise<[senderKey: string, sessionId: string][]>

  Promise which resolves to an array of [senderKey, sessionId]

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

storeCrossSigningKeys

• storeCrossSigningKeys(
      txn: IDBTransaction,
      keys: Record<string, CrossSigningKeyInfo>,
  ): void

• Write the cross-signing keys back to the store

  Parameters

  • txn: IDBTransaction

    An active transaction. See doTxn().
  • keys: Record<string, CrossSigningKeyInfo>

    keys object as getCrossSigningKeys()

  Returns void

storeEndToEndDeviceData

• storeEndToEndDeviceData(deviceData: IDeviceData, txn: IDBTransaction): void

• Store the state of all tracked devices This contains devices for each user, a tracking state for each user and a sync token matching the point in time the snapshot represents. These all need to be written out in full each time such that the snapshot is always consistent, so they are stored in one object.

  Parameters

  • deviceData: IDeviceData
  • txn: IDBTransaction

    An active transaction. See doTxn().

  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

storeEndToEndInboundGroupSessionWithheld

• storeEndToEndInboundGroupSessionWithheld(
      senderCurve25519Key: string,
      sessionId: string,
      sessionData: IWithheld,
      txn: IDBTransaction,
  ): void

• Parameters

  • senderCurve25519Key: string
  • sessionId: string
  • sessionData: IWithheld
  • txn: IDBTransaction

  Returns void

storeEndToEndRoom

• storeEndToEndRoom(
      roomId: string,
      roomInfo: IRoomEncryption,
      txn: IDBTransaction,
  ): void

• Store the end-to-end state for a room.

  Parameters

  • roomId: string

    The room's ID.
  • roomInfo: IRoomEncryption

    The end-to-end info for the room.
  • 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

storeEndToEndSessionProblem

• storeEndToEndSessionProblem(
      deviceKey: string,
      type: string,
      fixed: boolean,
  ): Promise<void>

• Parameters

  • deviceKey: string
  • type: string
  • fixed: boolean

  Returns Promise<void>

storeSecretStorePrivateKey

• storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
      txn: IDBTransaction,
      type: K,
      key: SecretStorePrivateKeys[K],
  ): void

• Write the cross-signing private keys back to the store

  Type Parameters

  • K extends keyof SecretStorePrivateKeys

  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

takeParkedSharedHistory

• takeParkedSharedHistory(
      roomId: string,
      txn?: IDBTransaction,
  ): Promise<ParkedSharedHistory[]>

• Pop out all shared-history group sessions for a room.

  Parameters

  • roomId: string
  • Optionaltxn: IDBTransaction

  Returns Promise<ParkedSharedHistory[]>

unmarkSessionsNeedingBackup

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

• Unmark 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 unmarked

updateOutgoingRoomKeyRequest

• updateOutgoingRoomKeyRequest(
      requestId: string,
      expectedState: number,
      updates: Partial<OutgoingRoomKeyRequest>,
  ): Promise<null | OutgoingRoomKeyRequest>

• Look for an existing room key request by id and state, and update it if found

  Parameters

  • requestId: string

    ID of request to update
  • expectedState: number

    state we expect to find the request in
  • updates: Partial<OutgoingRoomKeyRequest>

    name/value map of updates to apply

  Returns Promise<null | OutgoingRoomKeyRequest>

  resolves to OutgoingRoomKeyRequest updated request, or null if no matching row was found

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>