Class Client<ContentTypes>

constructor

• new Client<ContentTypes>(publicKeyBundle, apiClient, backupClient, keystore): Client<ContentTypes>

• Type Parameters

  • ContentTypes = any

  Parameters

  • publicKeyBundle: PublicKeyBundle
  • apiClient: ApiClient
  • backupClient: default
  • keystore: KeystoreInterfaces

  Returns Client<ContentTypes>

address

apiClient

contacts

keystore

publicKeyBundle

backupType

• get backupType(): BackupType

• Returns BackupType

conversations

• get conversations(): Conversations<ContentTypes>

• Returns Conversations<ContentTypes>

signedPublicKeyBundle

• get signedPublicKeyBundle(): SignedPublicKeyBundle

• Returns SignedPublicKeyBundle

canMessage

• canMessage(peerAddress): Promise<boolean>

• Check if

  Parameters

  • peerAddress: string

  Returns Promise<boolean>

  Peer Address

  can be messaged, specifically it checks that a PublicKeyBundle can be found for the given address

• canMessage(peerAddress): Promise<boolean[]>

• Check if

  Parameters

  • peerAddress: string[]

  Returns Promise<boolean[]>

  Peer Address

  can be messaged, specifically it checks that a PublicKeyBundle can be found for the given address

close

• close(): Promise<void>

• Returns Promise<void>

codecFor

• codecFor(contentType): undefined | ContentCodec<any>

• Find a matching codec for a given ContentTypeId from the client's codec registry

  Parameters

  • contentType: ContentTypeId

  Returns undefined | ContentCodec<any>

decodeContent

• decodeContent(contentBytes): Promise<{
      content: ContentTypes;
      contentFallback?: string;
      contentType: ContentTypeId;
      error?: Error;
  }>

• Parameters

  • contentBytes: Uint8Array

  Returns Promise<{
      content: ContentTypes;
      contentFallback?: string;
      contentType: ContentTypeId;
      error?: Error;
  }>

encodeContent

• encodeContent(content, options?): Promise<Uint8Array>

• Convert arbitrary content into a serialized EncodedContent instance with the given options

  Parameters

  • content: ContentTypes
  • Optional options: SendOptions

  Returns Promise<Uint8Array>

forgetContact

• forgetContact(peerAddress): void

• Used to force getUserContact fetch contact from the network.

  Parameters

  • peerAddress: string

  Returns void

getUserContact

• getUserContact(peerAddress): Promise<undefined | SignedPublicKeyBundle | PublicKeyBundle>

• Returns the cached PublicKeyBundle if one is known for the given address or fetches one from the network

  This throws if either the address is invalid or the contact is not published. See also [#canMessage].

  Parameters

  • peerAddress: string

  Returns Promise<undefined | SignedPublicKeyBundle | PublicKeyBundle>

getUserContacts

• getUserContacts(peerAddresses): Promise<(undefined | SignedPublicKeyBundle | PublicKeyBundle)[]>

• Identical to getUserContact but for multiple peer addresses

  Parameters

  • peerAddresses: string[]

  Returns Promise<(undefined | SignedPublicKeyBundle | PublicKeyBundle)[]>

listEnvelopes

• listEnvelopes<Out>(topic, mapper, opts?): Promise<Out[]>

• List stored messages from the specified topic.

  A specified mapper function will be applied to each envelope. If the mapper function throws an error during processing, the envelope will be discarded.

  Type Parameters

  • Out

  Parameters

  • topic: string
  • mapper: EnvelopeMapperWithMessage<Out>
  • Optional opts: ListMessagesOptions

  Returns Promise<Out[]>

listEnvelopesPaginated

• listEnvelopesPaginated<Out>(contentTopic, mapper, opts?): AsyncGenerator<Out[], any, unknown>

• List messages on a given set of content topics, yielding one page at a time

  Type Parameters

  • Out

  Parameters

  • contentTopic: string
  • mapper: EnvelopeMapper<Out>
  • Optional opts: ListMessagesPaginatedOptions

  Returns AsyncGenerator<Out[], any, unknown>

listInvitations

• listInvitations(opts?): Promise<Envelope[]>

• Parameters

  • Optional opts: ListMessagesOptions

  Returns Promise<Envelope[]>

publishEnvelopes

• publishEnvelopes(envelopes): Promise<void>

• Low level method for publishing envelopes to the XMTP network with no pre-processing or encryption applied.

  Primarily used internally

  Parameters

  • envelopes: PublishParams[]

    PublishParams[]

  Returns Promise<void>

publishUserContact

• publishUserContact(legacy?): Promise<void>

• Parameters

  • legacy: boolean = false

  Returns Promise<void>

registerCodec

• registerCodec<Codec>(codec): Client<ContentTypes | ExtractDecodedType<Codec>>

• Register a codec to be automatically used for encoding/decoding messages of the given Content Type

  Type Parameters

  • Codec extends ContentCodec<any>

  Parameters

  • codec: Codec

  Returns Client<ContentTypes | ExtractDecodedType<Codec>>

Static canMessage

• canMessage(peerAddress, opts?): Promise<boolean>

• Parameters

  • peerAddress: string
  • Optional opts: Partial<NetworkOptions>

  Returns Promise<boolean>

• canMessage(peerAddress, opts?): Promise<boolean[]>

• Parameters

  • peerAddress: string[]
  • Optional opts: Partial<NetworkOptions>

  Returns Promise<boolean[]>

Static create

• create<ContentCodecs>(wallet, opts?): Promise<Client<undefined | ExtractDecodedType<[...ContentCodecs[], TextCodec][number]>>>

• Create and start a client associated with given wallet.

  Type Parameters

  • ContentCodecs extends ContentCodec<any>[] = []

  Parameters

  • wallet: null | Signer | {
        account: undefined | Account;
        addChain: ((args) => Promise<void>);
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: undefined | Chain;
        deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>);
        extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
            [K in string | number | symbol]: client[K]
        } & WalletActions<undefined | Chain, undefined | Account>>);
        getAddresses: (() => Promise<GetAddressesReturnType>);
        getChainId: (() => Promise<number>);
        getPermissions: (() => Promise<GetPermissionsReturnType>);
        key: string;
        name: string;
        pollingInterval: number;
        prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
        request: EIP1193RequestFn<WalletRpcSchema>;
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signMessage: ((args) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
        switchChain: ((args) => Promise<void>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        watchAsset: ((args) => Promise<boolean>);
        writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>);
    }

    the wallet as a Signer instance
  • Optional opts: Partial<Flatten<NetworkOptions & KeyStoreOptions & ContentOptions & LegacyOptions & PreEventCallbackOptions>> & {
        codecs?: ContentCodecs;
    }

    specify how to to connect to the network

  Returns Promise<Client<undefined | ExtractDecodedType<[...ContentCodecs[], TextCodec][number]>>>

Static getKeys

• getKeys<U>(wallet, opts?): Promise<Uint8Array>

• Export the XMTP PrivateKeyBundle from the SDK as a Uint8Array.

  This bundle can then be provided as privateKeyOverride in a subsequent call to Client.create(...)

  Be very careful with these keys, as they can be used to impersonate a user on the XMTP network and read the user's messages.

  Type Parameters

  • U

  Parameters

  • wallet: null | Signer | {
        account: undefined | Account;
        addChain: ((args) => Promise<void>);
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: undefined | Chain;
        deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>);
        extend: (<const client>(fn) => Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, {
            [K in string | number | symbol]: client[K]
        } & WalletActions<undefined | Chain, undefined | Account>>);
        getAddresses: (() => Promise<GetAddressesReturnType>);
        getChainId: (() => Promise<number>);
        getPermissions: (() => Promise<GetPermissionsReturnType>);
        key: string;
        name: string;
        pollingInterval: number;
        prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
        request: EIP1193RequestFn<WalletRpcSchema>;
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args) => Promise<`0x${string}`>);
        sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signMessage: ((args) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
        signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
        switchChain: ((args) => Promise<void>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        watchAsset: ((args) => Promise<boolean>);
        writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>);
    }
  • Optional opts: Partial<Flatten<NetworkOptions & KeyStoreOptions & ContentOptions & LegacyOptions & PreEventCallbackOptions>> & {
        codecs?: U;
    }

  Returns Promise<Uint8Array>

Static isSnapsReady

• isSnapsReady(): Promise<boolean>

• Tells the caller whether the browser has a Snaps-compatible version of MetaMask installed

  Returns Promise<boolean>