Struct ApiClientWrapper 

pub struct ApiClientWrapper<ApiClient> {
    pub api_client: GuardedApi<ApiClient>,
    /* private fields */
}

Fields

api_client: GuardedApi<ApiClient>

Implementations

impl<C: XmtpBackendClient> ApiClientWrapper<C>

pub async fn create_upload( &self, request: CreateUploadRequest, ) -> Result<CreateUploadResponse>

Get the request to send to the configured storage target.

impl<C: XmtpBackendClient> ApiClientWrapper<C>

pub async fn get_configuration(&self) -> Result<GetConfigurationResponse>

Read what the deployment publishes about itself.

Not retried here: the caller decides what a failure means. build fails with ConfigurationUnavailable; a refresh attempt logs and waits out its own schedule.

pub fn backend_url(&self) -> Option<&str>

The backend URL this client sends to, when the transport knows it. None skips the comparison with the stored backend URL.

pub fn has_credential_source(&self) -> bool

Whether a credential source was configured on the transport.

impl<C: XmtpBackendClient> ApiClientWrapper<C>

pub async fn publish_identity_update<U: Into<IdentityUpdate>>( &self, update: U, ) -> Result<Cursor>

pub async fn get_identity_updates_v2( &self, filters: Vec<GetIdentityUpdatesV2Filter>, ) -> Result<HashMap<String, Vec<IdentityUpdateLog>>>

Read every update the filters name and return them by inbox, in sequence order. Use Self::fold_identity_updates to store a long history without retaining it all.

pub async fn fold_identity_updates<E: From<ApiError> + Display>( &self, filters: Vec<GetIdentityUpdatesV2Filter>, limits: IncomingBatchLimits, fold: impl FnMut(Vec<IdentityUpdateLog>) -> Result<(), E>, ) -> Result<(), E>

Read the updates the filters name one bounded page at a time, in sequence order for each inbox, without retaining earlier pages. Every update names one of the filters’ inboxes exactly. An API or fold error stops the read; the caller stores each page before the next request.

pub async fn get_inbox_ids( &self, identifiers: Vec<ApiIdentifier>, ) -> Result<Vec<Option<String>>>

Return one optional inbox id for every input, in the same order.

pub async fn verify_smart_contract_wallet_signatures( &self, request: VerifySmartContractWalletSignaturesRequest, ) -> Result<VerifySmartContractWalletSignaturesResponse>

Verify every signature and return one verdict per signature, in request order. The signatures go out in requests of at most the published max_scw_signatures, never more than MAX_SCW_SIGNATURES_PER_REQUEST, and within max_request_bytes, with up to MAX_READ_CHUNKS_IN_FLIGHT requests in flight. A response whose verdict count differs from its request’s is a retryable ApiError::VerdictCount.

impl<C: XmtpBackendClient> ApiClientWrapper<C>

pub async fn query_group_messages( &self, group_id: GroupId, ) -> Result<Vec<GroupMessage>>

pub async fn query_group_messages_with_cursors( &self, cursors: TopicCursor, ) -> Result<Vec<GroupMessage>>

pub async fn query_latest_group_message( &self, group_id: GroupId, ) -> Result<Option<GroupMessage>>

pub async fn query_welcome_messages<Id: AsRef<[u8]> + Copy>( &self, installation_id: Id, ) -> Result<Vec<WelcomeMessage>>

pub async fn query_first_welcome( &self, destination: InstallationId, max_bytes: usize, ) -> Result<Option<ServerEnvelope>>

The lowest-sequence envelope on the Welcome topic of destination, with validated metadata and an undecoded payload. One Query with limit 1 from cursor 0, so later envelopes are never fetched.

pub async fn query_welcome_messages_with_cursors( &self, cursors: TopicCursor, ) -> Result<Vec<WelcomeMessage>>

pub async fn upload_key_package( &self, key_package: Vec<u8>, ) -> Result<EnvelopeMeta>

pub async fn fetch_key_packages( &self, keys: &[InstallationId], ) -> Result<KeyPackageMap>

pub async fn newest_key_package( &self, id: &InstallationId, ) -> Result<Option<(KeyPackage, Cursor)>>

The newest package on the key package topic of id, with its sequence id.

pub async fn send_welcome_messages( &self, messages: &[WelcomeMessage], ) -> Result<Vec<EnvelopeMeta>>

pub async fn send_group_messages( &self, units: Vec<PublishUnit>, ) -> Result<Vec<EnvelopeMeta>>

pub async fn publish_commit_log( &self, entries: Vec<SealedCommitLogEntry>, stored: &mut Vec<EnvelopeMeta>, ) -> Result<()>

Publish commit-log entries in the given order, one request at a time, and stop at the first failed request. Each stored entry’s metadata is appended to stored, so on an error stored names the stored prefix of entries and a retry starts from the first entry after it.

pub async fn query_commit_log( &self, cursors: TopicCursor, ) -> Result<Vec<CommitLogEntry>>

Read commit-log topics without opening any entry. An envelope whose metadata does not decode is logged and left out; the read still returns every other envelope, so one bad envelope never fails it.

pub async fn get_newest_message_metadata( &self, group_ids: &[GroupId], ) -> Result<HashMap<GroupId, GroupMessageMetadata>>

impl<C: XmtpMlsStreams + XmtpBackendClient> ApiClientWrapper<C>

where C::GroupMessageStream: 'static, C::WelcomeMessageStream: 'static,

pub async fn subscribe_group_messages( &self, groups: &[&GroupId], ) -> Result<<GuardedApi<C> as XmtpMlsStreams>::GroupMessageStream>

pub async fn subscribe_group_messages_with_cursors( &self, cursors: &TopicCursor, ) -> Result<<GuardedApi<C> as XmtpMlsStreams>::GroupMessageStream>

pub async fn subscribe_welcome_messages( &self, installations: &[&InstallationId], ) -> Result<<GuardedApi<C> as XmtpMlsStreams>::WelcomeMessageStream>

pub async fn subscribe_welcome_messages_with_cursors( &self, cursors: &TopicCursor, ) -> Result<<GuardedApi<C> as XmtpMlsStreams>::WelcomeMessageStream>

impl<C: XmtpBackendClient> ApiClientWrapper<C>

Each request ends by deadline, which the caller shares across the requests of one notification turn. A rate-limit wait that would pass it returns the rejection at once, so the notification worker schedules the next attempt from its delay.

pub async fn register( &self, request: RegisterRequest, deadline: Instant, ) -> Result<RecipientState>

Create or renew a notification recipient.

pub async fn unregister( &self, request: UnregisterRequest, deadline: Instant, ) -> Result<UnregisterResponse>

Delete a notification recipient and its subscriptions.

pub async fn update_subscriptions( &self, request: UpdateSubscriptionsRequest, deadline: Instant, ) -> Result<RecipientState>

Atomically update notification subscriptions and renew the recipient.

impl<C: XmtpBackendClient> ApiClientWrapper<C>

pub async fn publish_units( &self, units: Vec<PublishUnit>, ) -> Result<Vec<EnvelopeMeta>>

Publish each atomic unit and return metadata in envelope order.

pub async fn publish_units_in_order( &self, units: Vec<PublishUnit>, stored: &mut Vec<EnvelopeMeta>, ) -> Result<()>

Publish units with one request in flight at a time, in unit order, and stop at the first failed request. Each stored envelope’s metadata is appended to stored as its request returns, so on an error stored names the stored prefix; the envelopes of the failed request may or may not be stored. A commit-log reader, which keeps only a continuous chain, never sees a later request stored ahead of an earlier one.

pub async fn query_ordered_page( &self, cursors: TopicCursor, limit: u32, limits: IncomingBatchLimits, ) -> Result<OrderedQueryPage>

Read one bounded ordered page without decoding MLS payloads. Commit each batch before requesting more from the new received prefix F.

pub async fn fold_ordered_pages<E: From<ApiError>>( &self, cursors: TopicCursor, limits: IncomingBatchLimits, fold: impl FnMut(Vec<OrderedEnvelopeBatch>, &mut TopicCursor) -> Result<(), E>, ) -> Result<(), E>

Fold one bounded ordered page at a time without retaining earlier pages. Cursors advance before the fold runs. Remove a topic from the fold’s cursors to stop reading it. An API or fold error stops the read immediately; the caller owns persistence of each page and its durable cursors.

pub async fn newest_topic_cursors( &self, topics: Vec<Topic>, ) -> Result<TopicCursor>

Capture fixed newest targets. Absent topics have target zero. Keep these targets unchanged while waiting for processing to reach them.

pub async fn query_all( &self, cursors: TopicCursor, limit: u32, ) -> Result<Vec<ServerEnvelope>>

Read every page. Each topic advances only to its own returned cursor. Use Self::fold_ordered_pages to process a backlog without retaining it all.

pub async fn settle_units( &self, units: &[PublishUnit], ) -> Result<Vec<Option<EnvelopeMeta>>>

Settle a publish whose outcome is unknown without resending it: a Query of every topic in units, from the start, returns the stored metadata of each envelope in envelope order, matched by its canonical hash. None marks an envelope the backend did not store. Pages that match nothing are dropped, and the read stops once every envelope matched. A record without valid metadata fails the read: it could be any envelope, so the read cannot prove one absent.

impl<ApiClient> ApiClientWrapper<ApiClient>

pub fn new( api_client: ApiClient, retry_strategy: Retry<ExponentialBackoff>, ) -> Self

pub fn set_configuration(&mut self, configuration: Arc<ServerConfiguration>)

Chunk and pre-validate every later request against this snapshot. Called once, by build, before the client runs.

pub fn configuration(&self) -> &ServerConfiguration

What this wrapper chunks and pre-validates against.

pub fn limits(&self) -> &LimitsConfiguration

The request shapes the deployment accepts.

pub fn attach_inbox_id(&mut self, inbox_id: Option<String>)

Attach an InboxId to this API Client Wrapper. Attaches an inbox_id context to tracing logs, useful for debugging

Trait Implementations

impl<A> Clone for ApiClientWrapper<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<ApiClient: Debug> Debug for ApiClientWrapper<ApiClient>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> SmartContractSignatureVerifier for ApiClientWrapper<C>

where C: XmtpBackendClient,

fn is_valid_signature<'life0, 'async_trait>( &'life0 self, account_id: AccountId, hash: [u8; 32], signature: Bytes, block_number: Option<BlockNumber>, ) -> Pin<Box<dyn Future<Output = Result<ValidationResponse, VerifierError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Verifies an ERC-6492https://eips.ethereum.org/EIPS/eip-6492 signature.

Arguments

• signer - can be the smart wallet address or EOA address.
• hash - Message digest for the signature.
• signature - Could be encoded smart wallet signature or raw ECDSA signature.

fn verify_many<'life0, 'life1, 'async_trait>( &'life0 self, inputs: &'life1 [ScwInput], ) -> Pin<Box<dyn Future<Output = Result<Vec<ValidationResponse>, VerifierError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Verify the inputs in as few backend requests as the published limits allow, and return the verdicts in input order. The split and the verdict-count check are those of ApiClientWrapper::verify_smart_contract_wallet_signatures; its error keeps its retryability.