nibiru-std 0.7.0

// @generated
/// FunToken is a fungible token mapping between a Bank Coin and a corresponding
/// ERC-20 smart contract. Bank Coins here refer to tokens like NIBI, IBC
/// coins (ICS-20), and token factory coins, which are each represented by the
/// "Coin" type in Golang.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FunToken {
    /// Hexadecimal address of the ERC20 token to which the `FunToken` maps
    #[prost(string, tag = "1")]
    pub erc20_addr: ::prost::alloc::string::String,
    /// bank_denom: Coin denomination in the Bank Module.
    #[prost(string, tag = "2")]
    pub bank_denom: ::prost::alloc::string::String,
    /// True if the `FunToken` mapping was created from an existing Bank Coin and
    /// the ERC-20 contract gets deployed by the module account. False if the
    /// mapping was created from an externally owned ERC-20 contract.
    #[prost(bool, tag = "3")]
    pub is_made_from_coin: bool,
}
/// Params defines the EVM module parameters
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Params {
    /// extra_eips defines the additional EIPs for the vm.Config
    #[prost(int64, repeated, packed = "false", tag = "4")]
    pub extra_eips: ::prost::alloc::vec::Vec<i64>,
    /// evm_channels is the list of channel identifiers from EVM compatible chains
    #[prost(string, repeated, tag = "8")]
    pub evm_channels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Fee deducted and burned when calling "CreateFunToken" in units of
    /// "evm_denom".
    #[prost(string, tag = "9")]
    pub create_funtoken_fee: ::prost::alloc::string::String,
}
/// State represents a single Storage key value pair item.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct State {
    /// key is the stored key
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// value is the stored value for the given key
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
/// Log represents an protobuf compatible Ethereum Log that defines a contract
/// log event. These events are generated by the LOG opcode and stored/indexed by
/// the node.
///
/// NOTE: address, topics and data are consensus fields. The rest of the fields
/// are derived, i.e. filled in by the nodes, but not secured by consensus.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Log {
    /// address of the contract that generated the event
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// topics is a list of topics provided by the contract.
    #[prost(string, repeated, tag = "2")]
    pub topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// data which is supplied by the contract, usually ABI-encoded
    #[prost(bytes = "bytes", tag = "3")]
    pub data: ::prost::bytes::Bytes,
    /// block_number of the block in which the transaction was included
    #[prost(uint64, tag = "4")]
    pub block_number: u64,
    /// tx_hash is the transaction hash
    #[prost(string, tag = "5")]
    pub tx_hash: ::prost::alloc::string::String,
    /// tx_index of the transaction in the block
    #[prost(uint64, tag = "6")]
    pub tx_index: u64,
    /// block_hash of the block in which the transaction was included
    #[prost(string, tag = "7")]
    pub block_hash: ::prost::alloc::string::String,
    /// index of the log in the block
    #[prost(uint64, tag = "8")]
    pub index: u64,
    /// removed is true if this log was reverted due to a chain
    /// reorganisation. You must pay attention to this field if you receive logs
    /// through a filter query.
    #[prost(bool, tag = "9")]
    pub removed: bool,
}
/// AccessTuple is the element type of an access list.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AccessTuple {
    /// address is a hex formatted ethereum address
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// storage_keys are hex formatted hashes of the storage keys
    #[prost(string, repeated, tag = "2")]
    pub storage_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// TracerConfig stores additional tracer args. For geth it's only one attr:
/// onlyTopCall
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TracerConfig {
    #[prost(bool, tag = "1")]
    pub only_top_call: bool,
}
/// TraceConfig holds extra parameters to trace functions.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TraceConfig {
    /// tracer is a custom javascript tracer
    #[prost(string, tag = "1")]
    pub tracer: ::prost::alloc::string::String,
    /// timeout overrides the default timeout of 5 seconds for JavaScript-based
    /// tracing calls
    #[prost(string, tag = "2")]
    pub timeout: ::prost::alloc::string::String,
    /// reexec defines the number of blocks the tracer is willing to go back
    #[prost(uint64, tag = "3")]
    pub reexec: u64,
    /// disable_stack switches stack capture
    #[prost(bool, tag = "5")]
    pub disable_stack: bool,
    /// disable_storage switches storage capture
    #[prost(bool, tag = "6")]
    pub disable_storage: bool,
    /// debug can be used to print output during capture end
    #[prost(bool, tag = "8")]
    pub debug: bool,
    /// limit defines the maximum length of output, but zero means unlimited
    #[prost(int32, tag = "9")]
    pub limit: i32,
    /// enable_memory switches memory capture
    #[prost(bool, tag = "11")]
    pub enable_memory: bool,
    /// enable_return_data switches the capture of return data
    #[prost(bool, tag = "12")]
    pub enable_return_data: bool,
    /// tracer_config configures the tracer options
    #[prost(message, optional, tag = "13")]
    pub tracer_config: ::core::option::Option<TracerConfig>,
}
/// EventEthereumTx defines the event for an Ethereum transaction
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventEthereumTx {
    /// amount
    #[prost(string, tag = "1")]
    pub amount: ::prost::alloc::string::String,
    /// eth_hash is the Ethereum hash of the transaction
    #[prost(string, tag = "2")]
    pub eth_hash: ::prost::alloc::string::String,
    /// index of the transaction in the block
    #[prost(string, tag = "3")]
    pub index: ::prost::alloc::string::String,
    /// gas_used is the amount of gas used by the transaction
    #[prost(string, tag = "4")]
    pub gas_used: ::prost::alloc::string::String,
    /// hash is the Tendermint hash of the transaction
    #[prost(string, tag = "5")]
    pub hash: ::prost::alloc::string::String,
    /// recipient of the transaction
    #[prost(string, tag = "6")]
    pub recipient: ::prost::alloc::string::String,
    /// vm_error contains a VM error should it occur
    #[prost(string, tag = "7")]
    pub vm_error: ::prost::alloc::string::String,
}
/// EventTxLog defines the event for an Ethereum transaction log
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventTxLog {
    /// tx_logs is an array of transaction logs
    #[prost(message, repeated, tag = "1")]
    pub logs: ::prost::alloc::vec::Vec<Log>,
}
/// EventBlockBloom defines an Ethereum block bloom filter event
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventBlockBloom {
    /// bloom is the bloom filter of the block
    #[prost(string, tag = "1")]
    pub bloom: ::prost::alloc::string::String,
}
/// EventFunTokenCreated defines a fun token creation event.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventFunTokenCreated {
    #[prost(string, tag = "1")]
    pub bank_denom: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub erc20_contract_address: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub creator: ::prost::alloc::string::String,
    #[prost(bool, tag = "4")]
    pub is_made_from_coin: bool,
}
/// ConvertCoinToEvm defines sending fun token to erc20 event.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventConvertCoinToEvm {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub erc20_contract_address: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub to_eth_addr: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub bank_coin:
        ::core::option::Option<crate::proto::cosmos::base::v1beta1::Coin>,
}
/// EventTransfer defines event for EVM transfer
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventTransfer {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub recipient: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub amount: ::prost::alloc::string::String,
}
/// EventContractDeployed defines event for EVM contract deployment
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventContractDeployed {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub contract_addr: ::prost::alloc::string::String,
}
/// EventContractExecuted defines event for EVM contract execution
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventContractExecuted {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub contract_addr: ::prost::alloc::string::String,
}
/// GenesisState defines the evm module's genesis state.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenesisState {
    /// accounts is an array containing the ethereum genesis accounts.
    #[prost(message, repeated, tag = "1")]
    pub accounts: ::prost::alloc::vec::Vec<GenesisAccount>,
    /// params defines all the parameters of the module.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<Params>,
    /// Fungible token mappings corresponding to ERC-20 smart contract tokens.
    #[prost(message, repeated, tag = "3")]
    pub funtoken_mappings: ::prost::alloc::vec::Vec<FunToken>,
}
/// GenesisAccount defines an account to be initialized in the genesis state.
/// Its main difference between with Geth's GenesisAccount is that it uses a
/// custom storage type and that it doesn't contain the private key field.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenesisAccount {
    /// address defines an ethereum hex formated address of an account
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// code defines the hex bytes of the account code.
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    /// storage defines the set of state key values for the account.
    #[prost(message, repeated, tag = "3")]
    pub storage: ::prost::alloc::vec::Vec<State>,
}
/// MsgEthereumTx encapsulates an Ethereum transaction as an SDK message.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgEthereumTx {
    /// data is inner transaction data of the Ethereum transaction
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<::prost_types::Any>,
    /// size is the encoded storage size of the transaction (DEPRECATED)
    #[prost(double, tag = "2")]
    pub size: f64,
    /// hash of the transaction in hex format
    #[prost(string, tag = "3")]
    pub hash: ::prost::alloc::string::String,
    /// from is the ethereum signer address in hex format. This address value is
    /// checked against the address derived from the signature (V, R, S) using the
    /// secp256k1 elliptic curve
    #[prost(string, tag = "4")]
    pub from: ::prost::alloc::string::String,
}
/// LegacyTx is the transaction data of regular Ethereum transactions.
///
/// Note that setting "evm.Params.AllowUnprotectedTxs" to false will cause all
/// non-EIP155 signed transactions to fail, as they'll lack replay protection.
///
/// LegacyTx is a custom implementation of "LegacyTx" from
/// "github.com/ethereum/go-ethereum/core/types".
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LegacyTx {
    /// nonce corresponds to the account nonce (transaction sequence).
    #[prost(uint64, tag = "1")]
    pub nonce: u64,
    /// gas_price defines the value for each gas unit
    #[prost(string, tag = "2")]
    pub gas_price: ::prost::alloc::string::String,
    /// gas defines the gas limit defined for the transaction.
    #[prost(uint64, tag = "3")]
    pub gas: u64,
    /// to is the hex formatted address of the recipient
    #[prost(string, tag = "4")]
    pub to: ::prost::alloc::string::String,
    /// value defines the unsigned integer value of the transaction amount.
    #[prost(string, tag = "5")]
    pub value: ::prost::alloc::string::String,
    /// data is the data payload bytes of the transaction.
    #[prost(bytes = "bytes", tag = "6")]
    pub data: ::prost::bytes::Bytes,
    /// v defines the recovery id as the "v" signature value from the elliptic
    /// curve digital signatute algorithm (ECDSA). It indicates which of two
    /// possible solutions should be used to reconstruct the public key from the
    /// signature. In Ethereum, "v" takes the value 27 or 28 for transactions that
    /// are not relay-protected.
    #[prost(bytes = "bytes", tag = "7")]
    pub v: ::prost::bytes::Bytes,
    /// r defines the x-coordinate of a point on the elliptic curve in the elliptic
    /// curve digital signatute algorithm (ECDSA). It's crucial in ensuring
    /// uniqueness of the signature.
    #[prost(bytes = "bytes", tag = "8")]
    pub r: ::prost::bytes::Bytes,
    /// s define the signature value derived from the private key, message hash,
    /// and the value of "r". It ensures that the signature is tied to both the
    /// message and the private key of the sender.
    #[prost(bytes = "bytes", tag = "9")]
    pub s: ::prost::bytes::Bytes,
}
/// AccessListTx is the data of EIP-2930 access list transactions.
/// It is a custom implementation of "AccessListTx" from
/// "github.com/ethereum/go-ethereum/core/types".
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AccessListTx {
    /// chain_id of the destination EVM chain
    #[prost(string, tag = "1")]
    pub chain_id: ::prost::alloc::string::String,
    /// nonce corresponds to the account nonce (transaction sequence).
    #[prost(uint64, tag = "2")]
    pub nonce: u64,
    /// gas_price defines the value for each gas unit
    #[prost(string, tag = "3")]
    pub gas_price: ::prost::alloc::string::String,
    /// gas defines the gas limit defined for the transaction.
    #[prost(uint64, tag = "4")]
    pub gas: u64,
    /// to is the recipient address in hex format
    #[prost(string, tag = "5")]
    pub to: ::prost::alloc::string::String,
    /// value defines the unsigned integer value of the transaction amount.
    #[prost(string, tag = "6")]
    pub value: ::prost::alloc::string::String,
    /// data is the data payload bytes of the transaction.
    #[prost(bytes = "bytes", tag = "7")]
    pub data: ::prost::bytes::Bytes,
    /// accesses is an array of access tuples
    #[prost(message, repeated, tag = "8")]
    pub accesses: ::prost::alloc::vec::Vec<AccessTuple>,
    /// v defines the recovery id and "v" signature value from the elliptic curve
    /// digital signatute algorithm (ECDSA). It indicates which of two possible
    /// solutions should be used to reconstruct the public key from the signature.
    /// In Ethereum, "v" takes the value 27 or 28 for transactions that are not
    /// relay-protected.
    #[prost(bytes = "bytes", tag = "9")]
    pub v: ::prost::bytes::Bytes,
    /// r defines the x-coordinate of a point on the elliptic curve in the elliptic
    /// curve digital signatute algorithm (ECDSA). It's crucial in ensuring
    /// uniqueness of the signature.
    #[prost(bytes = "bytes", tag = "10")]
    pub r: ::prost::bytes::Bytes,
    /// s define the signature value derived from the private key, message hash,
    /// and the value of "r". It ensures that the signature is tied to both the
    /// message and the private key of the sender.
    #[prost(bytes = "bytes", tag = "11")]
    pub s: ::prost::bytes::Bytes,
}
/// DynamicFeeTx is the data of EIP-1559 dynamic fee transactions. It is a custom
/// implementation of "DynamicFeeTx" from
/// "github.com/ethereum/go-ethereum/core/types".
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DynamicFeeTx {
    /// chain_id of the destination EVM chain
    #[prost(string, tag = "1")]
    pub chain_id: ::prost::alloc::string::String,
    /// nonce corresponds to the account nonce (transaction sequence).
    #[prost(uint64, tag = "2")]
    pub nonce: u64,
    /// gas_tip_cap defines the max value for the gas tip
    #[prost(string, tag = "3")]
    pub gas_tip_cap: ::prost::alloc::string::String,
    /// gas_fee_cap defines the max value for the gas fee
    #[prost(string, tag = "4")]
    pub gas_fee_cap: ::prost::alloc::string::String,
    /// gas defines the gas limit defined for the transaction.
    #[prost(uint64, tag = "5")]
    pub gas: u64,
    /// to is the hex formatted address of the recipient
    #[prost(string, tag = "6")]
    pub to: ::prost::alloc::string::String,
    /// value defines the the transaction amount.
    #[prost(string, tag = "7")]
    pub value: ::prost::alloc::string::String,
    /// data is the data payload bytes of the transaction.
    #[prost(bytes = "bytes", tag = "8")]
    pub data: ::prost::bytes::Bytes,
    /// accesses is an array of access tuples
    #[prost(message, repeated, tag = "9")]
    pub accesses: ::prost::alloc::vec::Vec<AccessTuple>,
    /// v defines the recovery id and "v" signature value from the elliptic curve
    /// digital signatute algorithm (ECDSA). It indicates which of two possible
    /// solutions should be used to reconstruct the public key from the signature.
    /// In Ethereum, "v" takes the value 27 or 28 for transactions that are not
    /// relay-protected.
    #[prost(bytes = "bytes", tag = "10")]
    pub v: ::prost::bytes::Bytes,
    /// r defines the x-coordinate of a point on the elliptic curve in the elliptic
    /// curve digital signatute algorithm (ECDSA). It's crucial in ensuring
    /// uniqueness of the signature.
    #[prost(bytes = "bytes", tag = "11")]
    pub r: ::prost::bytes::Bytes,
    /// s define the signature value derived from the private key, message hash,
    /// and the value of "r". It ensures that the signature is tied to both the
    /// message and the private key of the sender.
    #[prost(bytes = "bytes", tag = "12")]
    pub s: ::prost::bytes::Bytes,
}
/// ExtensionOptionsEthereumTx is an extension option for ethereum transactions
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExtensionOptionsEthereumTx {}
/// MsgEthereumTxResponse defines the Msg/EthereumTx response type.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgEthereumTxResponse {
    /// hash of the ethereum transaction in hex format. This hash differs from the
    /// Tendermint sha256 hash of the transaction bytes. See
    /// <https://github.com/tendermint/tendermint/issues/6539> for reference
    #[prost(string, tag = "1")]
    pub hash: ::prost::alloc::string::String,
    /// logs contains the transaction hash and the proto-compatible ethereum
    /// logs.
    #[prost(message, repeated, tag = "2")]
    pub logs: ::prost::alloc::vec::Vec<Log>,
    /// ret is the returned data from evm function (result or data supplied with
    /// revert opcode)
    #[prost(bytes = "bytes", tag = "3")]
    pub ret: ::prost::bytes::Bytes,
    /// vm_error is the error returned by vm execution
    #[prost(string, tag = "4")]
    pub vm_error: ::prost::alloc::string::String,
    /// gas_used specifies how much gas was consumed by the transaction
    #[prost(uint64, tag = "5")]
    pub gas_used: u64,
}
/// MsgUpdateParams defines a Msg for updating the x/evm module parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgUpdateParams {
    /// authority is the address of the governance account.
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// params defines the x/evm parameters to update.
    /// NOTE: All parameters must be supplied.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<Params>,
}
/// MsgUpdateParamsResponse defines the response structure for executing a
/// MsgUpdateParams message.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgUpdateParamsResponse {}
/// MsgCreateFunToken: Arguments to create a "FunToken" mapping. Either the ERC20
/// contract address can be given to create the mapping to a Bank Coin, or the
/// denomination for a Bank Coin can be given to create the mapping to an ERC20.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgCreateFunToken {
    /// Hexadecimal address of the ERC20 token to which the `FunToken` maps
    #[prost(string, tag = "1")]
    pub from_erc20: ::prost::alloc::string::String,
    /// Coin denomination in the Bank Module.
    #[prost(string, tag = "2")]
    pub from_bank_denom: ::prost::alloc::string::String,
    /// Sender: Address for the signer of the transaction.
    #[prost(string, tag = "3")]
    pub sender: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgCreateFunTokenResponse {
    /// Fungible token mapping corresponding to ERC20 tokens.
    #[prost(message, optional, tag = "1")]
    pub funtoken_mapping: ::core::option::Option<FunToken>,
}
/// MsgConvertCoinToEvm: Arguments to send a Bank Coin to ERC-20 representation
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgConvertCoinToEvm {
    /// Hexadecimal address of the ERC20 token to which the `FunToken` maps
    #[prost(string, tag = "1")]
    pub to_eth_addr: ::prost::alloc::string::String,
    /// Sender: Address for the signer of the transaction.
    #[prost(string, tag = "2")]
    pub sender: ::prost::alloc::string::String,
    /// Bank Coin to get converted to ERC20
    #[prost(message, optional, tag = "3")]
    pub bank_coin:
        ::core::option::Option<crate::proto::cosmos::base::v1beta1::Coin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MsgConvertCoinToEvmResponse {}
/// QueryEthAccountRequest is the request type for the Query/Account RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEthAccountRequest {
    /// address is the Ethereum hex address or nibi Bech32 address to query the account for.
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
}
/// QueryEthAccountResponse is the response type for the Query/EthAccount RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEthAccountResponse {
    /// balance is the balance of unibi (micronibi).
    #[prost(string, tag = "1")]
    pub balance: ::prost::alloc::string::String,
    /// balance_wei is the balance of wei (attoether, where NIBI is ether).
    #[prost(string, tag = "2")]
    pub balance_wei: ::prost::alloc::string::String,
    /// code_hash is the hex-formatted code bytes from the EOA.
    #[prost(string, tag = "3")]
    pub code_hash: ::prost::alloc::string::String,
    /// nonce is the account's sequence number.
    #[prost(uint64, tag = "4")]
    pub nonce: u64,
    /// eth_address: The hexadecimal-encoded string representing the 20 byte address
    /// of a Nibiru EVM account.
    #[prost(string, tag = "5")]
    pub eth_address: ::prost::alloc::string::String,
    /// bech32_address is the nibi-prefixed address of the account that can receive
    /// bank transfers ("cosmos.bank.v1beta1.MsgSend").
    #[prost(string, tag = "6")]
    pub bech32_address: ::prost::alloc::string::String,
}
/// QueryValidatorAccountRequest is the request type for the
/// Query/ValidatorAccount RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryValidatorAccountRequest {
    /// cons_address is the validator cons address to query the account for.
    #[prost(string, tag = "1")]
    pub cons_address: ::prost::alloc::string::String,
}
/// QueryValidatorAccountResponse is the response type for the
/// Query/ValidatorAccount RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryValidatorAccountResponse {
    /// account_address is the Nibiru address of the account in bech32 format.
    #[prost(string, tag = "1")]
    pub account_address: ::prost::alloc::string::String,
    /// sequence is the account's sequence number.
    #[prost(uint64, tag = "2")]
    pub sequence: u64,
    /// account_number is the account number
    #[prost(uint64, tag = "3")]
    pub account_number: u64,
}
/// QueryBalanceRequest is the request type for the Query/Balance RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryBalanceRequest {
    /// address is the ethereum hex address to query the balance for.
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
}
/// QueryBalanceResponse is the response type for the Query/Balance RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryBalanceResponse {
    /// balance is the balance of the EVM denomination
    #[prost(string, tag = "1")]
    pub balance: ::prost::alloc::string::String,
    /// balance is the balance of the EVM denomination in units of wei.
    #[prost(string, tag = "2")]
    pub balance_wei: ::prost::alloc::string::String,
}
/// QueryStorageRequest is the request type for the Query/Storage RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryStorageRequest {
    /// address is the ethereum hex address to query the storage state for.
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    /// key defines the key of the storage state
    #[prost(string, tag = "2")]
    pub key: ::prost::alloc::string::String,
}
/// QueryStorageResponse is the response type for the Query/Storage RPC
/// method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryStorageResponse {
    /// value defines the storage state value hash associated with the given key.
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
/// QueryCodeRequest is the request type for the Query/Code RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryCodeRequest {
    /// address is the ethereum hex address to query the code for.
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
}
/// QueryCodeResponse is the response type for the Query/Code RPC
/// method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryCodeResponse {
    /// code represents the code bytes from an ethereum address.
    #[prost(bytes = "bytes", tag = "1")]
    pub code: ::prost::bytes::Bytes,
}
/// QueryTxLogsRequest is the request type for the Query/TxLogs RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTxLogsRequest {
    /// hash is the ethereum transaction hex hash to query the logs for.
    #[prost(string, tag = "1")]
    pub hash: ::prost::alloc::string::String,
    /// pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination: ::core::option::Option<
        crate::proto::cosmos::base::query::v1beta1::PageRequest,
    >,
}
/// QueryTxLogsResponse is the response type for the Query/TxLogs RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTxLogsResponse {
    /// logs represents the ethereum logs generated from the given transaction.
    #[prost(message, repeated, tag = "1")]
    pub logs: ::prost::alloc::vec::Vec<Log>,
    /// pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination: ::core::option::Option<
        crate::proto::cosmos::base::query::v1beta1::PageResponse,
    >,
}
/// QueryParamsRequest defines the request type for querying x/evm parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryParamsRequest {}
/// QueryParamsResponse defines the response type for querying x/evm parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryParamsResponse {
    /// params define the evm module parameters.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
}
/// EthCallRequest defines EthCall request
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EthCallRequest {
    /// args uses the same json format as the json rpc api.
    #[prost(bytes = "bytes", tag = "1")]
    pub args: ::prost::bytes::Bytes,
    /// gas_cap defines the default gas cap to be used
    #[prost(uint64, tag = "2")]
    pub gas_cap: u64,
    /// proposer_address of the requested block in hex format
    #[prost(bytes = "bytes", tag = "3")]
    pub proposer_address: ::prost::bytes::Bytes,
    /// chain_id is the eip155 chain id parsed from the requested block header
    #[prost(int64, tag = "4")]
    pub chain_id: i64,
}
/// EstimateGasResponse defines EstimateGas response
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EstimateGasResponse {
    /// gas returns the estimated gas
    #[prost(uint64, tag = "1")]
    pub gas: u64,
}
/// QueryTraceTxRequest defines TraceTx request
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTraceTxRequest {
    /// msg is the MsgEthereumTx for the requested transaction
    #[prost(message, optional, tag = "1")]
    pub msg: ::core::option::Option<MsgEthereumTx>,
    /// trace_config holds extra parameters to trace functions.
    #[prost(message, optional, tag = "3")]
    pub trace_config: ::core::option::Option<TraceConfig>,
    /// predecessors is an array of transactions included in the same block
    /// need to be replayed first to get correct context for tracing.
    #[prost(message, repeated, tag = "4")]
    pub predecessors: ::prost::alloc::vec::Vec<MsgEthereumTx>,
    /// block_number of requested transaction
    #[prost(int64, tag = "5")]
    pub block_number: i64,
    /// block_hash of requested transaction
    #[prost(string, tag = "6")]
    pub block_hash: ::prost::alloc::string::String,
    /// block_time of requested transaction
    #[prost(message, optional, tag = "7")]
    pub block_time: ::core::option::Option<::prost_types::Timestamp>,
    /// proposer_address is the proposer of the requested block
    #[prost(bytes = "bytes", tag = "8")]
    pub proposer_address: ::prost::bytes::Bytes,
    /// chain_id is the the eip155 chain id parsed from the requested block header
    #[prost(int64, tag = "9")]
    pub chain_id: i64,
    /// block_max_gas of the block of the requested transaction
    #[prost(int64, tag = "10")]
    pub block_max_gas: i64,
}
/// QueryTraceTxResponse defines TraceTx response
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTraceTxResponse {
    /// data is the response serialized in bytes
    #[prost(bytes = "bytes", tag = "1")]
    pub data: ::prost::bytes::Bytes,
}
/// QueryTraceBlockRequest defines TraceTx request
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTraceBlockRequest {
    /// txs is an array of messages in the block
    #[prost(message, repeated, tag = "1")]
    pub txs: ::prost::alloc::vec::Vec<MsgEthereumTx>,
    /// trace_config holds extra parameters to trace functions.
    #[prost(message, optional, tag = "3")]
    pub trace_config: ::core::option::Option<TraceConfig>,
    /// block_number of the traced block
    #[prost(int64, tag = "5")]
    pub block_number: i64,
    /// block_hash (hex) of the traced block
    #[prost(string, tag = "6")]
    pub block_hash: ::prost::alloc::string::String,
    /// block_time of the traced block
    #[prost(message, optional, tag = "7")]
    pub block_time: ::core::option::Option<::prost_types::Timestamp>,
    /// proposer_address is the address of the requested block
    #[prost(bytes = "bytes", tag = "8")]
    pub proposer_address: ::prost::bytes::Bytes,
    /// chain_id is the eip155 chain id parsed from the requested block header
    #[prost(int64, tag = "9")]
    pub chain_id: i64,
    /// block_max_gas of the traced block
    #[prost(int64, tag = "10")]
    pub block_max_gas: i64,
}
/// QueryTraceBlockResponse defines TraceBlock response
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryTraceBlockResponse {
    /// data is the response serialized in bytes
    #[prost(bytes = "bytes", tag = "1")]
    pub data: ::prost::bytes::Bytes,
}
/// QueryBaseFeeRequest defines the request type for querying the EIP1559 base
/// fee.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryBaseFeeRequest {}
/// QueryBaseFeeResponse returns the EIP1559 base fee.
/// See <https://github.com/ethereum/EIPs/blob/ba6c342c23164072adb500c3136e3ae6eabff306/EIPS/eip-1559.md.>
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryBaseFeeResponse {
    /// base_fee is the EIP1559 base fee in units of wei.
    #[prost(string, tag = "1")]
    pub base_fee: ::prost::alloc::string::String,
    /// base_fee is the EIP1559 base fee in units of micronibi ("unibi").
    #[prost(string, tag = "2")]
    pub base_fee_unibi: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryFunTokenMappingRequest {
    /// Either the hexadecimal-encoded ERC20 contract address or denomination of the
    /// Bank Coin.
    #[prost(string, tag = "1")]
    pub token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryFunTokenMappingResponse {
    /// fun_token is a mapping between the Bank Coin and the ERC20 contract address
    #[prost(message, optional, tag = "1")]
    pub fun_token: ::core::option::Option<FunToken>,
}
// @@protoc_insertion_point(module)