import Long from "long";
import _m0 from "protobufjs/minimal";
export declare const protobufPackage = "cosmos.evm.vm.v1";
/** AccessType defines the types of permissions for the operations */
export 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
}
export declare function accessTypeFromJSON(object: any): AccessType;
export declare function accessTypeToJSON(object: AccessType): string;
/** Params defines the EVM module parameters */
export 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: Long[];
    /** 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 | undefined;
    /**
     * active_static_precompiles defines the slice of hex addresses of the
     * precompiled contracts that are active
     */
    activeStaticPrecompiles: string[];
    historyServeWindow: Long;
    extendedDenomOptions: ExtendedDenomOptions | undefined;
}
export interface ExtendedDenomOptions {
    extendedDenom: string;
}
/**
 * AccessControl defines the permission policy of the EVM
 * for creating and calling contracts
 */
export interface AccessControl {
    /** create defines the permission policy for creating contracts */
    create: AccessControlType | undefined;
    /** call defines the permission policy for calling contracts */
    call: AccessControlType | undefined;
}
/** AccessControlType defines the permission type for policies */
export 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[];
}
/**
 * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
 * instead of *big.Int.
 */
export 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: Long;
    /** denom is the denomination used on the EVM */
    denom: string;
    /** decimals is the real decimal precision of the denomination used on the EVM */
    decimals: Long;
    /**
     * 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;
}
/** State represents a single Storage key value pair item. */
export interface State {
    /** key is the stored key */
    key: string;
    /** value is the stored value for the given key */
    value: string;
}
/**
 * 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.
 */
export interface TransactionLogs {
    /** hash of the transaction */
    hash: string;
    /** logs is an array of Logs for the given transaction hash */
    logs: Log[];
}
/**
 * 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.
 */
export 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: Long;
    /** tx_hash is the transaction hash */
    txHash: string;
    /** tx_index of the transaction in the block */
    txIndex: Long;
    /** block_hash of the block in which the transaction was included */
    blockHash: string;
    /** index of the log in the block */
    index: Long;
    /**
     * 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: Long;
}
/** TxResult stores results of Tx execution. */
export 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 | undefined;
    /** 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: Long;
}
/** AccessTuple is the element type of an access list. */
export interface AccessTuple {
    /** address is a hex formatted ethereum address */
    address: string;
    /** storage_keys are hex formatted hashes of the storage keys */
    storageKeys: string[];
}
/** TraceConfig holds extra parameters to trace functions. */
export 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: Long;
    /** 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 | undefined;
    /** 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;
}
/**
 * Preinstall defines a contract that is preinstalled on-chain with a specific
 * contract address and bytecode
 */
export 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;
}
export interface EvmCoinInfo {
    denom: string;
    extendedDenom: string;
    displayDenom: string;
    decimals: number;
}
export declare const Params: {
    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
    fromJSON(object: any): Params;
    toJSON(message: Params): unknown;
    create(base?: DeepPartial<Params>): Params;
    fromPartial(object: DeepPartial<Params>): Params;
};
export declare const ExtendedDenomOptions: {
    encode(message: ExtendedDenomOptions, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ExtendedDenomOptions;
    fromJSON(object: any): ExtendedDenomOptions;
    toJSON(message: ExtendedDenomOptions): unknown;
    create(base?: DeepPartial<ExtendedDenomOptions>): ExtendedDenomOptions;
    fromPartial(object: DeepPartial<ExtendedDenomOptions>): ExtendedDenomOptions;
};
export declare const AccessControl: {
    encode(message: AccessControl, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): AccessControl;
    fromJSON(object: any): AccessControl;
    toJSON(message: AccessControl): unknown;
    create(base?: DeepPartial<AccessControl>): AccessControl;
    fromPartial(object: DeepPartial<AccessControl>): AccessControl;
};
export declare const AccessControlType: {
    encode(message: AccessControlType, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): AccessControlType;
    fromJSON(object: any): AccessControlType;
    toJSON(message: AccessControlType): unknown;
    create(base?: DeepPartial<AccessControlType>): AccessControlType;
    fromPartial(object: DeepPartial<AccessControlType>): AccessControlType;
};
export declare const ChainConfig: {
    encode(message: ChainConfig, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): ChainConfig;
    fromJSON(object: any): ChainConfig;
    toJSON(message: ChainConfig): unknown;
    create(base?: DeepPartial<ChainConfig>): ChainConfig;
    fromPartial(object: DeepPartial<ChainConfig>): ChainConfig;
};
export declare const State: {
    encode(message: State, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): State;
    fromJSON(object: any): State;
    toJSON(message: State): unknown;
    create(base?: DeepPartial<State>): State;
    fromPartial(object: DeepPartial<State>): State;
};
export declare const TransactionLogs: {
    encode(message: TransactionLogs, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TransactionLogs;
    fromJSON(object: any): TransactionLogs;
    toJSON(message: TransactionLogs): unknown;
    create(base?: DeepPartial<TransactionLogs>): TransactionLogs;
    fromPartial(object: DeepPartial<TransactionLogs>): TransactionLogs;
};
export declare const Log: {
    encode(message: Log, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Log;
    fromJSON(object: any): Log;
    toJSON(message: Log): unknown;
    create(base?: DeepPartial<Log>): Log;
    fromPartial(object: DeepPartial<Log>): Log;
};
export declare const TxResult: {
    encode(message: TxResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TxResult;
    fromJSON(object: any): TxResult;
    toJSON(message: TxResult): unknown;
    create(base?: DeepPartial<TxResult>): TxResult;
    fromPartial(object: DeepPartial<TxResult>): TxResult;
};
export declare const AccessTuple: {
    encode(message: AccessTuple, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): AccessTuple;
    fromJSON(object: any): AccessTuple;
    toJSON(message: AccessTuple): unknown;
    create(base?: DeepPartial<AccessTuple>): AccessTuple;
    fromPartial(object: DeepPartial<AccessTuple>): AccessTuple;
};
export declare const TraceConfig: {
    encode(message: TraceConfig, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TraceConfig;
    fromJSON(object: any): TraceConfig;
    toJSON(message: TraceConfig): unknown;
    create(base?: DeepPartial<TraceConfig>): TraceConfig;
    fromPartial(object: DeepPartial<TraceConfig>): TraceConfig;
};
export declare const Preinstall: {
    encode(message: Preinstall, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Preinstall;
    fromJSON(object: any): Preinstall;
    toJSON(message: Preinstall): unknown;
    create(base?: DeepPartial<Preinstall>): Preinstall;
    fromPartial(object: DeepPartial<Preinstall>): Preinstall;
};
export declare const EvmCoinInfo: {
    encode(message: EvmCoinInfo, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): EvmCoinInfo;
    fromJSON(object: any): EvmCoinInfo;
    toJSON(message: EvmCoinInfo): unknown;
    create(base?: DeepPartial<EvmCoinInfo>): EvmCoinInfo;
    fromPartial(object: DeepPartial<EvmCoinInfo>): EvmCoinInfo;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export {};