Class Client<ContentTypes>

constructor

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

• Type Parameters

  • ContentTypes = any

  Parameters

  • publicKeyBundle: PublicKeyBundle
  • apiClient: ApiClient
  • backupClient: BackupClient
  • 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>

• Parameters

  • peerAddress: string

  Returns Promise<boolean>

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

• Parameters

  • peerAddress: string[]

  Returns Promise<boolean[]>

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<{
      payload: Uint8Array;
      shouldPush: boolean;
  }>

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

  Parameters

  • content: ContentTypes
  • Optionaloptions: SendOptions

  Returns Promise<{
      payload: Uint8Array;
      shouldPush: boolean;
  }>

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>
  • Optionalopts: ListMessagesOptions

  Returns Promise<Out[]>

listEnvelopesPaginated

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

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

  Type Parameters

  • Out

  Parameters

  • contentTopic: string
  • mapper: EnvelopeMapper<Out>
  • Optionalopts: ListMessagesPaginatedOptions

  Returns AsyncGenerator<Out[], any, any>

listInvitations

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

• Parameters

  • Optionalopts: 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>>

StaticcanMessage

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

• Parameters

  • peerAddress: string
  • Optionalopts: Partial<NetworkOptions>

  Returns Promise<boolean>

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

• Parameters

  • peerAddress: string[]
  • Optionalopts: Partial<NetworkOptions>

  Returns Promise<boolean[]>

Staticcreate

• 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: AddChainParameters) => Promise<void>);
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: undefined | Chain;
        deployContract: (<const abi, chainOverride>(args: DeployContractParameters<abi, undefined | Chain, undefined | Account, chainOverride>) => Promise<`0x${string}`>);
        extend: (<const client>(fn: ((client: Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, WalletActions<undefined | Chain, undefined | Account>>) => client)) => 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: (<TParameterType, TChainOverride, TAccountOverride>(args: PrepareTransactionRequestParameters<undefined | Chain, undefined | Account, TChainOverride, TAccountOverride, TParameterType>) => Promise<PrepareTransactionRequestReturnType<Chain, undefined | Account, TChainOverride, TAccountOverride, TParameterType>>);
        request: EIP1193RequestFn<WalletRpcSchema>;
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args: {
            eth_accounts: Record<string, any>;
        }) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args: SendRawTransactionParameters) => Promise<`0x${string}`>);
        sendTransaction: (<TChainOverride>(args: SendTransactionParameters<undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
        signMessage: ((args: SignMessageParameters<undefined | Account>) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args: SignTransactionParameters<undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
        signTypedData: (<const TTypedData, TPrimaryType>(args: SignTypedDataParameters<TTypedData, TPrimaryType, undefined | Account>) => Promise<`0x${string}`>);
        switchChain: ((args: SwitchChainParameters) => Promise<void>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        watchAsset: ((args: WatchAssetParams) => Promise<boolean>);
        writeContract: (<const abi, functionName, args, TChainOverride>(args: WriteContractParameters<abi, functionName, args, undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
    }

    the wallet as a Signer instance
  • Optionalopts: 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]>>>

StaticgetKeys

• 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: AddChainParameters) => Promise<void>);
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: undefined | Chain;
        deployContract: (<const abi, chainOverride>(args: DeployContractParameters<abi, undefined | Chain, undefined | Account, chainOverride>) => Promise<`0x${string}`>);
        extend: (<const client>(fn: ((client: Client<Transport, undefined | Chain, undefined | Account, WalletRpcSchema, WalletActions<undefined | Chain, undefined | Account>>) => client)) => 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: (<TParameterType, TChainOverride, TAccountOverride>(args: PrepareTransactionRequestParameters<undefined | Chain, undefined | Account, TChainOverride, TAccountOverride, TParameterType>) => Promise<PrepareTransactionRequestReturnType<Chain, undefined | Account, TChainOverride, TAccountOverride, TParameterType>>);
        request: EIP1193RequestFn<WalletRpcSchema>;
        requestAddresses: (() => Promise<RequestAddressesReturnType>);
        requestPermissions: ((args: {
            eth_accounts: Record<string, any>;
        }) => Promise<RequestPermissionsReturnType>);
        sendRawTransaction: ((args: SendRawTransactionParameters) => Promise<`0x${string}`>);
        sendTransaction: (<TChainOverride>(args: SendTransactionParameters<undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
        signMessage: ((args: SignMessageParameters<undefined | Account>) => Promise<`0x${string}`>);
        signTransaction: (<TChainOverride>(args: SignTransactionParameters<undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
        signTypedData: (<const TTypedData, TPrimaryType>(args: SignTypedDataParameters<TTypedData, TPrimaryType, undefined | Account>) => Promise<`0x${string}`>);
        switchChain: ((args: SwitchChainParameters) => Promise<void>);
        transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        watchAsset: ((args: WatchAssetParams) => Promise<boolean>);
        writeContract: (<const abi, functionName, args, TChainOverride>(args: WriteContractParameters<abi, functionName, args, undefined | Chain, undefined | Account, TChainOverride>) => Promise<`0x${string}`>);
    }
  • Optionalopts: Partial<Flatten<NetworkOptions & KeyStoreOptions & ContentOptions & LegacyOptions & PreEventCallbackOptions>> & {
        codecs?: U;
    }

  Returns Promise<Uint8Array>

StaticisSnapsReady

• isSnapsReady(): Promise<boolean>

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

  Returns Promise<boolean>