Struct GuardedApi 

pub struct GuardedApi<A> { /* private fields */ }

Backend dispatch with a clone-shared client admission hook. The raw transport is private so a caller cannot skip admission through this value.

Implementations

impl<A> GuardedApi<A>

pub fn require_preflight(&self)

Mark the construction interval fail-closed until the client hook binds.

impl<A: XmtpBackendClient> GuardedApi<A>

pub fn bind_preflight( &self, make: impl FnOnce(Arc<dyn ConfigurationFetch>) -> Arc<dyn RequestPreflight>, ) -> bool

where A: 'static,

Install the client hook with its restricted configuration capability.

pub async fn check_preflight(&self) -> Result<()>

Trait Implementations

impl<A> Clone for GuardedApi<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for GuardedApi<A>

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

Formats the value using the given formatter.

impl<A: HasStats> HasStats for GuardedApi<A>

fn aggregate_stats(&self) -> AggregateStats

fn mls_stats(&self) -> ApiStats

fn identity_stats(&self) -> IdentityStats

impl<A: IsConnectedCheck> IsConnectedCheck for GuardedApi<A>

fn is_connected<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

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

Check if a client is connected

impl<A: XmtpBackendClient> XmtpBackendClient for GuardedApi<A>

type Error = ApiError

fn publish<'life0, 'async_trait>( &'life0 self, request: PublishRequest, ) -> Pin<Box<dyn Future<Output = Result<PublishResponse>> + Send + 'async_trait>>

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

fn create_upload<'life0, 'async_trait>( &'life0 self, request: CreateUploadRequest, ) -> Pin<Box<dyn Future<Output = Result<CreateUploadResponse>> + Send + 'async_trait>>

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

fn query<'life0, 'async_trait>( &'life0 self, request: QueryRequest, ) -> Pin<Box<dyn Future<Output = Result<QueryResponse>> + Send + 'async_trait>>

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

fn query_newest<'life0, 'async_trait>( &'life0 self, request: QueryNewestRequest, ) -> Pin<Box<dyn Future<Output = Result<QueryNewestResponse>> + Send + 'async_trait>>

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

fn get_inbox_ids<'life0, 'async_trait>( &'life0 self, request: GetInboxIdsRequest, ) -> Pin<Box<dyn Future<Output = Result<GetInboxIdsResponse>> + Send + 'async_trait>>

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

fn get_configuration<'life0, 'async_trait>( &'life0 self, request: GetConfigurationRequest, ) -> Pin<Box<dyn Future<Output = Result<GetConfigurationResponse>> + Send + 'async_trait>>

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

Read what this deployment publishes about itself. Served without a credential, so it is the one call a client can make before it knows whether the deployment requires one.

fn verify_smart_contract_wallet_signatures<'life0, 'async_trait>( &'life0 self, request: VerifySmartContractWalletSignaturesRequest, ) -> Pin<Box<dyn Future<Output = Result<VerifySmartContractWalletSignaturesResponse>> + Send + 'async_trait>>

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

fn register<'life0, 'async_trait>( &'life0 self, request: RegisterRequest, ) -> Pin<Box<dyn Future<Output = Result<RecipientState>> + Send + 'async_trait>>

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

fn unregister<'life0, 'async_trait>( &'life0 self, request: UnregisterRequest, ) -> Pin<Box<dyn Future<Output = Result<UnregisterResponse>> + Send + 'async_trait>>

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

fn update_subscriptions<'life0, 'async_trait>( &'life0 self, request: UpdateSubscriptionsRequest, ) -> Pin<Box<dyn Future<Output = Result<RecipientState>> + Send + 'async_trait>>

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

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

The backend URL this client sends to, when the transport knows it.

fn has_credential_source(&self) -> bool

Whether a credential source — an auth callback or an auth handle — was configured on this transport. A transport with no auth middleware reports false and build refuses a deployment that requires authentication. Defaults to true so a test double, which has no transport stack to ask, is never the thing that refuses a build.

fn set_limits(&self, limits: Arc<LimitsConfiguration>)

Install the shapes the deployment publishes, so the stream and metadata chunking that happens below ApiClientWrapper uses them too. Called once, by build, before any stream opens. A transport with nothing to chunk ignores it.

fn register_client_event_writer(&self, writer: &Arc<dyn EventWriter<()>>)

Register this client’s public event writer with a shared credential.

fn unregister_client_event_writer(&self, writer: &Arc<dyn EventWriter<()>>)

impl<A> XmtpMlsBidiStreams for GuardedApi<A>

where A: XmtpMlsBidiStreams + XmtpBackendClient, A::SubscribeStream: 'static,

type Error = ApiError

type SubscribeStream = Pin<Box<dyn Stream<Item = Result<SubscribeResponse, ApiError>> + Send>>

fn host(&self) -> &str

Return the URL used for bidi connections. Combine it with the API client’s Arc identity when selecting a shared connection.

fn bidi_limits(&self) -> Arc<LimitsConfiguration>

The frame shapes this deployment accepts, as installed by [XmtpBackendClient::set_limits]. The bidi ledger chunks interest updates below ApiClientWrapper, so it cannot read the wrapper’s copy and asks the transport instead. A transport that was never told reports the compiled defaults.

fn subscribe_bidi<'life0, 'async_trait>( &'life0 self, requests: BoxStream<'static, SubscribeRequest>, ) -> Pin<Box<dyn Future<Output = Result<Self::SubscribeStream>> + Send + 'async_trait>>

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

Open the bidirectional stream. requests is the outbound client→server frame stream (typically fed by a channel; the first frame is an Update naming the initial topic set); the returned stream yields the server→client frames.

impl<A> XmtpMlsStreams for GuardedApi<A>

where A: XmtpMlsStreams + XmtpBackendClient, A::GroupMessageStream: 'static, A::WelcomeMessageStream: 'static,

type Error = ApiError

type GroupMessageStream = Pin<Box<dyn Stream<Item = Result<GroupMessage, ApiError>> + Send>>

type WelcomeMessageStream = Pin<Box<dyn Stream<Item = Result<WelcomeMessage, ApiError>> + Send>>

fn subscribe_envelopes_with_cursors<'life0, 'life1, 'async_trait>( &'life0 self, cursors: &'life1 TopicCursor, limits: IncomingBatchLimits, ) -> Pin<Box<dyn Future<Output = Result<IncomingSubscription<ApiError>>> + Send + 'async_trait>>

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

Subscribe after committed receipt positions without decoding MLS payloads. Acknowledge new positions only after the raw envelopes commit to storage.

fn subscribe_group_messages<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, group_ids: &'life1 [&'life2 GroupId], ) -> Pin<Box<dyn Future<Output = Result<Self::GroupMessageStream>> + Send + 'async_trait>>

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

fn subscribe_group_messages_with_cursors<'life0, 'life1, 'async_trait>( &'life0 self, cursors: &'life1 TopicCursor, ) -> Pin<Box<dyn Future<Output = Result<Self::GroupMessageStream>> + Send + 'async_trait>>

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

fn subscribe_welcome_messages<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, installations: &'life1 [&'life2 InstallationId], ) -> Pin<Box<dyn Future<Output = Result<Self::WelcomeMessageStream>> + Send + 'async_trait>>

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

fn subscribe_welcome_messages_with_cursors<'life0, 'life1, 'async_trait>( &'life0 self, cursors: &'life1 TopicCursor, ) -> Pin<Box<dyn Future<Output = Result<Self::WelcomeMessageStream>> + Send + 'async_trait>>

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