trident-sdk 0.2.0

// This file is @generated by prost-build.
/// Request to get the synchronization status of a domain.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSyncStatusRequest {
    /// Trident domain identifier.
    #[prost(uint32, tag = "1")]
    pub domain: u32,
}
/// Synchronization status of a domain.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSyncStatusResponse {
    /// Last persisted unfinalized block, if any.
    #[prost(uint64, optional, tag = "3")]
    pub last_unfinalized_block: ::core::option::Option<u64>,
    /// Sync state. Unset when the domain has not been observed yet.
    #[prost(oneof = "get_sync_status_response::FinalizedTip", tags = "1, 2")]
    pub finalized_tip: ::core::option::Option<get_sync_status_response::FinalizedTip>,
}
/// Nested message and enum types in `GetSyncStatusResponse`.
pub mod get_sync_status_response {
    /// Sync state. Unset when the domain has not been observed yet.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum FinalizedTip {
        #[prost(message, tag = "1")]
        Synced(super::FinalizedTipSynced),
        #[prost(message, tag = "2")]
        Syncing(super::FinalizedTipSyncing),
    }
}
/// Domain is fully synced up to the tip.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FinalizedTipSynced {
    /// Tip block number.
    #[prost(uint64, tag = "1")]
    pub tip: u64,
}
/// Domain is still syncing to the tip.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FinalizedTipSyncing {
    /// Target tip block number the domain is syncing towards.
    #[prost(uint64, tag = "1")]
    pub tip: u64,
    /// Current synced block number.
    #[prost(uint64, tag = "2")]
    pub current: u64,
}
/// Wrapper carrying a signed spend intent for submission.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpendRequest {
    /// The signed spend intent to submit.
    #[prost(message, optional, tag = "1")]
    pub signed_spend_intent: ::core::option::Option<
        super::super::types::v1::SignedSpendIntent,
    >,
}
/// Result of a spend submission.
///
/// Exactly one variant is set: `accepted` on success, `rejected` on failure.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SpendResponse {
    #[prost(oneof = "spend_response::Result", tags = "1, 2")]
    pub result: ::core::option::Option<spend_response::Result>,
}
/// Nested message and enum types in `SpendResponse`.
pub mod spend_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Result {
        /// Attestation produced by the attester when the intent is accepted.
        #[prost(message, tag = "1")]
        Accepted(super::super::super::types::v1::SpendAttestation),
        /// Human-readable rejection reason.
        #[prost(string, tag = "2")]
        Rejected(::prost::alloc::string::String),
    }
}
/// Request to estimate fees for a spend intent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSpendFeesRequest {
    /// The unsigned spend intent to price.
    #[prost(message, optional, tag = "1")]
    pub spend_intent: ::core::option::Option<super::super::types::v1::SpendIntent>,
}
/// Fee estimate for a spend intent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSpendFeesResponse {
    /// Itemized fee breakdown.
    #[prost(message, optional, tag = "1")]
    pub fees_breakdown: ::core::option::Option<
        super::super::types::v1::SpendFeesBreakdown,
    >,
}
/// Request to list all deployments.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListDeploymentsRequest {}
/// A deployment known to Trident.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TridentDeployment {
    /// Trident domain identifier.
    #[prost(uint32, tag = "1")]
    pub domain: u32,
    /// Human-readable name for the deployment domain.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Finalized block for this domain, or the deployment anchor block if none has been observed yet.
    #[prost(uint64, tag = "3")]
    pub finalized_block: u64,
    /// Address of the deposit contract on this domain.
    #[prost(message, optional, tag = "4")]
    pub deposit_contract: ::core::option::Option<
        super::super::types::v1::MultiChainAddress,
    >,
    /// Address of the delivery contract on this domain.
    #[prost(message, optional, tag = "5")]
    pub delivery_contract: ::core::option::Option<
        super::super::types::v1::MultiChainAddress,
    >,
    /// Minimum spend intent expiry block height accepted by the attester for this domain.
    /// Implementers must set `expiry_height` at or above this value.
    #[prost(uint64, tag = "6")]
    pub spend_intent_min_expiry_height: u64,
}
/// Response containing all known deployments.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDeploymentsResponse {
    #[prost(message, repeated, tag = "1")]
    pub deployments: ::prost::alloc::vec::Vec<TridentDeployment>,
}
/// Request to get a single Trident token balance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDomainBalanceRequest {
    /// Trident domain where the balance is held.
    #[prost(uint32, tag = "1")]
    pub domain: u32,
    /// Account that holds the balance.
    #[prost(message, optional, tag = "2")]
    pub address: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Token whose balance is reported.
    #[prost(message, optional, tag = "3")]
    pub token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
}
/// Response containing a single Trident token balance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDomainBalanceResponse {
    /// Account's token balance on the requested domain.
    #[prost(message, optional, tag = "1")]
    pub balance: ::core::option::Option<TokenBalance>,
}
/// Request to list Trident token balances held by `address` on `domain`.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDomainBalancesRequest {
    /// Trident domain where balances are queried.
    #[prost(uint32, tag = "1")]
    pub domain: u32,
    /// Account that holds the balances.
    #[prost(message, optional, tag = "2")]
    pub address: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Page size. Clamped to 50 if greater, defaults to 50 if zero.
    #[prost(uint32, tag = "3")]
    pub limit: u32,
    /// Opaque cursor from a previous response. Omit for the first page.
    #[prost(bytes = "vec", optional, tag = "4")]
    pub cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Response containing a page of Trident token balances.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDomainBalancesResponse {
    /// Account's token balances on the requested domain, in the server's internal sort order.
    #[prost(message, repeated, tag = "1")]
    pub balances: ::prost::alloc::vec::Vec<TokenBalance>,
    /// Unset when no more pages remain.
    #[prost(bytes = "vec", optional, tag = "2")]
    pub next_cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// A Trident token balance held on a specific domain by a specific address.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TokenBalance {
    /// Token whose balance is reported.
    #[prost(message, optional, tag = "1")]
    pub token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Total deposited amount in the token's smallest unit.
    #[prost(message, optional, tag = "2")]
    pub deposited_balance: ::core::option::Option<super::super::types::v1::U256>,
    /// Amount available for new spend attestations in the token's smallest unit.
    #[prost(message, optional, tag = "3")]
    pub available_balance: ::core::option::Option<super::super::types::v1::U256>,
}
/// Request to look up a single attested spend intent by hash.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAttestedSpendIntentRequest {
    /// The 32-byte spend spec hash.
    #[prost(bytes = "vec", tag = "1")]
    pub spend_spec_hash: ::prost::alloc::vec::Vec<u8>,
}
/// Response containing a single attested spend intent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAttestedSpendIntentResponse {
    #[prost(message, optional, tag = "1")]
    pub attested_spend_intent: ::core::option::Option<
        super::super::types::v1::AttestedSpendIntent,
    >,
}
/// Request to list attested spend intents by source spender address and source domain.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetAttestedSpendIntentsBySrcSpenderRequest {
    /// Source spender address to filter by.
    #[prost(message, optional, tag = "1")]
    pub src_spender: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Source domain to filter by.
    #[prost(uint32, tag = "2")]
    pub src_domain: u32,
    /// Page size. Clamped to 50 if greater, defaults to 50 if zero.
    #[prost(uint32, tag = "3")]
    pub limit: u32,
    /// Opaque cursor from a previous response. Omit for first page.
    #[prost(bytes = "vec", optional, tag = "4")]
    pub cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Response containing a page of attested spend intents.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetAttestedSpendIntentsBySrcSpenderResponse {
    /// Attested spend intents matching the filter.
    #[prost(message, repeated, tag = "1")]
    pub attested_spend_intents: ::prost::alloc::vec::Vec<
        super::super::types::v1::AttestedSpendIntent,
    >,
    /// Unset when no more pages remain.
    #[prost(bytes = "vec", optional, tag = "2")]
    pub next_cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Request to list destination routes for a source token on a given source domain.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTokenRoutesRequest {
    /// Source domain the route originates from.
    #[prost(uint32, tag = "1")]
    pub from_domain: u32,
    /// Source token whose routes are queried.
    #[prost(message, optional, tag = "2")]
    pub from_token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Page size. Clamped to 50 if greater, defaults to 50 if zero.
    #[prost(uint32, tag = "3")]
    pub limit: u32,
    /// Opaque cursor from a previous response. Omit for the first page.
    #[prost(bytes = "vec", optional, tag = "4")]
    pub cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Response containing a page of token routes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTokenRoutesResponse {
    /// Routes on the queried source token, in the server's internal sort order.
    #[prost(message, repeated, tag = "1")]
    pub routes: ::prost::alloc::vec::Vec<TokenRoute>,
    /// Unset when no more pages remain.
    #[prost(bytes = "vec", optional, tag = "2")]
    pub next_cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Destination endpoint of a cross-chain route. `from_domain` and `from_token`
/// are implied by the request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TokenRoute {
    /// Destination domain the token can be bridged to.
    #[prost(uint32, tag = "1")]
    pub to_domain: u32,
    /// Destination token address on `to_domain`.
    #[prost(message, optional, tag = "2")]
    pub to_token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
}
/// Request to list routes leaving a source domain.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDomainRoutesRequest {
    /// Source domain whose outbound routes are queried.
    #[prost(uint32, tag = "1")]
    pub from_domain: u32,
    /// Page size. Clamped to 50 if greater, defaults to 50 if zero.
    #[prost(uint32, tag = "2")]
    pub limit: u32,
    /// Opaque cursor from a previous response. Omit for the first page.
    #[prost(bytes = "vec", optional, tag = "3")]
    pub cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// Response containing a page of domain routes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDomainRoutesResponse {
    /// Routes leaving the queried source domain.
    #[prost(message, repeated, tag = "1")]
    pub routes: ::prost::alloc::vec::Vec<DomainRoute>,
    /// Unset when no more pages remain.
    #[prost(bytes = "vec", optional, tag = "2")]
    pub next_cursor: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
}
/// A full route originating from a source domain. `from_domain` is implied by
/// the request.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DomainRoute {
    /// Source token this route originates from.
    #[prost(message, optional, tag = "1")]
    pub from_token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
    /// Destination domain the token can be bridged to.
    #[prost(uint32, tag = "2")]
    pub to_domain: u32,
    /// Destination token address on `to_domain`.
    #[prost(message, optional, tag = "3")]
    pub to_token: ::core::option::Option<super::super::types::v1::MultiChainAddress>,
}
/// Generated client implementations.
pub mod delivery_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service surface for submitting cross-chain spend intents and
    /// querying related Trident state.
    #[derive(Debug, Clone)]
    pub struct DeliveryServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DeliveryServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DeliveryServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            DeliveryServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Submit a signed spend intent for cross-chain execution.
        ///
        /// On success the attester returns an attestation that the caller can
        /// relay to the destination domain. On failure a human-readable
        /// rejection reason is returned instead.
        pub async fn spend(
            &mut self,
            request: impl tonic::IntoRequest<super::SpendRequest>,
        ) -> std::result::Result<tonic::Response<super::SpendResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/Spend",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("trident.delivery.v1.DeliveryService", "Spend"));
            self.inner.unary(req, path, codec).await
        }
        /// Estimate the fee breakdown for a spend intent without executing it.
        pub async fn get_spend_fees(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSpendFeesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSpendFeesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetSpendFees",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetSpendFees",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List all known deployments with their current finalized block metadata.
        pub async fn list_deployments(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDeploymentsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDeploymentsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/ListDeployments",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "ListDeployments",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get the synchronization status of a domain.
        pub async fn get_sync_status(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSyncStatusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSyncStatusResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetSyncStatus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetSyncStatus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the Trident token balance held by `address` for `token` on `domain`.
        pub async fn get_domain_balance(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDomainBalanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDomainBalanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetDomainBalance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetDomainBalance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns a paginated list of Trident token balances held by `address` on `domain`.
        pub async fn get_domain_balances(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDomainBalancesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDomainBalancesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetDomainBalances",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetDomainBalances",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Look up a single attested spend intent by its hash.
        pub async fn get_attested_spend_intent(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAttestedSpendIntentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetAttestedSpendIntentResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetAttestedSpendIntent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetAttestedSpendIntent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Paginated list of attested spend intents filtered by source spender address and source domain.
        pub async fn get_attested_spend_intents_by_src_spender(
            &mut self,
            request: impl tonic::IntoRequest<
                super::GetAttestedSpendIntentsBySrcSpenderRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::GetAttestedSpendIntentsBySrcSpenderResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetAttestedSpendIntentsBySrcSpender",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetAttestedSpendIntentsBySrcSpender",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns destination routes (`to_domain`, `to_token`) for a source token on a given source domain, paginated.
        pub async fn get_token_routes(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTokenRoutesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTokenRoutesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetTokenRoutes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetTokenRoutes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns every route (`from_token`, `to_domain`, `to_token`) leaving a given source domain, paginated.
        pub async fn get_domain_routes(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDomainRoutesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDomainRoutesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/trident.delivery.v1.DeliveryService/GetDomainRoutes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "trident.delivery.v1.DeliveryService",
                        "GetDomainRoutes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}