import { BinaryReader, BinaryWriter } from "../../../../binary.js";
import { DeepPartial } from "../../../../helpers.js";

//#region src/cosmos/evm/vm/v1/evm.d.ts
/** AccessType defines the types of permissions for the operations */
declare enum AccessType {
  /** ACCESS_TYPE_PERMISSIONLESS - ACCESS_TYPE_PERMISSIONLESS does not restrict the operation to anyone */
  ACCESS_TYPE_PERMISSIONLESS = 0,
  /** ACCESS_TYPE_RESTRICTED - ACCESS_TYPE_RESTRICTED restrict the operation to anyone */
  ACCESS_TYPE_RESTRICTED = 1,
  /** ACCESS_TYPE_PERMISSIONED - ACCESS_TYPE_PERMISSIONED only allows the operation for specific addresses */
  ACCESS_TYPE_PERMISSIONED = 2,
  UNRECOGNIZED = -1
}
declare const AccessTypeAmino: typeof AccessType;
declare function accessTypeFromJSON(object: any): AccessType;
declare function accessTypeToJSON(object: AccessType): string;
/**
 * Params defines the EVM module parameters
 * @name Params
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Params
 */
interface Params {
  /**
   * evm_denom represents the token denomination used to run the EVM state
   * transitions.
   */
  evmDenom: string;
  /**
   * extra_eips defines the additional EIPs for the vm.Config
   */
  extraEips: bigint[];
  /**
   * evm_channels is the list of channel identifiers from EVM compatible chains
   */
  evmChannels: string[];
  /**
   * access_control defines the permission policy of the EVM
   */
  accessControl: AccessControl;
  /**
   * active_static_precompiles defines the slice of hex addresses of the
   * precompiled contracts that are active
   */
  activeStaticPrecompiles: string[];
  historyServeWindow: bigint;
  extendedDenomOptions?: ExtendedDenomOptions;
}
interface ParamsProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.Params";
  value: Uint8Array;
}
/**
 * Params defines the EVM module parameters
 * @name ParamsAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Params
 */
interface ParamsAmino {
  /**
   * evm_denom represents the token denomination used to run the EVM state
   * transitions.
   */
  evm_denom: string;
  /**
   * extra_eips defines the additional EIPs for the vm.Config
   */
  extra_eips: string[];
  /**
   * evm_channels is the list of channel identifiers from EVM compatible chains
   */
  evm_channels: string[];
  /**
   * access_control defines the permission policy of the EVM
   */
  access_control: AccessControlAmino;
  /**
   * active_static_precompiles defines the slice of hex addresses of the
   * precompiled contracts that are active
   */
  active_static_precompiles: string[];
  history_serve_window: string;
  extended_denom_options?: ExtendedDenomOptionsAmino;
}
interface ParamsAminoMsg {
  type: "cosmos/evm/x/vm/Params";
  value: ParamsAmino;
}
/**
 * @name ExtendedDenomOptions
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ExtendedDenomOptions
 */
interface ExtendedDenomOptions {
  extendedDenom: string;
}
interface ExtendedDenomOptionsProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.ExtendedDenomOptions";
  value: Uint8Array;
}
/**
 * @name ExtendedDenomOptionsAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ExtendedDenomOptions
 */
interface ExtendedDenomOptionsAmino {
  extended_denom: string;
}
interface ExtendedDenomOptionsAminoMsg {
  type: "cosmos-sdk/ExtendedDenomOptions";
  value: ExtendedDenomOptionsAmino;
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 * @name AccessControl
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControl
 */
interface AccessControl {
  /**
   * create defines the permission policy for creating contracts
   */
  create: AccessControlType;
  /**
   * call defines the permission policy for calling contracts
   */
  call: AccessControlType;
}
interface AccessControlProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.AccessControl";
  value: Uint8Array;
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 * @name AccessControlAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControl
 */
interface AccessControlAmino {
  /**
   * create defines the permission policy for creating contracts
   */
  create: AccessControlTypeAmino;
  /**
   * call defines the permission policy for calling contracts
   */
  call: AccessControlTypeAmino;
}
interface AccessControlAminoMsg {
  type: "cosmos-sdk/AccessControl";
  value: AccessControlAmino;
}
/**
 * AccessControlType defines the permission type for policies
 * @name AccessControlType
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControlType
 */
interface AccessControlType {
  /**
   * access_type defines which type of permission is required for the operation
   */
  accessType: AccessType;
  /**
   * access_control_list defines defines different things depending on the
   * AccessType:
   * - ACCESS_TYPE_PERMISSIONLESS: list of addresses that are blocked from
   * performing the operation
   * - ACCESS_TYPE_RESTRICTED: ignored
   * - ACCESS_TYPE_PERMISSIONED: list of addresses that are allowed to perform
   * the operation
   */
  accessControlList: string[];
}
interface AccessControlTypeProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.AccessControlType";
  value: Uint8Array;
}
/**
 * AccessControlType defines the permission type for policies
 * @name AccessControlTypeAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControlType
 */
interface AccessControlTypeAmino {
  /**
   * access_type defines which type of permission is required for the operation
   */
  access_type: AccessType;
  /**
   * access_control_list defines defines different things depending on the
   * AccessType:
   * - ACCESS_TYPE_PERMISSIONLESS: list of addresses that are blocked from
   * performing the operation
   * - ACCESS_TYPE_RESTRICTED: ignored
   * - ACCESS_TYPE_PERMISSIONED: list of addresses that are allowed to perform
   * the operation
   */
  access_control_list: string[];
}
interface AccessControlTypeAminoMsg {
  type: "cosmos-sdk/AccessControlType";
  value: AccessControlTypeAmino;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfig
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ChainConfig
 */
interface ChainConfig {
  /**
   * homestead_block switch (nil no fork, 0 = already homestead)
   */
  homesteadBlock: string;
  /**
   * dao_fork_block corresponds to TheDAO hard-fork switch block (nil no fork)
   */
  daoForkBlock: string;
  /**
   * dao_fork_support defines whether the nodes supports or opposes the DAO
   * hard-fork
   */
  daoForkSupport: boolean;
  /**
   * eip150_block: EIP150 implements the Gas price changes
   * (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
   */
  eip150Block: string;
  /**
   * eip155_block: EIP155Block HF block
   */
  eip155Block: string;
  /**
   * eip158_block: EIP158 HF block
   */
  eip158Block: string;
  /**
   * byzantium_block: Byzantium switch block (nil no fork, 0 = already on
   * byzantium)
   */
  byzantiumBlock: string;
  /**
   * constantinople_block: Constantinople switch block (nil no fork, 0 = already
   * activated)
   */
  constantinopleBlock: string;
  /**
   * petersburg_block: Petersburg switch block (nil same as Constantinople)
   */
  petersburgBlock: string;
  /**
   * istanbul_block: Istanbul switch block (nil no fork, 0 = already on
   * istanbul)
   */
  istanbulBlock: string;
  /**
   * muir_glacier_block: Eip-2384 (bomb delay) switch block (nil no fork, 0 =
   * already activated)
   */
  muirGlacierBlock: string;
  /**
   * berlin_block: Berlin switch block (nil = no fork, 0 = already on berlin)
   */
  berlinBlock: string;
  /**
   * london_block: London switch block (nil = no fork, 0 = already on london)
   */
  londonBlock: string;
  /**
   * arrow_glacier_block: Eip-4345 (bomb delay) switch block (nil = no fork, 0 =
   * already activated)
   */
  arrowGlacierBlock: string;
  /**
   * gray_glacier_block: EIP-5133 (bomb delay) switch block (nil = no fork, 0 =
   * already activated)
   */
  grayGlacierBlock: string;
  /**
   * merge_netsplit_block: Virtual fork after The Merge to use as a network
   * splitter
   */
  mergeNetsplitBlock: string;
  /**
   * chain_id is the id of the chain (EIP-155)
   */
  chainId: bigint;
  /**
   * denom is the denomination used on the EVM
   */
  denom: string;
  /**
   * decimals is the real decimal precision of the denomination used on the EVM
   */
  decimals: bigint;
  /**
   * shanghai_time: Shanghai switch time (nil = no fork, 0 = already on
   * shanghai)
   */
  shanghaiTime: string;
  /**
   * cancun_time: Cancun switch time (nil = no fork, 0 = already on cancun)
   */
  cancunTime: string;
  /**
   * prague_time: Prague switch time (nil = no fork, 0 = already on prague)
   */
  pragueTime: string;
  /**
   * verkle_time: Verkle switch time (nil = no fork, 0 = already on verkle)
   */
  verkleTime: string;
  /**
   * osaka_time: Osaka switch time (nil = no fork, 0 = already on osaka)
   */
  osakaTime: string;
}
interface ChainConfigProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.ChainConfig";
  value: Uint8Array;
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfigAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ChainConfig
 */
interface ChainConfigAmino {
  /**
   * homestead_block switch (nil no fork, 0 = already homestead)
   */
  homestead_block: string;
  /**
   * dao_fork_block corresponds to TheDAO hard-fork switch block (nil no fork)
   */
  dao_fork_block: string;
  /**
   * dao_fork_support defines whether the nodes supports or opposes the DAO
   * hard-fork
   */
  dao_fork_support: boolean;
  /**
   * eip150_block: EIP150 implements the Gas price changes
   * (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
   */
  eip150_block: string;
  /**
   * eip155_block: EIP155Block HF block
   */
  eip155_block: string;
  /**
   * eip158_block: EIP158 HF block
   */
  eip158_block: string;
  /**
   * byzantium_block: Byzantium switch block (nil no fork, 0 = already on
   * byzantium)
   */
  byzantium_block: string;
  /**
   * constantinople_block: Constantinople switch block (nil no fork, 0 = already
   * activated)
   */
  constantinople_block: string;
  /**
   * petersburg_block: Petersburg switch block (nil same as Constantinople)
   */
  petersburg_block: string;
  /**
   * istanbul_block: Istanbul switch block (nil no fork, 0 = already on
   * istanbul)
   */
  istanbul_block: string;
  /**
   * muir_glacier_block: Eip-2384 (bomb delay) switch block (nil no fork, 0 =
   * already activated)
   */
  muir_glacier_block: string;
  /**
   * berlin_block: Berlin switch block (nil = no fork, 0 = already on berlin)
   */
  berlin_block: string;
  /**
   * london_block: London switch block (nil = no fork, 0 = already on london)
   */
  london_block: string;
  /**
   * arrow_glacier_block: Eip-4345 (bomb delay) switch block (nil = no fork, 0 =
   * already activated)
   */
  arrow_glacier_block: string;
  /**
   * gray_glacier_block: EIP-5133 (bomb delay) switch block (nil = no fork, 0 =
   * already activated)
   */
  gray_glacier_block: string;
  /**
   * merge_netsplit_block: Virtual fork after The Merge to use as a network
   * splitter
   */
  merge_netsplit_block: string;
  /**
   * chain_id is the id of the chain (EIP-155)
   */
  chain_id: string;
  /**
   * denom is the denomination used on the EVM
   */
  denom: string;
  /**
   * decimals is the real decimal precision of the denomination used on the EVM
   */
  decimals: string;
  /**
   * shanghai_time: Shanghai switch time (nil = no fork, 0 = already on
   * shanghai)
   */
  shanghai_time: string;
  /**
   * cancun_time: Cancun switch time (nil = no fork, 0 = already on cancun)
   */
  cancun_time: string;
  /**
   * prague_time: Prague switch time (nil = no fork, 0 = already on prague)
   */
  prague_time: string;
  /**
   * verkle_time: Verkle switch time (nil = no fork, 0 = already on verkle)
   */
  verkle_time: string;
  /**
   * osaka_time: Osaka switch time (nil = no fork, 0 = already on osaka)
   */
  osaka_time: string;
}
interface ChainConfigAminoMsg {
  type: "cosmos-sdk/ChainConfig";
  value: ChainConfigAmino;
}
/**
 * State represents a single Storage key value pair item.
 * @name State
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.State
 */
interface State {
  /**
   * key is the stored key
   */
  key: string;
  /**
   * value is the stored value for the given key
   */
  value: string;
}
interface StateProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.State";
  value: Uint8Array;
}
/**
 * State represents a single Storage key value pair item.
 * @name StateAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.State
 */
interface StateAmino {
  /**
   * key is the stored key
   */
  key: string;
  /**
   * value is the stored value for the given key
   */
  value: string;
}
interface StateAminoMsg {
  type: "cosmos-sdk/State";
  value: StateAmino;
}
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 * @name TransactionLogs
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TransactionLogs
 */
interface TransactionLogs {
  /**
   * hash of the transaction
   */
  hash: string;
  /**
   * logs is an array of Logs for the given transaction hash
   */
  logs: Log[];
}
interface TransactionLogsProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.TransactionLogs";
  value: Uint8Array;
}
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 * @name TransactionLogsAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TransactionLogs
 */
interface TransactionLogsAmino {
  /**
   * hash of the transaction
   */
  hash: string;
  /**
   * logs is an array of Logs for the given transaction hash
   */
  logs: LogAmino[];
}
interface TransactionLogsAminoMsg {
  type: "cosmos-sdk/TransactionLogs";
  value: TransactionLogsAmino;
}
/**
 * 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.
 * @name Log
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Log
 */
interface Log {
  /**
   * address of the contract that generated the event
   */
  address: string;
  /**
   * topics is a list of topics provided by the contract.
   */
  topics: string[];
  /**
   * data which is supplied by the contract, usually ABI-encoded
   */
  data: Uint8Array;
  /**
   * block_number of the block in which the transaction was included
   */
  blockNumber: bigint;
  /**
   * tx_hash is the transaction hash
   */
  txHash: string;
  /**
   * tx_index of the transaction in the block
   */
  txIndex: bigint;
  /**
   * block_hash of the block in which the transaction was included
   */
  blockHash: string;
  /**
   * index of the log in the block
   */
  index: bigint;
  /**
   * 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.
   */
  removed: boolean;
  /**
   * block_timestamp is the timestamp of the block in which the transaction was
   */
  blockTimestamp: bigint;
}
interface LogProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.Log";
  value: Uint8Array;
}
/**
 * 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.
 * @name LogAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Log
 */
interface LogAmino {
  /**
   * address of the contract that generated the event
   */
  address: string;
  /**
   * topics is a list of topics provided by the contract.
   */
  topics: string[];
  /**
   * data which is supplied by the contract, usually ABI-encoded
   */
  data: string;
  /**
   * block_number of the block in which the transaction was included
   */
  block_number: string;
  /**
   * tx_hash is the transaction hash
   */
  tx_hash: string;
  /**
   * tx_index of the transaction in the block
   */
  tx_index: string;
  /**
   * block_hash of the block in which the transaction was included
   */
  block_hash: string;
  /**
   * index of the log in the block
   */
  index: string;
  /**
   * 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.
   */
  removed: boolean;
  /**
   * block_timestamp is the timestamp of the block in which the transaction was
   */
  block_timestamp: string;
}
interface LogAminoMsg {
  type: "cosmos-sdk/Log";
  value: LogAmino;
}
/**
 * TxResult stores results of Tx execution.
 * @name TxResult
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TxResult
 */
interface TxResult {
  /**
   * contract_address contains the ethereum address of the created contract (if
   * any). If the state transition is an evm.Call, the contract address will be
   * empty.
   */
  contractAddress: string;
  /**
   * bloom represents the bloom filter bytes
   */
  bloom: Uint8Array;
  /**
   * tx_logs contains the transaction hash and the proto-compatible ethereum
   * logs.
   */
  txLogs: TransactionLogs;
  /**
   * ret defines the bytes from the execution.
   */
  ret: Uint8Array;
  /**
   * reverted flag is set to true when the call has been reverted
   */
  reverted: boolean;
  /**
   * gas_used notes the amount of gas consumed while execution
   */
  gasUsed: bigint;
}
interface TxResultProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.TxResult";
  value: Uint8Array;
}
/**
 * TxResult stores results of Tx execution.
 * @name TxResultAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TxResult
 */
interface TxResultAmino {
  /**
   * contract_address contains the ethereum address of the created contract (if
   * any). If the state transition is an evm.Call, the contract address will be
   * empty.
   */
  contract_address: string;
  /**
   * bloom represents the bloom filter bytes
   */
  bloom: string;
  /**
   * tx_logs contains the transaction hash and the proto-compatible ethereum
   * logs.
   */
  tx_logs: TransactionLogsAmino;
  /**
   * ret defines the bytes from the execution.
   */
  ret: string;
  /**
   * reverted flag is set to true when the call has been reverted
   */
  reverted: boolean;
  /**
   * gas_used notes the amount of gas consumed while execution
   */
  gas_used: string;
}
interface TxResultAminoMsg {
  type: "cosmos-sdk/TxResult";
  value: TxResultAmino;
}
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTuple
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessTuple
 */
interface AccessTuple {
  /**
   * address is a hex formatted ethereum address
   */
  address: string;
  /**
   * storage_keys are hex formatted hashes of the storage keys
   */
  storageKeys: string[];
}
interface AccessTupleProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.AccessTuple";
  value: Uint8Array;
}
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTupleAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessTuple
 */
interface AccessTupleAmino {
  /**
   * address is a hex formatted ethereum address
   */
  address: string;
  /**
   * storage_keys are hex formatted hashes of the storage keys
   */
  storage_keys: string[];
}
interface AccessTupleAminoMsg {
  type: "cosmos-sdk/AccessTuple";
  value: AccessTupleAmino;
}
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfig
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TraceConfig
 */
interface TraceConfig {
  /**
   * tracer is a custom javascript tracer
   */
  tracer: string;
  /**
   * timeout overrides the default timeout of 5 seconds for JavaScript-based
   * tracing calls
   */
  timeout: string;
  /**
   * reexec defines the number of blocks the tracer is willing to go back
   */
  reexec: bigint;
  /**
   * disable_stack switches stack capture
   */
  disableStack: boolean;
  /**
   * disable_storage switches storage capture
   */
  disableStorage: boolean;
  /**
   * debug can be used to print output during capture end
   */
  debug: boolean;
  /**
   * limit defines the maximum length of output, but zero means unlimited
   */
  limit: number;
  /**
   * overrides can be used to execute a trace using future fork rules
   */
  overrides?: ChainConfig;
  /**
   * enable_memory switches memory capture
   */
  enableMemory: boolean;
  /**
   * enable_return_data switches the capture of return data
   */
  enableReturnData: boolean;
  /**
   * tracer_json_config configures the tracer using a JSON string
   */
  tracerJsonConfig: string;
}
interface TraceConfigProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.TraceConfig";
  value: Uint8Array;
}
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfigAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TraceConfig
 */
interface TraceConfigAmino {
  /**
   * tracer is a custom javascript tracer
   */
  tracer: string;
  /**
   * timeout overrides the default timeout of 5 seconds for JavaScript-based
   * tracing calls
   */
  timeout: string;
  /**
   * reexec defines the number of blocks the tracer is willing to go back
   */
  reexec: string;
  /**
   * disable_stack switches stack capture
   */
  disable_stack: boolean;
  /**
   * disable_storage switches storage capture
   */
  disable_storage: boolean;
  /**
   * debug can be used to print output during capture end
   */
  debug: boolean;
  /**
   * limit defines the maximum length of output, but zero means unlimited
   */
  limit: number;
  /**
   * overrides can be used to execute a trace using future fork rules
   */
  overrides?: ChainConfigAmino;
  /**
   * enable_memory switches memory capture
   */
  enable_memory: boolean;
  /**
   * enable_return_data switches the capture of return data
   */
  enable_return_data: boolean;
  /**
   * tracer_json_config configures the tracer using a JSON string
   */
  tracer_json_config: string;
}
interface TraceConfigAminoMsg {
  type: "cosmos-sdk/TraceConfig";
  value: TraceConfigAmino;
}
/**
 * Preinstall defines a contract that is preinstalled on-chain with a specific
 * contract address and bytecode
 * @name Preinstall
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Preinstall
 */
interface Preinstall {
  /**
   * name of the preinstall contract
   */
  name: string;
  /**
   * address in hex format of the preinstall contract
   */
  address: string;
  /**
   * code in hex format for the preinstall contract
   */
  code: string;
}
interface PreinstallProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.Preinstall";
  value: Uint8Array;
}
/**
 * Preinstall defines a contract that is preinstalled on-chain with a specific
 * contract address and bytecode
 * @name PreinstallAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Preinstall
 */
interface PreinstallAmino {
  /**
   * name of the preinstall contract
   */
  name: string;
  /**
   * address in hex format of the preinstall contract
   */
  address: string;
  /**
   * code in hex format for the preinstall contract
   */
  code: string;
}
interface PreinstallAminoMsg {
  type: "cosmos-sdk/Preinstall";
  value: PreinstallAmino;
}
/**
 * @name EvmCoinInfo
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.EvmCoinInfo
 */
interface EvmCoinInfo {
  denom: string;
  extendedDenom: string;
  displayDenom: string;
  decimals: number;
}
interface EvmCoinInfoProtoMsg {
  typeUrl: "/cosmos.evm.vm.v1.EvmCoinInfo";
  value: Uint8Array;
}
/**
 * @name EvmCoinInfoAmino
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.EvmCoinInfo
 */
interface EvmCoinInfoAmino {
  denom: string;
  extended_denom: string;
  display_denom: string;
  decimals: number;
}
interface EvmCoinInfoAminoMsg {
  type: "cosmos-sdk/EvmCoinInfo";
  value: EvmCoinInfoAmino;
}
/**
 * Params defines the EVM module parameters
 * @name Params
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Params
 */
declare const Params: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is Params;
  isAmino(o: any): o is ParamsAmino;
  encode(message: Params, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): Params;
  fromPartial(object: DeepPartial<Params>): Params;
  fromAmino(object: ParamsAmino): Params;
  toAmino(message: Params): ParamsAmino;
  fromAminoMsg(object: ParamsAminoMsg): Params;
  toAminoMsg(message: Params): ParamsAminoMsg;
  fromProtoMsg(message: ParamsProtoMsg): Params;
  toProto(message: Params): Uint8Array;
  toProtoMsg(message: Params): ParamsProtoMsg;
  registerTypeUrl(): void;
};
/**
 * @name ExtendedDenomOptions
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ExtendedDenomOptions
 */
declare const ExtendedDenomOptions: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is ExtendedDenomOptions;
  isAmino(o: any): o is ExtendedDenomOptionsAmino;
  encode(message: ExtendedDenomOptions, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): ExtendedDenomOptions;
  fromPartial(object: DeepPartial<ExtendedDenomOptions>): ExtendedDenomOptions;
  fromAmino(object: ExtendedDenomOptionsAmino): ExtendedDenomOptions;
  toAmino(message: ExtendedDenomOptions): ExtendedDenomOptionsAmino;
  fromAminoMsg(object: ExtendedDenomOptionsAminoMsg): ExtendedDenomOptions;
  toAminoMsg(message: ExtendedDenomOptions): ExtendedDenomOptionsAminoMsg;
  fromProtoMsg(message: ExtendedDenomOptionsProtoMsg): ExtendedDenomOptions;
  toProto(message: ExtendedDenomOptions): Uint8Array;
  toProtoMsg(message: ExtendedDenomOptions): ExtendedDenomOptionsProtoMsg;
  registerTypeUrl(): void;
};
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 * @name AccessControl
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControl
 */
declare const AccessControl: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is AccessControl;
  isAmino(o: any): o is AccessControlAmino;
  encode(message: AccessControl, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): AccessControl;
  fromPartial(object: DeepPartial<AccessControl>): AccessControl;
  fromAmino(object: AccessControlAmino): AccessControl;
  toAmino(message: AccessControl): AccessControlAmino;
  fromAminoMsg(object: AccessControlAminoMsg): AccessControl;
  toAminoMsg(message: AccessControl): AccessControlAminoMsg;
  fromProtoMsg(message: AccessControlProtoMsg): AccessControl;
  toProto(message: AccessControl): Uint8Array;
  toProtoMsg(message: AccessControl): AccessControlProtoMsg;
  registerTypeUrl(): void;
};
/**
 * AccessControlType defines the permission type for policies
 * @name AccessControlType
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessControlType
 */
declare const AccessControlType: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is AccessControlType;
  isAmino(o: any): o is AccessControlTypeAmino;
  encode(message: AccessControlType, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): AccessControlType;
  fromPartial(object: DeepPartial<AccessControlType>): AccessControlType;
  fromAmino(object: AccessControlTypeAmino): AccessControlType;
  toAmino(message: AccessControlType): AccessControlTypeAmino;
  fromAminoMsg(object: AccessControlTypeAminoMsg): AccessControlType;
  toAminoMsg(message: AccessControlType): AccessControlTypeAminoMsg;
  fromProtoMsg(message: AccessControlTypeProtoMsg): AccessControlType;
  toProto(message: AccessControlType): Uint8Array;
  toProtoMsg(message: AccessControlType): AccessControlTypeProtoMsg;
  registerTypeUrl(): void;
};
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 * @name ChainConfig
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.ChainConfig
 */
declare const ChainConfig: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is ChainConfig;
  isAmino(o: any): o is ChainConfigAmino;
  encode(message: ChainConfig, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): ChainConfig;
  fromPartial(object: DeepPartial<ChainConfig>): ChainConfig;
  fromAmino(object: ChainConfigAmino): ChainConfig;
  toAmino(message: ChainConfig): ChainConfigAmino;
  fromAminoMsg(object: ChainConfigAminoMsg): ChainConfig;
  toAminoMsg(message: ChainConfig): ChainConfigAminoMsg;
  fromProtoMsg(message: ChainConfigProtoMsg): ChainConfig;
  toProto(message: ChainConfig): Uint8Array;
  toProtoMsg(message: ChainConfig): ChainConfigProtoMsg;
  registerTypeUrl(): void;
};
/**
 * State represents a single Storage key value pair item.
 * @name State
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.State
 */
declare const State: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is State;
  isAmino(o: any): o is StateAmino;
  encode(message: State, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): State;
  fromPartial(object: DeepPartial<State>): State;
  fromAmino(object: StateAmino): State;
  toAmino(message: State): StateAmino;
  fromAminoMsg(object: StateAminoMsg): State;
  toAminoMsg(message: State): StateAminoMsg;
  fromProtoMsg(message: StateProtoMsg): State;
  toProto(message: State): Uint8Array;
  toProtoMsg(message: State): StateProtoMsg;
  registerTypeUrl(): void;
};
/**
 * TransactionLogs define the logs generated from a transaction execution
 * with a given hash. It it used for import/export data as transactions are not
 * persisted on blockchain state after an upgrade.
 * @name TransactionLogs
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TransactionLogs
 */
declare const TransactionLogs: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is TransactionLogs;
  isAmino(o: any): o is TransactionLogsAmino;
  encode(message: TransactionLogs, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TransactionLogs;
  fromPartial(object: DeepPartial<TransactionLogs>): TransactionLogs;
  fromAmino(object: TransactionLogsAmino): TransactionLogs;
  toAmino(message: TransactionLogs): TransactionLogsAmino;
  fromAminoMsg(object: TransactionLogsAminoMsg): TransactionLogs;
  toAminoMsg(message: TransactionLogs): TransactionLogsAminoMsg;
  fromProtoMsg(message: TransactionLogsProtoMsg): TransactionLogs;
  toProto(message: TransactionLogs): Uint8Array;
  toProtoMsg(message: TransactionLogs): TransactionLogsProtoMsg;
  registerTypeUrl(): void;
};
/**
 * 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.
 * @name Log
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Log
 */
declare const Log: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is Log;
  isAmino(o: any): o is LogAmino;
  encode(message: Log, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): Log;
  fromPartial(object: DeepPartial<Log>): Log;
  fromAmino(object: LogAmino): Log;
  toAmino(message: Log): LogAmino;
  fromAminoMsg(object: LogAminoMsg): Log;
  toAminoMsg(message: Log): LogAminoMsg;
  fromProtoMsg(message: LogProtoMsg): Log;
  toProto(message: Log): Uint8Array;
  toProtoMsg(message: Log): LogProtoMsg;
  registerTypeUrl(): void;
};
/**
 * TxResult stores results of Tx execution.
 * @name TxResult
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TxResult
 */
declare const TxResult: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is TxResult;
  isAmino(o: any): o is TxResultAmino;
  encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TxResult;
  fromPartial(object: DeepPartial<TxResult>): TxResult;
  fromAmino(object: TxResultAmino): TxResult;
  toAmino(message: TxResult): TxResultAmino;
  fromAminoMsg(object: TxResultAminoMsg): TxResult;
  toAminoMsg(message: TxResult): TxResultAminoMsg;
  fromProtoMsg(message: TxResultProtoMsg): TxResult;
  toProto(message: TxResult): Uint8Array;
  toProtoMsg(message: TxResult): TxResultProtoMsg;
  registerTypeUrl(): void;
};
/**
 * AccessTuple is the element type of an access list.
 * @name AccessTuple
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.AccessTuple
 */
declare const AccessTuple: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is AccessTuple;
  isAmino(o: any): o is AccessTupleAmino;
  encode(message: AccessTuple, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): AccessTuple;
  fromPartial(object: DeepPartial<AccessTuple>): AccessTuple;
  fromAmino(object: AccessTupleAmino): AccessTuple;
  toAmino(message: AccessTuple): AccessTupleAmino;
  fromAminoMsg(object: AccessTupleAminoMsg): AccessTuple;
  toAminoMsg(message: AccessTuple): AccessTupleAminoMsg;
  fromProtoMsg(message: AccessTupleProtoMsg): AccessTuple;
  toProto(message: AccessTuple): Uint8Array;
  toProtoMsg(message: AccessTuple): AccessTupleProtoMsg;
  registerTypeUrl(): void;
};
/**
 * TraceConfig holds extra parameters to trace functions.
 * @name TraceConfig
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.TraceConfig
 */
declare const TraceConfig: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is TraceConfig;
  isAmino(o: any): o is TraceConfigAmino;
  encode(message: TraceConfig, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): TraceConfig;
  fromPartial(object: DeepPartial<TraceConfig>): TraceConfig;
  fromAmino(object: TraceConfigAmino): TraceConfig;
  toAmino(message: TraceConfig): TraceConfigAmino;
  fromAminoMsg(object: TraceConfigAminoMsg): TraceConfig;
  toAminoMsg(message: TraceConfig): TraceConfigAminoMsg;
  fromProtoMsg(message: TraceConfigProtoMsg): TraceConfig;
  toProto(message: TraceConfig): Uint8Array;
  toProtoMsg(message: TraceConfig): TraceConfigProtoMsg;
  registerTypeUrl(): void;
};
/**
 * Preinstall defines a contract that is preinstalled on-chain with a specific
 * contract address and bytecode
 * @name Preinstall
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.Preinstall
 */
declare const Preinstall: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is Preinstall;
  isAmino(o: any): o is PreinstallAmino;
  encode(message: Preinstall, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): Preinstall;
  fromPartial(object: DeepPartial<Preinstall>): Preinstall;
  fromAmino(object: PreinstallAmino): Preinstall;
  toAmino(message: Preinstall): PreinstallAmino;
  fromAminoMsg(object: PreinstallAminoMsg): Preinstall;
  toAminoMsg(message: Preinstall): PreinstallAminoMsg;
  fromProtoMsg(message: PreinstallProtoMsg): Preinstall;
  toProto(message: Preinstall): Uint8Array;
  toProtoMsg(message: Preinstall): PreinstallProtoMsg;
  registerTypeUrl(): void;
};
/**
 * @name EvmCoinInfo
 * @package cosmos.evm.vm.v1
 * @see proto type: cosmos.evm.vm.v1.EvmCoinInfo
 */
declare const EvmCoinInfo: {
  typeUrl: string;
  aminoType: string;
  is(o: any): o is EvmCoinInfo;
  isAmino(o: any): o is EvmCoinInfoAmino;
  encode(message: EvmCoinInfo, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): EvmCoinInfo;
  fromPartial(object: DeepPartial<EvmCoinInfo>): EvmCoinInfo;
  fromAmino(object: EvmCoinInfoAmino): EvmCoinInfo;
  toAmino(message: EvmCoinInfo): EvmCoinInfoAmino;
  fromAminoMsg(object: EvmCoinInfoAminoMsg): EvmCoinInfo;
  toAminoMsg(message: EvmCoinInfo): EvmCoinInfoAminoMsg;
  fromProtoMsg(message: EvmCoinInfoProtoMsg): EvmCoinInfo;
  toProto(message: EvmCoinInfo): Uint8Array;
  toProtoMsg(message: EvmCoinInfo): EvmCoinInfoProtoMsg;
  registerTypeUrl(): void;
};
//#endregion
export { AccessControl, AccessControlAmino, AccessControlAminoMsg, AccessControlProtoMsg, AccessControlType, AccessControlTypeAmino, AccessControlTypeAminoMsg, AccessControlTypeProtoMsg, AccessTuple, AccessTupleAmino, AccessTupleAminoMsg, AccessTupleProtoMsg, AccessType, AccessTypeAmino, ChainConfig, ChainConfigAmino, ChainConfigAminoMsg, ChainConfigProtoMsg, EvmCoinInfo, EvmCoinInfoAmino, EvmCoinInfoAminoMsg, EvmCoinInfoProtoMsg, ExtendedDenomOptions, ExtendedDenomOptionsAmino, ExtendedDenomOptionsAminoMsg, ExtendedDenomOptionsProtoMsg, Log, LogAmino, LogAminoMsg, LogProtoMsg, Params, ParamsAmino, ParamsAminoMsg, ParamsProtoMsg, Preinstall, PreinstallAmino, PreinstallAminoMsg, PreinstallProtoMsg, State, StateAmino, StateAminoMsg, StateProtoMsg, TraceConfig, TraceConfigAmino, TraceConfigAminoMsg, TraceConfigProtoMsg, TransactionLogs, TransactionLogsAmino, TransactionLogsAminoMsg, TransactionLogsProtoMsg, TxResult, TxResultAmino, TxResultAminoMsg, TxResultProtoMsg, accessTypeFromJSON, accessTypeToJSON };