From 772fc69034907cddfca5e68b08ef92b016968d89 Mon Sep 17 00:00:00 2001 From: Chris Czub Date: Mon, 30 Sep 2024 16:10:08 -0400 Subject: [PATCH] feat: Noble forwarding address registration in pcli (#4865) ## Describe your changes This adds support for registering Noble forwarding addresses, for example: `pcli tx register-forwarding-account --noble-node http://noble-testnet-grpc.polkachu.com:21590 --channel channel-216 --address-or-index 2` Note that your address will need to be funded prior to being registered; the [faucet](https://faucet.circle.com/) can be used along with the `pcli view noble-address ADDRESS_OR_INDEX --channel channel-216` command to get test funds. ## Issue ticket number and link Closes #4857 ## Checklist before requesting a review - [ ] If this code contains consensus-breaking changes, I have added the "consensus-breaking" label. Otherwise, I declare my belief that there are not consensus-breaking changes, for the following reason: > pcli only --- crates/bin/pcli/src/command/tx.rs | 132 + crates/bin/pcli/src/command/view.rs | 8 + .../pcli/src/command/view/noble_address.rs | 52 + crates/core/keys/src/address.rs | 45 + crates/proto/src/gen/cosmos.app.v1alpha1.rs | 102 + crates/proto/src/gen/cosmos.auth.v1beta1.rs | 83 + .../proto/src/gen/cosmos.base.abci.v1beta1.rs | 285 ++ .../src/gen/cosmos.crypto.multisig.v1beta1.rs | 35 + crates/proto/src/gen/cosmos.tx.config.v1.rs | 20 + .../src/gen/cosmos.tx.signing.v1beta1.rs | 189 ++ crates/proto/src/gen/cosmos.tx.v1beta1.rs | 1774 ++++++++++++ crates/proto/src/gen/noble.forwarding.v1.rs | 1083 +++++++ .../proto/src/gen/proto_descriptor.bin.no_lfs | Bin 549864 -> 642967 bytes crates/proto/src/gen/tendermint.abci.rs | 2579 +++++++++++++++++ crates/proto/src/gen/tendermint.types.rs | 118 + crates/proto/src/lib.rs | 70 + deployments/scripts/protobuf-codegen | 1 + proto/rust-vendored/google/protobuf/any.proto | 164 ++ .../noble/forwarding/v1/account.proto | 22 + .../noble/forwarding/v1/genesis.proto | 11 + .../noble/forwarding/v1/packet.proto | 18 + .../noble/forwarding/v1/query.proto | 66 + .../noble/forwarding/v1/tx.proto | 29 + tools/proto-compiler/src/main.rs | 12 + 24 files changed, 6898 insertions(+) create mode 100644 crates/bin/pcli/src/command/view/noble_address.rs create mode 100644 crates/proto/src/gen/cosmos.app.v1alpha1.rs create mode 100644 crates/proto/src/gen/cosmos.auth.v1beta1.rs create mode 100644 crates/proto/src/gen/cosmos.base.abci.v1beta1.rs create mode 100644 crates/proto/src/gen/cosmos.crypto.multisig.v1beta1.rs create mode 100644 crates/proto/src/gen/cosmos.tx.config.v1.rs create mode 100644 crates/proto/src/gen/cosmos.tx.signing.v1beta1.rs create mode 100644 crates/proto/src/gen/cosmos.tx.v1beta1.rs create mode 100644 crates/proto/src/gen/noble.forwarding.v1.rs create mode 100644 crates/proto/src/gen/tendermint.abci.rs create mode 100644 proto/rust-vendored/google/protobuf/any.proto create mode 100644 proto/rust-vendored/noble/forwarding/v1/account.proto create mode 100644 proto/rust-vendored/noble/forwarding/v1/genesis.proto create mode 100644 proto/rust-vendored/noble/forwarding/v1/packet.proto create mode 100644 proto/rust-vendored/noble/forwarding/v1/query.proto create mode 100644 proto/rust-vendored/noble/forwarding/v1/tx.proto diff --git a/crates/bin/pcli/src/command/tx.rs b/crates/bin/pcli/src/command/tx.rs index 90c49d523d..9289d1fb5c 100644 --- a/crates/bin/pcli/src/command/tx.rs +++ b/crates/bin/pcli/src/command/tx.rs @@ -51,7 +51,16 @@ use penumbra_proto::{ ValidatorPenaltyRequest, }, }, + cosmos::tx::v1beta1::{ + mode_info::{Single, Sum}, + service_client::ServiceClient as CosmosServiceClient, + AuthInfo as CosmosAuthInfo, BroadcastTxRequest as CosmosBroadcastTxRequest, + Fee as CosmosFee, ModeInfo, SignerInfo as CosmosSignerInfo, Tx as CosmosTx, + TxBody as CosmosTxBody, + }, + noble::forwarding::v1::{ForwardingPubKey, MsgRegisterAccount}, view::v1::GasPricesRequest, + Message, Name as _, }; use penumbra_shielded_pool::Ics20Withdrawal; use penumbra_stake::rate::RateData; @@ -60,6 +69,8 @@ use penumbra_transaction::{gas::swap_claim_gas_cost, Transaction}; use penumbra_view::{SpendableNoteRecord, ViewClient}; use penumbra_wallet::plan::{self, Planner}; use proposal::ProposalCmd; +use tonic::transport::{Channel, ClientTlsConfig}; +use url::Url; use crate::command::tx::auction::AuctionCmd; use crate::App; @@ -258,6 +269,22 @@ pub enum TxCmd { #[clap(long)] use_compat_address: bool, }, + #[clap(display_order = 970)] + /// Register a Noble forwarding account. + RegisterForwardingAccount { + /// The Noble node to submit the registration transaction to. + #[clap(long)] + noble_node: Url, + /// The Noble IBC channel to use for forwarding. + #[clap(long)] + channel: String, + /// The Penumbra address or address index to receive forwarded funds. + #[clap(long)] + address_or_index: String, + /// Whether or not to use an ephemeral address. + #[clap(long)] + ephemeral: bool, + }, /// Broadcast a saved transaction to the network #[clap(display_order = 1000)] Broadcast { @@ -319,6 +346,7 @@ impl TxCmd { TxCmd::Withdraw { .. } => false, TxCmd::Auction(_) => false, TxCmd::Broadcast { .. } => false, + TxCmd::RegisterForwardingAccount { .. } => false, } } @@ -326,6 +354,8 @@ impl TxCmd { // TODO: use a command line flag to determine the fee token, // and pull the appropriate GasPrices out of this rpc response, // the rest should follow + // TODO: fetching this here means that no tx commands + // can be run in offline mode, which is a bit annoying let gas_prices = app .view .as_mut() @@ -1333,7 +1363,109 @@ impl TxCmd { let transaction: Transaction = serde_json::from_slice(&fs::read(transaction)?)?; app.submit_transaction(transaction).await?; } + TxCmd::RegisterForwardingAccount { + noble_node, + channel, + address_or_index, + ephemeral, + } => { + let index: Result = address_or_index.parse(); + let fvk = app.config.full_viewing_key.clone(); + + let address = if let Ok(index) = index { + // address index provided + let (address, _dtk) = match ephemeral { + false => fvk.incoming().payment_address(index.into()), + true => fvk.incoming().ephemeral_address(OsRng, index.into()), + }; + + address + } else { + // address or nothing provided + let address: Address = address_or_index + .parse() + .map_err(|_| anyhow::anyhow!("Provided address is invalid."))?; + + address + }; + + let noble_address = address.noble_forwarding_address(channel); + + println!( + "registering Noble forwarding account with address {} to forward to Penumbra address {}...", + noble_address, address + ); + + let mut noble_client = CosmosServiceClient::new( + Channel::from_shared(noble_node.to_string())? + .tls_config(ClientTlsConfig::new())? + .connect() + .await?, + ); + + let tx = CosmosTx { + body: Some(CosmosTxBody { + messages: vec![pbjson_types::Any { + type_url: MsgRegisterAccount::type_url(), + value: MsgRegisterAccount { + signer: noble_address.to_string(), + recipient: address.to_string(), + channel: channel.to_string(), + } + .encode_to_vec() + .into(), + }], + memo: "".to_string(), + timeout_height: 0, + extension_options: vec![], + non_critical_extension_options: vec![], + }), + auth_info: Some(CosmosAuthInfo { + signer_infos: vec![CosmosSignerInfo { + public_key: Some(pbjson_types::Any { + type_url: ForwardingPubKey::type_url(), + value: ForwardingPubKey { + key: noble_address.bytes(), + } + .encode_to_vec() + .into(), + }), + mode_info: Some(ModeInfo { + // SIGN_MODE_DIRECT + sum: Some(Sum::Single(Single { mode: 1 })), + }), + sequence: 0, + }], + fee: Some(CosmosFee { + amount: vec![], + gas_limit: 200000u64, + payer: "".to_string(), + granter: "".to_string(), + }), + tip: None, + }), + signatures: vec![vec![]], + }; + let r = noble_client + .broadcast_tx(CosmosBroadcastTxRequest { + tx_bytes: tx.encode_to_vec().into(), + // sync + mode: 2, + }) + .await?; + + // let r = noble_client + // .register_account(MsgRegisterAccount { + // signer: noble_address, + // recipient: address.to_string(), + // channel: channel.to_string(), + // }) + // .await?; + + println!("Noble response: {:?}", r); + } } + Ok(()) } } diff --git a/crates/bin/pcli/src/command/view.rs b/crates/bin/pcli/src/command/view.rs index 3d57d1333c..0bc07a2d85 100644 --- a/crates/bin/pcli/src/command/view.rs +++ b/crates/bin/pcli/src/command/view.rs @@ -2,6 +2,7 @@ use anyhow::Result; use address::AddressCmd; use balance::BalanceCmd; +use noble_address::NobleAddressCmd; use staked::StakedCmd; use transaction_hashes::TransactionHashesCmd; use tx::TxCmd; @@ -14,6 +15,7 @@ use self::auction::AuctionCmd; mod address; mod auction; mod balance; +mod noble_address; mod staked; mod wallet_id; @@ -28,6 +30,8 @@ pub enum ViewCmd { WalletId(WalletIdCmd), /// View one of your addresses, either by numerical index, or a random ephemeral one. Address(AddressCmd), + /// View the Noble forwarding address associated with one of your addresses, either by numerical index, or a random ephemeral one. + NobleAddress(NobleAddressCmd), /// View your account balances. Balance(BalanceCmd), /// View your staked delegation tokens. @@ -52,6 +56,7 @@ impl ViewCmd { ViewCmd::Auction(auction_cmd) => auction_cmd.offline(), ViewCmd::WalletId(wallet_id_cmd) => wallet_id_cmd.offline(), ViewCmd::Address(address_cmd) => address_cmd.offline(), + ViewCmd::NobleAddress(address_cmd) => address_cmd.offline(), ViewCmd::Balance(balance_cmd) => balance_cmd.offline(), ViewCmd::Staked(staked_cmd) => staked_cmd.offline(), ViewCmd::Reset(_) => true, @@ -91,6 +96,9 @@ impl ViewCmd { ViewCmd::Address(address_cmd) => { address_cmd.exec(&full_viewing_key)?; } + ViewCmd::NobleAddress(noble_address_cmd) => { + noble_address_cmd.exec(&full_viewing_key)?; + } ViewCmd::Balance(balance_cmd) => { let view_client = app.view(); balance_cmd.exec(view_client).await?; diff --git a/crates/bin/pcli/src/command/view/noble_address.rs b/crates/bin/pcli/src/command/view/noble_address.rs new file mode 100644 index 0000000000..6f696147cc --- /dev/null +++ b/crates/bin/pcli/src/command/view/noble_address.rs @@ -0,0 +1,52 @@ +use anyhow::Result; +use rand_core::OsRng; + +use penumbra_keys::{Address, FullViewingKey}; + +#[derive(Debug, clap::Parser)] +pub struct NobleAddressCmd { + /// The address to provide information about + #[clap(default_value = "0")] + address_or_index: String, + /// Generate an ephemeral address instead of an indexed one. + #[clap(short, long)] + ephemeral: bool, + /// The Noble IBC channel to use for forwarding. + #[clap(long)] + channel: String, +} + +impl NobleAddressCmd { + /// Determine if this command requires a network sync before it executes. + pub fn offline(&self) -> bool { + true + } + + pub fn exec(&self, fvk: &FullViewingKey) -> Result<()> { + let index: Result = self.address_or_index.parse(); + + let address = if let Ok(index) = index { + // address index provided + let (address, _dtk) = match self.ephemeral { + false => fvk.incoming().payment_address(index.into()), + true => fvk.incoming().ephemeral_address(OsRng, index.into()), + }; + + address + } else { + // address or nothing provided + let address: Address = self + .address_or_index + .parse() + .map_err(|_| anyhow::anyhow!("Provided address is invalid."))?; + + address + }; + + let noble_address = address.noble_forwarding_address(&self.channel); + + println!("{}", noble_address); + + Ok(()) + } +} diff --git a/crates/core/keys/src/address.rs b/crates/core/keys/src/address.rs index e6dc61e918..3a136151b5 100644 --- a/crates/core/keys/src/address.rs +++ b/crates/core/keys/src/address.rs @@ -1,6 +1,7 @@ //! [Payment address][Address] facilities. use std::{ + fmt::Display, io::{Cursor, Read, Write}, sync::OnceLock, }; @@ -12,6 +13,7 @@ use f4jumble::{f4jumble, f4jumble_inv}; use penumbra_proto::{penumbra::core::keys::v1 as pb, serializers::bech32str, DomainType}; use rand::{CryptoRng, Rng}; use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; mod r1cs; pub use r1cs::AddressVar; @@ -214,6 +216,49 @@ impl Address { bech32str::Bech32, ) } + + /// Generate a Noble forwarding address. + pub fn noble_forwarding_address(&self, channel: &str) -> NobleForwardingAddress { + NobleForwardingAddress { + channel: channel.to_string(), + recipient: format!("{}", self), + } + } +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct NobleForwardingAddress { + pub channel: String, + pub recipient: String, +} + +impl NobleForwardingAddress { + pub fn bytes(&self) -> Vec { + // Based on https://github.com/noble-assets/forwarding/blob/main/x/forwarding/types/account.go#L17 + let channel = self.channel.clone(); + let recipient = self.recipient.clone(); + let bz = format!("{channel}{recipient}").as_bytes().to_owned(); + let th = Sha256::digest("forwarding".as_bytes()); + let mut hasher = Sha256::new(); + hasher.update(th); + hasher.update(bz); + + // This constructs the account bytes for the Noble forwarding address + // Only use bytes 12 and on: + hasher.finalize()[12..].to_vec() + } +} + +impl Display for NobleForwardingAddress { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + let addr_bytes = &self.bytes(); + + write!( + f, + "{}", + bech32str::encode(&addr_bytes, "noble", bech32str::Bech32) + ) + } } impl DomainType for Address { diff --git a/crates/proto/src/gen/cosmos.app.v1alpha1.rs b/crates/proto/src/gen/cosmos.app.v1alpha1.rs new file mode 100644 index 0000000000..de74556a7a --- /dev/null +++ b/crates/proto/src/gen/cosmos.app.v1alpha1.rs @@ -0,0 +1,102 @@ +/// ModuleDescriptor describes an app module. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ModuleDescriptor { + /// go_import names the package that should be imported by an app to load the + /// module in the runtime module registry. It is required to make debugging + /// of configuration errors easier for users. + #[prost(string, tag = "1")] + pub go_import: ::prost::alloc::string::String, + /// use_package refers to a protobuf package that this module + /// uses and exposes to the world. In an app, only one module should "use" + /// or own a single protobuf package. It is assumed that the module uses + /// all of the .proto files in a single package. + #[prost(message, repeated, tag = "2")] + pub use_package: ::prost::alloc::vec::Vec, + /// can_migrate_from defines which module versions this module can migrate + /// state from. The framework will check that one module version is able to + /// migrate from a previous module version before attempting to update its + /// config. It is assumed that modules can transitively migrate from earlier + /// versions. For instance if v3 declares it can migrate from v2, and v2 + /// declares it can migrate from v1, the framework knows how to migrate + /// from v1 to v3, assuming all 3 module versions are registered at runtime. + #[prost(message, repeated, tag = "3")] + pub can_migrate_from: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ModuleDescriptor { + const NAME: &'static str = "ModuleDescriptor"; + const PACKAGE: &'static str = "cosmos.app.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + } +} +/// PackageReference is a reference to a protobuf package used by a module. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PackageReference { + /// name is the fully-qualified name of the package. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// revision is the optional revision of the package that is being used. + /// Protobuf packages used in Cosmos should generally have a major version + /// as the last part of the package name, ex. foo.bar.baz.v1. + /// The revision of a package can be thought of as the minor version of a + /// package which has additional backwards compatible definitions that weren't + /// present in a previous version. + /// + /// A package should indicate its revision with a source code comment + /// above the package declaration in one of its files containing the + /// text "Revision N" where N is an integer revision. All packages start + /// at revision 0 the first time they are released in a module. + /// + /// When a new version of a module is released and items are added to existing + /// .proto files, these definitions should contain comments of the form + /// "Since: Revision N" where N is an integer revision. + /// + /// When the module runtime starts up, it will check the pinned proto + /// image and panic if there are runtime protobuf definitions that are not + /// in the pinned descriptor which do not have + /// a "Since Revision N" comment or have a "Since Revision N" comment where + /// N is \<= to the revision specified here. This indicates that the protobuf + /// files have been updated, but the pinned file descriptor hasn't. + /// + /// If there are items in the pinned file descriptor with a revision + /// greater than the value indicated here, this will also cause a panic + /// as it may mean that the pinned descriptor for a legacy module has been + /// improperly updated or that there is some other versioning discrepancy. + /// Runtime protobuf definitions will also be checked for compatibility + /// with pinned file descriptors to make sure there are no incompatible changes. + /// + /// This behavior ensures that: + /// + /// * pinned proto images are up-to-date + /// * protobuf files are carefully annotated with revision comments which + /// are important good client UX + /// * protobuf files are changed in backwards and forwards compatible ways + #[prost(uint32, tag = "2")] + pub revision: u32, +} +impl ::prost::Name for PackageReference { + const NAME: &'static str = "PackageReference"; + const PACKAGE: &'static str = "cosmos.app.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + } +} +/// MigrateFromInfo is information on a module version that a newer module +/// can migrate from. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MigrateFromInfo { + /// module is the fully-qualified protobuf name of the module config object + /// for the previous module version, ex: "cosmos.group.module.v1.Module". + #[prost(string, tag = "1")] + pub module: ::prost::alloc::string::String, +} +impl ::prost::Name for MigrateFromInfo { + const NAME: &'static str = "MigrateFromInfo"; + const PACKAGE: &'static str = "cosmos.app.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + } +} diff --git a/crates/proto/src/gen/cosmos.auth.v1beta1.rs b/crates/proto/src/gen/cosmos.auth.v1beta1.rs new file mode 100644 index 0000000000..494ee21f5f --- /dev/null +++ b/crates/proto/src/gen/cosmos.auth.v1beta1.rs @@ -0,0 +1,83 @@ +/// BaseAccount defines a base account type. It contains all the necessary fields +/// for basic account functionality. Any custom account type should extend this +/// type for additional functionality (e.g. vesting). +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BaseAccount { + #[prost(string, tag = "1")] + pub address: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub pub_key: ::core::option::Option<::pbjson_types::Any>, + #[prost(uint64, tag = "3")] + pub account_number: u64, + #[prost(uint64, tag = "4")] + pub sequence: u64, +} +impl ::prost::Name for BaseAccount { + const NAME: &'static str = "BaseAccount"; + const PACKAGE: &'static str = "cosmos.auth.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + } +} +/// ModuleAccount defines an account for modules that holds coins on a pool. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ModuleAccount { + #[prost(message, optional, tag = "1")] + pub base_account: ::core::option::Option, + #[prost(string, tag = "2")] + pub name: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "3")] + pub permissions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for ModuleAccount { + const NAME: &'static str = "ModuleAccount"; + const PACKAGE: &'static str = "cosmos.auth.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + } +} +/// ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ModuleCredential { + /// module_name is the name of the module used for address derivation (passed into address.Module). + #[prost(string, tag = "1")] + pub module_name: ::prost::alloc::string::String, + /// derivation_keys is for deriving a module account address (passed into address.Module) + /// adding more keys creates sub-account addresses (passed into address.Derive) + #[prost(bytes = "vec", repeated, tag = "2")] + pub derivation_keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for ModuleCredential { + const NAME: &'static str = "ModuleCredential"; + const PACKAGE: &'static str = "cosmos.auth.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + } +} +/// Params defines the parameters for the auth module. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + #[prost(uint64, tag = "1")] + pub max_memo_characters: u64, + #[prost(uint64, tag = "2")] + pub tx_sig_limit: u64, + #[prost(uint64, tag = "3")] + pub tx_size_cost_per_byte: u64, + #[prost(uint64, tag = "4")] + pub sig_verify_cost_ed25519: u64, + #[prost(uint64, tag = "5")] + pub sig_verify_cost_secp256k1: u64, +} +impl ::prost::Name for Params { + const NAME: &'static str = "Params"; + const PACKAGE: &'static str = "cosmos.auth.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + } +} diff --git a/crates/proto/src/gen/cosmos.base.abci.v1beta1.rs b/crates/proto/src/gen/cosmos.base.abci.v1beta1.rs new file mode 100644 index 0000000000..574a2519a4 --- /dev/null +++ b/crates/proto/src/gen/cosmos.base.abci.v1beta1.rs @@ -0,0 +1,285 @@ +/// TxResponse defines a structure containing relevant tx data and metadata. The +/// tags are stringified and the log is JSON decoded. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxResponse { + /// The block height + #[prost(int64, tag = "1")] + pub height: i64, + /// The transaction hash. + #[prost(string, tag = "2")] + pub txhash: ::prost::alloc::string::String, + /// Namespace for the Code + #[prost(string, tag = "3")] + pub codespace: ::prost::alloc::string::String, + /// Response code. + #[prost(uint32, tag = "4")] + pub code: u32, + /// Result bytes, if any. + #[prost(string, tag = "5")] + pub data: ::prost::alloc::string::String, + /// The output of the application's logger (raw string). May be + /// non-deterministic. + #[prost(string, tag = "6")] + pub raw_log: ::prost::alloc::string::String, + /// The output of the application's logger (typed). May be non-deterministic. + #[prost(message, repeated, tag = "7")] + pub logs: ::prost::alloc::vec::Vec, + /// Additional information. May be non-deterministic. + #[prost(string, tag = "8")] + pub info: ::prost::alloc::string::String, + /// Amount of gas requested for transaction. + #[prost(int64, tag = "9")] + pub gas_wanted: i64, + /// Amount of gas consumed by transaction. + #[prost(int64, tag = "10")] + pub gas_used: i64, + /// The request transaction bytes. + #[prost(message, optional, tag = "11")] + pub tx: ::core::option::Option<::pbjson_types::Any>, + /// Time of the previous block. For heights > 1, it's the weighted median of + /// the timestamps of the valid votes in the block.LastCommit. For height == 1, + /// it's genesis time. + #[prost(string, tag = "12")] + pub timestamp: ::prost::alloc::string::String, + /// Events defines all the events emitted by processing a transaction. Note, + /// these events include those emitted by processing all the messages and those + /// emitted from the ante. Whereas Logs contains the events, with + /// additional metadata, emitted only by processing the messages. + /// + /// Since: cosmos-sdk 0.42.11, 0.44.5, 0.45 + #[prost(message, repeated, tag = "13")] + pub events: ::prost::alloc::vec::Vec< + super::super::super::super::tendermint::abci::Event, + >, +} +impl ::prost::Name for TxResponse { + const NAME: &'static str = "TxResponse"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// ABCIMessageLog defines a structure containing an indexed tx ABCI message log. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AbciMessageLog { + #[prost(uint32, tag = "1")] + pub msg_index: u32, + #[prost(string, tag = "2")] + pub log: ::prost::alloc::string::String, + /// Events contains a slice of Event objects that were emitted during some + /// execution. + #[prost(message, repeated, tag = "3")] + pub events: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for AbciMessageLog { + const NAME: &'static str = "ABCIMessageLog"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// StringEvent defines en Event object wrapper where all the attributes +/// contain key/value pairs that are strings instead of raw bytes. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StringEvent { + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub attributes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for StringEvent { + const NAME: &'static str = "StringEvent"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// Attribute defines an attribute wrapper where the key and value are +/// strings instead of raw bytes. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Attribute { + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub value: ::prost::alloc::string::String, +} +impl ::prost::Name for Attribute { + const NAME: &'static str = "Attribute"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// GasInfo defines tx execution gas context. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GasInfo { + /// GasWanted is the maximum units of work we allow this tx to perform. + #[prost(uint64, tag = "1")] + pub gas_wanted: u64, + /// GasUsed is the amount of gas actually consumed. + #[prost(uint64, tag = "2")] + pub gas_used: u64, +} +impl ::prost::Name for GasInfo { + const NAME: &'static str = "GasInfo"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// Result is the union of ResponseFormat and ResponseCheckTx. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Result { + /// Data is any data returned from message or handler execution. It MUST be + /// length prefixed in order to separate data from multiple message executions. + /// Deprecated. This field is still populated, but prefer msg_response instead + /// because it also contains the Msg response typeURL. + #[deprecated] + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// Log contains the log information from message or handler execution. + #[prost(string, tag = "2")] + pub log: ::prost::alloc::string::String, + /// Events contains a slice of Event objects that were emitted during message + /// or handler execution. + #[prost(message, repeated, tag = "3")] + pub events: ::prost::alloc::vec::Vec< + super::super::super::super::tendermint::abci::Event, + >, + /// msg_responses contains the Msg handler responses type packed in Anys. + /// + /// Since: cosmos-sdk 0.46 + #[prost(message, repeated, tag = "4")] + pub msg_responses: ::prost::alloc::vec::Vec<::pbjson_types::Any>, +} +impl ::prost::Name for Result { + const NAME: &'static str = "Result"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// SimulationResponse defines the response generated when a transaction is +/// successfully simulated. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SimulationResponse { + #[prost(message, optional, tag = "1")] + pub gas_info: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub result: ::core::option::Option, +} +impl ::prost::Name for SimulationResponse { + const NAME: &'static str = "SimulationResponse"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// MsgData defines the data returned in a Result object during message +/// execution. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgData { + #[prost(string, tag = "1")] + pub msg_type: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgData { + const NAME: &'static str = "MsgData"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// TxMsgData defines a list of MsgData. A transaction will have a MsgData object +/// for each message. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxMsgData { + /// data field is deprecated and not populated. + #[deprecated] + #[prost(message, repeated, tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// msg_responses contains the Msg handler responses packed into Anys. + /// + /// Since: cosmos-sdk 0.46 + #[prost(message, repeated, tag = "2")] + pub msg_responses: ::prost::alloc::vec::Vec<::pbjson_types::Any>, +} +impl ::prost::Name for TxMsgData { + const NAME: &'static str = "TxMsgData"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// SearchTxsResult defines a structure for querying txs pageable +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SearchTxsResult { + /// Count of all txs + #[prost(uint64, tag = "1")] + pub total_count: u64, + /// Count of txs in current page + #[prost(uint64, tag = "2")] + pub count: u64, + /// Index of current page, start from 1 + #[prost(uint64, tag = "3")] + pub page_number: u64, + /// Count of total pages + #[prost(uint64, tag = "4")] + pub page_total: u64, + /// Max count txs per page + #[prost(uint64, tag = "5")] + pub limit: u64, + /// List of txs in current page + #[prost(message, repeated, tag = "6")] + pub txs: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SearchTxsResult { + const NAME: &'static str = "SearchTxsResult"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} +/// SearchBlocksResult defines a structure for querying blocks pageable +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SearchBlocksResult { + /// Count of all blocks + #[prost(int64, tag = "1")] + pub total_count: i64, + /// Count of blocks in current page + #[prost(int64, tag = "2")] + pub count: i64, + /// Index of current page, start from 1 + #[prost(int64, tag = "3")] + pub page_number: i64, + /// Count of total pages + #[prost(int64, tag = "4")] + pub page_total: i64, + /// Max count blocks per page + #[prost(int64, tag = "5")] + pub limit: i64, + /// List of blocks in current page + #[prost(message, repeated, tag = "6")] + pub blocks: ::prost::alloc::vec::Vec< + super::super::super::super::tendermint::types::Block, + >, +} +impl ::prost::Name for SearchBlocksResult { + const NAME: &'static str = "SearchBlocksResult"; + const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + } +} diff --git a/crates/proto/src/gen/cosmos.crypto.multisig.v1beta1.rs b/crates/proto/src/gen/cosmos.crypto.multisig.v1beta1.rs new file mode 100644 index 0000000000..1d784f6978 --- /dev/null +++ b/crates/proto/src/gen/cosmos.crypto.multisig.v1beta1.rs @@ -0,0 +1,35 @@ +/// MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey. +/// See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers +/// signed and with which modes. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MultiSignature { + #[prost(bytes = "vec", repeated, tag = "1")] + pub signatures: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for MultiSignature { + const NAME: &'static str = "MultiSignature"; + const PACKAGE: &'static str = "cosmos.crypto.multisig.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.crypto.multisig.v1beta1.{}", Self::NAME) + } +} +/// CompactBitArray is an implementation of a space efficient bit array. +/// This is used to ensure that the encoded data takes up a minimal amount of +/// space after proto encoding. +/// This is not thread safe, and is not intended for concurrent usage. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CompactBitArray { + #[prost(uint32, tag = "1")] + pub extra_bits_stored: u32, + #[prost(bytes = "vec", tag = "2")] + pub elems: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for CompactBitArray { + const NAME: &'static str = "CompactBitArray"; + const PACKAGE: &'static str = "cosmos.crypto.multisig.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.crypto.multisig.v1beta1.{}", Self::NAME) + } +} diff --git a/crates/proto/src/gen/cosmos.tx.config.v1.rs b/crates/proto/src/gen/cosmos.tx.config.v1.rs new file mode 100644 index 0000000000..b79ab2e0fd --- /dev/null +++ b/crates/proto/src/gen/cosmos.tx.config.v1.rs @@ -0,0 +1,20 @@ +/// Config is the config object of the x/auth/tx package. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Config { + /// skip_ante_handler defines whether the ante handler registration should be skipped in case an app wants to override + /// this functionality. + #[prost(bool, tag = "1")] + pub skip_ante_handler: bool, + /// skip_post_handler defines whether the post handler registration should be skipped in case an app wants to override + /// this functionality. + #[prost(bool, tag = "2")] + pub skip_post_handler: bool, +} +impl ::prost::Name for Config { + const NAME: &'static str = "Config"; + const PACKAGE: &'static str = "cosmos.tx.config.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.config.v1.{}", Self::NAME) + } +} diff --git a/crates/proto/src/gen/cosmos.tx.signing.v1beta1.rs b/crates/proto/src/gen/cosmos.tx.signing.v1beta1.rs new file mode 100644 index 0000000000..c5b8f2f52f --- /dev/null +++ b/crates/proto/src/gen/cosmos.tx.signing.v1beta1.rs @@ -0,0 +1,189 @@ +/// SignatureDescriptors wraps multiple SignatureDescriptor's. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignatureDescriptors { + /// signatures are the signature descriptors + #[prost(message, repeated, tag = "1")] + pub signatures: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SignatureDescriptors { + const NAME: &'static str = "SignatureDescriptors"; + const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.signing.v1beta1.{}", Self::NAME) + } +} +/// SignatureDescriptor is a convenience type which represents the full data for +/// a signature including the public key of the signer, signing modes and the +/// signature itself. It is primarily used for coordinating signatures between +/// clients. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignatureDescriptor { + /// public_key is the public key of the signer + #[prost(message, optional, tag = "1")] + pub public_key: ::core::option::Option<::pbjson_types::Any>, + #[prost(message, optional, tag = "2")] + pub data: ::core::option::Option, + /// sequence is the sequence of the account, which describes the + /// number of committed transactions signed by a given address. It is used to prevent + /// replay attacks. + #[prost(uint64, tag = "3")] + pub sequence: u64, +} +/// Nested message and enum types in `SignatureDescriptor`. +pub mod signature_descriptor { + /// Data represents signature data + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Data { + /// sum is the oneof that specifies whether this represents single or multi-signature data + #[prost(oneof = "data::Sum", tags = "1, 2")] + pub sum: ::core::option::Option, + } + /// Nested message and enum types in `Data`. + pub mod data { + /// Single is the signature data for a single signer + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Single { + /// mode is the signing mode of the single signer + #[prost(enumeration = "super::super::SignMode", tag = "1")] + pub mode: i32, + /// signature is the raw signature bytes + #[prost(bytes = "vec", tag = "2")] + pub signature: ::prost::alloc::vec::Vec, + } + impl ::prost::Name for Single { + const NAME: &'static str = "Single"; + const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.{}", Self::NAME + ) + } + } + /// Multi is the signature data for a multisig public key + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Multi { + /// bitarray specifies which keys within the multisig are signing + #[prost(message, optional, tag = "1")] + pub bitarray: ::core::option::Option< + super::super::super::super::super::crypto::multisig::v1beta1::CompactBitArray, + >, + /// signatures is the signatures of the multi-signature + #[prost(message, repeated, tag = "2")] + pub signatures: ::prost::alloc::vec::Vec, + } + impl ::prost::Name for Multi { + const NAME: &'static str = "Multi"; + const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.{}", Self::NAME + ) + } + } + /// sum is the oneof that specifies whether this represents single or multi-signature data + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Sum { + /// single represents a single signer + #[prost(message, tag = "1")] + Single(Single), + /// multi represents a multisig signer + #[prost(message, tag = "2")] + Multi(Multi), + } + } + impl ::prost::Name for Data { + const NAME: &'static str = "Data"; + const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "cosmos.tx.signing.v1beta1.SignatureDescriptor.{}", Self::NAME + ) + } + } +} +impl ::prost::Name for SignatureDescriptor { + const NAME: &'static str = "SignatureDescriptor"; + const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.signing.v1beta1.{}", Self::NAME) + } +} +/// SignMode represents a signing mode with its own security guarantees. +/// +/// This enum should be considered a registry of all known sign modes +/// in the Cosmos ecosystem. Apps are not expected to support all known +/// sign modes. Apps that would like to support custom sign modes are +/// encouraged to open a small PR against this file to add a new case +/// to this SignMode enum describing their sign mode so that different +/// apps have a consistent version of this enum. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SignMode { + /// SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be + /// rejected. + Unspecified = 0, + /// SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is + /// verified with raw bytes from Tx. + Direct = 1, + /// SIGN_MODE_TEXTUAL is a future signing mode that will verify some + /// human-readable textual representation on top of the binary representation + /// from SIGN_MODE_DIRECT. It is currently experimental, and should be used + /// for testing purposes only, until Textual is fully released. Please follow + /// the tracking issue + Textual = 2, + /// SIGN_MODE_DIRECT_AUX specifies a signing mode which uses + /// SignDocDirectAux. As opposed to SIGN_MODE_DIRECT, this sign mode does not + /// require signers signing over other signers' `signer_info`. It also allows + /// for adding Tips in transactions. + /// + /// Since: cosmos-sdk 0.46 + DirectAux = 3, + /// SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses + /// Amino JSON and will be removed in the future. + LegacyAminoJson = 127, + /// SIGN_MODE_EIP_191 specifies the sign mode for EIP 191 signing on the Cosmos + /// SDK. Ref: + /// + /// Currently, SIGN_MODE_EIP_191 is registered as a SignMode enum variant, + /// but is not implemented on the SDK by default. To enable EIP-191, you need + /// to pass a custom `TxConfig` that has an implementation of + /// `SignModeHandler` for EIP-191. The SDK may decide to fully support + /// EIP-191 in the future. + /// + /// Since: cosmos-sdk 0.45.2 + Eip191 = 191, +} +impl SignMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SignMode::Unspecified => "SIGN_MODE_UNSPECIFIED", + SignMode::Direct => "SIGN_MODE_DIRECT", + SignMode::Textual => "SIGN_MODE_TEXTUAL", + SignMode::DirectAux => "SIGN_MODE_DIRECT_AUX", + SignMode::LegacyAminoJson => "SIGN_MODE_LEGACY_AMINO_JSON", + SignMode::Eip191 => "SIGN_MODE_EIP_191", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SIGN_MODE_UNSPECIFIED" => Some(Self::Unspecified), + "SIGN_MODE_DIRECT" => Some(Self::Direct), + "SIGN_MODE_TEXTUAL" => Some(Self::Textual), + "SIGN_MODE_DIRECT_AUX" => Some(Self::DirectAux), + "SIGN_MODE_LEGACY_AMINO_JSON" => Some(Self::LegacyAminoJson), + "SIGN_MODE_EIP_191" => Some(Self::Eip191), + _ => None, + } + } +} diff --git a/crates/proto/src/gen/cosmos.tx.v1beta1.rs b/crates/proto/src/gen/cosmos.tx.v1beta1.rs new file mode 100644 index 0000000000..8aeb187cda --- /dev/null +++ b/crates/proto/src/gen/cosmos.tx.v1beta1.rs @@ -0,0 +1,1774 @@ +/// Tx is the standard type used for broadcasting transactions. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Tx { + /// body is the processable content of the transaction + #[prost(message, optional, tag = "1")] + pub body: ::core::option::Option, + /// auth_info is the authorization related content of the transaction, + /// specifically signers, signer modes and fee + #[prost(message, optional, tag = "2")] + pub auth_info: ::core::option::Option, + /// signatures is a list of signatures that matches the length and order of + /// AuthInfo's signer_infos to allow connecting signature meta information like + /// public key and signing mode by position. + #[prost(bytes = "vec", repeated, tag = "3")] + pub signatures: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for Tx { + const NAME: &'static str = "Tx"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxRaw is a variant of Tx that pins the signer's exact binary representation +/// of body and auth_info. This is used for signing, broadcasting and +/// verification. The binary `serialize(tx: TxRaw)` is stored in Tendermint and +/// the hash `sha256(serialize(tx: TxRaw))` becomes the "txhash", commonly used +/// as the transaction ID. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxRaw { + /// body_bytes is a protobuf serialization of a TxBody that matches the + /// representation in SignDoc. + #[prost(bytes = "vec", tag = "1")] + pub body_bytes: ::prost::alloc::vec::Vec, + /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the + /// representation in SignDoc. + #[prost(bytes = "vec", tag = "2")] + pub auth_info_bytes: ::prost::alloc::vec::Vec, + /// signatures is a list of signatures that matches the length and order of + /// AuthInfo's signer_infos to allow connecting signature meta information like + /// public key and signing mode by position. + #[prost(bytes = "vec", repeated, tag = "3")] + pub signatures: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for TxRaw { + const NAME: &'static str = "TxRaw"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// SignDoc is the type used for generating sign bytes for SIGN_MODE_DIRECT. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignDoc { + /// body_bytes is protobuf serialization of a TxBody that matches the + /// representation in TxRaw. + #[prost(bytes = "vec", tag = "1")] + pub body_bytes: ::prost::alloc::vec::Vec, + /// auth_info_bytes is a protobuf serialization of an AuthInfo that matches the + /// representation in TxRaw. + #[prost(bytes = "vec", tag = "2")] + pub auth_info_bytes: ::prost::alloc::vec::Vec, + /// chain_id is the unique identifier of the chain this transaction targets. + /// It prevents signed transactions from being used on another chain by an + /// attacker + #[prost(string, tag = "3")] + pub chain_id: ::prost::alloc::string::String, + /// account_number is the account number of the account in state + #[prost(uint64, tag = "4")] + pub account_number: u64, +} +impl ::prost::Name for SignDoc { + const NAME: &'static str = "SignDoc"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// SignDocDirectAux is the type used for generating sign bytes for +/// SIGN_MODE_DIRECT_AUX. +/// +/// Since: cosmos-sdk 0.46 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignDocDirectAux { + /// body_bytes is protobuf serialization of a TxBody that matches the + /// representation in TxRaw. + #[prost(bytes = "vec", tag = "1")] + pub body_bytes: ::prost::alloc::vec::Vec, + /// public_key is the public key of the signing account. + #[prost(message, optional, tag = "2")] + pub public_key: ::core::option::Option<::pbjson_types::Any>, + /// chain_id is the identifier of the chain this transaction targets. + /// It prevents signed transactions from being used on another chain by an + /// attacker. + #[prost(string, tag = "3")] + pub chain_id: ::prost::alloc::string::String, + /// account_number is the account number of the account in state. + #[prost(uint64, tag = "4")] + pub account_number: u64, + /// sequence is the sequence number of the signing account. + #[prost(uint64, tag = "5")] + pub sequence: u64, + /// Tip is the optional tip used for transactions fees paid in another denom. + /// It should be left empty if the signer is not the tipper for this + /// transaction. + /// + /// This field is ignored if the chain didn't enable tips, i.e. didn't add the + /// `TipDecorator` in its posthandler. + #[prost(message, optional, tag = "6")] + pub tip: ::core::option::Option, +} +impl ::prost::Name for SignDocDirectAux { + const NAME: &'static str = "SignDocDirectAux"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxBody is the body of a transaction that all signers sign over. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxBody { + /// messages is a list of messages to be executed. The required signers of + /// those messages define the number and order of elements in AuthInfo's + /// signer_infos and Tx's signatures. Each required signer address is added to + /// the list only the first time it occurs. + /// By convention, the first required signer (usually from the first message) + /// is referred to as the primary signer and pays the fee for the whole + /// transaction. + #[prost(message, repeated, tag = "1")] + pub messages: ::prost::alloc::vec::Vec<::pbjson_types::Any>, + /// memo is any arbitrary note/comment to be added to the transaction. + /// WARNING: in clients, any publicly exposed text should not be called memo, + /// but should be called `note` instead (see ). + #[prost(string, tag = "2")] + pub memo: ::prost::alloc::string::String, + /// timeout is the block height after which this transaction will not + /// be processed by the chain + #[prost(uint64, tag = "3")] + pub timeout_height: u64, + /// extension_options are arbitrary options that can be added by chains + /// when the default options are not sufficient. If any of these are present + /// and can't be handled, the transaction will be rejected + #[prost(message, repeated, tag = "1023")] + pub extension_options: ::prost::alloc::vec::Vec<::pbjson_types::Any>, + /// extension_options are arbitrary options that can be added by chains + /// when the default options are not sufficient. If any of these are present + /// and can't be handled, they will be ignored + #[prost(message, repeated, tag = "2047")] + pub non_critical_extension_options: ::prost::alloc::vec::Vec<::pbjson_types::Any>, +} +impl ::prost::Name for TxBody { + const NAME: &'static str = "TxBody"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// AuthInfo describes the fee and signer modes that are used to sign a +/// transaction. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AuthInfo { + /// signer_infos defines the signing modes for the required signers. The number + /// and order of elements must match the required signers from TxBody's + /// messages. The first element is the primary signer and the one which pays + /// the fee. + #[prost(message, repeated, tag = "1")] + pub signer_infos: ::prost::alloc::vec::Vec, + /// Fee is the fee and gas limit for the transaction. The first signer is the + /// primary signer and the one which pays the fee. The fee can be calculated + /// based on the cost of evaluating the body and doing signature verification + /// of the signers. This can be estimated via simulation. + #[prost(message, optional, tag = "2")] + pub fee: ::core::option::Option, + /// Tip is the optional tip used for transactions fees paid in another denom. + /// + /// This field is ignored if the chain didn't enable tips, i.e. didn't add the + /// `TipDecorator` in its posthandler. + /// + /// Since: cosmos-sdk 0.46 + #[prost(message, optional, tag = "3")] + pub tip: ::core::option::Option, +} +impl ::prost::Name for AuthInfo { + const NAME: &'static str = "AuthInfo"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// SignerInfo describes the public key and signing mode of a single top-level +/// signer. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignerInfo { + /// public_key is the public key of the signer. It is optional for accounts + /// that already exist in state. If unset, the verifier can use the required + /// signer address for this position and lookup the public key. + #[prost(message, optional, tag = "1")] + pub public_key: ::core::option::Option<::pbjson_types::Any>, + /// mode_info describes the signing mode of the signer and is a nested + /// structure to support nested multisig pubkey's + #[prost(message, optional, tag = "2")] + pub mode_info: ::core::option::Option, + /// sequence is the sequence of the account, which describes the + /// number of committed transactions signed by a given address. It is used to + /// prevent replay attacks. + #[prost(uint64, tag = "3")] + pub sequence: u64, +} +impl ::prost::Name for SignerInfo { + const NAME: &'static str = "SignerInfo"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// ModeInfo describes the signing mode of a single or nested multisig signer. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ModeInfo { + /// sum is the oneof that specifies whether this represents a single or nested + /// multisig signer + #[prost(oneof = "mode_info::Sum", tags = "1, 2")] + pub sum: ::core::option::Option, +} +/// Nested message and enum types in `ModeInfo`. +pub mod mode_info { + /// Single is the mode info for a single signer. It is structured as a message + /// to allow for additional fields such as locale for SIGN_MODE_TEXTUAL in the + /// future + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Single { + /// mode is the signing mode of the single signer + #[prost(enumeration = "super::super::signing::v1beta1::SignMode", tag = "1")] + pub mode: i32, + } + impl ::prost::Name for Single { + const NAME: &'static str = "Single"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.ModeInfo.{}", Self::NAME) + } + } + /// Multi is the mode info for a multisig public key + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Multi { + /// bitarray specifies which keys within the multisig are signing + #[prost(message, optional, tag = "1")] + pub bitarray: ::core::option::Option< + super::super::super::crypto::multisig::v1beta1::CompactBitArray, + >, + /// mode_infos is the corresponding modes of the signers of the multisig + /// which could include nested multisig public keys + #[prost(message, repeated, tag = "2")] + pub mode_infos: ::prost::alloc::vec::Vec, + } + impl ::prost::Name for Multi { + const NAME: &'static str = "Multi"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.ModeInfo.{}", Self::NAME) + } + } + /// sum is the oneof that specifies whether this represents a single or nested + /// multisig signer + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Sum { + /// single represents a single signer + #[prost(message, tag = "1")] + Single(Single), + /// multi represents a nested multisig signer + #[prost(message, tag = "2")] + Multi(Multi), + } +} +impl ::prost::Name for ModeInfo { + const NAME: &'static str = "ModeInfo"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// Fee includes the amount of coins paid in fees and the maximum +/// gas to be used by the transaction. The ratio yields an effective "gasprice", +/// which must be above some miminum to be accepted into the mempool. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fee { + /// amount is the amount of coins to be paid as a fee + #[prost(message, repeated, tag = "1")] + pub amount: ::prost::alloc::vec::Vec, + /// gas_limit is the maximum gas that can be used in transaction processing + /// before an out of gas error occurs + #[prost(uint64, tag = "2")] + pub gas_limit: u64, + /// if unset, the first signer is responsible for paying the fees. If set, the specified account must pay the fees. + /// the payer must be a tx signer (and thus have signed this field in AuthInfo). + /// setting this field does *not* change the ordering of required signers for the transaction. + #[prost(string, tag = "3")] + pub payer: ::prost::alloc::string::String, + /// if set, the fee payer (either the first signer or the value of the payer field) requests that a fee grant be used + /// to pay fees instead of the fee payer's own balance. If an appropriate fee grant does not exist or the chain does + /// not support fee grants, this will fail + #[prost(string, tag = "4")] + pub granter: ::prost::alloc::string::String, +} +impl ::prost::Name for Fee { + const NAME: &'static str = "Fee"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// Tip is the tip used for meta-transactions. +/// +/// Since: cosmos-sdk 0.46 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Tip { + /// amount is the amount of the tip + #[prost(message, repeated, tag = "1")] + pub amount: ::prost::alloc::vec::Vec, + /// tipper is the address of the account paying for the tip + #[prost(string, tag = "2")] + pub tipper: ::prost::alloc::string::String, +} +impl ::prost::Name for Tip { + const NAME: &'static str = "Tip"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// AuxSignerData is the intermediary format that an auxiliary signer (e.g. a +/// tipper) builds and sends to the fee payer (who will build and broadcast the +/// actual tx). AuxSignerData is not a valid tx in itself, and will be rejected +/// by the node if sent directly as-is. +/// +/// Since: cosmos-sdk 0.46 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AuxSignerData { + /// address is the bech32-encoded address of the auxiliary signer. If using + /// AuxSignerData across different chains, the bech32 prefix of the target + /// chain (where the final transaction is broadcasted) should be used. + #[prost(string, tag = "1")] + pub address: ::prost::alloc::string::String, + /// sign_doc is the SIGN_MODE_DIRECT_AUX sign doc that the auxiliary signer + /// signs. Note: we use the same sign doc even if we're signing with + /// LEGACY_AMINO_JSON. + #[prost(message, optional, tag = "2")] + pub sign_doc: ::core::option::Option, + /// mode is the signing mode of the single signer. + #[prost(enumeration = "super::signing::v1beta1::SignMode", tag = "3")] + pub mode: i32, + /// sig is the signature of the sign doc. + #[prost(bytes = "vec", tag = "4")] + pub sig: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for AuxSignerData { + const NAME: &'static str = "AuxSignerData"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetTxsEventRequest is the request type for the Service.TxsByEvents +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTxsEventRequest { + /// events is the list of transaction event type. + /// Deprecated post v0.47.x: use query instead, which should contain a valid + /// events query. + #[deprecated] + #[prost(string, repeated, tag = "1")] + pub events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// pagination defines a pagination for the request. + /// Deprecated post v0.46.x: use page and limit instead. + #[deprecated] + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option< + super::super::base::query::v1beta1::PageRequest, + >, + #[prost(enumeration = "OrderBy", tag = "3")] + pub order_by: i32, + /// page is the page number to query, starts at 1. If not provided, will + /// default to first page. + #[prost(uint64, tag = "4")] + pub page: u64, + /// limit is the total number of results to be returned in the result page. + /// If left empty it will default to a value to be set by each app. + #[prost(uint64, tag = "5")] + pub limit: u64, + /// query defines the transaction event query that is proxied to Tendermint's + /// TxSearch RPC method. The query must be valid. + /// + /// Since Cosmos SDK 0.48 + #[prost(string, tag = "6")] + pub query: ::prost::alloc::string::String, +} +impl ::prost::Name for GetTxsEventRequest { + const NAME: &'static str = "GetTxsEventRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetTxsEventResponse is the response type for the Service.TxsByEvents +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTxsEventResponse { + /// txs is the list of queried transactions. + #[prost(message, repeated, tag = "1")] + pub txs: ::prost::alloc::vec::Vec, + /// tx_responses is the list of queried TxResponses. + #[prost(message, repeated, tag = "2")] + pub tx_responses: ::prost::alloc::vec::Vec< + super::super::base::abci::v1beta1::TxResponse, + >, + /// pagination defines a pagination for the response. + /// Deprecated post v0.46.x: use total instead. + #[deprecated] + #[prost(message, optional, tag = "3")] + pub pagination: ::core::option::Option< + super::super::base::query::v1beta1::PageResponse, + >, + /// total is total number of results available + #[prost(uint64, tag = "4")] + pub total: u64, +} +impl ::prost::Name for GetTxsEventResponse { + const NAME: &'static str = "GetTxsEventResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// BroadcastTxRequest is the request type for the Service.BroadcastTxRequest +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BroadcastTxRequest { + /// tx_bytes is the raw transaction. + #[prost(bytes = "vec", tag = "1")] + pub tx_bytes: ::prost::alloc::vec::Vec, + #[prost(enumeration = "BroadcastMode", tag = "2")] + pub mode: i32, +} +impl ::prost::Name for BroadcastTxRequest { + const NAME: &'static str = "BroadcastTxRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// BroadcastTxResponse is the response type for the +/// Service.BroadcastTx method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BroadcastTxResponse { + /// tx_response is the queried TxResponses. + #[prost(message, optional, tag = "1")] + pub tx_response: ::core::option::Option< + super::super::base::abci::v1beta1::TxResponse, + >, +} +impl ::prost::Name for BroadcastTxResponse { + const NAME: &'static str = "BroadcastTxResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// SimulateRequest is the request type for the Service.Simulate +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SimulateRequest { + /// tx is the transaction to simulate. + /// Deprecated. Send raw tx bytes instead. + #[deprecated] + #[prost(message, optional, tag = "1")] + pub tx: ::core::option::Option, + /// tx_bytes is the raw transaction. + /// + /// Since: cosmos-sdk 0.43 + #[prost(bytes = "vec", tag = "2")] + pub tx_bytes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SimulateRequest { + const NAME: &'static str = "SimulateRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// SimulateResponse is the response type for the +/// Service.SimulateRPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SimulateResponse { + /// gas_info is the information about gas used in the simulation. + #[prost(message, optional, tag = "1")] + pub gas_info: ::core::option::Option, + /// result is the result of the simulation. + #[prost(message, optional, tag = "2")] + pub result: ::core::option::Option, +} +impl ::prost::Name for SimulateResponse { + const NAME: &'static str = "SimulateResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetTxRequest is the request type for the Service.GetTx +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTxRequest { + /// hash is the tx hash to query, encoded as a hex string. + #[prost(string, tag = "1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for GetTxRequest { + const NAME: &'static str = "GetTxRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetTxResponse is the response type for the Service.GetTx method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetTxResponse { + /// tx is the queried transaction. + #[prost(message, optional, tag = "1")] + pub tx: ::core::option::Option, + /// tx_response is the queried TxResponses. + #[prost(message, optional, tag = "2")] + pub tx_response: ::core::option::Option< + super::super::base::abci::v1beta1::TxResponse, + >, +} +impl ::prost::Name for GetTxResponse { + const NAME: &'static str = "GetTxResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetBlockWithTxsRequest is the request type for the Service.GetBlockWithTxs +/// RPC method. +/// +/// Since: cosmos-sdk 0.45.2 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBlockWithTxsRequest { + /// height is the height of the block to query. + #[prost(int64, tag = "1")] + pub height: i64, + /// pagination defines a pagination for the request. + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option< + super::super::base::query::v1beta1::PageRequest, + >, +} +impl ::prost::Name for GetBlockWithTxsRequest { + const NAME: &'static str = "GetBlockWithTxsRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// GetBlockWithTxsResponse is the response type for the Service.GetBlockWithTxs +/// method. +/// +/// Since: cosmos-sdk 0.45.2 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBlockWithTxsResponse { + /// txs are the transactions in the block. + #[prost(message, repeated, tag = "1")] + pub txs: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub block_id: ::core::option::Option< + super::super::super::tendermint::types::BlockId, + >, + #[prost(message, optional, tag = "3")] + pub block: ::core::option::Option, + /// pagination defines a pagination for the response. + #[prost(message, optional, tag = "4")] + pub pagination: ::core::option::Option< + super::super::base::query::v1beta1::PageResponse, + >, +} +impl ::prost::Name for GetBlockWithTxsResponse { + const NAME: &'static str = "GetBlockWithTxsResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxDecodeRequest is the request type for the Service.TxDecode +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxDecodeRequest { + /// tx_bytes is the raw transaction. + #[prost(bytes = "vec", tag = "1")] + pub tx_bytes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for TxDecodeRequest { + const NAME: &'static str = "TxDecodeRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxDecodeResponse is the response type for the +/// Service.TxDecode method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxDecodeResponse { + /// tx is the decoded transaction. + #[prost(message, optional, tag = "1")] + pub tx: ::core::option::Option, +} +impl ::prost::Name for TxDecodeResponse { + const NAME: &'static str = "TxDecodeResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxEncodeRequest is the request type for the Service.TxEncode +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxEncodeRequest { + /// tx is the transaction to encode. + #[prost(message, optional, tag = "1")] + pub tx: ::core::option::Option, +} +impl ::prost::Name for TxEncodeRequest { + const NAME: &'static str = "TxEncodeRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxEncodeResponse is the response type for the +/// Service.TxEncode method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxEncodeResponse { + /// tx_bytes is the encoded transaction bytes. + #[prost(bytes = "vec", tag = "1")] + pub tx_bytes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for TxEncodeResponse { + const NAME: &'static str = "TxEncodeResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxEncodeAminoRequest is the request type for the Service.TxEncodeAmino +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxEncodeAminoRequest { + #[prost(string, tag = "1")] + pub amino_json: ::prost::alloc::string::String, +} +impl ::prost::Name for TxEncodeAminoRequest { + const NAME: &'static str = "TxEncodeAminoRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxEncodeAminoResponse is the response type for the Service.TxEncodeAmino +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxEncodeAminoResponse { + #[prost(bytes = "vec", tag = "1")] + pub amino_binary: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for TxEncodeAminoResponse { + const NAME: &'static str = "TxEncodeAminoResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxDecodeAminoRequest is the request type for the Service.TxDecodeAmino +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxDecodeAminoRequest { + #[prost(bytes = "vec", tag = "1")] + pub amino_binary: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for TxDecodeAminoRequest { + const NAME: &'static str = "TxDecodeAminoRequest"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// TxDecodeAminoResponse is the response type for the Service.TxDecodeAmino +/// RPC method. +/// +/// Since: cosmos-sdk 0.47 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxDecodeAminoResponse { + #[prost(string, tag = "1")] + pub amino_json: ::prost::alloc::string::String, +} +impl ::prost::Name for TxDecodeAminoResponse { + const NAME: &'static str = "TxDecodeAminoResponse"; + const PACKAGE: &'static str = "cosmos.tx.v1beta1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + } +} +/// OrderBy defines the sorting order +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum OrderBy { + /// ORDER_BY_UNSPECIFIED specifies an unknown sorting order. OrderBy defaults + /// to ASC in this case. + Unspecified = 0, + /// ORDER_BY_ASC defines ascending order + Asc = 1, + /// ORDER_BY_DESC defines descending order + Desc = 2, +} +impl OrderBy { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OrderBy::Unspecified => "ORDER_BY_UNSPECIFIED", + OrderBy::Asc => "ORDER_BY_ASC", + OrderBy::Desc => "ORDER_BY_DESC", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ORDER_BY_UNSPECIFIED" => Some(Self::Unspecified), + "ORDER_BY_ASC" => Some(Self::Asc), + "ORDER_BY_DESC" => Some(Self::Desc), + _ => None, + } + } +} +/// BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC +/// method. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum BroadcastMode { + /// zero-value for mode ordering + Unspecified = 0, + /// DEPRECATED: use BROADCAST_MODE_SYNC instead, + /// BROADCAST_MODE_BLOCK is not supported by the SDK from v0.47.x onwards. + Block = 1, + /// BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits + /// for a CheckTx execution response only. + Sync = 2, + /// BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client + /// returns immediately. + Async = 3, +} +impl BroadcastMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + BroadcastMode::Unspecified => "BROADCAST_MODE_UNSPECIFIED", + BroadcastMode::Block => "BROADCAST_MODE_BLOCK", + BroadcastMode::Sync => "BROADCAST_MODE_SYNC", + BroadcastMode::Async => "BROADCAST_MODE_ASYNC", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "BROADCAST_MODE_UNSPECIFIED" => Some(Self::Unspecified), + "BROADCAST_MODE_BLOCK" => Some(Self::Block), + "BROADCAST_MODE_SYNC" => Some(Self::Sync), + "BROADCAST_MODE_ASYNC" => Some(Self::Async), + _ => None, + } + } +} +/// Generated client implementations. +#[cfg(feature = "rpc")] +pub mod service_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Service defines a gRPC service for interacting with transactions. + #[derive(Debug, Clone)] + pub struct ServiceClient { + inner: tonic::client::Grpc, + } + impl ServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl ServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + 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( + inner: T, + interceptor: F, + ) -> ServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + ServiceClient::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 + } + /// Simulate simulates executing a transaction for estimating gas usage. + pub async fn simulate( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/Simulate", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "Simulate")); + self.inner.unary(req, path, codec).await + } + /// GetTx fetches a tx by hash. + pub async fn get_tx( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/GetTx", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "GetTx")); + self.inner.unary(req, path, codec).await + } + /// BroadcastTx broadcast transaction. + pub async fn broadcast_tx( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/BroadcastTx", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "BroadcastTx")); + self.inner.unary(req, path, codec).await + } + /// GetTxsEvent fetches txs by event. + pub async fn get_txs_event( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/GetTxsEvent", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "GetTxsEvent")); + self.inner.unary(req, path, codec).await + } + /// GetBlockWithTxs fetches a block with decoded txs. + /// + /// Since: cosmos-sdk 0.45.2 + pub async fn get_block_with_txs( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/GetBlockWithTxs", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "GetBlockWithTxs")); + self.inner.unary(req, path, codec).await + } + /// TxDecode decodes the transaction. + /// + /// Since: cosmos-sdk 0.47 + pub async fn tx_decode( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/TxDecode", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxDecode")); + self.inner.unary(req, path, codec).await + } + /// TxEncode encodes the transaction. + /// + /// Since: cosmos-sdk 0.47 + pub async fn tx_encode( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/TxEncode", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxEncode")); + self.inner.unary(req, path, codec).await + } + /// TxEncodeAmino encodes an Amino transaction from JSON to encoded bytes. + /// + /// Since: cosmos-sdk 0.47 + pub async fn tx_encode_amino( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/TxEncodeAmino", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxEncodeAmino")); + self.inner.unary(req, path, codec).await + } + /// TxDecodeAmino decodes an Amino transaction from encoded bytes to JSON. + /// + /// Since: cosmos-sdk 0.47 + pub async fn tx_decode_amino( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/cosmos.tx.v1beta1.Service/TxDecodeAmino", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxDecodeAmino")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "rpc")] +pub mod service_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ServiceServer. + #[async_trait] + pub trait Service: Send + Sync + 'static { + /// Simulate simulates executing a transaction for estimating gas usage. + async fn simulate( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// GetTx fetches a tx by hash. + async fn get_tx( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// BroadcastTx broadcast transaction. + async fn broadcast_tx( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// GetTxsEvent fetches txs by event. + async fn get_txs_event( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// GetBlockWithTxs fetches a block with decoded txs. + /// + /// Since: cosmos-sdk 0.45.2 + async fn get_block_with_txs( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TxDecode decodes the transaction. + /// + /// Since: cosmos-sdk 0.47 + async fn tx_decode( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TxEncode encodes the transaction. + /// + /// Since: cosmos-sdk 0.47 + async fn tx_encode( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TxEncodeAmino encodes an Amino transaction from JSON to encoded bytes. + /// + /// Since: cosmos-sdk 0.47 + async fn tx_encode_amino( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TxDecodeAmino decodes an Amino transaction from encoded bytes to JSON. + /// + /// Since: cosmos-sdk 0.47 + async fn tx_decode_amino( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// Service defines a gRPC service for interacting with transactions. + #[derive(Debug)] + pub struct ServiceServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl ServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for ServiceServer + where + T: Service, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/cosmos.tx.v1beta1.Service/Simulate" => { + #[allow(non_camel_case_types)] + struct SimulateSvc(pub Arc); + impl tonic::server::UnaryService + for SimulateSvc { + type Response = super::SimulateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::simulate(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SimulateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/GetTx" => { + #[allow(non_camel_case_types)] + struct GetTxSvc(pub Arc); + impl tonic::server::UnaryService + for GetTxSvc { + type Response = super::GetTxResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_tx(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetTxSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/BroadcastTx" => { + #[allow(non_camel_case_types)] + struct BroadcastTxSvc(pub Arc); + impl< + T: Service, + > tonic::server::UnaryService + for BroadcastTxSvc { + type Response = super::BroadcastTxResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::broadcast_tx(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = BroadcastTxSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/GetTxsEvent" => { + #[allow(non_camel_case_types)] + struct GetTxsEventSvc(pub Arc); + impl< + T: Service, + > tonic::server::UnaryService + for GetTxsEventSvc { + type Response = super::GetTxsEventResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_txs_event(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetTxsEventSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/GetBlockWithTxs" => { + #[allow(non_camel_case_types)] + struct GetBlockWithTxsSvc(pub Arc); + impl< + T: Service, + > tonic::server::UnaryService + for GetBlockWithTxsSvc { + type Response = super::GetBlockWithTxsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_block_with_txs(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetBlockWithTxsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/TxDecode" => { + #[allow(non_camel_case_types)] + struct TxDecodeSvc(pub Arc); + impl tonic::server::UnaryService + for TxDecodeSvc { + type Response = super::TxDecodeResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tx_decode(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TxDecodeSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/TxEncode" => { + #[allow(non_camel_case_types)] + struct TxEncodeSvc(pub Arc); + impl tonic::server::UnaryService + for TxEncodeSvc { + type Response = super::TxEncodeResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tx_encode(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TxEncodeSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/TxEncodeAmino" => { + #[allow(non_camel_case_types)] + struct TxEncodeAminoSvc(pub Arc); + impl< + T: Service, + > tonic::server::UnaryService + for TxEncodeAminoSvc { + type Response = super::TxEncodeAminoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tx_encode_amino(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TxEncodeAminoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/cosmos.tx.v1beta1.Service/TxDecodeAmino" => { + #[allow(non_camel_case_types)] + struct TxDecodeAminoSvc(pub Arc); + impl< + T: Service, + > tonic::server::UnaryService + for TxDecodeAminoSvc { + type Response = super::TxDecodeAminoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::tx_decode_amino(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TxDecodeAminoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for ServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for ServiceServer { + const NAME: &'static str = "cosmos.tx.v1beta1.Service"; + } +} diff --git a/crates/proto/src/gen/noble.forwarding.v1.rs b/crates/proto/src/gen/noble.forwarding.v1.rs new file mode 100644 index 0000000000..1bfadd3576 --- /dev/null +++ b/crates/proto/src/gen/noble.forwarding.v1.rs @@ -0,0 +1,1083 @@ +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardingAccount { + #[prost(message, optional, tag = "1")] + pub base_account: ::core::option::Option< + super::super::super::cosmos::auth::v1beta1::BaseAccount, + >, + #[prost(string, tag = "2")] + pub channel: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub recipient: ::prost::alloc::string::String, + #[prost(int64, tag = "4")] + pub created_at: i64, +} +impl ::prost::Name for ForwardingAccount { + const NAME: &'static str = "ForwardingAccount"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardingPubKey { + #[prost(bytes = "vec", tag = "1")] + pub key: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ForwardingPubKey { + const NAME: &'static str = "ForwardingPubKey"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(map = "string, uint64", tag = "1")] + pub num_of_accounts: ::std::collections::HashMap< + ::prost::alloc::string::String, + u64, + >, + #[prost(map = "string, uint64", tag = "2")] + pub num_of_forwards: ::std::collections::HashMap< + ::prost::alloc::string::String, + u64, + >, + #[prost(map = "string, string", tag = "3")] + pub total_forwarded: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +impl ::prost::Name for GenesisState { + const NAME: &'static str = "GenesisState"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisterAccountData { + #[prost(string, tag = "1")] + pub recipient: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel: ::prost::alloc::string::String, +} +impl ::prost::Name for RegisterAccountData { + const NAME: &'static str = "RegisterAccountData"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisterAccountMemo { + #[prost(message, optional, tag = "1")] + pub noble: ::core::option::Option, +} +/// Nested message and enum types in `RegisterAccountMemo`. +pub mod register_account_memo { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct RegisterAccountDataWrapper { + #[prost(message, optional, tag = "1")] + pub forwarding: ::core::option::Option, + } + impl ::prost::Name for RegisterAccountDataWrapper { + const NAME: &'static str = "RegisterAccountDataWrapper"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "noble.forwarding.v1.RegisterAccountMemo.{}", Self::NAME + ) + } + } +} +impl ::prost::Name for RegisterAccountMemo { + const NAME: &'static str = "RegisterAccountMemo"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAddress { + #[prost(string, tag = "1")] + pub channel: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub recipient: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryAddress { + const NAME: &'static str = "QueryAddress"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAddressResponse { + #[prost(string, tag = "1")] + pub address: ::prost::alloc::string::String, + #[prost(bool, tag = "2")] + pub exists: bool, +} +impl ::prost::Name for QueryAddressResponse { + const NAME: &'static str = "QueryAddressResponse"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStats {} +impl ::prost::Name for QueryStats { + const NAME: &'static str = "QueryStats"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStatsResponse { + #[prost(map = "string, message", tag = "1")] + pub stats: ::std::collections::HashMap<::prost::alloc::string::String, Stats>, +} +impl ::prost::Name for QueryStatsResponse { + const NAME: &'static str = "QueryStatsResponse"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStatsByChannel { + #[prost(string, tag = "1")] + pub channel: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryStatsByChannel { + const NAME: &'static str = "QueryStatsByChannel"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStatsByChannelResponse { + #[prost(uint64, tag = "1")] + pub num_of_accounts: u64, + #[prost(uint64, tag = "2")] + pub num_of_forwards: u64, + #[prost(message, repeated, tag = "3")] + pub total_forwarded: ::prost::alloc::vec::Vec< + super::super::super::cosmos::base::v1beta1::Coin, + >, +} +impl ::prost::Name for QueryStatsByChannelResponse { + const NAME: &'static str = "QueryStatsByChannelResponse"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Stats { + #[prost(string, tag = "1")] + pub chain_id: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub num_of_accounts: u64, + #[prost(uint64, tag = "3")] + pub num_of_forwards: u64, + #[prost(message, repeated, tag = "4")] + pub total_forwarded: ::prost::alloc::vec::Vec< + super::super::super::cosmos::base::v1beta1::Coin, + >, +} +impl ::prost::Name for Stats { + const NAME: &'static str = "Stats"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +/// Generated client implementations. +#[cfg(feature = "rpc")] +pub mod query_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct QueryClient { + inner: tonic::client::Grpc, + } + impl QueryClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl QueryClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + 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( + inner: T, + interceptor: F, + ) -> QueryClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + QueryClient::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 + } + pub async fn address( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/noble.forwarding.v1.Query/Address", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("noble.forwarding.v1.Query", "Address")); + self.inner.unary(req, path, codec).await + } + pub async fn stats( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/noble.forwarding.v1.Query/Stats", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("noble.forwarding.v1.Query", "Stats")); + self.inner.unary(req, path, codec).await + } + pub async fn stats_by_channel( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/noble.forwarding.v1.Query/StatsByChannel", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("noble.forwarding.v1.Query", "StatsByChannel")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "rpc")] +pub mod query_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with QueryServer. + #[async_trait] + pub trait Query: Send + Sync + 'static { + async fn address( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn stats( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn stats_by_channel( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct QueryServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl QueryServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for QueryServer + where + T: Query, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/noble.forwarding.v1.Query/Address" => { + #[allow(non_camel_case_types)] + struct AddressSvc(pub Arc); + impl tonic::server::UnaryService + for AddressSvc { + type Response = super::QueryAddressResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::address(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = AddressSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/noble.forwarding.v1.Query/Stats" => { + #[allow(non_camel_case_types)] + struct StatsSvc(pub Arc); + impl tonic::server::UnaryService + for StatsSvc { + type Response = super::QueryStatsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::stats(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = StatsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/noble.forwarding.v1.Query/StatsByChannel" => { + #[allow(non_camel_case_types)] + struct StatsByChannelSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for StatsByChannelSvc { + type Response = super::QueryStatsByChannelResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::stats_by_channel(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = StatsByChannelSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for QueryServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for QueryServer { + const NAME: &'static str = "noble.forwarding.v1.Query"; + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterAccount { + #[prost(string, tag = "1")] + pub signer: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub recipient: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub channel: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterAccount { + const NAME: &'static str = "MsgRegisterAccount"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterAccountResponse { + #[prost(string, tag = "1")] + pub address: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterAccountResponse { + const NAME: &'static str = "MsgRegisterAccountResponse"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgClearAccount { + #[prost(string, tag = "1")] + pub signer: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub address: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgClearAccount { + const NAME: &'static str = "MsgClearAccount"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgClearAccountResponse {} +impl ::prost::Name for MsgClearAccountResponse { + const NAME: &'static str = "MsgClearAccountResponse"; + const PACKAGE: &'static str = "noble.forwarding.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("noble.forwarding.v1.{}", Self::NAME) + } +} +/// Generated client implementations. +#[cfg(feature = "rpc")] +pub mod msg_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct MsgClient { + inner: tonic::client::Grpc, + } + impl MsgClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl MsgClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + 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( + inner: T, + interceptor: F, + ) -> MsgClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + MsgClient::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 + } + pub async fn register_account( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/noble.forwarding.v1.Msg/RegisterAccount", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("noble.forwarding.v1.Msg", "RegisterAccount")); + self.inner.unary(req, path, codec).await + } + pub async fn clear_account( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/noble.forwarding.v1.Msg/ClearAccount", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("noble.forwarding.v1.Msg", "ClearAccount")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "rpc")] +pub mod msg_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with MsgServer. + #[async_trait] + pub trait Msg: Send + Sync + 'static { + async fn register_account( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn clear_account( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct MsgServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl MsgServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for MsgServer + where + T: Msg, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/noble.forwarding.v1.Msg/RegisterAccount" => { + #[allow(non_camel_case_types)] + struct RegisterAccountSvc(pub Arc); + impl tonic::server::UnaryService + for RegisterAccountSvc { + type Response = super::MsgRegisterAccountResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::register_account(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = RegisterAccountSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/noble.forwarding.v1.Msg/ClearAccount" => { + #[allow(non_camel_case_types)] + struct ClearAccountSvc(pub Arc); + impl tonic::server::UnaryService + for ClearAccountSvc { + type Response = super::MsgClearAccountResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::clear_account(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ClearAccountSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for MsgServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for MsgServer { + const NAME: &'static str = "noble.forwarding.v1.Msg"; + } +} diff --git a/crates/proto/src/gen/proto_descriptor.bin.no_lfs b/crates/proto/src/gen/proto_descriptor.bin.no_lfs index 049d2776782e15931731ee25bc163b11d42ee9ca..5127703ec3ff420ed8031f1a9a75fde97737de06 100644 GIT binary patch delta 86371 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 delta 681 zcmZvY!D|yi6vp@MZj#M}K(aIygM>+J%?8p#^HfwfZTW%k)<#BQ~tF_$ujzyDtYc$?-@tVIzBMI- z`HZxD<2I${Qxe=FwzWSA?znznxkF;qShfr0mH&0Ztu9=FOVL}HJ#uK+l-A-6*sE#@ozhIb%}`(?hnU&p6?R>=SwUXKOP4G+uQ}R!6RuXixMIrh=l31qDCugLH diff --git a/crates/proto/src/gen/tendermint.abci.rs b/crates/proto/src/gen/tendermint.abci.rs new file mode 100644 index 0000000000..2cb2c6e801 --- /dev/null +++ b/crates/proto/src/gen/tendermint.abci.rs @@ -0,0 +1,2579 @@ +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Request { + #[prost( + oneof = "request::Value", + tags = "1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17" + )] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Request`. +pub mod request { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(message, tag = "1")] + Echo(super::RequestEcho), + #[prost(message, tag = "2")] + Flush(super::RequestFlush), + #[prost(message, tag = "3")] + Info(super::RequestInfo), + #[prost(message, tag = "5")] + InitChain(super::RequestInitChain), + #[prost(message, tag = "6")] + Query(super::RequestQuery), + #[prost(message, tag = "7")] + BeginBlock(super::RequestBeginBlock), + #[prost(message, tag = "8")] + CheckTx(super::RequestCheckTx), + #[prost(message, tag = "9")] + DeliverTx(super::RequestDeliverTx), + #[prost(message, tag = "10")] + EndBlock(super::RequestEndBlock), + #[prost(message, tag = "11")] + Commit(super::RequestCommit), + #[prost(message, tag = "12")] + ListSnapshots(super::RequestListSnapshots), + #[prost(message, tag = "13")] + OfferSnapshot(super::RequestOfferSnapshot), + #[prost(message, tag = "14")] + LoadSnapshotChunk(super::RequestLoadSnapshotChunk), + #[prost(message, tag = "15")] + ApplySnapshotChunk(super::RequestApplySnapshotChunk), + #[prost(message, tag = "16")] + PrepareProposal(super::RequestPrepareProposal), + #[prost(message, tag = "17")] + ProcessProposal(super::RequestProcessProposal), + } +} +impl ::prost::Name for Request { + const NAME: &'static str = "Request"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestEcho { + #[prost(string, tag = "1")] + pub message: ::prost::alloc::string::String, +} +impl ::prost::Name for RequestEcho { + const NAME: &'static str = "RequestEcho"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestFlush {} +impl ::prost::Name for RequestFlush { + const NAME: &'static str = "RequestFlush"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestInfo { + #[prost(string, tag = "1")] + pub version: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub block_version: u64, + #[prost(uint64, tag = "3")] + pub p2p_version: u64, + #[prost(string, tag = "4")] + pub abci_version: ::prost::alloc::string::String, +} +impl ::prost::Name for RequestInfo { + const NAME: &'static str = "RequestInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestInitChain { + #[prost(message, optional, tag = "1")] + pub time: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(string, tag = "2")] + pub chain_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub consensus_params: ::core::option::Option, + #[prost(message, repeated, tag = "4")] + pub validators: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub app_state_bytes: ::prost::alloc::vec::Vec, + #[prost(int64, tag = "6")] + pub initial_height: i64, +} +impl ::prost::Name for RequestInitChain { + const NAME: &'static str = "RequestInitChain"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestQuery { + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + #[prost(string, tag = "2")] + pub path: ::prost::alloc::string::String, + #[prost(int64, tag = "3")] + pub height: i64, + #[prost(bool, tag = "4")] + pub prove: bool, +} +impl ::prost::Name for RequestQuery { + const NAME: &'static str = "RequestQuery"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestBeginBlock { + #[prost(bytes = "vec", tag = "1")] + pub hash: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub header: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub last_commit_info: ::core::option::Option, + #[prost(message, repeated, tag = "4")] + pub byzantine_validators: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RequestBeginBlock { + const NAME: &'static str = "RequestBeginBlock"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestCheckTx { + #[prost(bytes = "vec", tag = "1")] + pub tx: ::prost::alloc::vec::Vec, + #[prost(enumeration = "CheckTxType", tag = "2")] + pub r#type: i32, +} +impl ::prost::Name for RequestCheckTx { + const NAME: &'static str = "RequestCheckTx"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestDeliverTx { + #[prost(bytes = "vec", tag = "1")] + pub tx: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RequestDeliverTx { + const NAME: &'static str = "RequestDeliverTx"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestEndBlock { + #[prost(int64, tag = "1")] + pub height: i64, +} +impl ::prost::Name for RequestEndBlock { + const NAME: &'static str = "RequestEndBlock"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestCommit {} +impl ::prost::Name for RequestCommit { + const NAME: &'static str = "RequestCommit"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// lists available snapshots +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestListSnapshots {} +impl ::prost::Name for RequestListSnapshots { + const NAME: &'static str = "RequestListSnapshots"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// offers a snapshot to the application +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestOfferSnapshot { + /// snapshot offered by peers + #[prost(message, optional, tag = "1")] + pub snapshot: ::core::option::Option, + /// light client-verified app hash for snapshot height + #[prost(bytes = "vec", tag = "2")] + pub app_hash: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RequestOfferSnapshot { + const NAME: &'static str = "RequestOfferSnapshot"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// loads a snapshot chunk +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestLoadSnapshotChunk { + #[prost(uint64, tag = "1")] + pub height: u64, + #[prost(uint32, tag = "2")] + pub format: u32, + #[prost(uint32, tag = "3")] + pub chunk: u32, +} +impl ::prost::Name for RequestLoadSnapshotChunk { + const NAME: &'static str = "RequestLoadSnapshotChunk"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// Applies a snapshot chunk +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestApplySnapshotChunk { + #[prost(uint32, tag = "1")] + pub index: u32, + #[prost(bytes = "vec", tag = "2")] + pub chunk: ::prost::alloc::vec::Vec, + #[prost(string, tag = "3")] + pub sender: ::prost::alloc::string::String, +} +impl ::prost::Name for RequestApplySnapshotChunk { + const NAME: &'static str = "RequestApplySnapshotChunk"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestPrepareProposal { + /// the modified transactions cannot exceed this size. + #[prost(int64, tag = "1")] + pub max_tx_bytes: i64, + /// txs is an array of transactions that will be included in a block, + /// sent to the app for possible modifications. + #[prost(bytes = "vec", repeated, tag = "2")] + pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + #[prost(message, optional, tag = "3")] + pub local_last_commit: ::core::option::Option, + #[prost(message, repeated, tag = "4")] + pub misbehavior: ::prost::alloc::vec::Vec, + #[prost(int64, tag = "5")] + pub height: i64, + #[prost(message, optional, tag = "6")] + pub time: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(bytes = "vec", tag = "7")] + pub next_validators_hash: ::prost::alloc::vec::Vec, + /// address of the public key of the validator proposing the block. + #[prost(bytes = "vec", tag = "8")] + pub proposer_address: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RequestPrepareProposal { + const NAME: &'static str = "RequestPrepareProposal"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RequestProcessProposal { + #[prost(bytes = "vec", repeated, tag = "1")] + pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, + #[prost(message, optional, tag = "2")] + pub proposed_last_commit: ::core::option::Option, + #[prost(message, repeated, tag = "3")] + pub misbehavior: ::prost::alloc::vec::Vec, + /// hash is the merkle root hash of the fields of the proposed block. + #[prost(bytes = "vec", tag = "4")] + pub hash: ::prost::alloc::vec::Vec, + #[prost(int64, tag = "5")] + pub height: i64, + #[prost(message, optional, tag = "6")] + pub time: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(bytes = "vec", tag = "7")] + pub next_validators_hash: ::prost::alloc::vec::Vec, + /// address of the public key of the original proposer of the block. + #[prost(bytes = "vec", tag = "8")] + pub proposer_address: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RequestProcessProposal { + const NAME: &'static str = "RequestProcessProposal"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Response { + #[prost( + oneof = "response::Value", + tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18" + )] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `Response`. +pub mod response { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(message, tag = "1")] + Exception(super::ResponseException), + #[prost(message, tag = "2")] + Echo(super::ResponseEcho), + #[prost(message, tag = "3")] + Flush(super::ResponseFlush), + #[prost(message, tag = "4")] + Info(super::ResponseInfo), + #[prost(message, tag = "6")] + InitChain(super::ResponseInitChain), + #[prost(message, tag = "7")] + Query(super::ResponseQuery), + #[prost(message, tag = "8")] + BeginBlock(super::ResponseBeginBlock), + #[prost(message, tag = "9")] + CheckTx(super::ResponseCheckTx), + #[prost(message, tag = "10")] + DeliverTx(super::ResponseDeliverTx), + #[prost(message, tag = "11")] + EndBlock(super::ResponseEndBlock), + #[prost(message, tag = "12")] + Commit(super::ResponseCommit), + #[prost(message, tag = "13")] + ListSnapshots(super::ResponseListSnapshots), + #[prost(message, tag = "14")] + OfferSnapshot(super::ResponseOfferSnapshot), + #[prost(message, tag = "15")] + LoadSnapshotChunk(super::ResponseLoadSnapshotChunk), + #[prost(message, tag = "16")] + ApplySnapshotChunk(super::ResponseApplySnapshotChunk), + #[prost(message, tag = "17")] + PrepareProposal(super::ResponsePrepareProposal), + #[prost(message, tag = "18")] + ProcessProposal(super::ResponseProcessProposal), + } +} +impl ::prost::Name for Response { + const NAME: &'static str = "Response"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// nondeterministic +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseException { + #[prost(string, tag = "1")] + pub error: ::prost::alloc::string::String, +} +impl ::prost::Name for ResponseException { + const NAME: &'static str = "ResponseException"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseEcho { + #[prost(string, tag = "1")] + pub message: ::prost::alloc::string::String, +} +impl ::prost::Name for ResponseEcho { + const NAME: &'static str = "ResponseEcho"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseFlush {} +impl ::prost::Name for ResponseFlush { + const NAME: &'static str = "ResponseFlush"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseInfo { + #[prost(string, tag = "1")] + pub data: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub version: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub app_version: u64, + #[prost(int64, tag = "4")] + pub last_block_height: i64, + #[prost(bytes = "vec", tag = "5")] + pub last_block_app_hash: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseInfo { + const NAME: &'static str = "ResponseInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseInitChain { + #[prost(message, optional, tag = "1")] + pub consensus_params: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub validators: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "3")] + pub app_hash: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseInitChain { + const NAME: &'static str = "ResponseInitChain"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseQuery { + #[prost(uint32, tag = "1")] + pub code: u32, + /// bytes data = 2; // use "value" instead. + /// + /// nondeterministic + #[prost(string, tag = "3")] + pub log: ::prost::alloc::string::String, + /// nondeterministic + #[prost(string, tag = "4")] + pub info: ::prost::alloc::string::String, + #[prost(int64, tag = "5")] + pub index: i64, + #[prost(bytes = "vec", tag = "6")] + pub key: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "7")] + pub value: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "8")] + pub proof_ops: ::core::option::Option, + #[prost(int64, tag = "9")] + pub height: i64, + #[prost(string, tag = "10")] + pub codespace: ::prost::alloc::string::String, +} +impl ::prost::Name for ResponseQuery { + const NAME: &'static str = "ResponseQuery"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseBeginBlock { + #[prost(message, repeated, tag = "1")] + pub events: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseBeginBlock { + const NAME: &'static str = "ResponseBeginBlock"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseCheckTx { + #[prost(uint32, tag = "1")] + pub code: u32, + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// nondeterministic + #[prost(string, tag = "3")] + pub log: ::prost::alloc::string::String, + /// nondeterministic + #[prost(string, tag = "4")] + pub info: ::prost::alloc::string::String, + #[prost(int64, tag = "5")] + pub gas_wanted: i64, + #[prost(int64, tag = "6")] + pub gas_used: i64, + #[prost(message, repeated, tag = "7")] + pub events: ::prost::alloc::vec::Vec, + #[prost(string, tag = "8")] + pub codespace: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub sender: ::prost::alloc::string::String, + #[prost(int64, tag = "10")] + pub priority: i64, + /// mempool_error is set by CometBFT. + /// ABCI applictions creating a ResponseCheckTX should not set mempool_error. + #[prost(string, tag = "11")] + pub mempool_error: ::prost::alloc::string::String, +} +impl ::prost::Name for ResponseCheckTx { + const NAME: &'static str = "ResponseCheckTx"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseDeliverTx { + #[prost(uint32, tag = "1")] + pub code: u32, + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// nondeterministic + #[prost(string, tag = "3")] + pub log: ::prost::alloc::string::String, + /// nondeterministic + #[prost(string, tag = "4")] + pub info: ::prost::alloc::string::String, + #[prost(int64, tag = "5")] + pub gas_wanted: i64, + #[prost(int64, tag = "6")] + pub gas_used: i64, + /// nondeterministic + #[prost(message, repeated, tag = "7")] + pub events: ::prost::alloc::vec::Vec, + #[prost(string, tag = "8")] + pub codespace: ::prost::alloc::string::String, +} +impl ::prost::Name for ResponseDeliverTx { + const NAME: &'static str = "ResponseDeliverTx"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseEndBlock { + #[prost(message, repeated, tag = "1")] + pub validator_updates: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub consensus_param_updates: ::core::option::Option, + #[prost(message, repeated, tag = "3")] + pub events: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseEndBlock { + const NAME: &'static str = "ResponseEndBlock"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseCommit { + /// reserve 1 + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + #[prost(int64, tag = "3")] + pub retain_height: i64, +} +impl ::prost::Name for ResponseCommit { + const NAME: &'static str = "ResponseCommit"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseListSnapshots { + #[prost(message, repeated, tag = "1")] + pub snapshots: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseListSnapshots { + const NAME: &'static str = "ResponseListSnapshots"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseOfferSnapshot { + #[prost(enumeration = "response_offer_snapshot::Result", tag = "1")] + pub result: i32, +} +/// Nested message and enum types in `ResponseOfferSnapshot`. +pub mod response_offer_snapshot { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Result { + /// Unknown result, abort all snapshot restoration + Unknown = 0, + /// Snapshot accepted, apply chunks + Accept = 1, + /// Abort all snapshot restoration + Abort = 2, + /// Reject this specific snapshot, try others + Reject = 3, + /// Reject all snapshots of this format, try others + RejectFormat = 4, + /// Reject all snapshots from the sender(s), try others + RejectSender = 5, + } + impl Result { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Result::Unknown => "UNKNOWN", + Result::Accept => "ACCEPT", + Result::Abort => "ABORT", + Result::Reject => "REJECT", + Result::RejectFormat => "REJECT_FORMAT", + Result::RejectSender => "REJECT_SENDER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "ACCEPT" => Some(Self::Accept), + "ABORT" => Some(Self::Abort), + "REJECT" => Some(Self::Reject), + "REJECT_FORMAT" => Some(Self::RejectFormat), + "REJECT_SENDER" => Some(Self::RejectSender), + _ => None, + } + } + } +} +impl ::prost::Name for ResponseOfferSnapshot { + const NAME: &'static str = "ResponseOfferSnapshot"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseLoadSnapshotChunk { + #[prost(bytes = "vec", tag = "1")] + pub chunk: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ResponseLoadSnapshotChunk { + const NAME: &'static str = "ResponseLoadSnapshotChunk"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseApplySnapshotChunk { + #[prost(enumeration = "response_apply_snapshot_chunk::Result", tag = "1")] + pub result: i32, + /// Chunks to refetch and reapply + #[prost(uint32, repeated, tag = "2")] + pub refetch_chunks: ::prost::alloc::vec::Vec, + /// Chunk senders to reject and ban + #[prost(string, repeated, tag = "3")] + pub reject_senders: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Nested message and enum types in `ResponseApplySnapshotChunk`. +pub mod response_apply_snapshot_chunk { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Result { + /// Unknown result, abort all snapshot restoration + Unknown = 0, + /// Chunk successfully accepted + Accept = 1, + /// Abort all snapshot restoration + Abort = 2, + /// Retry chunk (combine with refetch and reject) + Retry = 3, + /// Retry snapshot (combine with refetch and reject) + RetrySnapshot = 4, + /// Reject this snapshot, try others + RejectSnapshot = 5, + } + impl Result { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Result::Unknown => "UNKNOWN", + Result::Accept => "ACCEPT", + Result::Abort => "ABORT", + Result::Retry => "RETRY", + Result::RetrySnapshot => "RETRY_SNAPSHOT", + Result::RejectSnapshot => "REJECT_SNAPSHOT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "ACCEPT" => Some(Self::Accept), + "ABORT" => Some(Self::Abort), + "RETRY" => Some(Self::Retry), + "RETRY_SNAPSHOT" => Some(Self::RetrySnapshot), + "REJECT_SNAPSHOT" => Some(Self::RejectSnapshot), + _ => None, + } + } + } +} +impl ::prost::Name for ResponseApplySnapshotChunk { + const NAME: &'static str = "ResponseApplySnapshotChunk"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponsePrepareProposal { + #[prost(bytes = "vec", repeated, tag = "1")] + pub txs: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for ResponsePrepareProposal { + const NAME: &'static str = "ResponsePrepareProposal"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResponseProcessProposal { + #[prost(enumeration = "response_process_proposal::ProposalStatus", tag = "1")] + pub status: i32, +} +/// Nested message and enum types in `ResponseProcessProposal`. +pub mod response_process_proposal { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum ProposalStatus { + Unknown = 0, + Accept = 1, + Reject = 2, + } + impl ProposalStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ProposalStatus::Unknown => "UNKNOWN", + ProposalStatus::Accept => "ACCEPT", + ProposalStatus::Reject => "REJECT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "ACCEPT" => Some(Self::Accept), + "REJECT" => Some(Self::Reject), + _ => None, + } + } + } +} +impl ::prost::Name for ResponseProcessProposal { + const NAME: &'static str = "ResponseProcessProposal"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CommitInfo { + #[prost(int32, tag = "1")] + pub round: i32, + #[prost(message, repeated, tag = "2")] + pub votes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for CommitInfo { + const NAME: &'static str = "CommitInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExtendedCommitInfo { + /// The round at which the block proposer decided in the previous height. + #[prost(int32, tag = "1")] + pub round: i32, + /// List of validators' addresses in the last validator set with their voting + /// information, including vote extensions. + #[prost(message, repeated, tag = "2")] + pub votes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ExtendedCommitInfo { + const NAME: &'static str = "ExtendedCommitInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// Event allows application developers to attach additional information to +/// ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx. +/// Later, transactions may be queried using these events. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Event { + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub attributes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Event { + const NAME: &'static str = "Event"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// EventAttribute is a single key-value pair, associated with an event. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EventAttribute { + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub value: ::prost::alloc::string::String, + /// nondeterministic + #[prost(bool, tag = "3")] + pub index: bool, +} +impl ::prost::Name for EventAttribute { + const NAME: &'static str = "EventAttribute"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// TxResult contains results of executing the transaction. +/// +/// One usage is indexing transaction results. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TxResult { + #[prost(int64, tag = "1")] + pub height: i64, + #[prost(uint32, tag = "2")] + pub index: u32, + #[prost(bytes = "vec", tag = "3")] + pub tx: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "4")] + pub result: ::core::option::Option, +} +impl ::prost::Name for TxResult { + const NAME: &'static str = "TxResult"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// Validator +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Validator { + /// The first 20 bytes of SHA256(public key) + #[prost(bytes = "vec", tag = "1")] + pub address: ::prost::alloc::vec::Vec, + /// PubKey pub_key = 2 \[(gogoproto.nullable)=false\]; + /// + /// The voting power + #[prost(int64, tag = "3")] + pub power: i64, +} +impl ::prost::Name for Validator { + const NAME: &'static str = "Validator"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// ValidatorUpdate +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ValidatorUpdate { + #[prost(message, optional, tag = "1")] + pub pub_key: ::core::option::Option, + #[prost(int64, tag = "2")] + pub power: i64, +} +impl ::prost::Name for ValidatorUpdate { + const NAME: &'static str = "ValidatorUpdate"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +/// VoteInfo +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VoteInfo { + #[prost(message, optional, tag = "1")] + pub validator: ::core::option::Option, + #[prost(bool, tag = "2")] + pub signed_last_block: bool, +} +impl ::prost::Name for VoteInfo { + const NAME: &'static str = "VoteInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExtendedVoteInfo { + #[prost(message, optional, tag = "1")] + pub validator: ::core::option::Option, + #[prost(bool, tag = "2")] + pub signed_last_block: bool, + /// Reserved for future use + #[prost(bytes = "vec", tag = "3")] + pub vote_extension: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ExtendedVoteInfo { + const NAME: &'static str = "ExtendedVoteInfo"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Misbehavior { + #[prost(enumeration = "MisbehaviorType", tag = "1")] + pub r#type: i32, + /// The offending validator + #[prost(message, optional, tag = "2")] + pub validator: ::core::option::Option, + /// The height when the offense occurred + #[prost(int64, tag = "3")] + pub height: i64, + /// The corresponding time where the offense occurred + #[prost(message, optional, tag = "4")] + pub time: ::core::option::Option<::pbjson_types::Timestamp>, + /// Total voting power of the validator set in case the ABCI application does + /// not store historical validators. + /// + #[prost(int64, tag = "5")] + pub total_voting_power: i64, +} +impl ::prost::Name for Misbehavior { + const NAME: &'static str = "Misbehavior"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Snapshot { + /// The height at which the snapshot was taken + #[prost(uint64, tag = "1")] + pub height: u64, + /// The application-specific snapshot format + #[prost(uint32, tag = "2")] + pub format: u32, + /// Number of chunks in the snapshot + #[prost(uint32, tag = "3")] + pub chunks: u32, + /// Arbitrary snapshot hash, equal only if identical + #[prost(bytes = "vec", tag = "4")] + pub hash: ::prost::alloc::vec::Vec, + /// Arbitrary application metadata + #[prost(bytes = "vec", tag = "5")] + pub metadata: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Snapshot { + const NAME: &'static str = "Snapshot"; + const PACKAGE: &'static str = "tendermint.abci"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.abci.{}", Self::NAME) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum CheckTxType { + New = 0, + Recheck = 1, +} +impl CheckTxType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + CheckTxType::New => "NEW", + CheckTxType::Recheck => "RECHECK", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NEW" => Some(Self::New), + "RECHECK" => Some(Self::Recheck), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum MisbehaviorType { + Unknown = 0, + DuplicateVote = 1, + LightClientAttack = 2, +} +impl MisbehaviorType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + MisbehaviorType::Unknown => "UNKNOWN", + MisbehaviorType::DuplicateVote => "DUPLICATE_VOTE", + MisbehaviorType::LightClientAttack => "LIGHT_CLIENT_ATTACK", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "DUPLICATE_VOTE" => Some(Self::DuplicateVote), + "LIGHT_CLIENT_ATTACK" => Some(Self::LightClientAttack), + _ => None, + } + } +} +/// Generated client implementations. +#[cfg(feature = "rpc")] +pub mod abci_application_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct AbciApplicationClient { + inner: tonic::client::Grpc, + } + impl AbciApplicationClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AbciApplicationClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + 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( + inner: T, + interceptor: F, + ) -> AbciApplicationClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AbciApplicationClient::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 + } + pub async fn echo( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/Echo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "Echo")); + self.inner.unary(req, path, codec).await + } + pub async fn flush( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/Flush", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "Flush")); + self.inner.unary(req, path, codec).await + } + pub async fn info( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/Info", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "Info")); + self.inner.unary(req, path, codec).await + } + pub async fn deliver_tx( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/DeliverTx", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "DeliverTx")); + self.inner.unary(req, path, codec).await + } + pub async fn check_tx( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/CheckTx", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "CheckTx")); + self.inner.unary(req, path, codec).await + } + pub async fn query( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/Query", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "Query")); + self.inner.unary(req, path, codec).await + } + pub async fn commit( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/Commit", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "Commit")); + self.inner.unary(req, path, codec).await + } + pub async fn init_chain( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/InitChain", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "InitChain")); + self.inner.unary(req, path, codec).await + } + pub async fn begin_block( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/BeginBlock", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("tendermint.abci.ABCIApplication", "BeginBlock"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn end_block( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/EndBlock", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("tendermint.abci.ABCIApplication", "EndBlock")); + self.inner.unary(req, path, codec).await + } + pub async fn list_snapshots( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/ListSnapshots", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("tendermint.abci.ABCIApplication", "ListSnapshots"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn offer_snapshot( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/OfferSnapshot", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("tendermint.abci.ABCIApplication", "OfferSnapshot"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn load_snapshot_chunk( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/LoadSnapshotChunk", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "tendermint.abci.ABCIApplication", + "LoadSnapshotChunk", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn apply_snapshot_chunk( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/ApplySnapshotChunk", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "tendermint.abci.ABCIApplication", + "ApplySnapshotChunk", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn prepare_proposal( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/PrepareProposal", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("tendermint.abci.ABCIApplication", "PrepareProposal"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn process_proposal( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/tendermint.abci.ABCIApplication/ProcessProposal", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("tendermint.abci.ABCIApplication", "ProcessProposal"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "rpc")] +pub mod abci_application_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AbciApplicationServer. + #[async_trait] + pub trait AbciApplication: Send + Sync + 'static { + async fn echo( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn flush( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn info( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn deliver_tx( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn check_tx( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn query( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn commit( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn init_chain( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn begin_block( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn end_block( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_snapshots( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn offer_snapshot( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn load_snapshot_chunk( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn apply_snapshot_chunk( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn prepare_proposal( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn process_proposal( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct AbciApplicationServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl AbciApplicationServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(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.max_decoding_message_size = Some(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.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AbciApplicationServer + where + T: AbciApplication, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/tendermint.abci.ABCIApplication/Echo" => { + #[allow(non_camel_case_types)] + struct EchoSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService for EchoSvc { + type Response = super::ResponseEcho; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::echo(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = EchoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/Flush" => { + #[allow(non_camel_case_types)] + struct FlushSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService for FlushSvc { + type Response = super::ResponseFlush; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::flush(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = FlushSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/Info" => { + #[allow(non_camel_case_types)] + struct InfoSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService for InfoSvc { + type Response = super::ResponseInfo; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::info(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = InfoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/DeliverTx" => { + #[allow(non_camel_case_types)] + struct DeliverTxSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for DeliverTxSvc { + type Response = super::ResponseDeliverTx; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::deliver_tx(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = DeliverTxSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/CheckTx" => { + #[allow(non_camel_case_types)] + struct CheckTxSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for CheckTxSvc { + type Response = super::ResponseCheckTx; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::check_tx(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = CheckTxSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/Query" => { + #[allow(non_camel_case_types)] + struct QuerySvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService for QuerySvc { + type Response = super::ResponseQuery; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::query(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = QuerySvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/Commit" => { + #[allow(non_camel_case_types)] + struct CommitSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for CommitSvc { + type Response = super::ResponseCommit; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::commit(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = CommitSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/InitChain" => { + #[allow(non_camel_case_types)] + struct InitChainSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for InitChainSvc { + type Response = super::ResponseInitChain; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::init_chain(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = InitChainSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/BeginBlock" => { + #[allow(non_camel_case_types)] + struct BeginBlockSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for BeginBlockSvc { + type Response = super::ResponseBeginBlock; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::begin_block(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = BeginBlockSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/EndBlock" => { + #[allow(non_camel_case_types)] + struct EndBlockSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for EndBlockSvc { + type Response = super::ResponseEndBlock; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::end_block(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = EndBlockSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/ListSnapshots" => { + #[allow(non_camel_case_types)] + struct ListSnapshotsSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for ListSnapshotsSvc { + type Response = super::ResponseListSnapshots; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_snapshots(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ListSnapshotsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/OfferSnapshot" => { + #[allow(non_camel_case_types)] + struct OfferSnapshotSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for OfferSnapshotSvc { + type Response = super::ResponseOfferSnapshot; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::offer_snapshot(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OfferSnapshotSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/LoadSnapshotChunk" => { + #[allow(non_camel_case_types)] + struct LoadSnapshotChunkSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for LoadSnapshotChunkSvc { + type Response = super::ResponseLoadSnapshotChunk; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::load_snapshot_chunk(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = LoadSnapshotChunkSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/ApplySnapshotChunk" => { + #[allow(non_camel_case_types)] + struct ApplySnapshotChunkSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for ApplySnapshotChunkSvc { + type Response = super::ResponseApplySnapshotChunk; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::apply_snapshot_chunk( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ApplySnapshotChunkSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/PrepareProposal" => { + #[allow(non_camel_case_types)] + struct PrepareProposalSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for PrepareProposalSvc { + type Response = super::ResponsePrepareProposal; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::prepare_proposal(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PrepareProposalSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/tendermint.abci.ABCIApplication/ProcessProposal" => { + #[allow(non_camel_case_types)] + struct ProcessProposalSvc(pub Arc); + impl< + T: AbciApplication, + > tonic::server::UnaryService + for ProcessProposalSvc { + type Response = super::ResponseProcessProposal; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::process_proposal(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ProcessProposalSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AbciApplicationServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for AbciApplicationServer { + const NAME: &'static str = "tendermint.abci.ABCIApplication"; + } +} diff --git a/crates/proto/src/gen/tendermint.types.rs b/crates/proto/src/gen/tendermint.types.rs index 8ea4e48fe9..dd05ee65c4 100644 --- a/crates/proto/src/gen/tendermint.types.rs +++ b/crates/proto/src/gen/tendermint.types.rs @@ -502,3 +502,121 @@ impl ::prost::Name for Block { ::prost::alloc::format!("tendermint.types.{}", Self::NAME) } } +/// ConsensusParams contains consensus critical parameters that determine the +/// validity of blocks. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusParams { + #[prost(message, optional, tag = "1")] + pub block: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub evidence: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub validator: ::core::option::Option, + #[prost(message, optional, tag = "4")] + pub version: ::core::option::Option, +} +impl ::prost::Name for ConsensusParams { + const NAME: &'static str = "ConsensusParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} +/// BlockParams contains limits on the block size. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BlockParams { + /// Max block size, in bytes. + /// Note: must be greater than 0 + #[prost(int64, tag = "1")] + pub max_bytes: i64, + /// Max gas per block. + /// Note: must be greater or equal to -1 + #[prost(int64, tag = "2")] + pub max_gas: i64, +} +impl ::prost::Name for BlockParams { + const NAME: &'static str = "BlockParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} +/// EvidenceParams determine how we handle evidence of malfeasance. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EvidenceParams { + /// Max age of evidence, in blocks. + /// + /// The basic formula for calculating this is: MaxAgeDuration / {average block + /// time}. + #[prost(int64, tag = "1")] + pub max_age_num_blocks: i64, + /// Max age of evidence, in time. + /// + /// It should correspond with an app's "unbonding period" or other similar + /// mechanism for handling [Nothing-At-Stake + /// attacks](). + #[prost(message, optional, tag = "2")] + pub max_age_duration: ::core::option::Option<::pbjson_types::Duration>, + /// This sets the maximum size of total evidence in bytes that can be committed in a single block. + /// and should fall comfortably under the max block bytes. + /// Default is 1048576 or 1MB + #[prost(int64, tag = "3")] + pub max_bytes: i64, +} +impl ::prost::Name for EvidenceParams { + const NAME: &'static str = "EvidenceParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} +/// ValidatorParams restrict the public key types validators can use. +/// NOTE: uses ABCI pubkey naming, not Amino names. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ValidatorParams { + #[prost(string, repeated, tag = "1")] + pub pub_key_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for ValidatorParams { + const NAME: &'static str = "ValidatorParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} +/// VersionParams contains the ABCI application version. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VersionParams { + #[prost(uint64, tag = "1")] + pub app: u64, +} +impl ::prost::Name for VersionParams { + const NAME: &'static str = "VersionParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} +/// HashedParams is a subset of ConsensusParams. +/// +/// It is hashed into the Header.ConsensusHash. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HashedParams { + #[prost(int64, tag = "1")] + pub block_max_bytes: i64, + #[prost(int64, tag = "2")] + pub block_max_gas: i64, +} +impl ::prost::Name for HashedParams { + const NAME: &'static str = "HashedParams"; + const PACKAGE: &'static str = "tendermint.types"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("tendermint.types.{}", Self::NAME) + } +} diff --git a/crates/proto/src/lib.rs b/crates/proto/src/lib.rs index 42bd785867..d48882a2c2 100644 --- a/crates/proto/src/lib.rs +++ b/crates/proto/src/lib.rs @@ -276,6 +276,76 @@ pub mod tendermint { pub mod p2p { include!("gen/tendermint.p2p.rs"); } + + pub mod abci { + include!("gen/tendermint.abci.rs"); + } +} + +pub mod noble { + pub mod forwarding { + pub mod v1 { + include!("gen/noble.forwarding.v1.rs"); + } + } +} + +pub mod cosmos { + pub mod base { + pub mod v1beta1 { + include!("gen/cosmos.base.v1beta1.rs"); + } + + pub mod query { + pub mod v1beta1 { + include!("gen/cosmos.base.query.v1beta1.rs"); + } + } + + pub mod abci { + pub mod v1beta1 { + include!("gen/cosmos.base.abci.v1beta1.rs"); + } + } + } + + pub mod auth { + pub mod v1beta1 { + include!("gen/cosmos.auth.v1beta1.rs"); + } + } + + pub mod bank { + pub mod v1beta1 { + include!("gen/cosmos.bank.v1beta1.rs"); + } + } + + pub mod tx { + pub mod v1beta1 { + include!("gen/cosmos.tx.v1beta1.rs"); + } + + pub mod config { + pub mod v1 { + include!("gen/cosmos.tx.config.v1.rs"); + } + } + + pub mod signing { + pub mod v1beta1 { + include!("gen/cosmos.tx.signing.v1beta1.rs"); + } + } + } + + pub mod crypto { + pub mod multisig { + pub mod v1beta1 { + include!("gen/cosmos.crypto.multisig.v1beta1.rs"); + } + } + } } #[cfg(feature = "rpc")] diff --git a/deployments/scripts/protobuf-codegen b/deployments/scripts/protobuf-codegen index 2765293cb0..9f9b2a7c2d 100755 --- a/deployments/scripts/protobuf-codegen +++ b/deployments/scripts/protobuf-codegen @@ -20,6 +20,7 @@ buf dep update penumbra # Pull our vendored cosmos/IBC proto defs so we can get reflection for service definitions. # The penumbra dependencies will override some of these. +buf export buf.build/noble-assets/forwarding:5a8609a6772d417584a9c60cd8b80881 --output rust-vendored/ buf export buf.build/cosmos/cosmos-sdk:e7a85cef453e4b999ad9aff8714ae05f --output rust-vendored/ buf export buf.build/cosmos/ibc:7ab44ae956a0488ea04e04511efa5f70 --output rust-vendored/ diff --git a/proto/rust-vendored/google/protobuf/any.proto b/proto/rust-vendored/google/protobuf/any.proto new file mode 100644 index 0000000000..58b511583a --- /dev/null +++ b/proto/rust-vendored/google/protobuf/any.proto @@ -0,0 +1,164 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +import "gogoproto/gogo.proto"; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "types"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "AnyProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; + +// `Any` contains an arbitrary serialized protocol buffer message along with a +// URL that describes the type of the serialized message. +// +// Protobuf library provides support to pack/unpack Any values in the form +// of utility functions or additional generated methods of the Any type. +// +// Example 1: Pack and unpack a message in C++. +// +// Foo foo = ...; +// Any any; +// any.PackFrom(foo); +// ... +// if (any.UnpackTo(&foo)) { +// ... +// } +// +// Example 2: Pack and unpack a message in Java. +// +// Foo foo = ...; +// Any any = Any.pack(foo); +// ... +// if (any.is(Foo.class)) { +// foo = any.unpack(Foo.class); +// } +// +// Example 3: Pack and unpack a message in Python. +// +// foo = Foo(...) +// any = Any() +// any.Pack(foo) +// ... +// if any.Is(Foo.DESCRIPTOR): +// any.Unpack(foo) +// ... +// +// Example 4: Pack and unpack a message in Go +// +// foo := &pb.Foo{...} +// any, err := ptypes.MarshalAny(foo) +// ... +// foo := &pb.Foo{} +// if err := ptypes.UnmarshalAny(any, foo); err != nil { +// ... +// } +// +// The pack methods provided by protobuf library will by default use +// 'type.googleapis.com/full.type.name' as the type URL and the unpack +// methods only use the fully qualified type name after the last '/' +// in the type URL, for example "foo.bar.com/x/y.z" will yield type +// name "y.z". +// +// +// JSON +// ==== +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the `@type` +// field. Example (for message [google.protobuf.Duration][]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +message Any { + // A URL/resource name that uniquely identifies the type of the serialized + // protocol buffer message. This string must contain at least + // one "/" character. The last segment of the URL's path must represent + // the fully qualified name of the type (as in + // `path/google.protobuf.Duration`). The name should be in a canonical form + // (e.g., leading "." is not accepted). + // + // In practice, teams usually precompile into the binary all types that they + // expect it to use in the context of Any. However, for URLs which use the + // scheme `http`, `https`, or no scheme, one can optionally set up a type + // server that maps type URLs to message definitions as follows: + // + // * If no scheme is provided, `https` is assumed. + // * An HTTP GET on the URL must yield a [google.protobuf.Type][] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Note: this functionality is not currently available in the official + // protobuf release, and it is not used for type URLs beginning with + // type.googleapis.com. + // + // Schemes other than `http`, `https` (or the empty scheme) might be + // used with implementation specific semantics. + // + string type_url = 1; + + // Must be a valid serialized protocol buffer of the above specified type. + bytes value = 2; + + option (gogoproto.typedecl) = false; + option (gogoproto.goproto_stringer) = false; + option (gogoproto.gostring) = false; + option (gogoproto.stringer) = false; +} + +option (gogoproto.goproto_registration) = false; diff --git a/proto/rust-vendored/noble/forwarding/v1/account.proto b/proto/rust-vendored/noble/forwarding/v1/account.proto new file mode 100644 index 0000000000..0fc9cdba7b --- /dev/null +++ b/proto/rust-vendored/noble/forwarding/v1/account.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; + +package noble.forwarding.v1; + +import "cosmos/auth/v1beta1/auth.proto"; +import "gogoproto/gogo.proto"; + +option go_package = "github.com/noble-assets/forwarding/x/forwarding/types"; + +message ForwardingAccount { + cosmos.auth.v1beta1.BaseAccount base_account = 1 [(gogoproto.embed) = true]; + + string channel = 2; + string recipient = 3; + int64 created_at = 4; +} + +message ForwardingPubKey { + option (gogoproto.goproto_stringer) = false; + + bytes key = 1; +} diff --git a/proto/rust-vendored/noble/forwarding/v1/genesis.proto b/proto/rust-vendored/noble/forwarding/v1/genesis.proto new file mode 100644 index 0000000000..bcbbc9f448 --- /dev/null +++ b/proto/rust-vendored/noble/forwarding/v1/genesis.proto @@ -0,0 +1,11 @@ +syntax = "proto3"; + +package noble.forwarding.v1; + +option go_package = "github.com/noble-assets/forwarding/x/forwarding/types"; + +message GenesisState { + map num_of_accounts = 1; + map num_of_forwards = 2; + map total_forwarded = 3; +} diff --git a/proto/rust-vendored/noble/forwarding/v1/packet.proto b/proto/rust-vendored/noble/forwarding/v1/packet.proto new file mode 100644 index 0000000000..875de708e0 --- /dev/null +++ b/proto/rust-vendored/noble/forwarding/v1/packet.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; + +package noble.forwarding.v1; + +option go_package = "github.com/noble-assets/forwarding/x/forwarding/types"; + +message RegisterAccountData { + string recipient = 1; + string channel = 2; +} + +message RegisterAccountMemo { + message RegisterAccountDataWrapper { + RegisterAccountData forwarding = 1; + } + + RegisterAccountDataWrapper noble = 1; +} diff --git a/proto/rust-vendored/noble/forwarding/v1/query.proto b/proto/rust-vendored/noble/forwarding/v1/query.proto new file mode 100644 index 0000000000..866ce6679e --- /dev/null +++ b/proto/rust-vendored/noble/forwarding/v1/query.proto @@ -0,0 +1,66 @@ +syntax = "proto3"; + +package noble.forwarding.v1; + +import "cosmos/base/v1beta1/coin.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/noble-assets/forwarding/x/forwarding/types"; + +service Query { + rpc Address(QueryAddress) returns (QueryAddressResponse) { + option (google.api.http).get = "/noble/forwarding/v1/address/{channel}/{recipient}"; + } + + rpc Stats(QueryStats) returns (QueryStatsResponse) { + option (google.api.http).get = "/noble/forwarding/v1/stats"; + } + + rpc StatsByChannel(QueryStatsByChannel) returns (QueryStatsByChannelResponse) { + option (google.api.http).get = "/noble/forwarding/v1/stats/{channel}"; + } +} + +// + +message QueryAddress { + string channel = 1; + string recipient = 2; +} + +message QueryAddressResponse { + string address = 1; + bool exists = 2; +} + +message QueryStats {} + +message QueryStatsResponse { + map stats = 1 [(gogoproto.nullable) = false]; +} + +message QueryStatsByChannel { + string channel = 1; +} + +message QueryStatsByChannelResponse { + uint64 num_of_accounts = 1; + uint64 num_of_forwards = 2; + repeated cosmos.base.v1beta1.Coin total_forwarded = 3 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins" + ]; +} + +// + +message Stats { + string chain_id = 1; + uint64 num_of_accounts = 2; + uint64 num_of_forwards = 3; + repeated cosmos.base.v1beta1.Coin total_forwarded = 4 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins" + ]; +} diff --git a/proto/rust-vendored/noble/forwarding/v1/tx.proto b/proto/rust-vendored/noble/forwarding/v1/tx.proto new file mode 100644 index 0000000000..0485a193b1 --- /dev/null +++ b/proto/rust-vendored/noble/forwarding/v1/tx.proto @@ -0,0 +1,29 @@ +syntax = "proto3"; + +package noble.forwarding.v1; + +option go_package = "github.com/noble-assets/forwarding/x/forwarding/types"; + +service Msg { + rpc RegisterAccount(noble.forwarding.v1.MsgRegisterAccount) returns (noble.forwarding.v1.MsgRegisterAccountResponse); + rpc ClearAccount(noble.forwarding.v1.MsgClearAccount) returns (noble.forwarding.v1.MsgClearAccountResponse); +} + +// + +message MsgRegisterAccount { + string signer = 1; + string recipient = 2; + string channel = 3; +} + +message MsgRegisterAccountResponse { + string address = 1; +} + +message MsgClearAccount { + string signer = 1; + string address = 2; +} + +message MsgClearAccountResponse {} diff --git a/tools/proto-compiler/src/main.rs b/tools/proto-compiler/src/main.rs index 0dfb4bfeed..8915c3d811 100644 --- a/tools/proto-compiler/src/main.rs +++ b/tools/proto-compiler/src/main.rs @@ -116,13 +116,25 @@ fn main() -> anyhow::Result<()> { "../../proto/penumbra/penumbra/tools/summoning/v1/summoning.proto", "../../proto/penumbra/penumbra/util/tendermint_proxy/v1/tendermint_proxy.proto", "../../proto/penumbra/penumbra/view/v1/view.proto", + "../../proto/rust-vendored/tendermint/abci/types.proto", "../../proto/rust-vendored/tendermint/types/validator.proto", "../../proto/rust-vendored/tendermint/p2p/types.proto", "../../proto/rust-vendored/cosmos/bank/v1beta1/query.proto", + "../../proto/rust-vendored/cosmos/tx/v1beta1/service.proto", + "../../proto/rust-vendored/cosmos/tx/v1beta1/tx.proto", + "../../proto/rust-vendored/cosmos/tx/config/v1/config.proto", + "../../proto/rust-vendored/cosmos/tx/signing/v1beta1/signing.proto", + "../../proto/rust-vendored/cosmos/base/abci/v1beta1/abci.proto", + "../../proto/rust-vendored/cosmos/crypto/multisig/v1beta1/multisig.proto", "../../proto/rust-vendored/ibc/applications/transfer/v1/query.proto", "../../proto/rust-vendored/ibc/core/channel/v1/query.proto", "../../proto/rust-vendored/ibc/core/client/v1/query.proto", "../../proto/rust-vendored/ibc/core/connection/v1/query.proto", + "../../proto/rust-vendored/noble/forwarding/v1/account.proto", + "../../proto/rust-vendored/noble/forwarding/v1/genesis.proto", + "../../proto/rust-vendored/noble/forwarding/v1/packet.proto", + "../../proto/rust-vendored/noble/forwarding/v1/query.proto", + "../../proto/rust-vendored/noble/forwarding/v1/tx.proto", ], &["../../proto/penumbra/", "../../proto/rust-vendored/"], )?;