// This file is @generated by prost-build.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateAdminRequest {
    /// The address to set for admin management operations
    #[prost(string, tag = "1")]
    pub admin_address: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateAdminResponse {
    /// The address that has been set for admin management operations
    #[prost(string, tag = "1")]
    pub admin_address: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeployCalldataRequest {
    /// The name of the chain to deploy the instance on. e.g. base-sepolia
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// Fee in basis points for the trading instance (e.g., 100 = 1%)
    #[prost(uint32, tag = "2")]
    pub fee_bps: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetDeployCalldataResponse {
    /// The factory contract address to call
    #[prost(string, tag = "1")]
    pub factory_address: ::prost::alloc::string::String,
    /// The ABI-encoded calldata for createInstance(signer, feeBps)
    /// The signer address is pre-populated with the correct instance signer
    #[prost(bytes = "vec", tag = "2")]
    pub calldata: ::prost::alloc::vec::Vec<u8>,
    /// The instance signer address that will own the deployed contract
    #[prost(string, tag = "3")]
    pub instance_signer_address: ::prost::alloc::string::String,
    /// The chain ID for transaction construction
    #[prost(uint32, tag = "4")]
    pub chain_id: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeployContractRequest {
    /// The name of the chain to deploy the instance on. e.g. base-sepolia
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// The signed transaction hash of the createInstance function call.
    /// Required for EVM (admin signs+broadcasts the tx locally, then asks
    /// arborter to confirm + register the result). Empty / omitted for Solana,
    /// where arborter signs and submits server-side using its own signer
    /// (the only key that can satisfy the factory's `has_one = owner` check).
    #[prost(string, tag = "2")]
    pub tx_hash: ::prost::alloc::string::String,
    /// Refuse the deploy if the chain already has a trade_contract
    /// registered. Defaults to false (refuse). Set to true to overwrite the
    /// existing registration — note that previously deposited balances live on
    /// the *old* contract/instance and become orphaned.
    #[prost(bool, tag = "3")]
    pub force: bool,
    /// Trading fee in basis points. Used by the Solana server-side path,
    /// which constructs the create_instance ix here (so it needs the fee at
    /// call time). Ignored by the EVM path — for EVM the fee was baked into
    /// the calldata returned by GetDeployCalldata and signed by the admin.
    #[prost(uint32, tag = "4")]
    pub fee_bps: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeployContractResponse {
    /// The address that the instance is deployed to on the specified chain.
    /// Hex (0x-prefixed) for EVM, base58 for Solana.
    #[prost(string, tag = "1")]
    pub contract_address: ::prost::alloc::string::String,
    /// Receipt for the on-chain operation. Populated for the Solana
    /// server-side path (base58 signature). Empty for EVM, where the admin
    /// already has the tx_hash they submitted.
    #[prost(string, tag = "2")]
    pub tx_signature: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetChainRequest {
    /// The chain to set
    #[prost(message, optional, tag = "1")]
    pub chain: ::core::option::Option<Chain>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetChainResponse {
    /// Indicates if the chain was set successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetTokenRequest {
    /// The name of the chain to set the token on. e.g. base-sepolia
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// The token to set
    #[prost(message, optional, tag = "2")]
    pub token: ::core::option::Option<Token>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetTokenResponse {
    /// Indicates if the token was set successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetMarketRequest {
    /// The base chain network
    #[prost(string, tag = "1")]
    pub base_chain_network: ::prost::alloc::string::String,
    /// The quote chain network
    #[prost(string, tag = "2")]
    pub quote_chain_network: ::prost::alloc::string::String,
    /// The base chain token symbol
    #[prost(string, tag = "3")]
    pub base_chain_token_symbol: ::prost::alloc::string::String,
    /// The quote chain token symbol
    #[prost(string, tag = "4")]
    pub quote_chain_token_symbol: ::prost::alloc::string::String,
    /// The base chain token address
    #[prost(string, tag = "5")]
    pub base_chain_token_address: ::prost::alloc::string::String,
    /// The quote chain token address
    #[prost(string, tag = "6")]
    pub quote_chain_token_address: ::prost::alloc::string::String,
    /// The base chain token decimals
    #[prost(int32, tag = "7")]
    pub base_chain_token_decimals: i32,
    /// The quote chain token decimals
    #[prost(int32, tag = "8")]
    pub quote_chain_token_decimals: i32,
    /// The pair decimals (this is chosen by the stack admin)
    #[prost(int32, tag = "9")]
    pub pair_decimals: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetMarketResponse {
    /// Indicates if the market was set successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetTradeContractRequest {
    /// The chain address of the trading instance
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// The chain network to associate the trading instance with
    #[prost(string, tag = "2")]
    pub chain_network: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetTradeContractResponse {
    /// The created trading instance
    #[prost(message, optional, tag = "1")]
    pub trade_contract: ::core::option::Option<TradeContract>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetOperatorFeeRequest {
    /// The chain network whose instance to update. e.g. base-sepolia
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// Operator-fee recipient address (0x-hex for EVM, base58 for Solana).
    #[prost(string, tag = "2")]
    pub recipient: ::prost::alloc::string::String,
    /// Operator fee in basis points. Combined with maintenance bps the contract
    /// rejects a total above the bps denominator (10000).
    #[prost(uint32, tag = "3")]
    pub bps: u32,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetOperatorFeeResponse {
    /// On-chain tx hash / signature for the setOperatorFee call (0x-hex EVM,
    /// base58 Solana).
    #[prost(string, tag = "1")]
    pub tx_signature: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetOperatorAdminRequest {
    /// The chain network whose instance to update.
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// The new operator_admin key (0x-hex for EVM, base58 for Solana).
    #[prost(string, tag = "2")]
    pub new_admin: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetOperatorAdminResponse {
    /// On-chain tx hash / signature for the setOperatorAdmin call.
    #[prost(string, tag = "1")]
    pub tx_signature: ::prost::alloc::string::String,
}
/// Request message for the service
///
/// Add optional filters in the future (e.g., chain or market name)
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetConfigRequest {}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetConfigResponse {
    /// The configuration object
    #[prost(message, optional, tag = "1")]
    pub config: ::core::option::Option<Configuration>,
}
/// The top-level response containing chains and markets
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Configuration {
    /// List of supported chains
    #[prost(message, repeated, tag = "1")]
    pub chains: ::prost::alloc::vec::Vec<Chain>,
    /// List of supported markets
    #[prost(message, repeated, tag = "2")]
    pub markets: ::prost::alloc::vec::Vec<Market>,
}
/// Represents the trading instance details
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TradeContract {
    /// Optional: For non-EVM chains like Hedera, Solana, etc.
    #[prost(string, optional, tag = "1")]
    pub contract_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The chain address of the trading instance
    #[prost(string, tag = "2")]
    pub address: ::prost::alloc::string::String,
}
/// Represents a single blockchain network
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Chain {
    /// The architecture of the chain (e.g., EVM, Hedera)
    #[prost(string, tag = "1")]
    pub architecture: ::prost::alloc::string::String,
    /// The canonical name of the chain (e.g., 'Ethereum Mainnet' | 'Hedera Testnet')
    #[prost(string, tag = "2")]
    pub canonical_name: ::prost::alloc::string::String,
    /// The chain network (e.g., op-mainnet, hedera-testnet)
    #[prost(string, tag = "3")]
    pub network: ::prost::alloc::string::String,
    /// The chain ID (e.g., Ethereum = 1)
    #[prost(uint32, tag = "4")]
    pub chain_id: u32,
    /// Pubkey address of the signer of the deployed trading instance
    #[prost(string, tag = "5")]
    pub instance_signer_address: ::prost::alloc::string::String,
    /// Optional: URL to the chain explorer
    #[prost(string, optional, tag = "6")]
    pub explorer_url: ::core::option::Option<::prost::alloc::string::String>,
    /// The RPC URL for the chain
    #[prost(string, tag = "7")]
    pub rpc_url: ::prost::alloc::string::String,
    /// The address of the factory contract on this chain. This is the address to call to deploy a new trading instance
    #[prost(string, tag = "8")]
    pub factory_address: ::prost::alloc::string::String,
    /// The trading instance details
    #[prost(message, optional, tag = "10")]
    pub trade_contract: ::core::option::Option<TradeContract>,
    /// Mapping of token symbols to token details
    #[prost(map = "string, message", tag = "11")]
    pub tokens: ::std::collections::HashMap<::prost::alloc::string::String, Token>,
}
/// Represents a market with a base- and quote- chain token pair
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Market {
    /// The market name, e.g. 'Base Sepolia USDC - OP Sepolia USDC'
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The base chain, e.g. 'base-sepolia'
    #[prost(string, tag = "2")]
    pub base_chain_network: ::prost::alloc::string::String,
    /// The quote chain, e.g. 'op-sepolia'
    #[prost(string, tag = "3")]
    pub quote_chain_network: ::prost::alloc::string::String,
    /// / The token symbol for the base chain
    #[prost(string, tag = "4")]
    pub base_chain_token_symbol: ::prost::alloc::string::String,
    /// / The token symbol for the quote chain
    #[prost(string, tag = "5")]
    pub quote_chain_token_symbol: ::prost::alloc::string::String,
    /// The base chain token decimals
    #[prost(int32, tag = "6")]
    pub base_chain_token_decimals: i32,
    /// The quote chain token decimals
    #[prost(int32, tag = "7")]
    pub quote_chain_token_decimals: i32,
    /// The pair decimals (this is chosen by the stack admin)
    #[prost(int32, tag = "8")]
    pub pair_decimals: i32,
    /// Identity the market: concat(base_network "::" token_address "::" quote_network "::" token_address)
    #[prost(string, tag = "9")]
    pub market_id: ::prost::alloc::string::String,
}
/// Represents a single token
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Token {
    /// The name of the token
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The symbol of the token
    #[prost(string, tag = "2")]
    pub symbol: ::prost::alloc::string::String,
    /// The chain address of the token contract
    #[prost(string, tag = "3")]
    pub address: ::prost::alloc::string::String,
    /// Optional: for networks that use IDs (e.g., Hedera)
    #[prost(string, optional, tag = "4")]
    pub token_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The number of decimal places the token is defined with
    #[prost(uint32, tag = "5")]
    pub decimals: u32,
}
/// Request to get signer public key(s)
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSignerPublicKeyRequest {
    /// Optional: Request specific chain by network name
    /// If omitted, returns all chains
    #[prost(string, optional, tag = "1")]
    pub chain_network: ::core::option::Option<::prost::alloc::string::String>,
}
/// Single chain's public key information
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChainPublicKey {
    /// The chain ID
    #[prost(uint32, tag = "1")]
    pub chain_id: u32,
    /// The chain network name (e.g., "anvil-1", "base-sepolia")
    #[prost(string, tag = "2")]
    pub chain_network: ::prost::alloc::string::String,
    /// The signer's public key (address) for this chain
    #[prost(string, tag = "3")]
    pub public_key: ::prost::alloc::string::String,
}
/// Response with public keys per chain
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSignerPublicKeyResponse {
    /// Map of chain network name to public key info
    #[prost(map = "string, message", tag = "1")]
    pub chain_keys: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ChainPublicKey,
    >,
}
/// Delete market request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteMarketRequest {
    /// The market ID to delete
    #[prost(string, tag = "1")]
    pub market_id: ::prost::alloc::string::String,
}
/// Delete market response
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteMarketResponse {
    /// Indicates if the market was deleted successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object after deletion
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
/// Delete token request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteTokenRequest {
    /// The chain network where the token exists
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
    /// The token symbol to delete
    #[prost(string, tag = "2")]
    pub token_symbol: ::prost::alloc::string::String,
}
/// Delete token response
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteTokenResponse {
    /// Indicates if the token was deleted successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object after deletion
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
/// Delete chain request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteChainRequest {
    /// The chain network to delete
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
}
/// Delete chain response
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteChainResponse {
    /// Indicates if the chain was deleted successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object after deletion
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
/// Delete trading instance request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteTradeContractRequest {
    /// The chain network to delete the trading instance from
    #[prost(string, tag = "1")]
    pub chain_network: ::prost::alloc::string::String,
}
/// Delete trading instance response
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteTradeContractResponse {
    /// Indicates if the trading instance was deleted successfully
    #[prost(bool, tag = "1")]
    pub success: bool,
    /// The configuration object after deletion
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<Configuration>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Empty {}
/// Version information in vergen style
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VersionInfo {
    /// The version of the application (e.g., "1.0.0")
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// The git commit hash
    #[prost(string, tag = "2")]
    pub git_commit_hash: ::prost::alloc::string::String,
    /// The git commit date
    #[prost(string, tag = "3")]
    pub git_commit_date: ::prost::alloc::string::String,
    /// The git branch name
    #[prost(string, tag = "4")]
    pub git_branch: ::prost::alloc::string::String,
    /// The build timestamp
    #[prost(string, tag = "5")]
    pub build_timestamp: ::prost::alloc::string::String,
    /// The target triple
    #[prost(string, tag = "6")]
    pub target_triple: ::prost::alloc::string::String,
    /// The rustc version used to build
    #[prost(string, tag = "7")]
    pub rustc_version: ::prost::alloc::string::String,
    /// The cargo features enabled
    #[prost(string, repeated, tag = "8")]
    pub cargo_features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod config_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The Configuration service definition
    #[derive(Debug, Clone)]
    pub struct ConfigServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ConfigServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ConfigServiceClient<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,
        ) -> ConfigServiceClient<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,
        {
            ConfigServiceClient::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
        }
        /// rpc service to set the admin address
        pub async fn update_admin(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateAdminRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateAdminResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/UpdateAdmin",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "UpdateAdmin",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to get pre-encoded calldata for deploying a trading instance
        pub async fn get_deploy_calldata(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDeployCalldataRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDeployCalldataResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/GetDeployCalldata",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "GetDeployCalldata",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to deploy a trading instance on the base and quote chains
        pub async fn deploy_contract(
            &mut self,
            request: impl tonic::IntoRequest<super::DeployContractRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeployContractResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/DeployContract",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "DeployContract",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to set a chain in the configuration
        pub async fn set_chain(
            &mut self,
            request: impl tonic::IntoRequest<super::SetChainRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetChainResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetChain",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetChain",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to set a new token to trade
        pub async fn set_token(
            &mut self,
            request: impl tonic::IntoRequest<super::SetTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetTokenResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetToken",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetToken",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to set a new market to trade
        pub async fn set_market(
            &mut self,
            request: impl tonic::IntoRequest<super::SetMarketRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetMarketResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetMarket",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetMarket",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to set a new trading instance
        pub async fn set_trade_contract(
            &mut self,
            request: impl tonic::IntoRequest<super::SetTradeContractRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetTradeContractResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetTradeContract",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetTradeContract",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to set an instance's operator fee (recipient + bps). The
        /// arborter submits the on-chain setOperatorFee/set_operator_fee as the
        /// instance's operator_admin (the arborter signer, while unrotated).
        pub async fn set_operator_fee(
            &mut self,
            request: impl tonic::IntoRequest<super::SetOperatorFeeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetOperatorFeeResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetOperatorFee",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetOperatorFee",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to rotate an instance's operator_admin key. After rotation the
        /// new admin (not the arborter) gates operator-fee changes.
        pub async fn set_operator_admin(
            &mut self,
            request: impl tonic::IntoRequest<super::SetOperatorAdminRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SetOperatorAdminResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/SetOperatorAdmin",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "SetOperatorAdmin",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to get the configuration
        pub async fn get_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetConfigResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/GetConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "GetConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to get version information
        pub async fn get_version(
            &mut self,
            request: impl tonic::IntoRequest<super::Empty>,
        ) -> std::result::Result<tonic::Response<super::VersionInfo>, 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(
                "/xyz.aspens.arborter_config.v1.ConfigService/GetVersion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "GetVersion",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to get the TPM signer public key
        pub async fn get_signer_public_key(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSignerPublicKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSignerPublicKeyResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/GetSignerPublicKey",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "GetSignerPublicKey",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to get TEE attestation from the signer
        pub async fn get_attestation(
            &mut self,
            request: impl tonic::IntoRequest<
                crate::attestation::v1::GetAttestationRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<
                crate::attestation::v1::GetAttestationResponse,
            >,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/GetAttestation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "GetAttestation",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to delete a market
        pub async fn delete_market(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteMarketRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteMarketResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/DeleteMarket",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "DeleteMarket",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to delete a token
        pub async fn delete_token(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteTokenResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/DeleteToken",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "DeleteToken",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to delete a chain
        pub async fn delete_chain(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteChainRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteChainResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/DeleteChain",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "DeleteChain",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// rpc service to delete a trading instance
        pub async fn delete_trade_contract(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTradeContractRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteTradeContractResponse>,
            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(
                "/xyz.aspens.arborter_config.v1.ConfigService/DeleteTradeContract",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "xyz.aspens.arborter_config.v1.ConfigService",
                        "DeleteTradeContract",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
