evm

package
v2.17.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 22, 2026 License: BSD-2-Clause Imports: 76 Imported by: 0

README

Nibiru - /evm

Nibiru EVM: the Go implementation of Nibiru's Ethereum-compatible execution layer. This package holds the Cosmos SDK module, state keeper, ante handlers, transaction types, and Nibiru-specific EVM precompiles.

⚡ NibiruChain/Nibiru/evm
├── 📂 cli              # `nibid` query and tx helpers for the EVM module
├── 📂 e2e              # JSON-RPC integration tests (ethers.js, Hardhat, Bun)
├── 📂 embeds           # Solidity fixtures and `@nibiruchain/solidity` publish artifacts
├── 📂 evmante          # AnteHandler steps for `MsgEthereumTx`
├── 📂 evmmodule        # Cosmos SDK `AppModule` wiring
├── 📂 evmstate         # EVM keeper, `StateDB` (`SDB`), and message server
├── 📂 evmtest          # Shared Go test helpers for EVM unit and integration tests
├── 📂 forge            # Foundry workspace for Solidity dev and passkey/P-256 tests
├── 📂 precompile       # Nibiru custom precompiles (FunToken, Oracle, Wasm, P-256)
├── *.go                # Core types: txs, genesis, params, FunToken, zero-gas
└── README.md

Related paths outside this directory:

  • directory eth/ — Ethereum JSON-RPC, account encoding, EIP-712 signing
  • directory proto/eth/evm/v1/ — protobuf definitions for the EVM module

Hacking

Install command just to run repo-level recipes. From the repository root, run command just -l to list them.

Go unit tests

Run package tests from the repository root:

go test ./evm/...

The directory evm/evmtest/ exports helpers used across EVM-related tests in this repo.

EVM end-to-end tests

The directory evm/e2e/ runs integration tests against a live Nibiru node with JSON-RPC enabled. See file evm/e2e/README.md for setup (localnet, .env, passkey/ERC-4337 flows).

From the repository root:

just test-e2e   # requires localnet; runs `just test` in evm/e2e/

Or from directory evm/e2e/:

just install
just test
Solidity embeds

Directory evm/embeds/ holds Hardhat-compiled test contracts and the npm package @nibiruchain/solidity. Regenerate ABIs with:

just gen-embeds

See file evm/embeds/README.md for npm usage.

Foundry workspace

Directory evm/forge/ is a Foundry project for Solidity development, including passkey/P-256 smart-account tests. See file evm/forge/README.md.

Precompiles

Package evm/precompile registers Nibiru custom precompiles alongside the standard Berlin set:

Precompile Address
FunToken 0x0000000000000000000000000000000000000800
Oracle 0x0000000000000000000000000000000000000801
Wasm 0x0000000000000000000000000000000000000802
P-256 (RIP-7212) 0x0000000000000000000000000000000000000100

Public docs: Nibiru EVM precompiles.

Zero-gas EVM fee exemption

EVM transactions whose to address is listed in always_zero_gas_contracts and whose transaction data passes normal non-fee validation are treated as fee-exempt. The raw signed Ethereum transaction is preserved for signature checks, transaction hashes, RPC transaction views, tracing, and debugging. After classification, the derived EVM execution message uses zero fee-price fields, and native NIBI gas fees are not required, deducted, burned, tipped, or refunded. If the transaction attaches native value through field msg.value, the sender must still have enough EVM native balance to cover that value.

Operators can recompute eligibility from recorded chain data:

nibid q sudo zero-gas-actors --height <height>
nibid q tx <tx-hash> --height <height>

Decode message type MsgEthereumTx, compare its signed to field against the allowlist at the transaction height, and confirm that the sender's native NIBI balance did not decrease by an EVM gas payment. A nonzero value may still move native NIBI as part of EVM execution. Fee-exempt EVM transactions still meter execution gas and count against block gas limits; event field EventEthereumTx.gas_used may be nonzero, while the usual tx.fee event from EVM gas deduction is absent.

Documentation

Overview

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Package evm is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Package evm is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Index

Constants

View Source 
const (
	// COMMIT_READONLY: Value to use for "commit" for any EVM queries, tracing,
	// or other read operations.
	//
	// Although counterintuitive, "commit" should be false when we apply multiple
	// EVM messages to the same `evmObj (*vm.EVM)`. The same VM can be used
	// for consecutive EVM operations, and "commit" should only occur at the
	// end when the transaction is successful and will be finalized.
	COMMIT_READONLY = false

	// COMMIT_ETH_TX: The counterpart to [COMMIT_CALL] used as the value for
	// "commit" in any Ethereum transaction ("eth.evm.v1.MsgEthereumTx").
	COMMIT_ETH_TX = true

	// Erc20GasLimitExecute used for transfer, mint and burn.
	// All must not exceed 200_000
	Erc20GasLimitExecute uint64 = 200_000

	// Erc20GasLimitQuery is the shared cap for readonly ERC20 calls such as
	// balanceOf, name, symbol, and decimals. Keep this small because only
	// malicious contracts should need more.
	Erc20GasLimitQuery uint64 = 100_000
)
View Source 
const (
	CtxKeyEvmSimulation            contextKey = "evm_simulation"
	CtxKeyGasEstimateZeroTolerance contextKey = "gas_estimate_zero_tolerance"
	CtxKeyZeroGasMeta              contextKey = "zero_gas_meta"
	CtxKeyEvmEventTruncationMark   contextKey = "evm_event_truncation_mark"
	CtxKeyVMSenderGuard            contextKey = "evm_vm_sender_guard"
)
View Source 
const (
	// ModuleName string name of module
	ModuleName = "evm"

	// StoreKey: Persistent storage key for ethereum storage data, account code
	// (StateDB) or block related data for the Eth Web3 API.
	StoreKey = ModuleName

	// TransientKey is the key to access the EVM transient store, that is reset
	// during the Commit phase.
	TransientKey = "transient_" + ModuleName

	// RouterKey uses module name for routing
	RouterKey = ModuleName
)
View Source 
const (
	KeyPrefixAccCodes     collections.Namespace = 1
	KeyPrefixAccState     collections.Namespace = 2
	KeyPrefixParams       collections.Namespace = 3
	KeyPrefixEthAddrIndex collections.Namespace = 4

	// KV store prefix for `FunToken` mappings
	KeyPrefixFunTokens collections.Namespace = 5
	// KV store prefix for indexing `FunToken` by ERC-20 address
	KeyPrefixFunTokenIdxErc20 collections.Namespace = 6
	// KV store prefix for indexing `FunToken` by bank coin denomination
	KeyPrefixFunTokenIdxBankDenom collections.Namespace = 7

	KeyPrefixNetWeiBlockDelta collections.Namespace = 8

	KeyPrefixWasmPlugins collections.Namespace = 9
)

prefix bytes for the EVM persistent store

View Source 
const (
	NamespaceBlockBloom   collections.Namespace = 1
	NamespaceBlockTxIndex collections.Namespace = 2
	NamespaceBlockLogSize collections.Namespace = 3
	NamespaceBlockGasUsed collections.Namespace = 4
)

KVStore transient prefix namespaces for the EVM Module. Transient stores only remain for current block, and have more gas efficient read and write access.

View Source 
const (
	ERC2470Address       = "0xce0042B868300000d44A59004Da54A005ffdcf9f"
	ERC2470Bech32Address = "nibi1ecqy9wrgxqqqp4z2tyqymf22qp0lmnulf283ls"
	ERC2470CodeHash      = "0xc4d5542b53a8b779595a20a8ddd60e58a6c49d3c3decc2df83ced1c69c8ca807"
	ERC2470RuntimeCode   = "" /* 616-byte string literal not displayed */
)
View Source 
const (
	// proto.MessageName(new(evm.EventBlockBloom))
	TypeUrlEventBlockBloom = "eth.evm.v1.EventBlockBloom"

	// proto.MessageName(new(evm.EventTxLog))
	TypeUrlEventTxLog = "eth.evm.v1.EventTxLog"

	// proto.MessageName(new(evm.EventEthereumTx))
	TypeUrlEventEthereumTx = "eth.evm.v1.EventEthereumTx"

	// proto.MessageName(new(evm.EventFunTokenCreated))
	TypeUrlEventFunToken = "eth.evm.v1.EventFunTokenCreated"

	// Used in non-typed event "message"
	MessageEventAttrTxType = "tx_type"

	// Used in non-typed event "pending_ethereum_tx"
	PendingEthereumTxEvent            = "pending_ethereum_tx"
	PendingEthereumTxEventAttrEthHash = "eth_hash"
	PendingEthereumTxEventAttrIndex   = "index"
)

Evm module events

View Source 
const (
	// EVMBankDenom specifies the bank denomination for the asset used to run EVM
	// state transitions as the analog to "ether". 1 ether in solidity means 1
	// NIBI on Nibru EVM, implying that the EVMBankDenom is "unibi", the coin
	// base of the NIBI token.
	EVMBankDenom = appconst.DENOM_UNIBI

	// WasmPluginNameXOracle identifies the Wasm adapter backing the legacy
	// oracle precompile at 0x0000000000000000000000000000000000000801.
	WasmPluginNameXOracle = "x-oracle"
)
View Source 
const (
	TracerAccessList = "access_list"
	TracerJSON       = "json"
	TracerStruct     = "struct"
	TracerMarkdown   = "markdown"
)
View Source 
const DefaultZeroGasTxPriority int64 = 0

DefaultZeroGasTxPriority is the fixed mempool priority for classified zero-gas EVM transactions. Raw wallet fee fields are ignored for payment and must not buy priority.

View Source 
const ErrStateDBCommit = "failed to commit stateDB"

ErrStateDBCommit defines the error message when commit after executing EVM transaction, for example transfer native token to a distribution module account using an evm transaction. Note, the transfer amount cannot be set to 0, otherwise this problem will not be triggered.

View Source 
const GasEstimateErrorRatioTolerance = 0.015

GasEstimateErrorRatioTolerance is the amount of overestimation eth_estimateGas is allowed to produce in order to speed up calculations.

Variables

View Source 
var (
	BASE_FEE_MICRONIBI = big.NewInt(1)
	BASE_FEE_WEI       = NativeToWei(BASE_FEE_MICRONIBI)

	// EmptyCodeHashBz is a known hash for empty EVM bytecode.
	// "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
	EmptyCodeHashBz = crypto.Keccak256(nil)
	EmptyCodeHash   = gethcommon.BytesToHash(EmptyCodeHashBz)
	EmptyHash       = gethcommon.Hash{} // Blank hash != Blank code hash

	CodeHashForNilAccount = gethcommon.Hash{}
)

BASE_FEE_MICRONIBI is the global base fee value for the network. It has a constant value of 1 unibi (micronibi) == 10^12 wei.

View Source 
var (
	EVM_MODULE_ADDRESS      gethcommon.Address
	EVM_MODULE_ADDRESS_NIBI sdk.AccAddress
	// EVM_READONLY_ADDR is a dedicated low-privilege EVM caller identity for
	// query-style external contract execution (for example ERC20 metadata and
	// balance wrappers). It avoids borrowing x/evm module authority
	// (EVM_MODULE_ADDRESS) for read paths while still allowing deterministic EVM
	// execution with a stable caller address.
	EVM_READONLY_ADDR         gethcommon.Address
	FEE_COLLECTOR_ADDR        gethcommon.Address
	FEE_COLLECTOR_BECH32_ADDR sdk.AccAddress
)
View Source 
var (
	// ErrInvalidState returns an error resulting from an invalid Storage State.
	ErrInvalidState = sdkioerrors.Register(ModuleName, codeErrInvalidState, "invalid storage state")

	// ErrZeroAddress returns an error resulting from an zero (empty) ethereum Address.
	ErrZeroAddress = sdkioerrors.Register(ModuleName, codeErrZeroAddress, "invalid zero address")

	// ErrInvalidAmount returns an error if a tx contains an invalid amount.
	ErrInvalidAmount = sdkioerrors.Register(ModuleName, codeErrInvalidAmount, "invalid transaction amount")

	// ErrInvalidGasPrice returns an error if an invalid gas price is provided to the tx.
	ErrInvalidGasPrice = sdkioerrors.Register(ModuleName, codeErrInvalidGasPrice, "invalid gas price")

	// ErrInvalidGasFee returns an error if the tx gas fee is out of bound.
	ErrInvalidGasFee = sdkioerrors.Register(ModuleName, codeErrInvalidGasFee, "invalid gas fee")

	// ErrInvalidRefund returns an error if the gas refund value is invalid.
	ErrInvalidRefund = sdkioerrors.Register(ModuleName, codeErrInvalidRefund, "invalid gas refund amount")

	// ErrInvalidGasCap returns an error if the gas cap value is negative or invalid
	ErrInvalidGasCap = sdkioerrors.Register(ModuleName, codeErrInvalidGasCap, "invalid gas cap")

	// ErrInvalidBaseFee returns an error if the base fee cap value is invalid
	ErrInvalidBaseFee = sdkioerrors.Register(ModuleName, codeErrInvalidBaseFee, "invalid base fee")

	// ErrInvalidAccount returns an error if the account is not an EVM compatible account
	ErrInvalidAccount = sdkioerrors.Register(ModuleName, codeErrInvalidAccount, "account type is not a valid ethereum account")

	ErrCanonicalWnibi = "canonical WNIBI address in state is a not a smart contract"
)
View Source 
var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthEvm        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvm          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvm = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (

	// ErrMempoolNonceCollision means another transaction owns the requested
	// authenticated sender and EVM nonce slot.
	ErrMempoolNonceCollision = errors.New("EVM mempool nonce slot already occupied")
	// ErrMempoolSenderLimit means a sender owns the configured maximum number
	// of live EVM nonce slots.
	ErrMempoolSenderLimit = errors.New("EVM mempool sender slot limit reached")
	// ErrMempoolNonceGap means a transaction is not part of a complete state
	// nonce chain during CheckTxType_Recheck. A state nonce chain is the
	// contiguous set of live slots from the committed state nonce through the
	// transaction nonce (for example slots 10, 11, and 12 when the state nonce
	// is 10; slots 10, 12, and 13 are not a chain). See [Mempool.CheckRecheck].
	ErrMempoolNonceGap = errors.New("EVM mempool state nonce chain is incomplete")
	// ErrMempoolTxMismatch means a transaction does not own the nonce slot it
	// identifies during recheck or decoded-transaction removal.
	ErrMempoolTxMismatch = errors.New("EVM mempool transaction does not own nonce slot")
)
View Source 
var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (

	// AminoCdc is a amino codec created to support amino JSON compatible msgs.
	AminoCdc = codec.NewAminoCodec(amino)
)
View Source 
var Big0 = big.NewInt(0)
View Source 
var DefaultPriorityReduction = sdk.DefaultPowerReduction

DefaultPriorityReduction is the default amount of price values required for 1 unit of priority. Because priority is `int64` while price is `big.Int`, it's necessary to scale down the range to keep it more pratical. The default value is the same as the `sdk.DefaultPowerReduction`.

View Source 
var KeyPrefixBzAccState = KeyPrefixAccState.Prefix()
View Source 
var PRECOMPILE_ADDRS []gethcommon.Address = set.New[gethcommon.Address](
	append(gethvm.PrecompiledAddressesBerlin, []gethcommon.Address{

		gethcommon.HexToAddress("0x0000000000000000000000000000000000000800"),

		gethcommon.HexToAddress("0x0000000000000000000000000000000000000801"),

		gethcommon.HexToAddress("0x0000000000000000000000000000000000000802"),

		gethcommon.HexToAddress("0x0000000000000000000000000000000000000100"),
	}...)...,
).ToSlice()

Functions

func AttributeKeyFeePayerEvm 

func AttributeKeyFeePayerEvm(ethAddr gethcommon.Address) sdk.Attribute

func BigIntMax 

func BigIntMax(x, y *big.Int) *big.Int

BigIntMax returns max(x,y).

func BinSearch 

func BinSearch(
	lo uint64,
	hi uint64,
	executable func(uint64) (bool, *MsgEthereumTxResponse, error),
	estimateTolernace float64,
) (uint64, error)

BinSearch executes the binary search and hone in on an executable gas limit

func DeriveChainID 

func DeriveChainID(v *big.Int) *big.Int

DeriveChainID derives the chain id from the given v parameter.

CONTRACT: v value is either:

  • {0,1} + CHAIN_ID * 2 + 35, if EIP155 is used
  • {0,1} + 27, otherwise

Ref: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md

func EthereumConfig 

func EthereumConfig(chainID *big.Int) *params.ChainConfig

EthereumConfig returns an Ethereum ChainConfig for EVM state transitions.

func GasPool 

func GasPool(gasLimit uint64) *gethcore.GasPool

func GetEthHashAndIndexFromPendingEthereumTxEvent 

func GetEthHashAndIndexFromPendingEthereumTxEvent(event abci.Event) (gethcommon.Hash, int32, error)

func GetEvmEventTruncationMark 

func GetEvmEventTruncationMark(ctx sdk.Context) (mark int, ok bool)

GetEvmEventTruncationMark returns the mark to use for truncating events.

func GetTxPriority 

func GetTxPriority(txData TxData, baseFee *big.Int) (priority int64)

GetTxPriority returns the priority of a given Ethereum tx. It relies on the priority reduction global variable to calculate the tx priority given the tx tip price: 

tx_priority = tip_price / priority_reduction

func IsEthTx 

func IsEthTx(tx sdk.Tx) bool

IsEthTx check if the tx is an eth tx

func IsVMSenderCtx 

func IsVMSenderCtx(ctx sdk.Context) bool

func IsZeroGasEthTx 

func IsZeroGasEthTx(ctx sdk.Context) bool

IsZeroGasEthTx returns true if the context has ZeroGasMeta set (i.e., this is a zero-gas EVM tx).

func IsZeroGasJsonTxArgs 

func IsZeroGasJsonTxArgs(
	ctx sdk.Context,
	sudoKeeper SudoKeeper,
	args JsonTxArgs,
) bool

IsZeroGasJsonTxArgs classifies JSON-RPC call args using the same destination policy as signed execution.

func IsZeroGasTxData 

func IsZeroGasTxData(
	ctx sdk.Context,
	sudoKeeper SudoKeeper,
	txData TxData,
) bool

IsZeroGasTxData returns true when txData targets a contract in the `always_zero_gas_contracts` set.

func LogsToEthereum 

func LogsToEthereum(logs []Log) []*gethcore.Log

LogsToEthereum casts the Proto Logs to a slice of Ethereum Logs.

func NativeToWei 

func NativeToWei(evmDenomAmount *big.Int) (weiAmount *big.Int)

NativeToWei converts a "unibi" amount to "wei" units for the EVM.

Micronibi, labeled "unibi", is the base denomination for NIBI. For NIBI to be considered "ether" by Ethereum clients, we need to follow the constraint equation: 1 NIBI = 10^18 wei.

Since 1 NIBI = 10^6 micronibi = 10^6 unibi, the following is true: 10^0 unibi == 10^12 wei

func NativeToWeiU256 

func NativeToWeiU256(evmDenomAmount *uint256.Int) (weiAmount *uint256.Int)

NativeToWeiU256 is the uint256 equivalent of the NativeToWei function.

func NewDefaultTracer 

func NewDefaultTracer() *tracers.Tracer

func NewFunTokenID 

func NewFunTokenID(erc20 gethcommon.Address, bankDenom string) []byte

func NewNoOpTracer 

func NewNoOpTracer() (tracer *tracers.Tracer)

NewNoOpTracer creates a no-op vm.Tracer

func NewRevertError 

func NewRevertError(revertReason []byte) error

NewRevertError unpacks the revert return bytes and returns a wrapped error with the return reason.

func NewTracer 

func NewTracer(
	tracer string,
	msg core.Message,
	cfg *params.ChainConfig,
	height int64,
) *tracing.Hooks

NewTracer creates a new Logger tracer to collect execution traces from an EVM transaction.

func NormalizeZeroGasMessage 

func NormalizeZeroGasMessage(msg core.Message) core.Message

NormalizeZeroGasMessage returns a copy of msg with fee-price semantics zeroed. It must be called only after sender recovery for signed transactions.

func PackTxData 

func PackTxData(txData TxData) (*codectypes.Any, error)

PackTxData constructs a new Any packed with the given tx data value. It returns an error if the client state can't be cast to a protobuf message or if the concrete implementation is not registered to the protobuf codec.

func ParseBlockTimeUnixU64 

func ParseBlockTimeUnixU64(ctx sdk.Context) uint64

Parses the block time as a Unix timestamp in seconds for use with "gethcore.MakeSigner".

func ParseOOGPanic 

func ParseOOGPanic(panicInfo any, formatUnexpected func(any) string) (oog bool, perr error)

ParseOOGPanic interprets the result of recover() and returns (oog bool, perr error). If panicInfo is nil, returns (false, nil). OOG panics (sdk.ErrorOutOfGas or message "out of gas") return (true, vm.ErrOutOfGas). Other panics return (false, err) with err from formatUnexpected(panicInfo). Callers should keep the line "panicInfo := recover()" explicit and pass panicInfo here.

func ParseWeiAsMultipleOfMicronibi 

func ParseWeiAsMultipleOfMicronibi(weiInt *big.Int) (newWeiInt *big.Int, err error)

ParseWeiAsMultipleOfMicronibi truncates the given wei amount to the highest multiple of 1 micronibi (10^12 wei). It returns the truncated value and an error if the input value is too small.

This function is NOT used in production and docmuments wei balance conversion semantics from before Nibiru v2.8.0.

Args:

  • weiInt (*big.Int): The amount of wei to be parsed.

Returns:

  • newWeiInt (*big.Int): The truncated amount of wei, which is a multiple of 1 micronibi.
  • err (error): An error indicating if the input value is within the range (1, 10^12) inclusive.

Example: 

```
Input  number:  123456789012345678901234567890
Parsed number:  123456789012345678 * 10^{12}
```

func PrefixAccStateEthAddr 

func PrefixAccStateEthAddr(address gethcommon.Address) []byte

PrefixAccStateEthAddr returns a prefix to iterate over a given account storage.

func RegisterInterfaces 

func RegisterInterfaces(registry codectypes.InterfaceRegistry)

RegisterInterfaces registers the client interfaces to protobuf Any.

func RegisterLegacyAminoCodec 

func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)

RegisterLegacyAminoCodec required for EIP-712

func RegisterMsgHandler 

func RegisterMsgHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMsgHandler registers the http handlers for service Msg to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMsgHandlerClient 

func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MsgClient) error

RegisterMsgHandlerClient registers the http handlers for service Msg to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MsgClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MsgClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MsgClient" to call the correct interceptors.

func RegisterMsgHandlerFromEndpoint 

func RegisterMsgHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMsgHandlerFromEndpoint is same as RegisterMsgHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMsgHandlerServer 

func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MsgServer) error

RegisterMsgHandlerServer registers the http handlers for service Msg to "mux". UnaryRPC :call MsgServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMsgHandlerFromEndpoint instead.

func RegisterMsgServer 

func RegisterMsgServer(s grpc1.Server, srv MsgServer)

func RegisterQueryHandler 

func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterQueryHandler registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterQueryHandlerClient 

func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error

RegisterQueryHandlerClient registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "QueryClient" to call the correct interceptors.

func RegisterQueryHandlerFromEndpoint 

func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterQueryHandlerServer 

func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error

RegisterQueryHandlerServer registers the http handlers for service Query to "mux". UnaryRPC :call QueryServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.

func RegisterQueryServer 

func RegisterQueryServer(s grpc1.Server, srv QueryServer)

func SafeConsumeGas 

func SafeConsumeGas(ctx sdk.Context, amount uint64, descriptor string) (err error)

SafeConsumeGas aligns the SDK gas meter with a gas-used value from another source (e.g. the EVM). It consumes the given amount from ctx.GasMeter(), so that Cosmos gas accounting (e.g. ResponseDeliverTx.GasUsed, block gas) can reflect that usage. If the meter would exceed its limit, ConsumeGas panics; SafeConsumeGas catches the panic and returns an error instead.

func StateKey 

func StateKey(address gethcommon.Address, key []byte) []byte

StateKey defines the full key under which an account state is stored.

func Validate 

func Validate() error

Validate performs a basic validation of the ChainConfig params. The function will return an error if any of the block values is uninitialized (i.e. nil) or if the EIP150Hash is an invalid hash.

func ValidateTxDataAmount 

func ValidateTxDataAmount(txData TxData) error

func ValidateTxDataChainID 

func ValidateTxDataChainID(txData TxData) error

func ValidateTxDataGasPrice 

func ValidateTxDataGasPrice(txData TxData) error

func ValidateTxDataTo 

func ValidateTxDataTo(txData TxData) error

func ValidateWasmPlugins 

func ValidateWasmPlugins(plugins []WasmPlugin) error

ValidateWasmPlugins checks the named Wasm plugin config used by EVM execution paths. Plugin order is preserved by callers, so the returned names from WasmPluginAddrsByName should be used for deterministic writes.

func ValidateZeroGasTxData 

func ValidateZeroGasTxData(txData TxData) error

ValidateZeroGasTxData preserves non-fee stateless checks for classified zero-gas transactions.

func WalletZeroBaseFeeWei 

func WalletZeroBaseFeeWei() *big.Int

WalletZeroBaseFeeWei returns the base fee shown by wallet-facing JSON-RPC fee hints.

Nibiru supports allowlisted zero-gas EVM transactions, but browser wallets run transaction-agnostic preflight checks before signing or broadcasting. If RPC fee hints expose the chain's internal base fee, those wallets can reject a valid zero-gas transaction because the sender has no native NIBI for gas. The wallet-facing RPC surface therefore reports a zero base fee so preflight UX matches the zero-cost transactions that the chain already accepts.

This value is only for JSON-RPC fee hints and serialization. Consensus, ante handlers, EVM execution, and the BASEFEE opcode continue to use the real chain base fee.

func WasmPluginAddrsByName 

func WasmPluginAddrsByName(
	plugins []WasmPlugin,
) (map[string]sdk.AccAddress, []string, error)

WasmPluginAddrsByName validates plugins and returns decoded addresses keyed by name, plus the original name order for deterministic state writes.

func WeiToNative 

func WeiToNative(weiAmount *big.Int) (evmDenomAmount *big.Int)

WeiToNative converts a "wei" amount to "unibi" units.

Micronibi, labeled "unibi", is the base denomination for NIBI. For NIBI to be considered "ether" by Ethereum clients, we need to follow the constraint equation: 1 NIBI = 10^18 wei.

Since 1 NIBI = 10^6 micronibi = 10^6 unibi, the following is true: 10^0 unibi == 10^12 wei

func WeiToNativeMustU256 

func WeiToNativeMustU256(wei *big.Int) (evmDenomAmount *uint256.Int)

WeiToNativeMustU256 is identical to WeiToNative, except it returns a uint256.Int instead of a big.Int.

NOTE: It's okay to panic on overflow here because NIBI has a max supply of 1.5 billion. That means the highest amount of NIBI is in wei units is 1.5 * 10^{9} * 10^{18} == 1.5 * 10^{27}, whereas the maximum uint256 value is 2^{256} - 1 == 1.15792089 * 10^{77}

func WithZeroGasMeta 

func WithZeroGasMeta(ctx sdk.Context) sdk.Context

WithZeroGasMeta stores the existing zero-gas marker on ctx.

Types

type AccessList 

type AccessList []AccessTuple

AccessList is an EIP-2930 access list that represents the slice of the protobuf AccessTuples.

func NewAccessList 

func NewAccessList(ethAccessList *gethcore.AccessList) AccessList

NewAccessList creates a new protobuf-compatible AccessList from an ethereum core AccessList type

func (AccessList) ToEthAccessList 

func (al AccessList) ToEthAccessList() *gethcore.AccessList

ToEthAccessList is a utility function to convert the protobuf compatible AccessList to eth core AccessList from go-ethereum

type AccessListTx 

type AccessListTx struct {
	// chain_id of the destination EVM chain
	ChainID *cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=cosmossdk.io/math.Int" json:"chainID"`
	// nonce corresponds to the account nonce (transaction sequence).
	Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// gas_price defines the value for each gas unit
	GasPrice *cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice,proto3,customtype=cosmossdk.io/math.Int" json:"gas_price,omitempty"`
	// gas defines the gas limit defined for the transaction.
	GasLimit uint64 `protobuf:"varint,4,opt,name=gas,proto3" json:"gas,omitempty"`
	// to is the recipient address in hex format
	To string `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
	// value defines the unsigned integer value of the transaction amount.
	Amount *cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=value,proto3,customtype=cosmossdk.io/math.Int" json:"value,omitempty"`
	// data is the data payload bytes of the transaction.
	Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
	// accesses is an array of access tuples
	Accesses AccessList `protobuf:"bytes,8,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"`
	// 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.
	V []byte `protobuf:"bytes,9,opt,name=v,proto3" json:"v,omitempty"`
	// 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.
	R []byte `protobuf:"bytes,10,opt,name=r,proto3" json:"r,omitempty"`
	// 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.
	S []byte `protobuf:"bytes,11,opt,name=s,proto3" json:"s,omitempty"`
}

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".

func (*AccessListTx) AsEthereumData 

func (tx *AccessListTx) AsEthereumData() gethcore.TxData

AsEthereumData returns an AccessListTx transaction tx from the proto-formatted TxData defined on the Cosmos EVM.

func (*AccessListTx) Copy 

func (tx *AccessListTx) Copy() TxData

Copy returns an instance with the same field values

func (AccessListTx) Cost 

func (tx AccessListTx) Cost() *big.Int

Cost returns amount + gasPrice * gasLimit.

func (*AccessListTx) Descriptor 

func (*AccessListTx) Descriptor() ([]byte, []int)

func (AccessListTx) EffectiveCostWei 

func (tx AccessListTx) EffectiveCostWei(baseFeeWei *big.Int) *big.Int

EffectiveCostWei is the same as Cost for AccessListTx

func (AccessListTx) EffectiveFeeWei 

func (tx AccessListTx) EffectiveFeeWei(baseFeeWei *big.Int) *big.Int

EffectiveFeeWei is the same as Fee for AccessListTx

func (*AccessListTx) EffectiveGasFeeCapWei 

func (tx *AccessListTx) EffectiveGasFeeCapWei(baseFeeWei *big.Int) *big.Int

func (AccessListTx) EffectiveGasPriceWeiPerGas 

func (tx AccessListTx) EffectiveGasPriceWeiPerGas(baseFeeWei *big.Int) *big.Int

EffectiveGasPriceWeiPerGas is the same as GasPrice for AccessListTx

func (AccessListTx) Fee 

func (tx AccessListTx) Fee() *big.Int

Fee returns gasPrice * gasLimit.

func (*AccessListTx) GetAccessList 

func (tx *AccessListTx) GetAccessList() gethcore.AccessList

GetAccessList returns the AccessList field.

func (*AccessListTx) GetChainID 

func (tx *AccessListTx) GetChainID() *big.Int

GetChainID returns the chain id field from the AccessListTx

func (*AccessListTx) GetData 

func (tx *AccessListTx) GetData() []byte

GetData returns a copy of the input data bytes.

func (*AccessListTx) GetGas 

func (tx *AccessListTx) GetGas() uint64

GetGas returns the gas limit.

func (*AccessListTx) GetGasFeeCapWei 

func (tx *AccessListTx) GetGasFeeCapWei() *big.Int

GetGasFeeCapWei returns a cap on the gas fees paid in units of wei: For an AccessListTx, this is taken to be the gas price.

The terminology "fee per gas" essentially means "wei per unit gas". See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas for more info.

func (*AccessListTx) GetGasPrice 

func (tx *AccessListTx) GetGasPrice() *big.Int

Gas price as wei spent per unit gas.

func (*AccessListTx) GetGasTipCapWei 

func (tx *AccessListTx) GetGasTipCapWei() *big.Int

GetGasTipCapWei returns a cap on the gas tip in units of wei. For an AccessListTx, this is taken to be the gas price.

Also called "maxPriorityFeePerGas" in Alchemy and Ethers. See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas. Base fees are determined by the network, not the end user that broadcasts the transaction. Adding a tip increases one's "priority" in the block.

The terminology "fee per gas" essentially means "wei per unit gas". See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas for more info.

func (*AccessListTx) GetNonce 

func (tx *AccessListTx) GetNonce() uint64

GetNonce returns the account sequence for the transaction.

func (*AccessListTx) GetRawSignatureValues 

func (tx *AccessListTx) GetRawSignatureValues() (v, r, s *big.Int)

GetRawSignatureValues returns the V, R, S signature values of the transaction. The return values should not be modified by the caller.

func (*AccessListTx) GetTo 

func (tx *AccessListTx) GetTo() *common.Address

GetTo returns the pointer to the recipient address.

func (*AccessListTx) GetToRaw 

func (tx *AccessListTx) GetToRaw() string

func (*AccessListTx) GetValueWei 

func (tx *AccessListTx) GetValueWei() *big.Int

GetValueWei returns the tx amount.

func (*AccessListTx) Marshal 

func (m *AccessListTx) Marshal() (dAtA []byte, err error)

func (*AccessListTx) MarshalTo 

func (m *AccessListTx) MarshalTo(dAtA []byte) (int, error)

func (*AccessListTx) MarshalToSizedBuffer 

func (m *AccessListTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*AccessListTx) ProtoMessage 

func (*AccessListTx) ProtoMessage()

func (*AccessListTx) Reset 

func (m *AccessListTx) Reset()

func (*AccessListTx) SetSignatureValues 

func (tx *AccessListTx) SetSignatureValues(chainID, v, r, s *big.Int)

SetSignatureValues sets the signature values to the transaction.

func (*AccessListTx) Size 

func (m *AccessListTx) Size() (n int)

func (*AccessListTx) String 

func (m *AccessListTx) String() string

func (*AccessListTx) TxType 

func (tx *AccessListTx) TxType() uint8

TxType returns a byte (uint8) identifying the tx as a LegacyTx (0), AccessListTx (1), or DynamicFeeTx (2).

func (*AccessListTx) Unmarshal 

func (m *AccessListTx) Unmarshal(dAtA []byte) error

func (AccessListTx) Validate 

func (tx AccessListTx) Validate() error

Validate performs a stateless validation of the tx fields.

func (*AccessListTx) XXX_DiscardUnknown 

func (m *AccessListTx) XXX_DiscardUnknown()

func (*AccessListTx) XXX_Marshal 

func (m *AccessListTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AccessListTx) XXX_Merge 

func (m *AccessListTx) XXX_Merge(src proto.Message)

func (*AccessListTx) XXX_Size 

func (m *AccessListTx) XXX_Size() int

func (*AccessListTx) XXX_Unmarshal 

func (m *AccessListTx) XXX_Unmarshal(b []byte) error

type AccessTuple 

type AccessTuple struct {
	// address is a hex formatted ethereum address
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// storage_keys are hex formatted hashes of the storage keys
	StorageKeys []string `protobuf:"bytes,2,rep,name=storage_keys,json=storageKeys,proto3" json:"storageKeys"`
}

AccessTuple is the element type of an access list.

func (*AccessTuple) Descriptor 

func (*AccessTuple) Descriptor() ([]byte, []int)

func (*AccessTuple) Marshal 

func (m *AccessTuple) Marshal() (dAtA []byte, err error)

func (*AccessTuple) MarshalTo 

func (m *AccessTuple) MarshalTo(dAtA []byte) (int, error)

func (*AccessTuple) MarshalToSizedBuffer 

func (m *AccessTuple) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*AccessTuple) ProtoMessage 

func (*AccessTuple) ProtoMessage()

func (*AccessTuple) Reset 

func (m *AccessTuple) Reset()

func (*AccessTuple) Size 

func (m *AccessTuple) Size() (n int)

func (*AccessTuple) String 

func (m *AccessTuple) String() string

func (*AccessTuple) Unmarshal 

func (m *AccessTuple) Unmarshal(dAtA []byte) error

func (*AccessTuple) XXX_DiscardUnknown 

func (m *AccessTuple) XXX_DiscardUnknown()

func (*AccessTuple) XXX_Marshal 

func (m *AccessTuple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*AccessTuple) XXX_Merge 

func (m *AccessTuple) XXX_Merge(src proto.Message)

func (*AccessTuple) XXX_Size 

func (m *AccessTuple) XXX_Size() int

func (*AccessTuple) XXX_Unmarshal 

func (m *AccessTuple) XXX_Unmarshal(b []byte) error

type AccountKeeper 

type AccountKeeper interface {
	NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI

	// GetModuleAccount gets the module account from the auth account store, if the
	// account does not exist in the AccountKeeper, then it is created. This
	// differs from the "GetModuleAddress" function, which performs a pure
	// computation.
	GetModuleAccount(ctx sdk.Context, moduleName string) authtypes.ModuleAccountI

	// GetModuleAddress returns an address based on the module name, however it
	// does not modify state at all. To create initialize the module account,
	// instead use "GetModuleAccount".
	GetModuleAddress(moduleName string) sdk.AccAddress
	GetAllAccounts(ctx sdk.Context) (accounts []authtypes.AccountI)
	IterateAccounts(ctx sdk.Context, cb func(account authtypes.AccountI) bool)
	GetSequence(sdk.Context, sdk.AccAddress) (uint64, error)
	GetAccount(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
	SetAccount(ctx sdk.Context, account authtypes.AccountI)
	RemoveAccount(ctx sdk.Context, account authtypes.AccountI)
	GetParams(ctx sdk.Context) (params authtypes.Params)
	SetModuleAccount(ctx sdk.Context, macc authtypes.ModuleAccountI)
}

AccountKeeper defines the expected account keeper interface

type Addrs 

type Addrs struct {
	Eth    gethcommon.Address
	Bech32 sdk.AccAddress
}

Addrs holds Corresponding nibi-prefixed Bech32 and Ethereum hexadecimal addresses for an account.

type BalanceBank 

type BalanceBank struct {
	Symbol       string `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	BalanceHuman string `protobuf:"bytes,2,opt,name=balance_human,json=balanceHuman,proto3" json:"balance_human,omitempty"`
	Decimals     uint32 `protobuf:"varint,3,opt,name=decimals,proto3" json:"decimals,omitempty"`
	CoinDenom    string `protobuf:"bytes,4,opt,name=coin_denom,json=coinDenom,proto3" json:"coin_denom,omitempty"`
	BalanceBase  string `protobuf:"bytes,5,opt,name=balance_base,json=balanceBase,proto3" json:"balance_base,omitempty"`
}

BalanceBank is the Bank module balance view for a token.

func (*BalanceBank) Descriptor 

func (*BalanceBank) Descriptor() ([]byte, []int)

func (*BalanceBank) GetBalanceBase 

func (m *BalanceBank) GetBalanceBase() string

func (*BalanceBank) GetBalanceHuman 

func (m *BalanceBank) GetBalanceHuman() string

func (*BalanceBank) GetCoinDenom 

func (m *BalanceBank) GetCoinDenom() string

func (*BalanceBank) GetDecimals 

func (m *BalanceBank) GetDecimals() uint32

func (*BalanceBank) GetSymbol 

func (m *BalanceBank) GetSymbol() string

func (*BalanceBank) Marshal 

func (m *BalanceBank) Marshal() (dAtA []byte, err error)

func (*BalanceBank) MarshalTo 

func (m *BalanceBank) MarshalTo(dAtA []byte) (int, error)

func (*BalanceBank) MarshalToSizedBuffer 

func (m *BalanceBank) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BalanceBank) ProtoMessage 

func (*BalanceBank) ProtoMessage()

func (*BalanceBank) Reset 

func (m *BalanceBank) Reset()

func (*BalanceBank) Size 

func (m *BalanceBank) Size() (n int)

func (*BalanceBank) String 

func (m *BalanceBank) String() string

func (*BalanceBank) Unmarshal 

func (m *BalanceBank) Unmarshal(dAtA []byte) error

func (*BalanceBank) XXX_DiscardUnknown 

func (m *BalanceBank) XXX_DiscardUnknown()

func (*BalanceBank) XXX_Marshal 

func (m *BalanceBank) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BalanceBank) XXX_Merge 

func (m *BalanceBank) XXX_Merge(src proto.Message)

func (*BalanceBank) XXX_Size 

func (m *BalanceBank) XXX_Size() int

func (*BalanceBank) XXX_Unmarshal 

func (m *BalanceBank) XXX_Unmarshal(b []byte) error

type BalanceERC20 

type BalanceERC20 struct {
	Address      string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Symbol       string `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
	BalanceHuman string `protobuf:"bytes,3,opt,name=balance_human,json=balanceHuman,proto3" json:"balance_human,omitempty"`
	Decimals     uint32 `protobuf:"varint,4,opt,name=decimals,proto3" json:"decimals,omitempty"`
	Name         string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
	BalanceBase  string `protobuf:"bytes,6,opt,name=balance_base,json=balanceBase,proto3" json:"balance_base,omitempty"`
}

BalanceERC20 is the ERC20 balance view for a token.

func (*BalanceERC20) Descriptor 

func (*BalanceERC20) Descriptor() ([]byte, []int)

func (*BalanceERC20) GetAddress 

func (m *BalanceERC20) GetAddress() string

func (*BalanceERC20) GetBalanceBase 

func (m *BalanceERC20) GetBalanceBase() string

func (*BalanceERC20) GetBalanceHuman 

func (m *BalanceERC20) GetBalanceHuman() string

func (*BalanceERC20) GetDecimals 

func (m *BalanceERC20) GetDecimals() uint32

func (*BalanceERC20) GetName 

func (m *BalanceERC20) GetName() string

func (*BalanceERC20) GetSymbol 

func (m *BalanceERC20) GetSymbol() string

func (*BalanceERC20) Marshal 

func (m *BalanceERC20) Marshal() (dAtA []byte, err error)

func (*BalanceERC20) MarshalTo 

func (m *BalanceERC20) MarshalTo(dAtA []byte) (int, error)

func (*BalanceERC20) MarshalToSizedBuffer 

func (m *BalanceERC20) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*BalanceERC20) ProtoMessage 

func (*BalanceERC20) ProtoMessage()

func (*BalanceERC20) Reset 

func (m *BalanceERC20) Reset()

func (*BalanceERC20) Size 

func (m *BalanceERC20) Size() (n int)

func (*BalanceERC20) String 

func (m *BalanceERC20) String() string

func (*BalanceERC20) Unmarshal 

func (m *BalanceERC20) Unmarshal(dAtA []byte) error

func (*BalanceERC20) XXX_DiscardUnknown 

func (m *BalanceERC20) XXX_DiscardUnknown()

func (*BalanceERC20) XXX_Marshal 

func (m *BalanceERC20) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BalanceERC20) XXX_Merge 

func (m *BalanceERC20) XXX_Merge(src proto.Message)

func (*BalanceERC20) XXX_Size 

func (m *BalanceERC20) XXX_Size() int

func (*BalanceERC20) XXX_Unmarshal 

func (m *BalanceERC20) XXX_Unmarshal(b []byte) error

type DynamicFeeTx 

type DynamicFeeTx struct {
	// chain_id of the destination EVM chain
	ChainID *cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=cosmossdk.io/math.Int" json:"chainID"`
	// nonce corresponds to the account nonce (transaction sequence).
	Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// gas_tip_cap defines the max value for the gas tip
	GasTipCap *cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=gas_tip_cap,json=gasTipCap,proto3,customtype=cosmossdk.io/math.Int" json:"gas_tip_cap,omitempty"`
	// gas_fee_cap defines the max value for the gas fee
	GasFeeCap *cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=gas_fee_cap,json=gasFeeCap,proto3,customtype=cosmossdk.io/math.Int" json:"gas_fee_cap,omitempty"`
	// gas defines the gas limit defined for the transaction.
	GasLimit uint64 `protobuf:"varint,5,opt,name=gas,proto3" json:"gas,omitempty"`
	// to is the hex formatted address of the recipient
	To string `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
	// value defines the the transaction amount.
	Amount *cosmossdk_io_math.Int `protobuf:"bytes,7,opt,name=value,proto3,customtype=cosmossdk.io/math.Int" json:"value,omitempty"`
	// data is the data payload bytes of the transaction.
	Data []byte `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"`
	// accesses is an array of access tuples
	Accesses AccessList `protobuf:"bytes,9,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"`
	// 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.
	V []byte `protobuf:"bytes,10,opt,name=v,proto3" json:"v,omitempty"`
	// 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.
	R []byte `protobuf:"bytes,11,opt,name=r,proto3" json:"r,omitempty"`
	// 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.
	S []byte `protobuf:"bytes,12,opt,name=s,proto3" json:"s,omitempty"`
}

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".

func NewDynamicFeeTx 

func NewDynamicFeeTx(tx *gethcore.Transaction) (*DynamicFeeTx, error)

func (*DynamicFeeTx) AsEthereumData 

func (tx *DynamicFeeTx) AsEthereumData() gethcore.TxData

AsEthereumData returns an DynamicFeeTx transaction tx from the proto-formatted TxData defined on the Cosmos EVM.

func (*DynamicFeeTx) Copy 

func (tx *DynamicFeeTx) Copy() TxData

Copy returns an instance with the same field values

func (DynamicFeeTx) Cost 

func (tx DynamicFeeTx) Cost() *big.Int

Cost returns amount + gasPrice * gasLimit.

func (*DynamicFeeTx) Descriptor 

func (*DynamicFeeTx) Descriptor() ([]byte, []int)

func (DynamicFeeTx) EffectiveCostWei 

func (tx DynamicFeeTx) EffectiveCostWei(baseFeeWei *big.Int) *big.Int

EffectiveCostWei returns amount + effective_gasPrice * gasLimit.

func (DynamicFeeTx) EffectiveFeeWei 

func (tx DynamicFeeTx) EffectiveFeeWei(baseFeeWei *big.Int) *big.Int

EffectiveFeeWei returns effective_gasPrice * gasLimit.

func (*DynamicFeeTx) EffectiveGasFeeCapWei 

func (tx *DynamicFeeTx) EffectiveGasFeeCapWei(baseFeeWei *big.Int) *big.Int

func (*DynamicFeeTx) EffectiveGasPriceWeiPerGas 

func (tx *DynamicFeeTx) EffectiveGasPriceWeiPerGas(baseFeeWei *big.Int) *big.Int

EffectiveGasPriceWeiPerGas returns the effective gas price based on EIP-1559 rules. `effectiveGasPrice = min(baseFee + tipCap, feeCap)`

func (DynamicFeeTx) Fee 

func (tx DynamicFeeTx) Fee() *big.Int

Fee returns gasPrice * gasLimit.

func (*DynamicFeeTx) GetAccessList 

func (tx *DynamicFeeTx) GetAccessList() gethcore.AccessList

GetAccessList returns the AccessList field.

func (*DynamicFeeTx) GetChainID 

func (tx *DynamicFeeTx) GetChainID() *big.Int

GetChainID returns the chain id field from the DynamicFeeTx

func (*DynamicFeeTx) GetData 

func (tx *DynamicFeeTx) GetData() []byte

GetData returns a copy of the input data bytes.

func (*DynamicFeeTx) GetGas 

func (tx *DynamicFeeTx) GetGas() uint64

GetGas returns the gas limit.

func (*DynamicFeeTx) GetGasFeeCapWei 

func (tx *DynamicFeeTx) GetGasFeeCapWei() *big.Int

GetGasFeeCapWei returns a cap on the gas fees paid in units of wei, where:

feesWithoutCap := effective gas price (wei per gas) * gas units gas fee cap -> min(feesWithoutCap, gasFeeCap)

Also called "maxFeePerGas" in Alchemy and Ethers. maxFeePerGas := baseFeePerGas + maxPriorityFeePerGas

The terminology "fee per gas" essentially means "wei per unit gas". See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas for more info.

func (*DynamicFeeTx) GetGasPrice 

func (tx *DynamicFeeTx) GetGasPrice() *big.Int

Gas price as wei spent per unit gas.

func (*DynamicFeeTx) GetGasTipCapWei 

func (tx *DynamicFeeTx) GetGasTipCapWei() *big.Int

GetGasTipCapWei returns a cap on the gas tip in units of wei.

Also called "maxPriorityFeePerGas" in Alchemy and Ethers. See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas. Base fees are determined by the network, not the end user that broadcasts the transaction. Adding a tip increases one's "priority" in the block.

The terminology "fee per gas" essentially means "wei per unit gas". See Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas for more info.

func (*DynamicFeeTx) GetNonce 

func (tx *DynamicFeeTx) GetNonce() uint64

GetNonce returns the account sequence for the transaction.

func (*DynamicFeeTx) GetRawSignatureValues 

func (tx *DynamicFeeTx) GetRawSignatureValues() (v, r, s *big.Int)

GetRawSignatureValues returns the V, R, S signature values of the transaction. The return values should not be modified by the caller.

func (*DynamicFeeTx) GetTo 

func (tx *DynamicFeeTx) GetTo() *common.Address

GetTo returns the pointer to the recipient address.

func (*DynamicFeeTx) GetToRaw 

func (tx *DynamicFeeTx) GetToRaw() string

func (*DynamicFeeTx) GetValueWei 

func (tx *DynamicFeeTx) GetValueWei() *big.Int

GetValueWei returns the tx amount.

func (*DynamicFeeTx) Marshal 

func (m *DynamicFeeTx) Marshal() (dAtA []byte, err error)

func (*DynamicFeeTx) MarshalTo 

func (m *DynamicFeeTx) MarshalTo(dAtA []byte) (int, error)

func (*DynamicFeeTx) MarshalToSizedBuffer 

func (m *DynamicFeeTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*DynamicFeeTx) ProtoMessage 

func (*DynamicFeeTx) ProtoMessage()

func (*DynamicFeeTx) Reset 

func (m *DynamicFeeTx) Reset()

func (*DynamicFeeTx) SetSignatureValues 

func (tx *DynamicFeeTx) SetSignatureValues(chainID, v, r, s *big.Int)

SetSignatureValues sets the signature values to the transaction.

func (*DynamicFeeTx) Size 

func (m *DynamicFeeTx) Size() (n int)

func (*DynamicFeeTx) String 

func (m *DynamicFeeTx) String() string

func (*DynamicFeeTx) TxType 

func (tx *DynamicFeeTx) TxType() uint8

TxType returns a byte (uint8) identifying the tx as a LegacyTx (0), AccessListTx (1), or DynamicFeeTx (2).

func (*DynamicFeeTx) Unmarshal 

func (m *DynamicFeeTx) Unmarshal(dAtA []byte) error

func (DynamicFeeTx) Validate 

func (tx DynamicFeeTx) Validate() error

Validate performs a stateless validation of the tx fields.

func (*DynamicFeeTx) XXX_DiscardUnknown 

func (m *DynamicFeeTx) XXX_DiscardUnknown()

func (*DynamicFeeTx) XXX_Marshal 

func (m *DynamicFeeTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DynamicFeeTx) XXX_Merge 

func (m *DynamicFeeTx) XXX_Merge(src proto.Message)

func (*DynamicFeeTx) XXX_Size 

func (m *DynamicFeeTx) XXX_Size() int

func (*DynamicFeeTx) XXX_Unmarshal 

func (m *DynamicFeeTx) XXX_Unmarshal(b []byte) error

type ERC20Metadata 

type ERC20Metadata struct {
	Name     string
	Symbol   string
	Decimals uint8
}

ERC20Metadata: Optional metadata fields parsed from an ERC20 contract. The Wrapped Ether contract is a good example for reference. 

```solidity
constract WETH9 {
  string public name     = "Wrapped Ether";
  string public symbol   = "WETH"
  uint8  public decimals = 18;
}
```

Note that the name and symbol fields may be empty, according to the ERC20 specification.

func ValidateFunTokenBankMetadata 

func ValidateFunTokenBankMetadata(
	bc bank.Metadata, allowZeroDecimals bool,
) (out ERC20Metadata, err error)

Checks that the necessary ERC20 metadata fields can be parsed from the given Bank Coin metadata for a FunToken mapping. ERC20.decimals can only be zero if "allowZeroDecimals" is true.

type EstimateGasResponse 

type EstimateGasResponse struct {
	// gas returns the estimated gas
	Gas uint64 `protobuf:"varint,1,opt,name=gas,proto3" json:"gas,omitempty"`
}

EstimateGasResponse defines EstimateGas response

func (*EstimateGasResponse) Descriptor 

func (*EstimateGasResponse) Descriptor() ([]byte, []int)

func (*EstimateGasResponse) GetGas 

func (m *EstimateGasResponse) GetGas() uint64

func (*EstimateGasResponse) Marshal 

func (m *EstimateGasResponse) Marshal() (dAtA []byte, err error)

func (*EstimateGasResponse) MarshalTo 

func (m *EstimateGasResponse) MarshalTo(dAtA []byte) (int, error)

func (*EstimateGasResponse) MarshalToSizedBuffer 

func (m *EstimateGasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EstimateGasResponse) ProtoMessage 

func (*EstimateGasResponse) ProtoMessage()

func (*EstimateGasResponse) Reset 

func (m *EstimateGasResponse) Reset()

func (*EstimateGasResponse) Size 

func (m *EstimateGasResponse) Size() (n int)

func (*EstimateGasResponse) String 

func (m *EstimateGasResponse) String() string

func (*EstimateGasResponse) Unmarshal 

func (m *EstimateGasResponse) Unmarshal(dAtA []byte) error

func (*EstimateGasResponse) XXX_DiscardUnknown 

func (m *EstimateGasResponse) XXX_DiscardUnknown()

func (*EstimateGasResponse) XXX_Marshal 

func (m *EstimateGasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EstimateGasResponse) XXX_Merge 

func (m *EstimateGasResponse) XXX_Merge(src proto.Message)

func (*EstimateGasResponse) XXX_Size 

func (m *EstimateGasResponse) XXX_Size() int

func (*EstimateGasResponse) XXX_Unmarshal 

func (m *EstimateGasResponse) XXX_Unmarshal(b []byte) error

type EthCallRequest 

type EthCallRequest struct {
	// args uses the same json format as the json rpc api.
	Args []byte `protobuf:"bytes,1,opt,name=args,proto3" json:"args,omitempty"`
	// gas_cap defines the default gas cap to be used
	GasCap uint64 `protobuf:"varint,2,opt,name=gas_cap,json=gasCap,proto3" json:"gas_cap,omitempty"`
	// proposer_address of the requested block in hex format
	ProposerAddress github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress `` /* 181-byte string literal not displayed */
	// chain_id is the eip155 chain id parsed from the requested block header
	ChainId int64 `protobuf:"varint,4,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

EthCallRequest defines EthCall request

func (*EthCallRequest) Descriptor 

func (*EthCallRequest) Descriptor() ([]byte, []int)

func (*EthCallRequest) GetArgs 

func (m *EthCallRequest) GetArgs() []byte

func (*EthCallRequest) GetChainId 

func (m *EthCallRequest) GetChainId() int64

func (*EthCallRequest) GetGasCap 

func (m *EthCallRequest) GetGasCap() uint64

func (*EthCallRequest) GetProposerAddress 

func (m *EthCallRequest) GetProposerAddress() github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress

func (*EthCallRequest) Marshal 

func (m *EthCallRequest) Marshal() (dAtA []byte, err error)

func (*EthCallRequest) MarshalTo 

func (m *EthCallRequest) MarshalTo(dAtA []byte) (int, error)

func (*EthCallRequest) MarshalToSizedBuffer 

func (m *EthCallRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EthCallRequest) ProtoMessage 

func (*EthCallRequest) ProtoMessage()

func (*EthCallRequest) Reset 

func (m *EthCallRequest) Reset()

func (*EthCallRequest) Size 

func (m *EthCallRequest) Size() (n int)

func (*EthCallRequest) String 

func (m *EthCallRequest) String() string

func (*EthCallRequest) Unmarshal 

func (m *EthCallRequest) Unmarshal(dAtA []byte) error

func (*EthCallRequest) Validate 

func (req *EthCallRequest) Validate() error

func (*EthCallRequest) XXX_DiscardUnknown 

func (m *EthCallRequest) XXX_DiscardUnknown()

func (*EthCallRequest) XXX_Marshal 

func (m *EthCallRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EthCallRequest) XXX_Merge 

func (m *EthCallRequest) XXX_Merge(src proto.Message)

func (*EthCallRequest) XXX_Size 

func (m *EthCallRequest) XXX_Size() int

func (*EthCallRequest) XXX_Unmarshal 

func (m *EthCallRequest) XXX_Unmarshal(b []byte) error

type EventBlockBloom 

type EventBlockBloom struct {
	// bloom is the bloom filter of the block
	Bloom string `protobuf:"bytes,1,opt,name=bloom,proto3" json:"bloom,omitempty"`
}

EventBlockBloom contains the bloom filter for an Ethereum block. The bloom filter encodes logs for efficient event filtering.

func EventBlockBloomFromABCIEvent 

func EventBlockBloomFromABCIEvent(event abci.Event) (*EventBlockBloom, error)

func (*EventBlockBloom) Descriptor 

func (*EventBlockBloom) Descriptor() ([]byte, []int)

func (*EventBlockBloom) GetBloom 

func (m *EventBlockBloom) GetBloom() string

func (*EventBlockBloom) Marshal 

func (m *EventBlockBloom) Marshal() (dAtA []byte, err error)

func (*EventBlockBloom) MarshalTo 

func (m *EventBlockBloom) MarshalTo(dAtA []byte) (int, error)

func (*EventBlockBloom) MarshalToSizedBuffer 

func (m *EventBlockBloom) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventBlockBloom) ProtoMessage 

func (*EventBlockBloom) ProtoMessage()

func (*EventBlockBloom) Reset 

func (m *EventBlockBloom) Reset()

func (*EventBlockBloom) Size 

func (m *EventBlockBloom) Size() (n int)

func (*EventBlockBloom) String 

func (m *EventBlockBloom) String() string

func (*EventBlockBloom) Unmarshal 

func (m *EventBlockBloom) Unmarshal(dAtA []byte) error

func (*EventBlockBloom) XXX_DiscardUnknown 

func (m *EventBlockBloom) XXX_DiscardUnknown()

func (*EventBlockBloom) XXX_Marshal 

func (m *EventBlockBloom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventBlockBloom) XXX_Merge 

func (m *EventBlockBloom) XXX_Merge(src proto.Message)

func (*EventBlockBloom) XXX_Size 

func (m *EventBlockBloom) XXX_Size() int

func (*EventBlockBloom) XXX_Unmarshal 

func (m *EventBlockBloom) XXX_Unmarshal(b []byte) error

type EventContractDeployed 

type EventContractDeployed struct {
	Sender       string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	ContractAddr string `protobuf:"bytes,2,opt,name=contract_addr,json=contractAddr,proto3" json:"contract_addr,omitempty"`
}

EventContractDeployed defines event for EVM contract deployment

func (*EventContractDeployed) Descriptor 

func (*EventContractDeployed) Descriptor() ([]byte, []int)

func (*EventContractDeployed) GetContractAddr 

func (m *EventContractDeployed) GetContractAddr() string

func (*EventContractDeployed) GetSender 

func (m *EventContractDeployed) GetSender() string

func (*EventContractDeployed) Marshal 

func (m *EventContractDeployed) Marshal() (dAtA []byte, err error)

func (*EventContractDeployed) MarshalTo 

func (m *EventContractDeployed) MarshalTo(dAtA []byte) (int, error)

func (*EventContractDeployed) MarshalToSizedBuffer 

func (m *EventContractDeployed) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventContractDeployed) ProtoMessage 

func (*EventContractDeployed) ProtoMessage()

func (*EventContractDeployed) Reset 

func (m *EventContractDeployed) Reset()

func (*EventContractDeployed) Size 

func (m *EventContractDeployed) Size() (n int)

func (*EventContractDeployed) String 

func (m *EventContractDeployed) String() string

func (*EventContractDeployed) Unmarshal 

func (m *EventContractDeployed) Unmarshal(dAtA []byte) error

func (*EventContractDeployed) XXX_DiscardUnknown 

func (m *EventContractDeployed) XXX_DiscardUnknown()

func (*EventContractDeployed) XXX_Marshal 

func (m *EventContractDeployed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventContractDeployed) XXX_Merge 

func (m *EventContractDeployed) XXX_Merge(src proto.Message)

func (*EventContractDeployed) XXX_Size 

func (m *EventContractDeployed) XXX_Size() int

func (*EventContractDeployed) XXX_Unmarshal 

func (m *EventContractDeployed) XXX_Unmarshal(b []byte) error

type EventContractExecuted 

type EventContractExecuted struct {
	Sender       string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	ContractAddr string `protobuf:"bytes,2,opt,name=contract_addr,json=contractAddr,proto3" json:"contract_addr,omitempty"`
}

EventContractExecuted defines event for EVM contract execution

func (*EventContractExecuted) Descriptor 

func (*EventContractExecuted) Descriptor() ([]byte, []int)

func (*EventContractExecuted) GetContractAddr 

func (m *EventContractExecuted) GetContractAddr() string

func (*EventContractExecuted) GetSender 

func (m *EventContractExecuted) GetSender() string

func (*EventContractExecuted) Marshal 

func (m *EventContractExecuted) Marshal() (dAtA []byte, err error)

func (*EventContractExecuted) MarshalTo 

func (m *EventContractExecuted) MarshalTo(dAtA []byte) (int, error)

func (*EventContractExecuted) MarshalToSizedBuffer 

func (m *EventContractExecuted) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventContractExecuted) ProtoMessage 

func (*EventContractExecuted) ProtoMessage()

func (*EventContractExecuted) Reset 

func (m *EventContractExecuted) Reset()

func (*EventContractExecuted) Size 

func (m *EventContractExecuted) Size() (n int)

func (*EventContractExecuted) String 

func (m *EventContractExecuted) String() string

func (*EventContractExecuted) Unmarshal 

func (m *EventContractExecuted) Unmarshal(dAtA []byte) error

func (*EventContractExecuted) XXX_DiscardUnknown 

func (m *EventContractExecuted) XXX_DiscardUnknown()

func (*EventContractExecuted) XXX_Marshal 

func (m *EventContractExecuted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventContractExecuted) XXX_Merge 

func (m *EventContractExecuted) XXX_Merge(src proto.Message)

func (*EventContractExecuted) XXX_Size 

func (m *EventContractExecuted) XXX_Size() int

func (*EventContractExecuted) XXX_Unmarshal 

func (m *EventContractExecuted) XXX_Unmarshal(b []byte) error

type EventConvertCoinToEvm 

type EventConvertCoinToEvm struct {
	Sender               string     `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Erc20ContractAddress string     `protobuf:"bytes,2,opt,name=erc20_contract_address,json=erc20ContractAddress,proto3" json:"erc20_contract_address,omitempty"`
	ToEthAddr            string     `protobuf:"bytes,3,opt,name=to_eth_addr,json=toEthAddr,proto3" json:"to_eth_addr,omitempty"`
	BankCoin             types.Coin `protobuf:"bytes,4,opt,name=bank_coin,json=bankCoin,proto3" json:"bank_coin" yaml:"bank_coin"`
	EvmLogs              []LogLite  `protobuf:"bytes,5,rep,name=evm_logs,json=evmLogs,proto3" json:"evm_logs"`
}

EventConvertCoinToEvm is an event emitted when converting Bank Coins into ERC20 tokens with the "eth.evm.v1.MsgConvertCoinToEvm" transaction message.

func (*EventConvertCoinToEvm) Descriptor 

func (*EventConvertCoinToEvm) Descriptor() ([]byte, []int)

func (*EventConvertCoinToEvm) GetBankCoin 

func (m *EventConvertCoinToEvm) GetBankCoin() types.Coin

func (*EventConvertCoinToEvm) GetErc20ContractAddress 

func (m *EventConvertCoinToEvm) GetErc20ContractAddress() string

func (*EventConvertCoinToEvm) GetEvmLogs 

func (m *EventConvertCoinToEvm) GetEvmLogs() []LogLite

func (*EventConvertCoinToEvm) GetSender 

func (m *EventConvertCoinToEvm) GetSender() string

func (*EventConvertCoinToEvm) GetToEthAddr 

func (m *EventConvertCoinToEvm) GetToEthAddr() string

func (*EventConvertCoinToEvm) Marshal 

func (m *EventConvertCoinToEvm) Marshal() (dAtA []byte, err error)

func (*EventConvertCoinToEvm) MarshalTo 

func (m *EventConvertCoinToEvm) MarshalTo(dAtA []byte) (int, error)

func (*EventConvertCoinToEvm) MarshalToSizedBuffer 

func (m *EventConvertCoinToEvm) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventConvertCoinToEvm) ProtoMessage 

func (*EventConvertCoinToEvm) ProtoMessage()

func (*EventConvertCoinToEvm) Reset 

func (m *EventConvertCoinToEvm) Reset()

func (*EventConvertCoinToEvm) Size 

func (m *EventConvertCoinToEvm) Size() (n int)

func (*EventConvertCoinToEvm) String 

func (m *EventConvertCoinToEvm) String() string

func (*EventConvertCoinToEvm) Unmarshal 

func (m *EventConvertCoinToEvm) Unmarshal(dAtA []byte) error

func (*EventConvertCoinToEvm) XXX_DiscardUnknown 

func (m *EventConvertCoinToEvm) XXX_DiscardUnknown()

func (*EventConvertCoinToEvm) XXX_Marshal 

func (m *EventConvertCoinToEvm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventConvertCoinToEvm) XXX_Merge 

func (m *EventConvertCoinToEvm) XXX_Merge(src proto.Message)

func (*EventConvertCoinToEvm) XXX_Size 

func (m *EventConvertCoinToEvm) XXX_Size() int

func (*EventConvertCoinToEvm) XXX_Unmarshal 

func (m *EventConvertCoinToEvm) XXX_Unmarshal(b []byte) error

type EventConvertEvmToCoin 

type EventConvertEvmToCoin struct {
	Sender               string     `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Erc20ContractAddress string     `protobuf:"bytes,2,opt,name=erc20_contract_address,json=erc20ContractAddress,proto3" json:"erc20_contract_address,omitempty"`
	ToAddress            string     `protobuf:"bytes,3,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	BankCoin             types.Coin `protobuf:"bytes,4,opt,name=bank_coin,json=bankCoin,proto3" json:"bank_coin" yaml:"bank_coin"`
	SenderEthAddr        string     `protobuf:"bytes,6,opt,name=sender_eth_addr,json=senderEthAddr,proto3" json:"sender_eth_addr,omitempty"`
	EvmLogs              []LogLite  `protobuf:"bytes,7,rep,name=evm_logs,json=evmLogs,proto3" json:"evm_logs"`
}

EventConvertEvmToCoin is an event emitted when converting ERC20 tokens to Bank Coins with the "eth.evm.v1.MsgConvertEvmToCoin" transaction message.

func (*EventConvertEvmToCoin) Descriptor 

func (*EventConvertEvmToCoin) Descriptor() ([]byte, []int)

func (*EventConvertEvmToCoin) GetBankCoin 

func (m *EventConvertEvmToCoin) GetBankCoin() types.Coin

func (*EventConvertEvmToCoin) GetErc20ContractAddress 

func (m *EventConvertEvmToCoin) GetErc20ContractAddress() string

func (*EventConvertEvmToCoin) GetEvmLogs 

func (m *EventConvertEvmToCoin) GetEvmLogs() []LogLite

func (*EventConvertEvmToCoin) GetSender 

func (m *EventConvertEvmToCoin) GetSender() string

func (*EventConvertEvmToCoin) GetSenderEthAddr 

func (m *EventConvertEvmToCoin) GetSenderEthAddr() string

func (*EventConvertEvmToCoin) GetToAddress 

func (m *EventConvertEvmToCoin) GetToAddress() string

func (*EventConvertEvmToCoin) Marshal 

func (m *EventConvertEvmToCoin) Marshal() (dAtA []byte, err error)

func (*EventConvertEvmToCoin) MarshalTo 

func (m *EventConvertEvmToCoin) MarshalTo(dAtA []byte) (int, error)

func (*EventConvertEvmToCoin) MarshalToSizedBuffer 

func (m *EventConvertEvmToCoin) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventConvertEvmToCoin) ProtoMessage 

func (*EventConvertEvmToCoin) ProtoMessage()

func (*EventConvertEvmToCoin) Reset 

func (m *EventConvertEvmToCoin) Reset()

func (*EventConvertEvmToCoin) Size 

func (m *EventConvertEvmToCoin) Size() (n int)

func (*EventConvertEvmToCoin) String 

func (m *EventConvertEvmToCoin) String() string

func (*EventConvertEvmToCoin) Unmarshal 

func (m *EventConvertEvmToCoin) Unmarshal(dAtA []byte) error

func (*EventConvertEvmToCoin) XXX_DiscardUnknown 

func (m *EventConvertEvmToCoin) XXX_DiscardUnknown()

func (*EventConvertEvmToCoin) XXX_Marshal 

func (m *EventConvertEvmToCoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventConvertEvmToCoin) XXX_Merge 

func (m *EventConvertEvmToCoin) XXX_Merge(src proto.Message)

func (*EventConvertEvmToCoin) XXX_Size 

func (m *EventConvertEvmToCoin) XXX_Size() int

func (*EventConvertEvmToCoin) XXX_Unmarshal 

func (m *EventConvertEvmToCoin) XXX_Unmarshal(b []byte) error

type EventEthereumTx 

type EventEthereumTx struct {
	// amount
	Amount string `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
	// eth_hash is the Ethereum hash of the transaction
	EthHash string `protobuf:"bytes,2,opt,name=eth_hash,json=ethHash,proto3" json:"eth_hash,omitempty"`
	// index of the transaction in the block
	Index string `protobuf:"bytes,3,opt,name=index,proto3" json:"index,omitempty"`
	// gas_used is the amount of gas used by the transaction
	GasUsed string `protobuf:"bytes,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
	// hash is the Tendermint hash of the transaction
	Hash string `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
	// recipient of the transaction
	Recipient string `protobuf:"bytes,6,opt,name=recipient,proto3" json:"recipient,omitempty"`
	// vm_error contains a VM error should it occur
	VmError string `protobuf:"bytes,7,opt,name=vm_error,json=vmError,proto3" json:"vm_error,omitempty"`
}

EventEthereumTx defines the event for an Ethereum transaction

func EventEthereumTxFromABCIEvent 

func EventEthereumTxFromABCIEvent(event abci.Event) (*EventEthereumTx, error)

func (*EventEthereumTx) Descriptor 

func (*EventEthereumTx) Descriptor() ([]byte, []int)

func (*EventEthereumTx) GetAmount 

func (m *EventEthereumTx) GetAmount() string

func (*EventEthereumTx) GetEthHash 

func (m *EventEthereumTx) GetEthHash() string

func (*EventEthereumTx) GetGasUsed 

func (m *EventEthereumTx) GetGasUsed() string

func (*EventEthereumTx) GetHash 

func (m *EventEthereumTx) GetHash() string

func (*EventEthereumTx) GetIndex 

func (m *EventEthereumTx) GetIndex() string

func (*EventEthereumTx) GetRecipient 

func (m *EventEthereumTx) GetRecipient() string

func (*EventEthereumTx) GetVmError 

func (m *EventEthereumTx) GetVmError() string

func (*EventEthereumTx) Marshal 

func (m *EventEthereumTx) Marshal() (dAtA []byte, err error)

func (*EventEthereumTx) MarshalTo 

func (m *EventEthereumTx) MarshalTo(dAtA []byte) (int, error)

func (*EventEthereumTx) MarshalToSizedBuffer 

func (m *EventEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventEthereumTx) ProtoMessage 

func (*EventEthereumTx) ProtoMessage()

func (*EventEthereumTx) Reset 

func (m *EventEthereumTx) Reset()

func (*EventEthereumTx) Size 

func (m *EventEthereumTx) Size() (n int)

func (*EventEthereumTx) String 

func (m *EventEthereumTx) String() string

func (*EventEthereumTx) Unmarshal 

func (m *EventEthereumTx) Unmarshal(dAtA []byte) error

func (*EventEthereumTx) XXX_DiscardUnknown 

func (m *EventEthereumTx) XXX_DiscardUnknown()

func (*EventEthereumTx) XXX_Marshal 

func (m *EventEthereumTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventEthereumTx) XXX_Merge 

func (m *EventEthereumTx) XXX_Merge(src proto.Message)

func (*EventEthereumTx) XXX_Size 

func (m *EventEthereumTx) XXX_Size() int

func (*EventEthereumTx) XXX_Unmarshal 

func (m *EventEthereumTx) XXX_Unmarshal(b []byte) error

type EventFunTokenCreated 

type EventFunTokenCreated struct {
	BankDenom            string `protobuf:"bytes,1,opt,name=bank_denom,json=bankDenom,proto3" json:"bank_denom,omitempty"`
	Erc20ContractAddress string `protobuf:"bytes,2,opt,name=erc20_contract_address,json=erc20ContractAddress,proto3" json:"erc20_contract_address,omitempty"`
	Creator              string `protobuf:"bytes,3,opt,name=creator,proto3" json:"creator,omitempty"`
	IsMadeFromCoin       bool   `protobuf:"varint,4,opt,name=is_made_from_coin,json=isMadeFromCoin,proto3" json:"is_made_from_coin,omitempty"`
}

EventFunTokenCreated defines a fun token creation event.

func EventFunTokenCreatedFromABCIEvent 

func EventFunTokenCreatedFromABCIEvent(event abci.Event) (*EventFunTokenCreated, error)

func (*EventFunTokenCreated) Descriptor 

func (*EventFunTokenCreated) Descriptor() ([]byte, []int)

func (*EventFunTokenCreated) GetBankDenom 

func (m *EventFunTokenCreated) GetBankDenom() string

func (*EventFunTokenCreated) GetCreator 

func (m *EventFunTokenCreated) GetCreator() string

func (*EventFunTokenCreated) GetErc20ContractAddress 

func (m *EventFunTokenCreated) GetErc20ContractAddress() string

func (*EventFunTokenCreated) GetIsMadeFromCoin 

func (m *EventFunTokenCreated) GetIsMadeFromCoin() bool

func (*EventFunTokenCreated) Marshal 

func (m *EventFunTokenCreated) Marshal() (dAtA []byte, err error)

func (*EventFunTokenCreated) MarshalTo 

func (m *EventFunTokenCreated) MarshalTo(dAtA []byte) (int, error)

func (*EventFunTokenCreated) MarshalToSizedBuffer 

func (m *EventFunTokenCreated) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventFunTokenCreated) ProtoMessage 

func (*EventFunTokenCreated) ProtoMessage()

func (*EventFunTokenCreated) Reset 

func (m *EventFunTokenCreated) Reset()

func (*EventFunTokenCreated) Size 

func (m *EventFunTokenCreated) Size() (n int)

func (*EventFunTokenCreated) String 

func (m *EventFunTokenCreated) String() string

func (*EventFunTokenCreated) Unmarshal 

func (m *EventFunTokenCreated) Unmarshal(dAtA []byte) error

func (*EventFunTokenCreated) XXX_DiscardUnknown 

func (m *EventFunTokenCreated) XXX_DiscardUnknown()

func (*EventFunTokenCreated) XXX_Marshal 

func (m *EventFunTokenCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventFunTokenCreated) XXX_Merge 

func (m *EventFunTokenCreated) XXX_Merge(src proto.Message)

func (*EventFunTokenCreated) XXX_Size 

func (m *EventFunTokenCreated) XXX_Size() int

func (*EventFunTokenCreated) XXX_Unmarshal 

func (m *EventFunTokenCreated) XXX_Unmarshal(b []byte) error

type EventTransfer 

type EventTransfer struct {
	Sender    string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	Recipient string `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty"`
	Amount    string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
}

EventTransfer defines event for EVM transfer

func (*EventTransfer) Descriptor 

func (*EventTransfer) Descriptor() ([]byte, []int)

func (*EventTransfer) GetAmount 

func (m *EventTransfer) GetAmount() string

func (*EventTransfer) GetRecipient 

func (m *EventTransfer) GetRecipient() string

func (*EventTransfer) GetSender 

func (m *EventTransfer) GetSender() string

func (*EventTransfer) Marshal 

func (m *EventTransfer) Marshal() (dAtA []byte, err error)

func (*EventTransfer) MarshalTo 

func (m *EventTransfer) MarshalTo(dAtA []byte) (int, error)

func (*EventTransfer) MarshalToSizedBuffer 

func (m *EventTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventTransfer) ProtoMessage 

func (*EventTransfer) ProtoMessage()

func (*EventTransfer) Reset 

func (m *EventTransfer) Reset()

func (*EventTransfer) Size 

func (m *EventTransfer) Size() (n int)

func (*EventTransfer) String 

func (m *EventTransfer) String() string

func (*EventTransfer) Unmarshal 

func (m *EventTransfer) Unmarshal(dAtA []byte) error

func (*EventTransfer) XXX_DiscardUnknown 

func (m *EventTransfer) XXX_DiscardUnknown()

func (*EventTransfer) XXX_Marshal 

func (m *EventTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventTransfer) XXX_Merge 

func (m *EventTransfer) XXX_Merge(src proto.Message)

func (*EventTransfer) XXX_Size 

func (m *EventTransfer) XXX_Size() int

func (*EventTransfer) XXX_Unmarshal 

func (m *EventTransfer) XXX_Unmarshal(b []byte) error

type EventTxLog 

type EventTxLog struct {
	// tx_logs is an array of transaction logs
	Logs []Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs"`
}

EventTxLog defines the event for an Ethereum transaction log

func EventTxLogFromABCIEvent 

func EventTxLogFromABCIEvent(event abci.Event) (*EventTxLog, error)

func (*EventTxLog) Descriptor 

func (*EventTxLog) Descriptor() ([]byte, []int)

func (*EventTxLog) GetLogs 

func (m *EventTxLog) GetLogs() []Log

func (*EventTxLog) Marshal 

func (m *EventTxLog) Marshal() (dAtA []byte, err error)

func (*EventTxLog) MarshalTo 

func (m *EventTxLog) MarshalTo(dAtA []byte) (int, error)

func (*EventTxLog) MarshalToSizedBuffer 

func (m *EventTxLog) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventTxLog) ProtoMessage 

func (*EventTxLog) ProtoMessage()

func (*EventTxLog) Reset 

func (m *EventTxLog) Reset()

func (*EventTxLog) Size 

func (m *EventTxLog) Size() (n int)

func (*EventTxLog) String 

func (m *EventTxLog) String() string

func (*EventTxLog) Unmarshal 

func (m *EventTxLog) Unmarshal(dAtA []byte) error

func (*EventTxLog) XXX_DiscardUnknown 

func (m *EventTxLog) XXX_DiscardUnknown()

func (*EventTxLog) XXX_Marshal 

func (m *EventTxLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventTxLog) XXX_Merge 

func (m *EventTxLog) XXX_Merge(src proto.Message)

func (*EventTxLog) XXX_Size 

func (m *EventTxLog) XXX_Size() int

func (*EventTxLog) XXX_Unmarshal 

func (m *EventTxLog) XXX_Unmarshal(b []byte) error

type EventWeiBlockDelta 

type EventWeiBlockDelta struct {
	// net_wei_block_delta is the new sum of all "wei_block_delta" changes up to
	// this point. It is the value for "NetWeiBlockDelta" in the EVM state.
	NetWeiBlockDelta cosmossdk_io_math.Int `` /* 136-byte string literal not displayed */
	// WeiBlockDelta is the net sum of all calls of "AddWei" and "SubWei" in the
	// current block. There is no guarantee in the functional sense that the EVM
	// State DB will add the same amount it subtracts. It is possible for the
	// total amount of wei (NIBI) across all accounts to diverge from the initial
	// supply. "WeiBlockDelta" is a mechanism for recording that if it happens.
	WeiBlockDelta cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=wei_block_delta,json=weiBlockDelta,proto3,customtype=cosmossdk.io/math.Int" json:"wei_block_delta"`
	// block_number for which this event is emitted during EVM EndBlock
	BlockNumber uint64 `protobuf:"varint,3,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
}

EventWeiBlockDelta is an event emitted when there is a non-zero value for block delta (change) in wei in the EVM end block handler.

func (*EventWeiBlockDelta) Descriptor 

func (*EventWeiBlockDelta) Descriptor() ([]byte, []int)

func (*EventWeiBlockDelta) GetBlockNumber 

func (m *EventWeiBlockDelta) GetBlockNumber() uint64

func (*EventWeiBlockDelta) Marshal 

func (m *EventWeiBlockDelta) Marshal() (dAtA []byte, err error)

func (*EventWeiBlockDelta) MarshalTo 

func (m *EventWeiBlockDelta) MarshalTo(dAtA []byte) (int, error)

func (*EventWeiBlockDelta) MarshalToSizedBuffer 

func (m *EventWeiBlockDelta) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventWeiBlockDelta) ProtoMessage 

func (*EventWeiBlockDelta) ProtoMessage()

func (*EventWeiBlockDelta) Reset 

func (m *EventWeiBlockDelta) Reset()

func (*EventWeiBlockDelta) Size 

func (m *EventWeiBlockDelta) Size() (n int)

func (*EventWeiBlockDelta) String 

func (m *EventWeiBlockDelta) String() string

func (*EventWeiBlockDelta) Unmarshal 

func (m *EventWeiBlockDelta) Unmarshal(dAtA []byte) error

func (*EventWeiBlockDelta) XXX_DiscardUnknown 

func (m *EventWeiBlockDelta) XXX_DiscardUnknown()

func (*EventWeiBlockDelta) XXX_Marshal 

func (m *EventWeiBlockDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventWeiBlockDelta) XXX_Merge 

func (m *EventWeiBlockDelta) XXX_Merge(src proto.Message)

func (*EventWeiBlockDelta) XXX_Size 

func (m *EventWeiBlockDelta) XXX_Size() int

func (*EventWeiBlockDelta) XXX_Unmarshal 

func (m *EventWeiBlockDelta) XXX_Unmarshal(b []byte) error

type EvmTxArgs 

type EvmTxArgs struct {
	Nonce     uint64
	GasLimit  uint64
	Input     []byte
	GasFeeCap *big.Int
	GasPrice  *big.Int
	ChainID   *big.Int
	Amount    *big.Int
	GasTipCap *big.Int
	To        *common.Address
	Accesses  *gethcore.AccessList
}

EvmTxArgs encapsulates all possible params to create all EVM txs types. This includes LegacyTx, DynamicFeeTx and AccessListTx TODO(k-yang): replace with JsonTxArgs.

type ExtensionOptionsEthereumTx 

type ExtensionOptionsEthereumTx struct {
}

ExtensionOptionsEthereumTx is an extension option for ethereum transactions

func (*ExtensionOptionsEthereumTx) Descriptor 

func (*ExtensionOptionsEthereumTx) Descriptor() ([]byte, []int)

func (*ExtensionOptionsEthereumTx) Marshal 

func (m *ExtensionOptionsEthereumTx) Marshal() (dAtA []byte, err error)

func (*ExtensionOptionsEthereumTx) MarshalTo 

func (m *ExtensionOptionsEthereumTx) MarshalTo(dAtA []byte) (int, error)

func (*ExtensionOptionsEthereumTx) MarshalToSizedBuffer 

func (m *ExtensionOptionsEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*ExtensionOptionsEthereumTx) ProtoMessage 

func (*ExtensionOptionsEthereumTx) ProtoMessage()

func (*ExtensionOptionsEthereumTx) Reset 

func (m *ExtensionOptionsEthereumTx) Reset()

func (*ExtensionOptionsEthereumTx) Size 

func (m *ExtensionOptionsEthereumTx) Size() (n int)

func (*ExtensionOptionsEthereumTx) String 

func (m *ExtensionOptionsEthereumTx) String() string

func (*ExtensionOptionsEthereumTx) Unmarshal 

func (m *ExtensionOptionsEthereumTx) Unmarshal(dAtA []byte) error

func (*ExtensionOptionsEthereumTx) XXX_DiscardUnknown 

func (m *ExtensionOptionsEthereumTx) XXX_DiscardUnknown()

func (*ExtensionOptionsEthereumTx) XXX_Marshal 

func (m *ExtensionOptionsEthereumTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExtensionOptionsEthereumTx) XXX_Merge 

func (m *ExtensionOptionsEthereumTx) XXX_Merge(src proto.Message)

func (*ExtensionOptionsEthereumTx) XXX_Size 

func (m *ExtensionOptionsEthereumTx) XXX_Size() int

func (*ExtensionOptionsEthereumTx) XXX_Unmarshal 

func (m *ExtensionOptionsEthereumTx) XXX_Unmarshal(b []byte) error

type FunToken 

type FunToken struct {
	// Hexadecimal address of the ERC20 token to which the `FunToken` maps
	Erc20Addr github_com_NibiruChain_nibiru_v2_eth.EIP55Addr `` /* 136-byte string literal not displayed */
	// bank_denom: Coin denomination in the Bank Module.
	BankDenom string `protobuf:"bytes,2,opt,name=bank_denom,json=bankDenom,proto3" json:"bank_denom,omitempty"`
	// 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.
	IsMadeFromCoin bool `protobuf:"varint,3,opt,name=is_made_from_coin,json=isMadeFromCoin,proto3" json:"is_made_from_coin,omitempty"`
}

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.

func NewFunToken 

func NewFunToken(
	erc20 gethcommon.Address, bankDenom string, isMadeFromCoin bool,
) FunToken

NewFunToken is a canonical constructor for the FunToken type. Using this function helps guarantee a consistent string representation from the hex-encoded Ethereum address.

func (*FunToken) Descriptor 

func (*FunToken) Descriptor() ([]byte, []int)

func (*FunToken) GetBankDenom 

func (m *FunToken) GetBankDenom() string

func (*FunToken) GetIsMadeFromCoin 

func (m *FunToken) GetIsMadeFromCoin() bool

func (FunToken) ID 

func (fun FunToken) ID() []byte

FIXME: Explore problems arrising from ERC1155 creating multiple fungible tokens that are valid ERC20s with the same address. https://github.com/NibiruChain/nibiru/issues/1933

func (*FunToken) Marshal 

func (m *FunToken) Marshal() (dAtA []byte, err error)

func (*FunToken) MarshalTo 

func (m *FunToken) MarshalTo(dAtA []byte) (int, error)

func (*FunToken) MarshalToSizedBuffer 

func (m *FunToken) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*FunToken) ProtoMessage 

func (*FunToken) ProtoMessage()

func (*FunToken) Reset 

func (m *FunToken) Reset()

func (*FunToken) Size 

func (m *FunToken) Size() (n int)

func (*FunToken) String 

func (m *FunToken) String() string

func (*FunToken) Unmarshal 

func (m *FunToken) Unmarshal(dAtA []byte) error

func (FunToken) Validate 

func (fun FunToken) Validate() error

func (*FunToken) XXX_DiscardUnknown 

func (m *FunToken) XXX_DiscardUnknown()

func (*FunToken) XXX_Marshal 

func (m *FunToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FunToken) XXX_Merge 

func (m *FunToken) XXX_Merge(src proto.Message)

func (*FunToken) XXX_Size 

func (m *FunToken) XXX_Size() int

func (*FunToken) XXX_Unmarshal 

func (m *FunToken) XXX_Unmarshal(b []byte) error

type GenesisAccount 

type GenesisAccount struct {
	// address defines an ethereum hex formated address of an account
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// code defines the hex bytes of the account code.
	Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"`
	// storage defines the set of state key values for the account.
	Storage Storage `protobuf:"bytes,3,rep,name=storage,proto3,castrepeated=Storage" json:"storage"`
}

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.

func ERC2470GenesisAccount 

func ERC2470GenesisAccount() GenesisAccount

ERC2470GenesisAccount returns the canonical factory as a default EVM genesis account. The account has no initialized storage.

func (*GenesisAccount) Descriptor 

func (*GenesisAccount) Descriptor() ([]byte, []int)

func (*GenesisAccount) GetAddress 

func (m *GenesisAccount) GetAddress() string

func (*GenesisAccount) GetCode 

func (m *GenesisAccount) GetCode() string

func (*GenesisAccount) GetStorage 

func (m *GenesisAccount) GetStorage() Storage

func (*GenesisAccount) Marshal 

func (m *GenesisAccount) Marshal() (dAtA []byte, err error)

func (*GenesisAccount) MarshalTo 

func (m *GenesisAccount) MarshalTo(dAtA []byte) (int, error)

func (*GenesisAccount) MarshalToSizedBuffer 

func (m *GenesisAccount) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*GenesisAccount) ProtoMessage 

func (*GenesisAccount) ProtoMessage()

func (*GenesisAccount) Reset 

func (m *GenesisAccount) Reset()

func (*GenesisAccount) Size 

func (m *GenesisAccount) Size() (n int)

func (*GenesisAccount) String 

func (m *GenesisAccount) String() string

func (*GenesisAccount) Unmarshal 

func (m *GenesisAccount) Unmarshal(dAtA []byte) error

func (GenesisAccount) Validate 

func (ga GenesisAccount) Validate() error

Validate performs a basic validation of a GenesisAccount fields.

func (*GenesisAccount) XXX_DiscardUnknown 

func (m *GenesisAccount) XXX_DiscardUnknown()

func (*GenesisAccount) XXX_Marshal 

func (m *GenesisAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenesisAccount) XXX_Merge 

func (m *GenesisAccount) XXX_Merge(src proto.Message)

func (*GenesisAccount) XXX_Size 

func (m *GenesisAccount) XXX_Size() int

func (*GenesisAccount) XXX_Unmarshal 

func (m *GenesisAccount) XXX_Unmarshal(b []byte) error

type GenesisState 

type GenesisState struct {
	// accounts is an array containing the ethereum genesis accounts.
	Accounts []GenesisAccount `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts"`
	// params defines all the parameters of the module.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
	// Fungible token mappings corresponding to ERC-20 smart contract tokens.
	FuntokenMappings []FunToken `protobuf:"bytes,3,rep,name=funtoken_mappings,json=funtokenMappings,proto3" json:"funtoken_mappings"`
}

GenesisState defines the evm module's genesis state.

func DefaultGenesisState 

func DefaultGenesisState() *GenesisState

DefaultGenesisState sets default evm genesis state with empty accounts and default params and chain config values.

func (*GenesisState) Descriptor 

func (*GenesisState) Descriptor() ([]byte, []int)

func (*GenesisState) GetAccounts 

func (m *GenesisState) GetAccounts() []GenesisAccount

func (*GenesisState) GetFuntokenMappings 

func (m *GenesisState) GetFuntokenMappings() []FunToken

func (*GenesisState) GetParams 

func (m *GenesisState) GetParams() Params

func (*GenesisState) Marshal 

func (m *GenesisState) Marshal() (dAtA []byte, err error)

func (*GenesisState) MarshalTo 

func (m *GenesisState) MarshalTo(dAtA []byte) (int, error)

func (*GenesisState) MarshalToSizedBuffer 

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*GenesisState) ProtoMessage 

func (*GenesisState) ProtoMessage()

func (*GenesisState) Reset 

func (m *GenesisState) Reset()

func (*GenesisState) Size 

func (m *GenesisState) Size() (n int)

func (*GenesisState) String 

func (m *GenesisState) String() string

func (*GenesisState) Unmarshal 

func (m *GenesisState) Unmarshal(dAtA []byte) error

func (GenesisState) Validate 

func (gs GenesisState) Validate() error

Validate performs basic genesis state validation returning an error upon any failure.

func (*GenesisState) XXX_DiscardUnknown 

func (m *GenesisState) XXX_DiscardUnknown()

func (*GenesisState) XXX_Marshal 

func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenesisState) XXX_Merge 

func (m *GenesisState) XXX_Merge(src proto.Message)

func (*GenesisState) XXX_Size 

func (m *GenesisState) XXX_Size() int

func (*GenesisState) XXX_Unmarshal 

func (m *GenesisState) XXX_Unmarshal(b []byte) error

type JsonTxArgs 

type JsonTxArgs struct {
	From                 *common.Address `json:"from"`
	To                   *common.Address `json:"to"`
	Gas                  *hexutil.Uint64 `json:"gas"`
	GasPrice             *hexutil.Big    `json:"gasPrice"`
	MaxFeePerGas         *hexutil.Big    `json:"maxFeePerGas"`
	MaxPriorityFeePerGas *hexutil.Big    `json:"maxPriorityFeePerGas"`
	Value                *hexutil.Big    `json:"value"`
	Nonce                *hexutil.Uint64 `json:"nonce"`

	// We accept "data" and "input" for backwards-compatibility reasons.
	// "input" is the newer name and should be preferred by clients.
	// Issue detail: https://github.com/ethereum/go-ethereum/issues/15628
	Data *hexutil.Bytes `json:"data"`
	// Both "data" and "input" are accepted for backwards-compatibility reasons.
	// "input" is the newer name and should be preferred by clients.
	// Issue detail: https://github.com/ethereum/go-ethereum/issues/15628
	Input *hexutil.Bytes `json:"input"`

	// Introduced by AccessListTxType transaction.
	AccessList *geth.AccessList `json:"accessList,omitempty"`
	ChainID    *hexutil.Big     `json:"chainId,omitempty"`
}

JsonTxArgs represents the arguments to construct a new transaction or a message call using JSON-RPC. Duplicate struct definition since geth struct is in internal package Ref: https://github.com/ethereum/go-ethereum/blob/release/1.10.4/internal/ethapi/transaction_args.go#L36

func (*JsonTxArgs) GetData 

func (args *JsonTxArgs) GetData() []byte

GetData retrieves the transaction calldata. Input field is preferred.

func (*JsonTxArgs) GetFrom 

func (args *JsonTxArgs) GetFrom() common.Address

GetFrom retrieves the transaction sender address.

func (*JsonTxArgs) String 

func (args *JsonTxArgs) String() string

String return the struct in a string format

func (*JsonTxArgs) ToMessage 

func (args *JsonTxArgs) ToMessage(globalGasCap uint64, baseFeeWei *big.Int) (core.Message, error)

ToMessage converts the arguments to the Message type used by the core evm. This assumes that setTxDefaults has been called.

func (*JsonTxArgs) ToMsgEthTx 

func (args *JsonTxArgs) ToMsgEthTx() *MsgEthereumTx

ToMsgEthTx converts the arguments to an ethereum transaction. This assumes that setTxDefaults has been called.

func (*JsonTxArgs) ToZeroGasMessage 

func (args *JsonTxArgs) ToZeroGasMessage(globalGasCap uint64, baseFeeWei *big.Int) (core.Message, error)

ToZeroGasMessage converts JSON-RPC args into an EVM message while ignoring fee-style conflicts and normalizing fee-price fields to zero.

type LegacyTx 

type LegacyTx struct {
	// nonce corresponds to the account nonce (transaction sequence).
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// gas_price defines the value for each gas unit
	GasPrice *cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=gas_price,json=gasPrice,proto3,customtype=cosmossdk.io/math.Int" json:"gas_price,omitempty"`
	// gas defines the gas limit defined for the transaction.
	GasLimit uint64 `protobuf:"varint,3,opt,name=gas,proto3" json:"gas,omitempty"`
	// to is the hex formatted address of the recipient
	To string `protobuf:"bytes,4,opt,name=to,proto3" json:"to,omitempty"`
	// value defines the unsigned integer value of the transaction amount.
	Amount *cosmossdk_io_math.Int `protobuf:"bytes,5,opt,name=value,proto3,customtype=cosmossdk.io/math.Int" json:"value,omitempty"`
	// data is the data payload bytes of the transaction.
	Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
	// 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.
	V []byte `protobuf:"bytes,7,opt,name=v,proto3" json:"v,omitempty"`
	// 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.
	R []byte `protobuf:"bytes,8,opt,name=r,proto3" json:"r,omitempty"`
	// 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.
	S []byte `protobuf:"bytes,9,opt,name=s,proto3" json:"s,omitempty"`
}

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".

func NewLegacyTx 

func NewLegacyTx(tx *gethcore.Transaction) (*LegacyTx, error)

func (*LegacyTx) AsEthereumData 

func (tx *LegacyTx) AsEthereumData() gethcore.TxData

AsEthereumData returns an LegacyTx transaction tx from the proto-formatted TxData defined on the Cosmos EVM.

func (*LegacyTx) Copy 

func (tx *LegacyTx) Copy() TxData

Copy returns an instance with the same field values

func (LegacyTx) Cost 

func (tx LegacyTx) Cost() *big.Int

Cost returns amount + gasPrice * gasLimit.

func (*LegacyTx) Descriptor 

func (*LegacyTx) Descriptor() ([]byte, []int)

func (LegacyTx) EffectiveCostWei 

func (tx LegacyTx) EffectiveCostWei(baseFeeWei *big.Int) *big.Int

EffectiveCostWei is the same as Cost for LegacyTx

func (LegacyTx) EffectiveFeeWei 

func (tx LegacyTx) EffectiveFeeWei(baseFeeWei *big.Int) *big.Int

EffectiveFeeWei is the same as Fee for LegacyTx

func (*LegacyTx) EffectiveGasFeeCapWei 

func (tx *LegacyTx) EffectiveGasFeeCapWei(baseFeeWei *big.Int) *big.Int

func (LegacyTx) EffectiveGasPriceWeiPerGas 

func (tx LegacyTx) EffectiveGasPriceWeiPerGas(baseFeeWei *big.Int) *big.Int

EffectiveGasPriceWeiPerGas is the same as GasPrice for LegacyTx

func (LegacyTx) Fee 

func (tx LegacyTx) Fee() *big.Int

Fee := gasPrice (wei per gas) * gasLimit (gas). Thus, fee is in units of wei.

func (*LegacyTx) GetAccessList 

func (tx *LegacyTx) GetAccessList() gethcore.AccessList

GetAccessList returns nil

func (*LegacyTx) GetChainID 

func (tx *LegacyTx) GetChainID() *big.Int

GetChainID returns the chain id field from the derived signature values

func (*LegacyTx) GetData 

func (tx *LegacyTx) GetData() []byte

GetData returns a copy of the input data bytes.

func (*LegacyTx) GetGas 

func (tx *LegacyTx) GetGas() uint64

GetGas returns the gas limit.

func (*LegacyTx) GetGasFeeCapWei 

func (tx *LegacyTx) GetGasFeeCapWei() *big.Int

GetGasFeeCapWei returns a cap on the gas fees paid in units of wei. For a LegacyTx, this is taken to be the gas price.

func (*LegacyTx) GetGasPrice 

func (tx *LegacyTx) GetGasPrice() *big.Int

GetGasPrice is equivalent to wei per unit gas.

func (*LegacyTx) GetGasTipCapWei 

func (tx *LegacyTx) GetGasTipCapWei() *big.Int

GetGasTipCapWei returns a cap on the gas tip in units of wei. For a LegacyTx, this is taken to be the gas price.

func (*LegacyTx) GetNonce 

func (tx *LegacyTx) GetNonce() uint64

GetNonce returns the account sequence for the transaction.

func (*LegacyTx) GetRawSignatureValues 

func (tx *LegacyTx) GetRawSignatureValues() (v, r, s *big.Int)

GetRawSignatureValues returns the V, R, S signature values of the transaction. The return values should not be modified by the caller.

func (*LegacyTx) GetTo 

func (tx *LegacyTx) GetTo() *common.Address

GetTo returns the pointer to the recipient address.

func (*LegacyTx) GetToRaw 

func (tx *LegacyTx) GetToRaw() string

func (*LegacyTx) GetValueWei 

func (tx *LegacyTx) GetValueWei() *big.Int

GetValueWei returns the tx amount.

func (*LegacyTx) Marshal 

func (m *LegacyTx) Marshal() (dAtA []byte, err error)

func (*LegacyTx) MarshalTo 

func (m *LegacyTx) MarshalTo(dAtA []byte) (int, error)

func (*LegacyTx) MarshalToSizedBuffer 

func (m *LegacyTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*LegacyTx) ProtoMessage 

func (*LegacyTx) ProtoMessage()

func (*LegacyTx) Reset 

func (m *LegacyTx) Reset()

func (*LegacyTx) SetSignatureValues 

func (tx *LegacyTx) SetSignatureValues(_, v, r, s *big.Int)

SetSignatureValues sets the signature values to the transaction.

func (*LegacyTx) Size 

func (m *LegacyTx) Size() (n int)

func (*LegacyTx) String 

func (m *LegacyTx) String() string

func (*LegacyTx) TxType 

func (tx *LegacyTx) TxType() uint8

TxType returns a byte (uint8) identifying the tx as a LegacyTx (0), AccessListTx (1), or DynamicFeeTx (2).

func (*LegacyTx) Unmarshal 

func (m *LegacyTx) Unmarshal(dAtA []byte) error

func (LegacyTx) Validate 

func (tx LegacyTx) Validate() error

Validate performs a stateless validation of the tx fields.

func (*LegacyTx) XXX_DiscardUnknown 

func (m *LegacyTx) XXX_DiscardUnknown()

func (*LegacyTx) XXX_Marshal 

func (m *LegacyTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LegacyTx) XXX_Merge 

func (m *LegacyTx) XXX_Merge(src proto.Message)

func (*LegacyTx) XXX_Size 

func (m *LegacyTx) XXX_Size() int

func (*LegacyTx) XXX_Unmarshal 

func (m *LegacyTx) XXX_Unmarshal(b []byte) error

type Log 

type Log struct {
	// address of the contract that generated the event
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// topics is a list of topics provided by the contract.
	Topics []string `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"`
	// data which is supplied by the contract, usually ABI-encoded
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// block_number of the block in which the transaction was included
	BlockNumber uint64 `protobuf:"varint,4,opt,name=block_number,json=blockNumber,proto3" json:"blockNumber"`
	// tx_hash is the transaction hash
	TxHash string `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3" json:"transactionHash"`
	// tx_index of the transaction in the block
	TxIndex uint64 `protobuf:"varint,6,opt,name=tx_index,json=txIndex,proto3" json:"transactionIndex"`
	// block_hash of the block in which the transaction was included
	BlockHash string `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3" json:"blockHash"`
	// index of the log in the block
	Index uint64 `protobuf:"varint,8,opt,name=index,proto3" json:"logIndex"`
	// 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 bool `protobuf:"varint,9,opt,name=removed,proto3" json:"removed,omitempty"`
}

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.

func NewLogFromEth 

func NewLogFromEth(log *gethcore.Log) Log

NewLogFromEth creates a new Log instance from an Ethereum type Log.

func NewLogsFromEth 

func NewLogsFromEth(ethlogs []*gethcore.Log) []Log

func (*Log) Descriptor 

func (*Log) Descriptor() ([]byte, []int)

func (*Log) GetAddress 

func (m *Log) GetAddress() string

func (*Log) GetBlockHash 

func (m *Log) GetBlockHash() string

func (*Log) GetBlockNumber 

func (m *Log) GetBlockNumber() uint64

func (*Log) GetData 

func (m *Log) GetData() []byte

func (*Log) GetIndex 

func (m *Log) GetIndex() uint64

func (*Log) GetRemoved 

func (m *Log) GetRemoved() bool

func (*Log) GetTopics 

func (m *Log) GetTopics() []string

func (*Log) GetTxHash 

func (m *Log) GetTxHash() string

func (*Log) GetTxIndex 

func (m *Log) GetTxIndex() uint64

func (*Log) Marshal 

func (m *Log) Marshal() (dAtA []byte, err error)

func (*Log) MarshalTo 

func (m *Log) MarshalTo(dAtA []byte) (int, error)

func (*Log) MarshalToSizedBuffer 

func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Log) ProtoMessage 

func (*Log) ProtoMessage()

func (*Log) Reset 

func (m *Log) Reset()

func (*Log) Size 

func (m *Log) Size() (n int)

func (*Log) String 

func (m *Log) String() string

func (*Log) ToEthereum 

func (log *Log) ToEthereum() *gethcore.Log

ToEthereum returns the Ethereum type Log from a Ethermint proto compatible Log.

func (Log) ToLogLite 

func (log Log) ToLogLite() LogLite

func (*Log) Unmarshal 

func (m *Log) Unmarshal(dAtA []byte) error

func (*Log) Validate 

func (log *Log) Validate() error

Validate performs a basic validation of an ethereum Log fields.

func (*Log) XXX_DiscardUnknown 

func (m *Log) XXX_DiscardUnknown()

func (*Log) XXX_Marshal 

func (m *Log) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Log) XXX_Merge 

func (m *Log) XXX_Merge(src proto.Message)

func (*Log) XXX_Size 

func (m *Log) XXX_Size() int

func (*Log) XXX_Unmarshal 

func (m *Log) XXX_Unmarshal(b []byte) error

type LogLite 

type LogLite struct {
	// address of the contract that generated the event
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// topics is a list of topics provided by the contract.
	Topics []string `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"`
	// data which is supplied by the contract, usually ABI-encoded
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}

LogLite holds the consensus fields from an Ethereum log for a contract event. This structure is used to record EVM logs emitted within non-Ethreum transactions, such as "eth.evm.v1.MsgConvertCoinToEvm". Similar to full logs, these events are generated by the LOG opcode, however LogLite instances are not stored/indexed by the node.

func LogsToLogLite 

func LogsToLogLite(logs []Log) []LogLite

func (*LogLite) Descriptor 

func (*LogLite) Descriptor() ([]byte, []int)

func (*LogLite) GetAddress 

func (m *LogLite) GetAddress() string

func (*LogLite) GetData 

func (m *LogLite) GetData() []byte

func (*LogLite) GetTopics 

func (m *LogLite) GetTopics() []string

func (*LogLite) Marshal 

func (m *LogLite) Marshal() (dAtA []byte, err error)

func (*LogLite) MarshalTo 

func (m *LogLite) MarshalTo(dAtA []byte) (int, error)

func (*LogLite) MarshalToSizedBuffer 

func (m *LogLite) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*LogLite) ProtoMessage 

func (*LogLite) ProtoMessage()

func (*LogLite) Reset 

func (m *LogLite) Reset()

func (*LogLite) Size 

func (m *LogLite) Size() (n int)

func (*LogLite) String 

func (m *LogLite) String() string

func (*LogLite) Unmarshal 

func (m *LogLite) Unmarshal(dAtA []byte) error

func (*LogLite) XXX_DiscardUnknown 

func (m *LogLite) XXX_DiscardUnknown()

func (*LogLite) XXX_Marshal 

func (m *LogLite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*LogLite) XXX_Merge 

func (m *LogLite) XXX_Merge(src proto.Message)

func (*LogLite) XXX_Size 

func (m *LogLite) XXX_Size() int

func (*LogLite) XXX_Unmarshal 

func (m *LogLite) XXX_Unmarshal(b []byte) error

type Mempool 

type Mempool struct {
	// contains filtered or unexported fields
}

Mempool is Nibiru's node-local EVM transaction index.

Mempool implements sdkmempool.Mempool but indexes only standard EVM transactions. Non-EVM insertion and removal are no-ops because the custom PrepareProposal handler obtains non-EVM candidates from RequestPrepareProposal.Txs.

Each authenticated sender may own at most maxSlotsPerSender live nonce slots. The first accepted transaction owns a (sender, transaction nonce) slot; a different cmttypes.TxKey for that slot is rejected rather than replaced (no fee replacement). Mempool is process-local: only CheckTxType_New, CheckTxType_Recheck, and this node's PrepareProposal may consult it. ProcessProposal and block delivery must not use local mempool membership.

func NewMempool 

func NewMempool(maxSlotsPerSender uint64) *Mempool

NewMempool returns an empty Mempool with the given live-slot limit. maxSlotsPerSender must be greater than zero.

func (*Mempool) CheckNewTx 

func (m *Mempool) CheckNewTx(
	txKey cmttypes.TxKey,
	sender gethcommon.Address,
	nonce uint64,
) error

CheckNewTx performs the read-only CheckTxType_New admission guard for occupied slots and the live-slot count. A successful result does not reserve a nonce slot; Mempool.Insert repeats the checks atomically after the complete ante handler succeeds. The state-nonce admission window is enforced by the EVM ante nonce step, not here.

func (*Mempool) CheckRecheck 

func (m *Mempool) CheckRecheck(
	txKey cmttypes.TxKey,
	sender gethcommon.Address,
	stateNonce uint64,
	txNonce uint64,
) error

CheckRecheck determines whether an indexed EVM transaction remains part of a complete state nonce chain during CheckTxType_Recheck. A state nonce chain requires a live slot for every nonce from the committed state nonce through the transaction nonce, and the outer cmttypes.TxKey must own that slot. Mempool.CheckRecheck validates only; BaseApp removes the transaction by cmttypes.TxKey when the surrounding recheck fails.

func (*Mempool) CountTx 

func (m *Mempool) CountTx() int

CountTx returns the number of live EVM transactions in the mempool.

func (*Mempool) Insert 

func (m *Mempool) Insert(goCtx context.Context, tx sdk.Tx) error

Insert atomically admits an EVM transaction after its complete ante handler succeeds. The original outer bytes from sdk.Context.TxBytes are the authoritative bytes used for cmttypes.TxKey calculation and later proposal construction. An exact retransmission (same cmttypes.TxKey) is an idempotent no-op.

func (*Mempool) Remove 

func (m *Mempool) Remove(tx sdk.Tx) error

Remove removes tx only when its signed Ethereum hash matches the transaction occupying the derived sender and nonce slot. BaseApp lifecycle integration should prefer Mempool.RemoveByTxKey because Mempool.Remove cannot recover the original outer SDK transaction bytes.

func (*Mempool) RemoveByTxKey 

func (m *Mempool) RemoveByTxKey(txKey cmttypes.TxKey) error

RemoveByTxKey removes exactly the transaction identified by CometBFT's outer cmttypes.TxKey. Removing a transaction that is no longer present is successful, making failed-recheck and DeliverTx lifecycle cleanup idempotent.

func (*Mempool) Select 

func (m *Mempool) Select(context.Context, [][]byte) sdkmempool.Iterator

Select returns a read-only iterator over a point-in-time copy of the decoded EVM transactions for sdkmempool.Mempool. The custom PrepareProposal handler uses Mempool.Snapshot because it also requires original outer bytes and EVM-specific metadata.

func (*Mempool) Snapshot 

func (m *Mempool) Snapshot() []MempoolSender

Snapshot returns a deep copy of the mempool grouped by sender. Sender groups have deterministic address order, and transactions within a group have ascending nonce order. MempoolSender.MinNonce is the lowest live slot in that group, not necessarily the committed state nonce. Proposal code holds no mempool lock while reading application state or running ante validation.

type MempoolSender 

type MempoolSender struct {
	Sender   gethcommon.Address
	MinNonce uint64
	Txs      []MempoolTx
}

MempoolSender is a point-in-time copy of one sender's live EVM nonce slots. MempoolSender.MinNonce is the lowest live nonce in MempoolSender.Txs; it is not necessarily the sender's committed state nonce and is not the admission-window origin. MempoolSender.Txs is ordered by EVM nonce in ascending order and may contain nonce gaps.

type MempoolTx 

type MempoolTx struct {
	TxBytes   []byte
	TxKey     cmttypes.TxKey
	EVMHash   gethcommon.Hash
	Sender    gethcommon.Address
	Nonce     uint64
	Priority  int64
	GasWanted uint64
	ArrivalID uint64
}

MempoolTx is an immutable snapshot of one EVM transaction held by Mempool.

MempoolTx.TxBytes holds the original outer SDK transaction bytes from sdk.Context.TxBytes during BaseApp.CheckTx. Proposal construction must return those bytes instead of re-encoding the decoded transaction because EVM ante validation populates MsgEthereumTx.From and re-encoding can change the outer bytes. MempoolTx.Nonce is the transaction nonce from the signed EVM payload.

type MsgClient 

type MsgClient interface {
	// EthereumTx defines a method submitting Ethereum transactions.
	EthereumTx(ctx context.Context, in *MsgEthereumTx, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error)
	// UpdateParams defined a governance operation for updating the x/evm module
	// parameters. The authority is hard-coded to the x/gov module account
	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
	// CreateFunToken: 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.
	CreateFunToken(ctx context.Context, in *MsgCreateFunToken, opts ...grpc.CallOption) (*MsgCreateFunTokenResponse, error)
	// ConvertCoinToEvm: Sends a coin with a valid "FunToken" mapping to the
	// given recipient address ("to_eth_addr") in the corresponding ERC20
	// representation.
	ConvertCoinToEvm(ctx context.Context, in *MsgConvertCoinToEvm, opts ...grpc.CallOption) (*MsgConvertCoinToEvmResponse, error)
	// ConvertEvmToCoin: Sends an ERC20 token with a valid "FunToken" mapping to
	// the given recipient address as a bank coin.
	ConvertEvmToCoin(ctx context.Context, in *MsgConvertEvmToCoin, opts ...grpc.CallOption) (*MsgConvertEvmToCoinResponse, error)
}

MsgClient is the client API for Msg service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMsgClient 

func NewMsgClient(cc grpc1.ClientConn) MsgClient

type MsgConvertCoinToEvm 

type MsgConvertCoinToEvm struct {
	// Hexadecimal address of the ERC20 token to which the `FunToken` maps
	ToEthAddr github_com_NibiruChain_nibiru_v2_eth.EIP55Addr `` /* 138-byte string literal not displayed */
	// Sender: Address for the signer of the transaction.
	Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	// Bank Coin to get converted to ERC20
	BankCoin types1.Coin `protobuf:"bytes,3,opt,name=bank_coin,json=bankCoin,proto3" json:"bank_coin" yaml:"bank_coin"`
}

MsgConvertCoinToEvm: Arguments to send a Bank Coin to ERC-20 representation

func (*MsgConvertCoinToEvm) Descriptor 

func (*MsgConvertCoinToEvm) Descriptor() ([]byte, []int)

func (*MsgConvertCoinToEvm) GetBankCoin 

func (m *MsgConvertCoinToEvm) GetBankCoin() types1.Coin

func (*MsgConvertCoinToEvm) GetSender 

func (m *MsgConvertCoinToEvm) GetSender() string

func (MsgConvertCoinToEvm) GetSignBytes 

func (m MsgConvertCoinToEvm) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg interface.

func (MsgConvertCoinToEvm) GetSigners 

func (m MsgConvertCoinToEvm) GetSigners() []sdk.AccAddress

GetSigners returns the expected signers for a MsgConvertCoinToEvm message.

func (*MsgConvertCoinToEvm) Marshal 

func (m *MsgConvertCoinToEvm) Marshal() (dAtA []byte, err error)

func (*MsgConvertCoinToEvm) MarshalTo 

func (m *MsgConvertCoinToEvm) MarshalTo(dAtA []byte) (int, error)

func (*MsgConvertCoinToEvm) MarshalToSizedBuffer 

func (m *MsgConvertCoinToEvm) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgConvertCoinToEvm) ProtoMessage 

func (*MsgConvertCoinToEvm) ProtoMessage()

func (*MsgConvertCoinToEvm) Reset 

func (m *MsgConvertCoinToEvm) Reset()

func (*MsgConvertCoinToEvm) Size 

func (m *MsgConvertCoinToEvm) Size() (n int)

func (*MsgConvertCoinToEvm) String 

func (m *MsgConvertCoinToEvm) String() string

func (*MsgConvertCoinToEvm) Unmarshal 

func (m *MsgConvertCoinToEvm) Unmarshal(dAtA []byte) error

func (*MsgConvertCoinToEvm) ValidateBasic 

func (m *MsgConvertCoinToEvm) ValidateBasic() error

ValidateBasic does a sanity check of the provided data

func (*MsgConvertCoinToEvm) XXX_DiscardUnknown 

func (m *MsgConvertCoinToEvm) XXX_DiscardUnknown()

func (*MsgConvertCoinToEvm) XXX_Marshal 

func (m *MsgConvertCoinToEvm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgConvertCoinToEvm) XXX_Merge 

func (m *MsgConvertCoinToEvm) XXX_Merge(src proto.Message)

func (*MsgConvertCoinToEvm) XXX_Size 

func (m *MsgConvertCoinToEvm) XXX_Size() int

func (*MsgConvertCoinToEvm) XXX_Unmarshal 

func (m *MsgConvertCoinToEvm) XXX_Unmarshal(b []byte) error

type MsgConvertCoinToEvmResponse 

type MsgConvertCoinToEvmResponse struct {
}

func (*MsgConvertCoinToEvmResponse) Descriptor 

func (*MsgConvertCoinToEvmResponse) Descriptor() ([]byte, []int)

func (*MsgConvertCoinToEvmResponse) Marshal 

func (m *MsgConvertCoinToEvmResponse) Marshal() (dAtA []byte, err error)

func (*MsgConvertCoinToEvmResponse) MarshalTo 

func (m *MsgConvertCoinToEvmResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgConvertCoinToEvmResponse) MarshalToSizedBuffer 

func (m *MsgConvertCoinToEvmResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgConvertCoinToEvmResponse) ProtoMessage 

func (*MsgConvertCoinToEvmResponse) ProtoMessage()

func (*MsgConvertCoinToEvmResponse) Reset 

func (m *MsgConvertCoinToEvmResponse) Reset()

func (*MsgConvertCoinToEvmResponse) Size 

func (m *MsgConvertCoinToEvmResponse) Size() (n int)

func (*MsgConvertCoinToEvmResponse) String 

func (m *MsgConvertCoinToEvmResponse) String() string

func (*MsgConvertCoinToEvmResponse) Unmarshal 

func (m *MsgConvertCoinToEvmResponse) Unmarshal(dAtA []byte) error

func (*MsgConvertCoinToEvmResponse) XXX_DiscardUnknown 

func (m *MsgConvertCoinToEvmResponse) XXX_DiscardUnknown()

func (*MsgConvertCoinToEvmResponse) XXX_Marshal 

func (m *MsgConvertCoinToEvmResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgConvertCoinToEvmResponse) XXX_Merge 

func (m *MsgConvertCoinToEvmResponse) XXX_Merge(src proto.Message)

func (*MsgConvertCoinToEvmResponse) XXX_Size 

func (m *MsgConvertCoinToEvmResponse) XXX_Size() int

func (*MsgConvertCoinToEvmResponse) XXX_Unmarshal 

func (m *MsgConvertCoinToEvmResponse) XXX_Unmarshal(b []byte) error

type MsgConvertEvmToCoin 

type MsgConvertEvmToCoin struct {
	// Sender: "nibi"-prefixed Bech32 address for the signer of the transaction.
	// This is also the address whose ERC20 balance will be deducted.
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	// Hexadecimal address of the ERC20 token to be converted and sent
	Erc20Addr github_com_NibiruChain_nibiru_v2_eth.EIP55Addr `` /* 136-byte string literal not displayed */
	// Amount of ERC20 tokens to convert
	Amount cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	// Recipient address for the bank coins in Ethereum hexadecimal or
	// nibi-prefixed Bech32 format.
	//
	// Currently, accounts corresponding to Wasm contracts cannot hold ERC20
	// tokens because the function that maps between Bech32 and Eth hex addresses
	// is not bijective for these types of accounts.
	//
	// See [bug(evm): nibid q evm account is not symmetric for wasm
	// addresses](https://github.com/NibiruChain/nibiru/issues/2138)
	ToAddr string `protobuf:"bytes,4,opt,name=to_addr,json=toAddr,proto3" json:"to_addr,omitempty"`
}

MsgConvertEvmToCoin: Arguments to send an ERC20 token to bank coin representation

func (*MsgConvertEvmToCoin) Descriptor 

func (*MsgConvertEvmToCoin) Descriptor() ([]byte, []int)

func (*MsgConvertEvmToCoin) GetSender 

func (m *MsgConvertEvmToCoin) GetSender() string

func (MsgConvertEvmToCoin) GetSignBytes 

func (m MsgConvertEvmToCoin) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg interface.

func (MsgConvertEvmToCoin) GetSigners 

func (m MsgConvertEvmToCoin) GetSigners() []sdk.AccAddress

GetSigners returns the expected signers for a MsgConvertEvmToCoin message.

func (*MsgConvertEvmToCoin) GetToAddr 

func (m *MsgConvertEvmToCoin) GetToAddr() string

func (*MsgConvertEvmToCoin) Marshal 

func (m *MsgConvertEvmToCoin) Marshal() (dAtA []byte, err error)

func (*MsgConvertEvmToCoin) MarshalTo 

func (m *MsgConvertEvmToCoin) MarshalTo(dAtA []byte) (int, error)

func (*MsgConvertEvmToCoin) MarshalToSizedBuffer 

func (m *MsgConvertEvmToCoin) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgConvertEvmToCoin) ProtoMessage 

func (*MsgConvertEvmToCoin) ProtoMessage()

func (*MsgConvertEvmToCoin) Reset 

func (m *MsgConvertEvmToCoin) Reset()

func (*MsgConvertEvmToCoin) Size 

func (m *MsgConvertEvmToCoin) Size() (n int)

func (*MsgConvertEvmToCoin) String 

func (m *MsgConvertEvmToCoin) String() string

func (*MsgConvertEvmToCoin) Unmarshal 

func (m *MsgConvertEvmToCoin) Unmarshal(dAtA []byte) error

func (*MsgConvertEvmToCoin) Validate 

func (m *MsgConvertEvmToCoin) Validate() (
	sender Addrs,
	erc20 eth.EIP55Addr,
	amount *uint256.Int,
	toAddr Addrs,
	err error,
)

Validate does a sanity check of the provided data

func (*MsgConvertEvmToCoin) ValidateBasic 

func (m *MsgConvertEvmToCoin) ValidateBasic() error

ValidateBasic does a sanity check of the provided data

func (*MsgConvertEvmToCoin) XXX_DiscardUnknown 

func (m *MsgConvertEvmToCoin) XXX_DiscardUnknown()

func (*MsgConvertEvmToCoin) XXX_Marshal 

func (m *MsgConvertEvmToCoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgConvertEvmToCoin) XXX_Merge 

func (m *MsgConvertEvmToCoin) XXX_Merge(src proto.Message)

func (*MsgConvertEvmToCoin) XXX_Size 

func (m *MsgConvertEvmToCoin) XXX_Size() int

func (*MsgConvertEvmToCoin) XXX_Unmarshal 

func (m *MsgConvertEvmToCoin) XXX_Unmarshal(b []byte) error

type MsgConvertEvmToCoinResponse 

type MsgConvertEvmToCoinResponse struct {
}

func (*MsgConvertEvmToCoinResponse) Descriptor 

func (*MsgConvertEvmToCoinResponse) Descriptor() ([]byte, []int)

func (*MsgConvertEvmToCoinResponse) Marshal 

func (m *MsgConvertEvmToCoinResponse) Marshal() (dAtA []byte, err error)

func (*MsgConvertEvmToCoinResponse) MarshalTo 

func (m *MsgConvertEvmToCoinResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgConvertEvmToCoinResponse) MarshalToSizedBuffer 

func (m *MsgConvertEvmToCoinResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgConvertEvmToCoinResponse) ProtoMessage 

func (*MsgConvertEvmToCoinResponse) ProtoMessage()

func (*MsgConvertEvmToCoinResponse) Reset 

func (m *MsgConvertEvmToCoinResponse) Reset()

func (*MsgConvertEvmToCoinResponse) Size 

func (m *MsgConvertEvmToCoinResponse) Size() (n int)

func (*MsgConvertEvmToCoinResponse) String 

func (m *MsgConvertEvmToCoinResponse) String() string

func (*MsgConvertEvmToCoinResponse) Unmarshal 

func (m *MsgConvertEvmToCoinResponse) Unmarshal(dAtA []byte) error

func (*MsgConvertEvmToCoinResponse) XXX_DiscardUnknown 

func (m *MsgConvertEvmToCoinResponse) XXX_DiscardUnknown()

func (*MsgConvertEvmToCoinResponse) XXX_Marshal 

func (m *MsgConvertEvmToCoinResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgConvertEvmToCoinResponse) XXX_Merge 

func (m *MsgConvertEvmToCoinResponse) XXX_Merge(src proto.Message)

func (*MsgConvertEvmToCoinResponse) XXX_Size 

func (m *MsgConvertEvmToCoinResponse) XXX_Size() int

func (*MsgConvertEvmToCoinResponse) XXX_Unmarshal 

func (m *MsgConvertEvmToCoinResponse) XXX_Unmarshal(b []byte) error

type MsgCreateFunToken 

type MsgCreateFunToken struct {
	// Hexadecimal address of the ERC20 token to which the `FunToken` maps
	FromErc20 *github_com_NibiruChain_nibiru_v2_eth.EIP55Addr `` /* 146-byte string literal not displayed */
	// Coin denomination in the Bank Module.
	FromBankDenom string `protobuf:"bytes,2,opt,name=from_bank_denom,json=fromBankDenom,proto3" json:"from_bank_denom,omitempty"`
	// Sender: Address for the signer of the transaction.
	Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"`
	// Optional flag to allow the `FunToken` mapping to be created with 0 decimals
	// in the ERC20 sense. Often times, tokens are meant to behave like money and
	// be divisible, meaning "decimals = 0" is often a mistake. This field
	// defaults to false as a safety guard against accidental creation of
	// FunTokens with missing metadata. Set this to true if the token is truly
	// intended to have 0 decimals.
	AllowZeroDecimals bool `protobuf:"varint,4,opt,name=allow_zero_decimals,json=allowZeroDecimals,proto3" json:"allow_zero_decimals,omitempty"`
}

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.

func (*MsgCreateFunToken) Descriptor 

func (*MsgCreateFunToken) Descriptor() ([]byte, []int)

func (*MsgCreateFunToken) GetAllowZeroDecimals 

func (m *MsgCreateFunToken) GetAllowZeroDecimals() bool

func (*MsgCreateFunToken) GetFromBankDenom 

func (m *MsgCreateFunToken) GetFromBankDenom() string

func (*MsgCreateFunToken) GetSender 

func (m *MsgCreateFunToken) GetSender() string

func (MsgCreateFunToken) GetSignBytes 

func (m MsgCreateFunToken) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg interface.

func (MsgCreateFunToken) GetSigners 

func (m MsgCreateFunToken) GetSigners() []sdk.AccAddress

GetSigners returns the expected signers for a MsgCreateFunToken message.

func (*MsgCreateFunToken) Marshal 

func (m *MsgCreateFunToken) Marshal() (dAtA []byte, err error)

func (*MsgCreateFunToken) MarshalTo 

func (m *MsgCreateFunToken) MarshalTo(dAtA []byte) (int, error)

func (*MsgCreateFunToken) MarshalToSizedBuffer 

func (m *MsgCreateFunToken) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgCreateFunToken) ProtoMessage 

func (*MsgCreateFunToken) ProtoMessage()

func (*MsgCreateFunToken) Reset 

func (m *MsgCreateFunToken) Reset()

func (*MsgCreateFunToken) Size 

func (m *MsgCreateFunToken) Size() (n int)

func (*MsgCreateFunToken) String 

func (m *MsgCreateFunToken) String() string

func (*MsgCreateFunToken) Unmarshal 

func (m *MsgCreateFunToken) Unmarshal(dAtA []byte) error

func (*MsgCreateFunToken) ValidateBasic 

func (m *MsgCreateFunToken) ValidateBasic() error

ValidateBasic does a sanity check of the provided data

func (*MsgCreateFunToken) XXX_DiscardUnknown 

func (m *MsgCreateFunToken) XXX_DiscardUnknown()

func (*MsgCreateFunToken) XXX_Marshal 

func (m *MsgCreateFunToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgCreateFunToken) XXX_Merge 

func (m *MsgCreateFunToken) XXX_Merge(src proto.Message)

func (*MsgCreateFunToken) XXX_Size 

func (m *MsgCreateFunToken) XXX_Size() int

func (*MsgCreateFunToken) XXX_Unmarshal 

func (m *MsgCreateFunToken) XXX_Unmarshal(b []byte) error

type MsgCreateFunTokenResponse 

type MsgCreateFunTokenResponse struct {
	// Fungible token mapping corresponding to ERC20 tokens.
	FuntokenMapping FunToken `protobuf:"bytes,1,opt,name=funtoken_mapping,json=funtokenMapping,proto3" json:"funtoken_mapping"`
}

func (*MsgCreateFunTokenResponse) Descriptor 

func (*MsgCreateFunTokenResponse) Descriptor() ([]byte, []int)

func (*MsgCreateFunTokenResponse) GetFuntokenMapping 

func (m *MsgCreateFunTokenResponse) GetFuntokenMapping() FunToken

func (*MsgCreateFunTokenResponse) Marshal 

func (m *MsgCreateFunTokenResponse) Marshal() (dAtA []byte, err error)

func (*MsgCreateFunTokenResponse) MarshalTo 

func (m *MsgCreateFunTokenResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgCreateFunTokenResponse) MarshalToSizedBuffer 

func (m *MsgCreateFunTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgCreateFunTokenResponse) ProtoMessage 

func (*MsgCreateFunTokenResponse) ProtoMessage()

func (*MsgCreateFunTokenResponse) Reset 

func (m *MsgCreateFunTokenResponse) Reset()

func (*MsgCreateFunTokenResponse) Size 

func (m *MsgCreateFunTokenResponse) Size() (n int)

func (*MsgCreateFunTokenResponse) String 

func (m *MsgCreateFunTokenResponse) String() string

func (*MsgCreateFunTokenResponse) Unmarshal 

func (m *MsgCreateFunTokenResponse) Unmarshal(dAtA []byte) error

func (*MsgCreateFunTokenResponse) XXX_DiscardUnknown 

func (m *MsgCreateFunTokenResponse) XXX_DiscardUnknown()

func (*MsgCreateFunTokenResponse) XXX_Marshal 

func (m *MsgCreateFunTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgCreateFunTokenResponse) XXX_Merge 

func (m *MsgCreateFunTokenResponse) XXX_Merge(src proto.Message)

func (*MsgCreateFunTokenResponse) XXX_Size 

func (m *MsgCreateFunTokenResponse) XXX_Size() int

func (*MsgCreateFunTokenResponse) XXX_Unmarshal 

func (m *MsgCreateFunTokenResponse) XXX_Unmarshal(b []byte) error

type MsgEthereumTx 

type MsgEthereumTx struct {
	// data is inner transaction data of the Ethereum transaction
	Data *types.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// size is the encoded storage size of the transaction (DEPRECATED)
	Size_ float64 `protobuf:"fixed64,2,opt,name=size,proto3" json:"-"`
	// hash of the transaction in hex format
	Hash string `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty" rlp:"-"`
	// 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
	From string `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty"`
}

MsgEthereumTx encapsulates an Ethereum transaction as an SDK message.

func NewTx 

func NewTx(
	tx *EvmTxArgs,
) *MsgEthereumTx

NewTx returns a reference to a new Ethereum transaction message.

func RequireStandardEVMTxMsg 

func RequireStandardEVMTxMsg(tx sdk.Tx) (*MsgEthereumTx, error)

func UnwrapEthereumMsg 

func UnwrapEthereumMsg(tx *sdk.Tx, ethHash gethcommon.Hash) (*MsgEthereumTx, error)

UnwrapEthereumMsg extracts MsgEthereumTx from wrapping sdk.Tx

func (MsgEthereumTx) AsTransaction 

func (msg MsgEthereumTx) AsTransaction() *gethcore.Transaction

AsTransaction creates an Ethereum Transaction type from the msg fields

func (MsgEthereumTx) AsTransactionSafe 

func (msg MsgEthereumTx) AsTransactionSafe() (
	coreTx *gethcore.Transaction, err error,
)

AsTransactionSafe creates an Ethereum transaction of type (*gethcore.Transaction) without silently skipping the tx data error.

func (*MsgEthereumTx) BuildTx 

func (msg *MsgEthereumTx) BuildTx(b client.TxBuilder, evmDenom string) (signing.Tx, error)

BuildTx builds the Cosmos-SDK signing.Tx from ethereum tx (MsgEthereumTx)

func (*MsgEthereumTx) Descriptor 

func (*MsgEthereumTx) Descriptor() ([]byte, []int)

func (MsgEthereumTx) EffectiveFeeWei 

func (msg MsgEthereumTx) EffectiveFeeWei(baseFee *big.Int) *big.Int

EffectiveFeeWei returns the fee for dynamic fee tx

func (MsgEthereumTx) EffectiveGasCapWei 

func (msg MsgEthereumTx) EffectiveGasCapWei(baseFeeWei *big.Int) *big.Int

func (MsgEthereumTx) EffectiveGasPriceWeiPerGas 

func (msg MsgEthereumTx) EffectiveGasPriceWeiPerGas(baseFeeWei *big.Int) *big.Int

EffectiveGasPriceWeiPerGas returns the effective gas price according to the base fee. This value is in units of "wei per unit gas".

func (*MsgEthereumTx) FromAddr 

func (msg *MsgEthereumTx) FromAddr() gethcommon.Address

func (*MsgEthereumTx) FromAddrBech32 

func (msg *MsgEthereumTx) FromAddrBech32() sdk.AccAddress

FromAddrBech32 loads the ethereum sender address from the sigcache and returns an sdk.AccAddress from its bytes

func (*MsgEthereumTx) FromEthereumTx 

func (msg *MsgEthereumTx) FromEthereumTx(tx *gethcore.Transaction) error

FromEthereumTx populates the message fields from the given ethereum transaction

func (MsgEthereumTx) GetFee 

func (msg MsgEthereumTx) GetFee() *big.Int

GetFee returns the fee for non dynamic fee tx

func (MsgEthereumTx) GetGas 

func (msg MsgEthereumTx) GetGas() uint64

GetGas implements the GasTx interface. It returns the GasLimit of the transaction.

func (*MsgEthereumTx) GetMsgs 

func (msg *MsgEthereumTx) GetMsgs() []sdk.Msg

GetMsgs returns a single MsgEthereumTx as sdk.Msg.

func (*MsgEthereumTx) GetSender 

func (msg *MsgEthereumTx) GetSender(chainID *big.Int) (gethcommon.Address, error)

GetSender extracts the sender address from the signature values using the latest signer for the given chainID.

func (MsgEthereumTx) GetSignBytes 

func (msg MsgEthereumTx) GetSignBytes() []byte

GetSignBytes returns the Amino bytes of an Ethereum transaction message used for signing.

NOTE: This method cannot be used as a chain ID is needed to create valid bytes to sign over. Use 'RLPSignBytes' instead.

func (*MsgEthereumTx) GetSigners 

func (msg *MsgEthereumTx) GetSigners() []sdk.AccAddress

GetSigners returns the expected signers for an Ethereum transaction message. For such a message, there should exist only a single 'signer'.

NOTE: This method panics if 'Sign' hasn't been called first.

func (*MsgEthereumTx) Marshal 

func (m *MsgEthereumTx) Marshal() (dAtA []byte, err error)

func (*MsgEthereumTx) MarshalTo 

func (m *MsgEthereumTx) MarshalTo(dAtA []byte) (int, error)

func (*MsgEthereumTx) MarshalToSizedBuffer 

func (m *MsgEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgEthereumTx) ProtoMessage 

func (*MsgEthereumTx) ProtoMessage()

func (*MsgEthereumTx) Reset 

func (m *MsgEthereumTx) Reset()

func (MsgEthereumTx) Route 

func (msg MsgEthereumTx) Route() string

Route returns the route value of an MsgEthereumTx.

func (*MsgEthereumTx) Sign 

func (msg *MsgEthereumTx) Sign(ethSigner gethcore.Signer, keyringSigner keyring.Signer) error

Sign calculates a secp256k1 ECDSA signature and signs the transaction. It takes a keyring signer and the chainID to sign an Ethereum transaction according to EIP155 standard. This method mutates the transaction as it populates the V, R, S fields of the Transaction's Signature. The function will fail if the sender address is not defined for the msg or if the sender is not registered on the keyring

func (*MsgEthereumTx) Size 

func (m *MsgEthereumTx) Size() (n int)

func (*MsgEthereumTx) String 

func (m *MsgEthereumTx) String() string

func (MsgEthereumTx) ToGethCoreMsg 

func (msg MsgEthereumTx) ToGethCoreMsg(
	signer gethcore.Signer,
	baseFeeWei *big.Int,
) (*core.Message, error)

ToGethCoreMsg creates an Go-Ethereum core.Message from the msg fields

func (MsgEthereumTx) Type 

func (msg MsgEthereumTx) Type() string

func (*MsgEthereumTx) Unmarshal 

func (m *MsgEthereumTx) Unmarshal(dAtA []byte) error

func (*MsgEthereumTx) UnmarshalBinary 

func (msg *MsgEthereumTx) UnmarshalBinary(b []byte) error

UnmarshalBinary decodes the canonical encoding of transactions.

func (MsgEthereumTx) UnpackInterfaces 

func (msg MsgEthereumTx) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

UnpackInterfaces implements UnpackInterfacesMesssage.UnpackInterfaces

func (MsgEthereumTx) Validate 

func (msg MsgEthereumTx) Validate(
	kind TxGasKind,
) (
	coreTx *gethcore.Transaction,
	txData TxData,

	rerr error,
)

Validate performs stateless validation for the transaction. Here, "stateless" means validation that does not depend on the blockchain state.

func (MsgEthereumTx) ValidateBasic 

func (msg MsgEthereumTx) ValidateBasic() error

ValidateBasic implements the sdk.Msg interface. It performs basic (stateless) validation checks of a Transaction. If returns an error if validation fails.

func (*MsgEthereumTx) XXX_DiscardUnknown 

func (m *MsgEthereumTx) XXX_DiscardUnknown()

func (*MsgEthereumTx) XXX_Marshal 

func (m *MsgEthereumTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgEthereumTx) XXX_Merge 

func (m *MsgEthereumTx) XXX_Merge(src proto.Message)

func (*MsgEthereumTx) XXX_Size 

func (m *MsgEthereumTx) XXX_Size() int

func (*MsgEthereumTx) XXX_Unmarshal 

func (m *MsgEthereumTx) XXX_Unmarshal(b []byte) error

type MsgEthereumTxResponse 

type MsgEthereumTxResponse struct {
	// 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
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// logs contains the transaction hash and the proto-compatible ethereum
	// logs.
	Logs []Log `protobuf:"bytes,2,rep,name=logs,proto3" json:"logs"`
	// ret is the returned data from evm function (result or data supplied with
	// revert opcode)
	Ret []byte `protobuf:"bytes,3,opt,name=ret,proto3" json:"ret,omitempty"`
	// vm_error is the error returned by vm execution
	VmError string `protobuf:"bytes,4,opt,name=vm_error,json=vmError,proto3" json:"vm_error,omitempty"`
	// gas_used specifies how much gas was consumed by the transaction
	GasUsed uint64 `protobuf:"varint,5,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
}

MsgEthereumTxResponse defines the Msg/EthereumTx response type.

func DecodeTxResponse 

func DecodeTxResponse(in []byte) (*MsgEthereumTxResponse, error)

DecodeTxResponse decodes an protobuf-encoded byte slice into TxResponse

func (*MsgEthereumTxResponse) Descriptor 

func (*MsgEthereumTxResponse) Descriptor() ([]byte, []int)

func (*MsgEthereumTxResponse) Failed 

func (m *MsgEthereumTxResponse) Failed() bool

Failed returns if the contract execution failed in vm errors

func (*MsgEthereumTxResponse) Marshal 

func (m *MsgEthereumTxResponse) Marshal() (dAtA []byte, err error)

func (*MsgEthereumTxResponse) MarshalTo 

func (m *MsgEthereumTxResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgEthereumTxResponse) MarshalToSizedBuffer 

func (m *MsgEthereumTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgEthereumTxResponse) ProtoMessage 

func (*MsgEthereumTxResponse) ProtoMessage()

func (*MsgEthereumTxResponse) Reset 

func (m *MsgEthereumTxResponse) Reset()

func (*MsgEthereumTxResponse) Return 

func (m *MsgEthereumTxResponse) Return() []byte

Return is a helper function to help caller distinguish between revert reason and function return. Return returns the data after execution if no error occurs.

func (*MsgEthereumTxResponse) Revert 

func (m *MsgEthereumTxResponse) Revert() []byte

Revert returns the concrete revert reason if the execution is aborted by `REVERT` opcode. Note the reason can be nil if no data supplied with revert opcode.

func (*MsgEthereumTxResponse) Size 

func (m *MsgEthereumTxResponse) Size() (n int)

func (*MsgEthereumTxResponse) String 

func (m *MsgEthereumTxResponse) String() string

func (*MsgEthereumTxResponse) Unmarshal 

func (m *MsgEthereumTxResponse) Unmarshal(dAtA []byte) error

func (*MsgEthereumTxResponse) XXX_DiscardUnknown 

func (m *MsgEthereumTxResponse) XXX_DiscardUnknown()

func (*MsgEthereumTxResponse) XXX_Marshal 

func (m *MsgEthereumTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgEthereumTxResponse) XXX_Merge 

func (m *MsgEthereumTxResponse) XXX_Merge(src proto.Message)

func (*MsgEthereumTxResponse) XXX_Size 

func (m *MsgEthereumTxResponse) XXX_Size() int

func (*MsgEthereumTxResponse) XXX_Unmarshal 

func (m *MsgEthereumTxResponse) XXX_Unmarshal(b []byte) error

type MsgServer 

type MsgServer interface {
	// EthereumTx defines a method submitting Ethereum transactions.
	EthereumTx(context.Context, *MsgEthereumTx) (*MsgEthereumTxResponse, error)
	// UpdateParams defined a governance operation for updating the x/evm module
	// parameters. The authority is hard-coded to the x/gov module account
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
	// CreateFunToken: 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.
	CreateFunToken(context.Context, *MsgCreateFunToken) (*MsgCreateFunTokenResponse, error)
	// ConvertCoinToEvm: Sends a coin with a valid "FunToken" mapping to the
	// given recipient address ("to_eth_addr") in the corresponding ERC20
	// representation.
	ConvertCoinToEvm(context.Context, *MsgConvertCoinToEvm) (*MsgConvertCoinToEvmResponse, error)
	// ConvertEvmToCoin: Sends an ERC20 token with a valid "FunToken" mapping to
	// the given recipient address as a bank coin.
	ConvertEvmToCoin(context.Context, *MsgConvertEvmToCoin) (*MsgConvertEvmToCoinResponse, error)
}

MsgServer is the server API for Msg service.

type MsgUpdateParams 

type MsgUpdateParams struct {
	// authority is the address of the governance account.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// params defines the x/evm parameters to update.
	// NOTE: All parameters must be supplied.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

MsgUpdateParams defines a Msg for updating the x/evm module parameters.

func (*MsgUpdateParams) Descriptor 

func (*MsgUpdateParams) Descriptor() ([]byte, []int)

func (*MsgUpdateParams) GetAuthority 

func (m *MsgUpdateParams) GetAuthority() string

func (*MsgUpdateParams) GetParams 

func (m *MsgUpdateParams) GetParams() Params

func (MsgUpdateParams) GetSignBytes 

func (m MsgUpdateParams) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg interface.

func (MsgUpdateParams) GetSigners 

func (m MsgUpdateParams) GetSigners() []sdk.AccAddress

GetSigners returns the expected signers for a MsgUpdateParams message.

func (*MsgUpdateParams) Marshal 

func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error)

func (*MsgUpdateParams) MarshalTo 

func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateParams) MarshalToSizedBuffer 

func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateParams) ProtoMessage 

func (*MsgUpdateParams) ProtoMessage()

func (*MsgUpdateParams) Reset 

func (m *MsgUpdateParams) Reset()

func (*MsgUpdateParams) Size 

func (m *MsgUpdateParams) Size() (n int)

func (*MsgUpdateParams) String 

func (m *MsgUpdateParams) String() string

func (*MsgUpdateParams) Unmarshal 

func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error

func (*MsgUpdateParams) ValidateBasic 

func (m *MsgUpdateParams) ValidateBasic() error

ValidateBasic does a sanity check of the provided data

func (*MsgUpdateParams) XXX_DiscardUnknown 

func (m *MsgUpdateParams) XXX_DiscardUnknown()

func (*MsgUpdateParams) XXX_Marshal 

func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateParams) XXX_Merge 

func (m *MsgUpdateParams) XXX_Merge(src proto.Message)

func (*MsgUpdateParams) XXX_Size 

func (m *MsgUpdateParams) XXX_Size() int

func (*MsgUpdateParams) XXX_Unmarshal 

func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error

type MsgUpdateParamsResponse 

type MsgUpdateParamsResponse struct {
}

MsgUpdateParamsResponse defines the response structure for executing a MsgUpdateParams message.

func (*MsgUpdateParamsResponse) Descriptor 

func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateParamsResponse) Marshal 

func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateParamsResponse) MarshalTo 

func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateParamsResponse) MarshalToSizedBuffer 

func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateParamsResponse) ProtoMessage 

func (*MsgUpdateParamsResponse) ProtoMessage()

func (*MsgUpdateParamsResponse) Reset 

func (m *MsgUpdateParamsResponse) Reset()

func (*MsgUpdateParamsResponse) Size 

func (m *MsgUpdateParamsResponse) Size() (n int)

func (*MsgUpdateParamsResponse) String 

func (m *MsgUpdateParamsResponse) String() string

func (*MsgUpdateParamsResponse) Unmarshal 

func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateParamsResponse) XXX_DiscardUnknown 

func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown()

func (*MsgUpdateParamsResponse) XXX_Marshal 

func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateParamsResponse) XXX_Merge 

func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateParamsResponse) XXX_Size 

func (m *MsgUpdateParamsResponse) XXX_Size() int

func (*MsgUpdateParamsResponse) XXX_Unmarshal 

func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error

type Params 

type Params struct {
	// extra_eips defines the additional EIPs for the vm.Config
	ExtraEIPs []int64 `protobuf:"varint,4,rep,packed,name=extra_eips,json=extraEips,proto3" json:"extra_eips,omitempty" yaml:"extra_eips"`
	// evm_channels is the list of channel identifiers from EVM compatible chains
	EVMChannels []string `protobuf:"bytes,8,rep,name=evm_channels,json=evmChannels,proto3" json:"evm_channels,omitempty"`
	// Fee deducted and burned when calling "CreateFunToken" in units of
	// "evm_denom".
	CreateFuntokenFee cosmossdk_io_math.Int `` /* 137-byte string literal not displayed */
	// Hexadecimal address of the canonical WNIBI contract on Nibiru mainnet
	CanonicalWnibi github_com_NibiruChain_nibiru_v2_eth.EIP55Addr `` /* 152-byte string literal not displayed */
	WasmPlugins    []WasmPlugin                                   `protobuf:"bytes,11,rep,name=wasm_plugins,json=wasmPlugins,proto3" json:"wasm_plugins"`
}

Params defines the EVM module parameters

func DefaultParams 

func DefaultParams() Params

DefaultParams returns default evm parameters ExtraEIPs is empty to prevent overriding the latest hard fork instruction set

func (*Params) Descriptor 

func (*Params) Descriptor() ([]byte, []int)

func (Params) EIPs 

func (p Params) EIPs() []int

EIPs returns the ExtraEIPS as a int slice

func (*Params) Equal 

func (this *Params) Equal(that interface{}) bool

func (*Params) GetEVMChannels 

func (m *Params) GetEVMChannels() []string

func (*Params) GetExtraEIPs 

func (m *Params) GetExtraEIPs() []int64

func (*Params) GetWasmPlugins 

func (m *Params) GetWasmPlugins() []WasmPlugin

func (Params) IsEVMChannel 

func (p Params) IsEVMChannel(channel string) bool

IsEVMChannel returns true if the channel provided is in the list of EVM channels

func (*Params) Marshal 

func (m *Params) Marshal() (dAtA []byte, err error)

func (*Params) MarshalTo 

func (m *Params) MarshalTo(dAtA []byte) (int, error)

func (*Params) MarshalToSizedBuffer 

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Params) ProtoMessage 

func (*Params) ProtoMessage()

func (*Params) Reset 

func (m *Params) Reset()

func (*Params) Size 

func (m *Params) Size() (n int)

func (*Params) String 

func (m *Params) String() string

func (*Params) Unmarshal 

func (m *Params) Unmarshal(dAtA []byte) error

func (Params) Validate 

func (p Params) Validate() error

Validate performs basic validation on evm parameters.

func (*Params) XXX_DiscardUnknown 

func (m *Params) XXX_DiscardUnknown()

func (*Params) XXX_Marshal 

func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Params) XXX_Merge 

func (m *Params) XXX_Merge(src proto.Message)

func (*Params) XXX_Size 

func (m *Params) XXX_Size() int

func (*Params) XXX_Unmarshal 

func (m *Params) XXX_Unmarshal(b []byte) error

type QueryBalanceRequest 

type QueryBalanceRequest struct {
	// address is the ethereum hex address to query the balance for.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// token is an ERC20 address or bank denom to query alongside the native EVM
	// balance. Leave empty to query only the native EVM balance.
	Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
}

QueryBalanceRequest: Response type for "/eth.evm.v1.Query/Balance"

func (*QueryBalanceRequest) Descriptor 

func (*QueryBalanceRequest) Descriptor() ([]byte, []int)

func (*QueryBalanceRequest) Marshal 

func (m *QueryBalanceRequest) Marshal() (dAtA []byte, err error)

func (*QueryBalanceRequest) MarshalTo 

func (m *QueryBalanceRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryBalanceRequest) MarshalToSizedBuffer 

func (m *QueryBalanceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBalanceRequest) ProtoMessage 

func (*QueryBalanceRequest) ProtoMessage()

func (*QueryBalanceRequest) Reset 

func (m *QueryBalanceRequest) Reset()

func (*QueryBalanceRequest) Size 

func (m *QueryBalanceRequest) Size() (n int)

func (*QueryBalanceRequest) String 

func (m *QueryBalanceRequest) String() string

func (*QueryBalanceRequest) Unmarshal 

func (m *QueryBalanceRequest) Unmarshal(dAtA []byte) error

func (*QueryBalanceRequest) Validate 

func (req *QueryBalanceRequest) Validate() (addrBech32 sdk.AccAddress, err error)

func (*QueryBalanceRequest) XXX_DiscardUnknown 

func (m *QueryBalanceRequest) XXX_DiscardUnknown()

func (*QueryBalanceRequest) XXX_Marshal 

func (m *QueryBalanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBalanceRequest) XXX_Merge 

func (m *QueryBalanceRequest) XXX_Merge(src proto.Message)

func (*QueryBalanceRequest) XXX_Size 

func (m *QueryBalanceRequest) XXX_Size() int

func (*QueryBalanceRequest) XXX_Unmarshal 

func (m *QueryBalanceRequest) XXX_Unmarshal(b []byte) error

type QueryBalanceResponse 

type QueryBalanceResponse struct {
	// balance is the balance of the EVM denomination in units of wei. 1 wei is 1
	// attoNIBI.
	BalanceWei string `protobuf:"bytes,2,opt,name=balance_wei,json=balanceWei,proto3" json:"balance_wei,omitempty"`
	// bank is the Bank module token balance details when a bank representation is
	// available for the requested token.
	Bank *BalanceBank `protobuf:"bytes,3,opt,name=bank,proto3" json:"bank,omitempty"`
	// erc20 is the ERC20 token balance details when an ERC20 representation is
	// available for the requested token.
	Erc20 *BalanceERC20 `protobuf:"bytes,4,opt,name=erc20,proto3" json:"erc20,omitempty"`
}

QueryBalanceResponse: Response type for "/eth.evm.v1.Query/Balance"

func (*QueryBalanceResponse) Descriptor 

func (*QueryBalanceResponse) Descriptor() ([]byte, []int)

func (*QueryBalanceResponse) GetBalanceWei 

func (m *QueryBalanceResponse) GetBalanceWei() string

func (*QueryBalanceResponse) GetBank 

func (m *QueryBalanceResponse) GetBank() *BalanceBank

func (*QueryBalanceResponse) GetErc20 

func (m *QueryBalanceResponse) GetErc20() *BalanceERC20

func (*QueryBalanceResponse) Marshal 

func (m *QueryBalanceResponse) Marshal() (dAtA []byte, err error)

func (*QueryBalanceResponse) MarshalTo 

func (m *QueryBalanceResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryBalanceResponse) MarshalToSizedBuffer 

func (m *QueryBalanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBalanceResponse) ProtoMessage 

func (*QueryBalanceResponse) ProtoMessage()

func (*QueryBalanceResponse) Reset 

func (m *QueryBalanceResponse) Reset()

func (*QueryBalanceResponse) Size 

func (m *QueryBalanceResponse) Size() (n int)

func (*QueryBalanceResponse) String 

func (m *QueryBalanceResponse) String() string

func (*QueryBalanceResponse) Unmarshal 

func (m *QueryBalanceResponse) Unmarshal(dAtA []byte) error

func (*QueryBalanceResponse) XXX_DiscardUnknown 

func (m *QueryBalanceResponse) XXX_DiscardUnknown()

func (*QueryBalanceResponse) XXX_Marshal 

func (m *QueryBalanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBalanceResponse) XXX_Merge 

func (m *QueryBalanceResponse) XXX_Merge(src proto.Message)

func (*QueryBalanceResponse) XXX_Size 

func (m *QueryBalanceResponse) XXX_Size() int

func (*QueryBalanceResponse) XXX_Unmarshal 

func (m *QueryBalanceResponse) XXX_Unmarshal(b []byte) error

type QueryBaseFeeRequest 

type QueryBaseFeeRequest struct {
}

QueryBaseFeeRequest defines the request type for querying the EIP1559 base fee.

func (*QueryBaseFeeRequest) Descriptor 

func (*QueryBaseFeeRequest) Descriptor() ([]byte, []int)

func (*QueryBaseFeeRequest) Marshal 

func (m *QueryBaseFeeRequest) Marshal() (dAtA []byte, err error)

func (*QueryBaseFeeRequest) MarshalTo 

func (m *QueryBaseFeeRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryBaseFeeRequest) MarshalToSizedBuffer 

func (m *QueryBaseFeeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBaseFeeRequest) ProtoMessage 

func (*QueryBaseFeeRequest) ProtoMessage()

func (*QueryBaseFeeRequest) Reset 

func (m *QueryBaseFeeRequest) Reset()

func (*QueryBaseFeeRequest) Size 

func (m *QueryBaseFeeRequest) Size() (n int)

func (*QueryBaseFeeRequest) String 

func (m *QueryBaseFeeRequest) String() string

func (*QueryBaseFeeRequest) Unmarshal 

func (m *QueryBaseFeeRequest) Unmarshal(dAtA []byte) error

func (*QueryBaseFeeRequest) XXX_DiscardUnknown 

func (m *QueryBaseFeeRequest) XXX_DiscardUnknown()

func (*QueryBaseFeeRequest) XXX_Marshal 

func (m *QueryBaseFeeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBaseFeeRequest) XXX_Merge 

func (m *QueryBaseFeeRequest) XXX_Merge(src proto.Message)

func (*QueryBaseFeeRequest) XXX_Size 

func (m *QueryBaseFeeRequest) XXX_Size() int

func (*QueryBaseFeeRequest) XXX_Unmarshal 

func (m *QueryBaseFeeRequest) XXX_Unmarshal(b []byte) error

type QueryBaseFeeResponse 

type QueryBaseFeeResponse struct {
	// base_fee is the EIP1559 base fee in units of wei.
	BaseFee *cosmossdk_io_math.Int `protobuf:"bytes,1,opt,name=base_fee,json=baseFee,proto3,customtype=cosmossdk.io/math.Int" json:"base_fee,omitempty"`
	// base_fee is the EIP1559 base fee in units of micronibi ("unibi").
	BaseFeeUnibi *cosmossdk_io_math.Int `` /* 132-byte string literal not displayed */
}

QueryBaseFeeResponse returns the EIP1559 base fee. See https://github.com/ethereum/EIPs/blob/ba6c342c23164072adb500c3136e3ae6eabff306/EIPS/eip-1559.md.

func (*QueryBaseFeeResponse) Descriptor 

func (*QueryBaseFeeResponse) Descriptor() ([]byte, []int)

func (*QueryBaseFeeResponse) Marshal 

func (m *QueryBaseFeeResponse) Marshal() (dAtA []byte, err error)

func (*QueryBaseFeeResponse) MarshalTo 

func (m *QueryBaseFeeResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryBaseFeeResponse) MarshalToSizedBuffer 

func (m *QueryBaseFeeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryBaseFeeResponse) ProtoMessage 

func (*QueryBaseFeeResponse) ProtoMessage()

func (*QueryBaseFeeResponse) Reset 

func (m *QueryBaseFeeResponse) Reset()

func (*QueryBaseFeeResponse) Size 

func (m *QueryBaseFeeResponse) Size() (n int)

func (*QueryBaseFeeResponse) String 

func (m *QueryBaseFeeResponse) String() string

func (*QueryBaseFeeResponse) Unmarshal 

func (m *QueryBaseFeeResponse) Unmarshal(dAtA []byte) error

func (*QueryBaseFeeResponse) XXX_DiscardUnknown 

func (m *QueryBaseFeeResponse) XXX_DiscardUnknown()

func (*QueryBaseFeeResponse) XXX_Marshal 

func (m *QueryBaseFeeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryBaseFeeResponse) XXX_Merge 

func (m *QueryBaseFeeResponse) XXX_Merge(src proto.Message)

func (*QueryBaseFeeResponse) XXX_Size 

func (m *QueryBaseFeeResponse) XXX_Size() int

func (*QueryBaseFeeResponse) XXX_Unmarshal 

func (m *QueryBaseFeeResponse) XXX_Unmarshal(b []byte) error

type QueryClient 

type QueryClient interface {
	// EthAccount queries a Nibiru account using its EVM address or Bech32 Nibiru
	// address.
	EthAccount(ctx context.Context, in *QueryEthAccountRequest, opts ...grpc.CallOption) (*QueryEthAccountResponse, error)
	// ValidatorAccount queries an Ethereum account's from a validator consensus
	// Address.
	ValidatorAccount(ctx context.Context, in *QueryValidatorAccountRequest, opts ...grpc.CallOption) (*QueryValidatorAccountResponse, error)
	// Balance queries the balance of the NIBI (ether for the EVM) in units of wei
	// for a single EthAccount. 1 wei == 1 attoNIBI == 10^{-18} NIBI.
	Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error)
	// Storage queries the balance of all coins for a single account.
	Storage(ctx context.Context, in *QueryStorageRequest, opts ...grpc.CallOption) (*QueryStorageResponse, error)
	// Code queries the balance of all coins for a single account.
	Code(ctx context.Context, in *QueryCodeRequest, opts ...grpc.CallOption) (*QueryCodeResponse, error)
	// Params queries the parameters of x/evm module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// EthCall implements the `eth_call` rpc api
	EthCall(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error)
	// EstimateGas implements the `eth_estimateGas` rpc api
	EstimateGas(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
	// TraceTx implements the `debug_traceTransaction` rpc api
	TraceTx(ctx context.Context, in *QueryTraceTxRequest, opts ...grpc.CallOption) (*QueryTraceTxResponse, error)
	// TraceBlock implements the `debug_traceBlockByNumber` and
	// `debug_traceBlockByHash` rpc api
	TraceBlock(ctx context.Context, in *QueryTraceBlockRequest, opts ...grpc.CallOption) (*QueryTraceBlockResponse, error)
	// TraceCall implements the `debug_traceCall` rpc api
	TraceCall(ctx context.Context, in *QueryTraceTxRequest, opts ...grpc.CallOption) (*QueryTraceTxResponse, error)
	// BaseFee queries the base fee of the parent block of the current block,
	// Similar to feemarket module's method
	BaseFee(ctx context.Context, in *QueryBaseFeeRequest, opts ...grpc.CallOption) (*QueryBaseFeeResponse, error)
	FunTokenMapping(ctx context.Context, in *QueryFunTokenMappingRequest, opts ...grpc.CallOption) (*QueryFunTokenMappingResponse, error)
}

QueryClient is the client API for Query service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewQueryClient 

func NewQueryClient(cc grpc1.ClientConn) QueryClient

type QueryCodeRequest 

type QueryCodeRequest struct {
	// address is the ethereum hex address to query the code for.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

QueryCodeRequest is the request type for the Query/Code RPC method.

func (*QueryCodeRequest) Descriptor 

func (*QueryCodeRequest) Descriptor() ([]byte, []int)

func (*QueryCodeRequest) Marshal 

func (m *QueryCodeRequest) Marshal() (dAtA []byte, err error)

func (*QueryCodeRequest) MarshalTo 

func (m *QueryCodeRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryCodeRequest) MarshalToSizedBuffer 

func (m *QueryCodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryCodeRequest) ProtoMessage 

func (*QueryCodeRequest) ProtoMessage()

func (*QueryCodeRequest) Reset 

func (m *QueryCodeRequest) Reset()

func (*QueryCodeRequest) Size 

func (m *QueryCodeRequest) Size() (n int)

func (*QueryCodeRequest) String 

func (m *QueryCodeRequest) String() string

func (*QueryCodeRequest) Unmarshal 

func (m *QueryCodeRequest) Unmarshal(dAtA []byte) error

func (*QueryCodeRequest) Validate 

func (req *QueryCodeRequest) Validate() error

func (*QueryCodeRequest) XXX_DiscardUnknown 

func (m *QueryCodeRequest) XXX_DiscardUnknown()

func (*QueryCodeRequest) XXX_Marshal 

func (m *QueryCodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryCodeRequest) XXX_Merge 

func (m *QueryCodeRequest) XXX_Merge(src proto.Message)

func (*QueryCodeRequest) XXX_Size 

func (m *QueryCodeRequest) XXX_Size() int

func (*QueryCodeRequest) XXX_Unmarshal 

func (m *QueryCodeRequest) XXX_Unmarshal(b []byte) error

type QueryCodeResponse 

type QueryCodeResponse struct {
	// code represents the code bytes from an ethereum address.
	Code []byte `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
}

QueryCodeResponse is the response type for the Query/Code RPC method.

func (*QueryCodeResponse) Descriptor 

func (*QueryCodeResponse) Descriptor() ([]byte, []int)

func (*QueryCodeResponse) GetCode 

func (m *QueryCodeResponse) GetCode() []byte

func (*QueryCodeResponse) Marshal 

func (m *QueryCodeResponse) Marshal() (dAtA []byte, err error)

func (*QueryCodeResponse) MarshalTo 

func (m *QueryCodeResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryCodeResponse) MarshalToSizedBuffer 

func (m *QueryCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryCodeResponse) ProtoMessage 

func (*QueryCodeResponse) ProtoMessage()

func (*QueryCodeResponse) Reset 

func (m *QueryCodeResponse) Reset()

func (*QueryCodeResponse) Size 

func (m *QueryCodeResponse) Size() (n int)

func (*QueryCodeResponse) String 

func (m *QueryCodeResponse) String() string

func (*QueryCodeResponse) Unmarshal 

func (m *QueryCodeResponse) Unmarshal(dAtA []byte) error

func (*QueryCodeResponse) XXX_DiscardUnknown 

func (m *QueryCodeResponse) XXX_DiscardUnknown()

func (*QueryCodeResponse) XXX_Marshal 

func (m *QueryCodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryCodeResponse) XXX_Merge 

func (m *QueryCodeResponse) XXX_Merge(src proto.Message)

func (*QueryCodeResponse) XXX_Size 

func (m *QueryCodeResponse) XXX_Size() int

func (*QueryCodeResponse) XXX_Unmarshal 

func (m *QueryCodeResponse) XXX_Unmarshal(b []byte) error

type QueryEthAccountRequest 

type QueryEthAccountRequest struct {
	// address is the Ethereum hex address or nibi Bech32 address to query the
	// account for.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

QueryEthAccountRequest: Request type for "/eth.evm.v1.Query/EthAccount"

func (*QueryEthAccountRequest) Descriptor 

func (*QueryEthAccountRequest) Descriptor() ([]byte, []int)

func (*QueryEthAccountRequest) Marshal 

func (m *QueryEthAccountRequest) Marshal() (dAtA []byte, err error)

func (*QueryEthAccountRequest) MarshalTo 

func (m *QueryEthAccountRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryEthAccountRequest) MarshalToSizedBuffer 

func (m *QueryEthAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryEthAccountRequest) ProtoMessage 

func (*QueryEthAccountRequest) ProtoMessage()

func (*QueryEthAccountRequest) Reset 

func (m *QueryEthAccountRequest) Reset()

func (*QueryEthAccountRequest) Size 

func (m *QueryEthAccountRequest) Size() (n int)

func (*QueryEthAccountRequest) String 

func (m *QueryEthAccountRequest) String() string

func (*QueryEthAccountRequest) Unmarshal 

func (m *QueryEthAccountRequest) Unmarshal(dAtA []byte) error

func (*QueryEthAccountRequest) Validate 

func (req *QueryEthAccountRequest) Validate() (addrBech32 sdk.AccAddress, err error)

func (*QueryEthAccountRequest) XXX_DiscardUnknown 

func (m *QueryEthAccountRequest) XXX_DiscardUnknown()

func (*QueryEthAccountRequest) XXX_Marshal 

func (m *QueryEthAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryEthAccountRequest) XXX_Merge 

func (m *QueryEthAccountRequest) XXX_Merge(src proto.Message)

func (*QueryEthAccountRequest) XXX_Size 

func (m *QueryEthAccountRequest) XXX_Size() int

func (*QueryEthAccountRequest) XXX_Unmarshal 

func (m *QueryEthAccountRequest) XXX_Unmarshal(b []byte) error

type QueryEthAccountResponse 

type QueryEthAccountResponse struct {
	// balance_wei is the balance of wei (attoNIBI, since NIBI is ether).
	BalanceWei string `protobuf:"bytes,2,opt,name=balance_wei,json=balanceWei,proto3" json:"balance_wei,omitempty"`
	// code_hash is the hex-encoded hash of the contract bytecode for the
	// account. Ethereum defines a code hash as the keccack 256 hash of the bytes.
	// Note that externally owned accounts (EOAs) have the empty/nil code hash
	// (`crypto.Keccak256(nil)`).
	CodeHash string `protobuf:"bytes,3,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"`
	// nonce is the account's sequence number.
	Nonce uint64 `protobuf:"varint,4,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// eth_address: The hexadecimal-encoded string representing the 20 byte
	// address of a Nibiru EVM account. Note that this field may be empty if the
	// account queried is a Wasm contract (32 byte address).
	EthAddress string `protobuf:"bytes,5,opt,name=eth_address,json=ethAddress,proto3" json:"eth_address,omitempty"`
	// bech32_address is the nibi-prefixed address of the account that can receive
	// bank transfers ("cosmos.bank.v1beta1.MsgSend").
	Bech32Address string `protobuf:"bytes,6,opt,name=bech32_address,json=bech32Address,proto3" json:"bech32_address,omitempty"`
}

QueryEthAccountResponse: Response type for "/eth.evm.v1.Query/EthAccount"

func (*QueryEthAccountResponse) Descriptor 

func (*QueryEthAccountResponse) Descriptor() ([]byte, []int)

func (*QueryEthAccountResponse) GetBalanceWei 

func (m *QueryEthAccountResponse) GetBalanceWei() string

func (*QueryEthAccountResponse) GetBech32Address 

func (m *QueryEthAccountResponse) GetBech32Address() string

func (*QueryEthAccountResponse) GetCodeHash 

func (m *QueryEthAccountResponse) GetCodeHash() string

func (*QueryEthAccountResponse) GetEthAddress 

func (m *QueryEthAccountResponse) GetEthAddress() string

func (*QueryEthAccountResponse) GetNonce 

func (m *QueryEthAccountResponse) GetNonce() uint64

func (*QueryEthAccountResponse) Marshal 

func (m *QueryEthAccountResponse) Marshal() (dAtA []byte, err error)

func (*QueryEthAccountResponse) MarshalTo 

func (m *QueryEthAccountResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryEthAccountResponse) MarshalToSizedBuffer 

func (m *QueryEthAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryEthAccountResponse) ProtoMessage 

func (*QueryEthAccountResponse) ProtoMessage()

func (*QueryEthAccountResponse) Reset 

func (m *QueryEthAccountResponse) Reset()

func (*QueryEthAccountResponse) Size 

func (m *QueryEthAccountResponse) Size() (n int)

func (*QueryEthAccountResponse) String 

func (m *QueryEthAccountResponse) String() string

func (*QueryEthAccountResponse) Unmarshal 

func (m *QueryEthAccountResponse) Unmarshal(dAtA []byte) error

func (*QueryEthAccountResponse) XXX_DiscardUnknown 

func (m *QueryEthAccountResponse) XXX_DiscardUnknown()

func (*QueryEthAccountResponse) XXX_Marshal 

func (m *QueryEthAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryEthAccountResponse) XXX_Merge 

func (m *QueryEthAccountResponse) XXX_Merge(src proto.Message)

func (*QueryEthAccountResponse) XXX_Size 

func (m *QueryEthAccountResponse) XXX_Size() int

func (*QueryEthAccountResponse) XXX_Unmarshal 

func (m *QueryEthAccountResponse) XXX_Unmarshal(b []byte) error

type QueryFunTokenMappingRequest 

type QueryFunTokenMappingRequest struct {
	// Either the hexadecimal-encoded ERC20 contract address or denomination of
	// the Bank Coin.
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
}

func (*QueryFunTokenMappingRequest) Descriptor 

func (*QueryFunTokenMappingRequest) Descriptor() ([]byte, []int)

func (*QueryFunTokenMappingRequest) Marshal 

func (m *QueryFunTokenMappingRequest) Marshal() (dAtA []byte, err error)

func (*QueryFunTokenMappingRequest) MarshalTo 

func (m *QueryFunTokenMappingRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryFunTokenMappingRequest) MarshalToSizedBuffer 

func (m *QueryFunTokenMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryFunTokenMappingRequest) ProtoMessage 

func (*QueryFunTokenMappingRequest) ProtoMessage()

func (*QueryFunTokenMappingRequest) Reset 

func (m *QueryFunTokenMappingRequest) Reset()

func (*QueryFunTokenMappingRequest) Size 

func (m *QueryFunTokenMappingRequest) Size() (n int)

func (*QueryFunTokenMappingRequest) String 

func (m *QueryFunTokenMappingRequest) String() string

func (*QueryFunTokenMappingRequest) Unmarshal 

func (m *QueryFunTokenMappingRequest) Unmarshal(dAtA []byte) error

func (*QueryFunTokenMappingRequest) XXX_DiscardUnknown 

func (m *QueryFunTokenMappingRequest) XXX_DiscardUnknown()

func (*QueryFunTokenMappingRequest) XXX_Marshal 

func (m *QueryFunTokenMappingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryFunTokenMappingRequest) XXX_Merge 

func (m *QueryFunTokenMappingRequest) XXX_Merge(src proto.Message)

func (*QueryFunTokenMappingRequest) XXX_Size 

func (m *QueryFunTokenMappingRequest) XXX_Size() int

func (*QueryFunTokenMappingRequest) XXX_Unmarshal 

func (m *QueryFunTokenMappingRequest) XXX_Unmarshal(b []byte) error

type QueryFunTokenMappingResponse 

type QueryFunTokenMappingResponse struct {
	// fun_token is a mapping between the Bank Coin and the ERC20 contract address
	FunToken *FunToken `protobuf:"bytes,1,opt,name=fun_token,json=funToken,proto3" json:"fun_token,omitempty"`
}

func (*QueryFunTokenMappingResponse) Descriptor 

func (*QueryFunTokenMappingResponse) Descriptor() ([]byte, []int)

func (*QueryFunTokenMappingResponse) Marshal 

func (m *QueryFunTokenMappingResponse) Marshal() (dAtA []byte, err error)

func (*QueryFunTokenMappingResponse) MarshalTo 

func (m *QueryFunTokenMappingResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryFunTokenMappingResponse) MarshalToSizedBuffer 

func (m *QueryFunTokenMappingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryFunTokenMappingResponse) ProtoMessage 

func (*QueryFunTokenMappingResponse) ProtoMessage()

func (*QueryFunTokenMappingResponse) Reset 

func (m *QueryFunTokenMappingResponse) Reset()

func (*QueryFunTokenMappingResponse) Size 

func (m *QueryFunTokenMappingResponse) Size() (n int)

func (*QueryFunTokenMappingResponse) String 

func (m *QueryFunTokenMappingResponse) String() string

func (*QueryFunTokenMappingResponse) Unmarshal 

func (m *QueryFunTokenMappingResponse) Unmarshal(dAtA []byte) error

func (*QueryFunTokenMappingResponse) XXX_DiscardUnknown 

func (m *QueryFunTokenMappingResponse) XXX_DiscardUnknown()

func (*QueryFunTokenMappingResponse) XXX_Marshal 

func (m *QueryFunTokenMappingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryFunTokenMappingResponse) XXX_Merge 

func (m *QueryFunTokenMappingResponse) XXX_Merge(src proto.Message)

func (*QueryFunTokenMappingResponse) XXX_Size 

func (m *QueryFunTokenMappingResponse) XXX_Size() int

func (*QueryFunTokenMappingResponse) XXX_Unmarshal 

func (m *QueryFunTokenMappingResponse) XXX_Unmarshal(b []byte) error

type QueryParamsRequest 

type QueryParamsRequest struct {
}

QueryParamsRequest defines the request type for querying x/evm parameters.

func (*QueryParamsRequest) Descriptor 

func (*QueryParamsRequest) Descriptor() ([]byte, []int)

func (*QueryParamsRequest) Marshal 

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error)

func (*QueryParamsRequest) MarshalTo 

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsRequest) MarshalToSizedBuffer 

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsRequest) ProtoMessage 

func (*QueryParamsRequest) ProtoMessage()

func (*QueryParamsRequest) Reset 

func (m *QueryParamsRequest) Reset()

func (*QueryParamsRequest) Size 

func (m *QueryParamsRequest) Size() (n int)

func (*QueryParamsRequest) String 

func (m *QueryParamsRequest) String() string

func (*QueryParamsRequest) Unmarshal 

func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error

func (*QueryParamsRequest) XXX_DiscardUnknown 

func (m *QueryParamsRequest) XXX_DiscardUnknown()

func (*QueryParamsRequest) XXX_Marshal 

func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsRequest) XXX_Merge 

func (m *QueryParamsRequest) XXX_Merge(src proto.Message)

func (*QueryParamsRequest) XXX_Size 

func (m *QueryParamsRequest) XXX_Size() int

func (*QueryParamsRequest) XXX_Unmarshal 

func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error

type QueryParamsResponse 

type QueryParamsResponse struct {
	// params define the evm module parameters.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

QueryParamsResponse defines the response type for querying x/evm parameters.

func (*QueryParamsResponse) Descriptor 

func (*QueryParamsResponse) Descriptor() ([]byte, []int)

func (*QueryParamsResponse) GetParams 

func (m *QueryParamsResponse) GetParams() Params

func (*QueryParamsResponse) Marshal 

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error)

func (*QueryParamsResponse) MarshalTo 

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsResponse) MarshalToSizedBuffer 

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsResponse) ProtoMessage 

func (*QueryParamsResponse) ProtoMessage()

func (*QueryParamsResponse) Reset 

func (m *QueryParamsResponse) Reset()

func (*QueryParamsResponse) Size 

func (m *QueryParamsResponse) Size() (n int)

func (*QueryParamsResponse) String 

func (m *QueryParamsResponse) String() string

func (*QueryParamsResponse) Unmarshal 

func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error

func (*QueryParamsResponse) XXX_DiscardUnknown 

func (m *QueryParamsResponse) XXX_DiscardUnknown()

func (*QueryParamsResponse) XXX_Marshal 

func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsResponse) XXX_Merge 

func (m *QueryParamsResponse) XXX_Merge(src proto.Message)

func (*QueryParamsResponse) XXX_Size 

func (m *QueryParamsResponse) XXX_Size() int

func (*QueryParamsResponse) XXX_Unmarshal 

func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error

type QueryServer 

type QueryServer interface {
	// EthAccount queries a Nibiru account using its EVM address or Bech32 Nibiru
	// address.
	EthAccount(context.Context, *QueryEthAccountRequest) (*QueryEthAccountResponse, error)
	// ValidatorAccount queries an Ethereum account's from a validator consensus
	// Address.
	ValidatorAccount(context.Context, *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error)
	// Balance queries the balance of the NIBI (ether for the EVM) in units of wei
	// for a single EthAccount. 1 wei == 1 attoNIBI == 10^{-18} NIBI.
	Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error)
	// Storage queries the balance of all coins for a single account.
	Storage(context.Context, *QueryStorageRequest) (*QueryStorageResponse, error)
	// Code queries the balance of all coins for a single account.
	Code(context.Context, *QueryCodeRequest) (*QueryCodeResponse, error)
	// Params queries the parameters of x/evm module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// EthCall implements the `eth_call` rpc api
	EthCall(context.Context, *EthCallRequest) (*MsgEthereumTxResponse, error)
	// EstimateGas implements the `eth_estimateGas` rpc api
	EstimateGas(context.Context, *EthCallRequest) (*EstimateGasResponse, error)
	// TraceTx implements the `debug_traceTransaction` rpc api
	TraceTx(context.Context, *QueryTraceTxRequest) (*QueryTraceTxResponse, error)
	// TraceBlock implements the `debug_traceBlockByNumber` and
	// `debug_traceBlockByHash` rpc api
	TraceBlock(context.Context, *QueryTraceBlockRequest) (*QueryTraceBlockResponse, error)
	// TraceCall implements the `debug_traceCall` rpc api
	TraceCall(context.Context, *QueryTraceTxRequest) (*QueryTraceTxResponse, error)
	// BaseFee queries the base fee of the parent block of the current block,
	// Similar to feemarket module's method
	BaseFee(context.Context, *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error)
	FunTokenMapping(context.Context, *QueryFunTokenMappingRequest) (*QueryFunTokenMappingResponse, error)
}

QueryServer is the server API for Query service.

type QueryStorageRequest 

type QueryStorageRequest struct {
	// address is the ethereum hex address to query the storage state for.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// key defines the key of the storage state
	Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

QueryStorageRequest is the request type for the Query/Storage RPC method.

func (*QueryStorageRequest) Descriptor 

func (*QueryStorageRequest) Descriptor() ([]byte, []int)

func (*QueryStorageRequest) Marshal 

func (m *QueryStorageRequest) Marshal() (dAtA []byte, err error)

func (*QueryStorageRequest) MarshalTo 

func (m *QueryStorageRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryStorageRequest) MarshalToSizedBuffer 

func (m *QueryStorageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryStorageRequest) ProtoMessage 

func (*QueryStorageRequest) ProtoMessage()

func (*QueryStorageRequest) Reset 

func (m *QueryStorageRequest) Reset()

func (*QueryStorageRequest) Size 

func (m *QueryStorageRequest) Size() (n int)

func (*QueryStorageRequest) String 

func (m *QueryStorageRequest) String() string

func (*QueryStorageRequest) Unmarshal 

func (m *QueryStorageRequest) Unmarshal(dAtA []byte) error

func (*QueryStorageRequest) Validate 

func (req *QueryStorageRequest) Validate() error

func (*QueryStorageRequest) XXX_DiscardUnknown 

func (m *QueryStorageRequest) XXX_DiscardUnknown()

func (*QueryStorageRequest) XXX_Marshal 

func (m *QueryStorageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryStorageRequest) XXX_Merge 

func (m *QueryStorageRequest) XXX_Merge(src proto.Message)

func (*QueryStorageRequest) XXX_Size 

func (m *QueryStorageRequest) XXX_Size() int

func (*QueryStorageRequest) XXX_Unmarshal 

func (m *QueryStorageRequest) XXX_Unmarshal(b []byte) error

type QueryStorageResponse 

type QueryStorageResponse struct {
	// value defines the storage state value hash associated with the given key.
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

QueryStorageResponse is the response type for the Query/Storage RPC method.

func (*QueryStorageResponse) Descriptor 

func (*QueryStorageResponse) Descriptor() ([]byte, []int)

func (*QueryStorageResponse) GetValue 

func (m *QueryStorageResponse) GetValue() string

func (*QueryStorageResponse) Marshal 

func (m *QueryStorageResponse) Marshal() (dAtA []byte, err error)

func (*QueryStorageResponse) MarshalTo 

func (m *QueryStorageResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryStorageResponse) MarshalToSizedBuffer 

func (m *QueryStorageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryStorageResponse) ProtoMessage 

func (*QueryStorageResponse) ProtoMessage()

func (*QueryStorageResponse) Reset 

func (m *QueryStorageResponse) Reset()

func (*QueryStorageResponse) Size 

func (m *QueryStorageResponse) Size() (n int)

func (*QueryStorageResponse) String 

func (m *QueryStorageResponse) String() string

func (*QueryStorageResponse) Unmarshal 

func (m *QueryStorageResponse) Unmarshal(dAtA []byte) error

func (*QueryStorageResponse) XXX_DiscardUnknown 

func (m *QueryStorageResponse) XXX_DiscardUnknown()

func (*QueryStorageResponse) XXX_Marshal 

func (m *QueryStorageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryStorageResponse) XXX_Merge 

func (m *QueryStorageResponse) XXX_Merge(src proto.Message)

func (*QueryStorageResponse) XXX_Size 

func (m *QueryStorageResponse) XXX_Size() int

func (*QueryStorageResponse) XXX_Unmarshal 

func (m *QueryStorageResponse) XXX_Unmarshal(b []byte) error

type QueryTraceBlockRequest 

type QueryTraceBlockRequest struct {
	// txs is an array of messages in the block
	Txs []*MsgEthereumTx `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
	// trace_config holds extra parameters to trace functions.
	TraceConfig *TraceConfig `protobuf:"bytes,3,opt,name=trace_config,json=traceConfig,proto3" json:"trace_config,omitempty"`
	// block_number of the traced block
	BlockNumber int64 `protobuf:"varint,5,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	// block_hash (hex) of the traced block
	BlockHash string `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	// block_time of the traced block
	BlockTime time.Time `protobuf:"bytes,7,opt,name=block_time,json=blockTime,proto3,stdtime" json:"block_time"`
	// proposer_address is the address of the requested block
	ProposerAddress github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress `` /* 181-byte string literal not displayed */
	// chain_id is the eip155 chain id parsed from the requested block header
	ChainId int64 `protobuf:"varint,9,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// block_max_gas of the traced block
	BlockMaxGas int64 `protobuf:"varint,10,opt,name=block_max_gas,json=blockMaxGas,proto3" json:"block_max_gas,omitempty"`
}

QueryTraceBlockRequest defines TraceTx request

func (*QueryTraceBlockRequest) Descriptor 

func (*QueryTraceBlockRequest) Descriptor() ([]byte, []int)

func (*QueryTraceBlockRequest) GetBlockHash 

func (m *QueryTraceBlockRequest) GetBlockHash() string

func (*QueryTraceBlockRequest) GetBlockMaxGas 

func (m *QueryTraceBlockRequest) GetBlockMaxGas() int64

func (*QueryTraceBlockRequest) GetBlockNumber 

func (m *QueryTraceBlockRequest) GetBlockNumber() int64

func (*QueryTraceBlockRequest) GetBlockTime 

func (m *QueryTraceBlockRequest) GetBlockTime() time.Time

func (*QueryTraceBlockRequest) GetChainId 

func (m *QueryTraceBlockRequest) GetChainId() int64

func (*QueryTraceBlockRequest) GetProposerAddress 

func (m *QueryTraceBlockRequest) GetProposerAddress() github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress

func (*QueryTraceBlockRequest) GetTraceConfig 

func (m *QueryTraceBlockRequest) GetTraceConfig() *TraceConfig

func (*QueryTraceBlockRequest) GetTxs 

func (m *QueryTraceBlockRequest) GetTxs() []*MsgEthereumTx

func (*QueryTraceBlockRequest) Marshal 

func (m *QueryTraceBlockRequest) Marshal() (dAtA []byte, err error)

func (*QueryTraceBlockRequest) MarshalTo 

func (m *QueryTraceBlockRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryTraceBlockRequest) MarshalToSizedBuffer 

func (m *QueryTraceBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTraceBlockRequest) ProtoMessage 

func (*QueryTraceBlockRequest) ProtoMessage()

func (*QueryTraceBlockRequest) Reset 

func (m *QueryTraceBlockRequest) Reset()

func (*QueryTraceBlockRequest) Size 

func (m *QueryTraceBlockRequest) Size() (n int)

func (*QueryTraceBlockRequest) String 

func (m *QueryTraceBlockRequest) String() string

func (*QueryTraceBlockRequest) Unmarshal 

func (m *QueryTraceBlockRequest) Unmarshal(dAtA []byte) error

func (QueryTraceBlockRequest) UnpackInterfaces 

func (m QueryTraceBlockRequest) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (*QueryTraceBlockRequest) Validate 

func (req *QueryTraceBlockRequest) Validate() error

func (*QueryTraceBlockRequest) XXX_DiscardUnknown 

func (m *QueryTraceBlockRequest) XXX_DiscardUnknown()

func (*QueryTraceBlockRequest) XXX_Marshal 

func (m *QueryTraceBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTraceBlockRequest) XXX_Merge 

func (m *QueryTraceBlockRequest) XXX_Merge(src proto.Message)

func (*QueryTraceBlockRequest) XXX_Size 

func (m *QueryTraceBlockRequest) XXX_Size() int

func (*QueryTraceBlockRequest) XXX_Unmarshal 

func (m *QueryTraceBlockRequest) XXX_Unmarshal(b []byte) error

type QueryTraceBlockResponse 

type QueryTraceBlockResponse struct {
	// data is the response serialized in bytes
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

QueryTraceBlockResponse defines TraceBlock response

func (*QueryTraceBlockResponse) Descriptor 

func (*QueryTraceBlockResponse) Descriptor() ([]byte, []int)

func (*QueryTraceBlockResponse) GetData 

func (m *QueryTraceBlockResponse) GetData() []byte

func (*QueryTraceBlockResponse) Marshal 

func (m *QueryTraceBlockResponse) Marshal() (dAtA []byte, err error)

func (*QueryTraceBlockResponse) MarshalTo 

func (m *QueryTraceBlockResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryTraceBlockResponse) MarshalToSizedBuffer 

func (m *QueryTraceBlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTraceBlockResponse) ProtoMessage 

func (*QueryTraceBlockResponse) ProtoMessage()

func (*QueryTraceBlockResponse) Reset 

func (m *QueryTraceBlockResponse) Reset()

func (*QueryTraceBlockResponse) Size 

func (m *QueryTraceBlockResponse) Size() (n int)

func (*QueryTraceBlockResponse) String 

func (m *QueryTraceBlockResponse) String() string

func (*QueryTraceBlockResponse) Unmarshal 

func (m *QueryTraceBlockResponse) Unmarshal(dAtA []byte) error

func (*QueryTraceBlockResponse) XXX_DiscardUnknown 

func (m *QueryTraceBlockResponse) XXX_DiscardUnknown()

func (*QueryTraceBlockResponse) XXX_Marshal 

func (m *QueryTraceBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTraceBlockResponse) XXX_Merge 

func (m *QueryTraceBlockResponse) XXX_Merge(src proto.Message)

func (*QueryTraceBlockResponse) XXX_Size 

func (m *QueryTraceBlockResponse) XXX_Size() int

func (*QueryTraceBlockResponse) XXX_Unmarshal 

func (m *QueryTraceBlockResponse) XXX_Unmarshal(b []byte) error

type QueryTraceTxRequest 

type QueryTraceTxRequest struct {
	// msg is the MsgEthereumTx for the requested transaction
	Msg *MsgEthereumTx `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// trace_config holds extra parameters to trace functions.
	TraceConfig *TraceConfig `protobuf:"bytes,3,opt,name=trace_config,json=traceConfig,proto3" json:"trace_config,omitempty"`
	// predecessors is an array of transactions included in the same block
	// need to be replayed first to get correct context for tracing.
	Predecessors []*MsgEthereumTx `protobuf:"bytes,4,rep,name=predecessors,proto3" json:"predecessors,omitempty"`
	// block_number of requested transaction
	BlockNumber int64 `protobuf:"varint,5,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	// block_hash of requested transaction
	BlockHash string `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	// block_time of requested transaction
	BlockTime time.Time `protobuf:"bytes,7,opt,name=block_time,json=blockTime,proto3,stdtime" json:"block_time"`
	// proposer_address is the proposer of the requested block
	ProposerAddress github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress `` /* 181-byte string literal not displayed */
	// chain_id is the the eip155 chain id parsed from the requested block header
	ChainId int64 `protobuf:"varint,9,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// block_max_gas of the block of the requested transaction
	BlockMaxGas int64 `protobuf:"varint,10,opt,name=block_max_gas,json=blockMaxGas,proto3" json:"block_max_gas,omitempty"`
}

QueryTraceTxRequest defines TraceTx request

func (*QueryTraceTxRequest) Descriptor 

func (*QueryTraceTxRequest) Descriptor() ([]byte, []int)

func (*QueryTraceTxRequest) GetBlockHash 

func (m *QueryTraceTxRequest) GetBlockHash() string

func (*QueryTraceTxRequest) GetBlockMaxGas 

func (m *QueryTraceTxRequest) GetBlockMaxGas() int64

func (*QueryTraceTxRequest) GetBlockNumber 

func (m *QueryTraceTxRequest) GetBlockNumber() int64

func (*QueryTraceTxRequest) GetBlockTime 

func (m *QueryTraceTxRequest) GetBlockTime() time.Time

func (*QueryTraceTxRequest) GetChainId 

func (m *QueryTraceTxRequest) GetChainId() int64

func (*QueryTraceTxRequest) GetMsg 

func (m *QueryTraceTxRequest) GetMsg() *MsgEthereumTx

func (*QueryTraceTxRequest) GetPredecessors 

func (m *QueryTraceTxRequest) GetPredecessors() []*MsgEthereumTx

func (*QueryTraceTxRequest) GetProposerAddress 

func (m *QueryTraceTxRequest) GetProposerAddress() github_com_NibiruChain_nibiru_v2_lib_cosmos_sdk_types.ConsAddress

func (*QueryTraceTxRequest) GetTraceConfig 

func (m *QueryTraceTxRequest) GetTraceConfig() *TraceConfig

func (*QueryTraceTxRequest) Marshal 

func (m *QueryTraceTxRequest) Marshal() (dAtA []byte, err error)

func (*QueryTraceTxRequest) MarshalTo 

func (m *QueryTraceTxRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryTraceTxRequest) MarshalToSizedBuffer 

func (m *QueryTraceTxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTraceTxRequest) ProtoMessage 

func (*QueryTraceTxRequest) ProtoMessage()

func (*QueryTraceTxRequest) Reset 

func (m *QueryTraceTxRequest) Reset()

func (*QueryTraceTxRequest) Size 

func (m *QueryTraceTxRequest) Size() (n int)

func (*QueryTraceTxRequest) String 

func (m *QueryTraceTxRequest) String() string

func (*QueryTraceTxRequest) Unmarshal 

func (m *QueryTraceTxRequest) Unmarshal(dAtA []byte) error

func (QueryTraceTxRequest) UnpackInterfaces 

func (m QueryTraceTxRequest) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (*QueryTraceTxRequest) Validate 

func (req *QueryTraceTxRequest) Validate() error

func (*QueryTraceTxRequest) XXX_DiscardUnknown 

func (m *QueryTraceTxRequest) XXX_DiscardUnknown()

func (*QueryTraceTxRequest) XXX_Marshal 

func (m *QueryTraceTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTraceTxRequest) XXX_Merge 

func (m *QueryTraceTxRequest) XXX_Merge(src proto.Message)

func (*QueryTraceTxRequest) XXX_Size 

func (m *QueryTraceTxRequest) XXX_Size() int

func (*QueryTraceTxRequest) XXX_Unmarshal 

func (m *QueryTraceTxRequest) XXX_Unmarshal(b []byte) error

type QueryTraceTxResponse 

type QueryTraceTxResponse struct {
	// data is the response serialized in bytes
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

QueryTraceTxResponse defines TraceTx response

func (*QueryTraceTxResponse) Descriptor 

func (*QueryTraceTxResponse) Descriptor() ([]byte, []int)

func (*QueryTraceTxResponse) GetData 

func (m *QueryTraceTxResponse) GetData() []byte

func (*QueryTraceTxResponse) Marshal 

func (m *QueryTraceTxResponse) Marshal() (dAtA []byte, err error)

func (*QueryTraceTxResponse) MarshalTo 

func (m *QueryTraceTxResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryTraceTxResponse) MarshalToSizedBuffer 

func (m *QueryTraceTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTraceTxResponse) ProtoMessage 

func (*QueryTraceTxResponse) ProtoMessage()

func (*QueryTraceTxResponse) Reset 

func (m *QueryTraceTxResponse) Reset()

func (*QueryTraceTxResponse) Size 

func (m *QueryTraceTxResponse) Size() (n int)

func (*QueryTraceTxResponse) String 

func (m *QueryTraceTxResponse) String() string

func (*QueryTraceTxResponse) Unmarshal 

func (m *QueryTraceTxResponse) Unmarshal(dAtA []byte) error

func (*QueryTraceTxResponse) XXX_DiscardUnknown 

func (m *QueryTraceTxResponse) XXX_DiscardUnknown()

func (*QueryTraceTxResponse) XXX_Marshal 

func (m *QueryTraceTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTraceTxResponse) XXX_Merge 

func (m *QueryTraceTxResponse) XXX_Merge(src proto.Message)

func (*QueryTraceTxResponse) XXX_Size 

func (m *QueryTraceTxResponse) XXX_Size() int

func (*QueryTraceTxResponse) XXX_Unmarshal 

func (m *QueryTraceTxResponse) XXX_Unmarshal(b []byte) error

type QueryTxLogsRequest 

type QueryTxLogsRequest struct {
	// hash is the ethereum transaction hex hash to query the logs for.
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryTxLogsRequest is the request type for the Query/TxLogs RPC method.

func (*QueryTxLogsRequest) Descriptor 

func (*QueryTxLogsRequest) Descriptor() ([]byte, []int)

func (*QueryTxLogsRequest) Marshal 

func (m *QueryTxLogsRequest) Marshal() (dAtA []byte, err error)

func (*QueryTxLogsRequest) MarshalTo 

func (m *QueryTxLogsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryTxLogsRequest) MarshalToSizedBuffer 

func (m *QueryTxLogsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTxLogsRequest) ProtoMessage 

func (*QueryTxLogsRequest) ProtoMessage()

func (*QueryTxLogsRequest) Reset 

func (m *QueryTxLogsRequest) Reset()

func (*QueryTxLogsRequest) Size 

func (m *QueryTxLogsRequest) Size() (n int)

func (*QueryTxLogsRequest) String 

func (m *QueryTxLogsRequest) String() string

func (*QueryTxLogsRequest) Unmarshal 

func (m *QueryTxLogsRequest) Unmarshal(dAtA []byte) error

func (*QueryTxLogsRequest) XXX_DiscardUnknown 

func (m *QueryTxLogsRequest) XXX_DiscardUnknown()

func (*QueryTxLogsRequest) XXX_Marshal 

func (m *QueryTxLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTxLogsRequest) XXX_Merge 

func (m *QueryTxLogsRequest) XXX_Merge(src proto.Message)

func (*QueryTxLogsRequest) XXX_Size 

func (m *QueryTxLogsRequest) XXX_Size() int

func (*QueryTxLogsRequest) XXX_Unmarshal 

func (m *QueryTxLogsRequest) XXX_Unmarshal(b []byte) error

type QueryTxLogsResponse 

type QueryTxLogsResponse struct {
	// logs represents the ethereum logs generated from the given transaction.
	Logs []*Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryTxLogsResponse is the response type for the Query/TxLogs RPC method.

func (*QueryTxLogsResponse) Descriptor 

func (*QueryTxLogsResponse) Descriptor() ([]byte, []int)

func (*QueryTxLogsResponse) GetLogs 

func (m *QueryTxLogsResponse) GetLogs() []*Log

func (*QueryTxLogsResponse) GetPagination 

func (m *QueryTxLogsResponse) GetPagination() *query.PageResponse

func (*QueryTxLogsResponse) Marshal 

func (m *QueryTxLogsResponse) Marshal() (dAtA []byte, err error)

func (*QueryTxLogsResponse) MarshalTo 

func (m *QueryTxLogsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryTxLogsResponse) MarshalToSizedBuffer 

func (m *QueryTxLogsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTxLogsResponse) ProtoMessage 

func (*QueryTxLogsResponse) ProtoMessage()

func (*QueryTxLogsResponse) Reset 

func (m *QueryTxLogsResponse) Reset()

func (*QueryTxLogsResponse) Size 

func (m *QueryTxLogsResponse) Size() (n int)

func (*QueryTxLogsResponse) String 

func (m *QueryTxLogsResponse) String() string

func (*QueryTxLogsResponse) Unmarshal 

func (m *QueryTxLogsResponse) Unmarshal(dAtA []byte) error

func (*QueryTxLogsResponse) XXX_DiscardUnknown 

func (m *QueryTxLogsResponse) XXX_DiscardUnknown()

func (*QueryTxLogsResponse) XXX_Marshal 

func (m *QueryTxLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTxLogsResponse) XXX_Merge 

func (m *QueryTxLogsResponse) XXX_Merge(src proto.Message)

func (*QueryTxLogsResponse) XXX_Size 

func (m *QueryTxLogsResponse) XXX_Size() int

func (*QueryTxLogsResponse) XXX_Unmarshal 

func (m *QueryTxLogsResponse) XXX_Unmarshal(b []byte) error

type QueryValidatorAccountRequest 

type QueryValidatorAccountRequest struct {
	// cons_address is the validator cons address to query the account for.
	ConsAddress string `protobuf:"bytes,1,opt,name=cons_address,json=consAddress,proto3" json:"cons_address,omitempty"`
}

QueryValidatorAccountRequest is the request type for the Query/ValidatorAccount RPC method.

func (*QueryValidatorAccountRequest) Descriptor 

func (*QueryValidatorAccountRequest) Descriptor() ([]byte, []int)

func (*QueryValidatorAccountRequest) Marshal 

func (m *QueryValidatorAccountRequest) Marshal() (dAtA []byte, err error)

func (*QueryValidatorAccountRequest) MarshalTo 

func (m *QueryValidatorAccountRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryValidatorAccountRequest) MarshalToSizedBuffer 

func (m *QueryValidatorAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryValidatorAccountRequest) ProtoMessage 

func (*QueryValidatorAccountRequest) ProtoMessage()

func (*QueryValidatorAccountRequest) Reset 

func (m *QueryValidatorAccountRequest) Reset()

func (*QueryValidatorAccountRequest) Size 

func (m *QueryValidatorAccountRequest) Size() (n int)

func (*QueryValidatorAccountRequest) String 

func (m *QueryValidatorAccountRequest) String() string

func (*QueryValidatorAccountRequest) Unmarshal 

func (m *QueryValidatorAccountRequest) Unmarshal(dAtA []byte) error

func (*QueryValidatorAccountRequest) Validate 

func (req *QueryValidatorAccountRequest) Validate() (
	consAddr sdk.ConsAddress, err error,
)

func (*QueryValidatorAccountRequest) XXX_DiscardUnknown 

func (m *QueryValidatorAccountRequest) XXX_DiscardUnknown()

func (*QueryValidatorAccountRequest) XXX_Marshal 

func (m *QueryValidatorAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryValidatorAccountRequest) XXX_Merge 

func (m *QueryValidatorAccountRequest) XXX_Merge(src proto.Message)

func (*QueryValidatorAccountRequest) XXX_Size 

func (m *QueryValidatorAccountRequest) XXX_Size() int

func (*QueryValidatorAccountRequest) XXX_Unmarshal 

func (m *QueryValidatorAccountRequest) XXX_Unmarshal(b []byte) error

type QueryValidatorAccountResponse 

type QueryValidatorAccountResponse struct {
	// account_address is the Nibiru address of the account in bech32 format.
	AccountAddress string `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
	// sequence is the account's sequence number.
	Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// account_number is the account number
	AccountNumber uint64 `protobuf:"varint,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"`
}

QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method.

func (*QueryValidatorAccountResponse) Descriptor 

func (*QueryValidatorAccountResponse) Descriptor() ([]byte, []int)

func (*QueryValidatorAccountResponse) GetAccountAddress 

func (m *QueryValidatorAccountResponse) GetAccountAddress() string

func (*QueryValidatorAccountResponse) GetAccountNumber 

func (m *QueryValidatorAccountResponse) GetAccountNumber() uint64

func (*QueryValidatorAccountResponse) GetSequence 

func (m *QueryValidatorAccountResponse) GetSequence() uint64

func (*QueryValidatorAccountResponse) Marshal 

func (m *QueryValidatorAccountResponse) Marshal() (dAtA []byte, err error)

func (*QueryValidatorAccountResponse) MarshalTo 

func (m *QueryValidatorAccountResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryValidatorAccountResponse) MarshalToSizedBuffer 

func (m *QueryValidatorAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryValidatorAccountResponse) ProtoMessage 

func (*QueryValidatorAccountResponse) ProtoMessage()

func (*QueryValidatorAccountResponse) Reset 

func (m *QueryValidatorAccountResponse) Reset()

func (*QueryValidatorAccountResponse) Size 

func (m *QueryValidatorAccountResponse) Size() (n int)

func (*QueryValidatorAccountResponse) String 

func (m *QueryValidatorAccountResponse) String() string

func (*QueryValidatorAccountResponse) Unmarshal 

func (m *QueryValidatorAccountResponse) Unmarshal(dAtA []byte) error

func (*QueryValidatorAccountResponse) XXX_DiscardUnknown 

func (m *QueryValidatorAccountResponse) XXX_DiscardUnknown()

func (*QueryValidatorAccountResponse) XXX_Marshal 

func (m *QueryValidatorAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryValidatorAccountResponse) XXX_Merge 

func (m *QueryValidatorAccountResponse) XXX_Merge(src proto.Message)

func (*QueryValidatorAccountResponse) XXX_Size 

func (m *QueryValidatorAccountResponse) XXX_Size() int

func (*QueryValidatorAccountResponse) XXX_Unmarshal 

func (m *QueryValidatorAccountResponse) XXX_Unmarshal(b []byte) error

type RevertError 

type RevertError struct {
	// contains filtered or unexported fields
}

RevertError is an API error that encompass an EVM revert with JSON error code and a binary data blob.

type StakingKeeper 

type StakingKeeper interface {
	GetHistoricalInfo(ctx sdk.Context, height int64) (stakingtypes.HistoricalInfo, bool)
	GetValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAddress) (validator stakingtypes.Validator, found bool)
}

StakingKeeper returns the historical headers kept in store.

type State 

type State struct {
	// key is the stored key
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// value is the stored value for the given key
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

State represents a single Storage key value pair item.

func NewStateFromEthHashes 

func NewStateFromEthHashes(key, value common.Hash) State

NewStateFromEthHashes creates a State struct from Eth hashes.

func (*State) Descriptor 

func (*State) Descriptor() ([]byte, []int)

func (*State) GetKey 

func (m *State) GetKey() string

func (*State) GetValue 

func (m *State) GetValue() string

func (*State) Marshal 

func (m *State) Marshal() (dAtA []byte, err error)

func (*State) MarshalTo 

func (m *State) MarshalTo(dAtA []byte) (int, error)

func (*State) MarshalToSizedBuffer 

func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*State) ProtoMessage 

func (*State) ProtoMessage()

func (*State) Reset 

func (m *State) Reset()

func (*State) Size 

func (m *State) Size() (n int)

func (*State) String 

func (m *State) String() string

func (*State) Unmarshal 

func (m *State) Unmarshal(dAtA []byte) error

func (State) Validate 

func (s State) Validate() error

Validate performs a basic validation of the State fields. Note that State can be empty.

func (*State) XXX_DiscardUnknown 

func (m *State) XXX_DiscardUnknown()

func (*State) XXX_Marshal 

func (m *State) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*State) XXX_Merge 

func (m *State) XXX_Merge(src proto.Message)

func (*State) XXX_Size 

func (m *State) XXX_Size() int

func (*State) XXX_Unmarshal 

func (m *State) XXX_Unmarshal(b []byte) error

type Storage 

type Storage []State

Storage represents the account Storage map as a slice of single key value State pairs. This is to prevent non determinism at genesis initialization or export.

func (Storage) Copy 

func (s Storage) Copy() Storage

Copy returns a copy of storage.

func (Storage) String 

func (s Storage) String() string

String implements the stringer interface

func (Storage) Validate 

func (s Storage) Validate() error

Validate performs a basic validation of the Storage fields.

type SudoKeeper 

type SudoKeeper interface {
	// CheckPermissions Checks if a contract is contained within the set of sudo
	// contracts defined in the x/sudo module. These smart contracts are able to
	// execute certain permissioned functions.
	CheckPermissions(contract sdk.AccAddress, ctx sdk.Context) error

	// GetZeroGasEvmContracts returns the subset of zero-gas actors that are
	// EVM contracts as a set (map) for O(1) lookup. This method avoids
	// exposing x/sudo-specific types in the EVM dependency interface.
	GetZeroGasEvmContracts(ctx sdk.Context) map[gethcommon.Address]struct{}
}

type TraceConfig 

type TraceConfig struct {
	// tracer is a custom javascript tracer
	Tracer string `protobuf:"bytes,1,opt,name=tracer,proto3" json:"tracer,omitempty"`
	// timeout overrides the default timeout of 5 seconds for JavaScript-based
	// tracing calls
	Timeout string `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// reexec defines the number of blocks the tracer is willing to go back
	Reexec uint64 `protobuf:"varint,3,opt,name=reexec,proto3" json:"reexec,omitempty"`
	// disable_stack switches stack capture
	DisableStack bool `protobuf:"varint,5,opt,name=disable_stack,json=disableStack,proto3" json:"disableStack"`
	// disable_storage switches storage capture
	DisableStorage bool `protobuf:"varint,6,opt,name=disable_storage,json=disableStorage,proto3" json:"disableStorage"`
	// debug can be used to print output during capture end
	Debug bool `protobuf:"varint,8,opt,name=debug,proto3" json:"debug,omitempty"`
	// limit defines the maximum length of output, but zero means unlimited
	Limit int32 `protobuf:"varint,9,opt,name=limit,proto3" json:"limit,omitempty"`
	// enable_memory switches memory capture
	EnableMemory bool `protobuf:"varint,11,opt,name=enable_memory,json=enableMemory,proto3" json:"enableMemory"`
	// enable_return_data switches the capture of return data
	EnableReturnData bool `protobuf:"varint,12,opt,name=enable_return_data,json=enableReturnData,proto3" json:"enableReturnData"`
	// tracer_config configures the tracer options
	TracerConfig *TracerConfig `protobuf:"bytes,13,opt,name=tracer_config,json=tracerConfig,proto3" json:"tracerConfig"`
}

TraceConfig holds extra parameters to trace functions.

func (*TraceConfig) Descriptor 

func (*TraceConfig) Descriptor() ([]byte, []int)

func (*TraceConfig) GetDebug 

func (m *TraceConfig) GetDebug() bool

func (*TraceConfig) GetDisableStack 

func (m *TraceConfig) GetDisableStack() bool

func (*TraceConfig) GetDisableStorage 

func (m *TraceConfig) GetDisableStorage() bool

func (*TraceConfig) GetEnableMemory 

func (m *TraceConfig) GetEnableMemory() bool

func (*TraceConfig) GetEnableReturnData 

func (m *TraceConfig) GetEnableReturnData() bool

func (*TraceConfig) GetLimit 

func (m *TraceConfig) GetLimit() int32

func (*TraceConfig) GetReexec 

func (m *TraceConfig) GetReexec() uint64

func (*TraceConfig) GetTimeout 

func (m *TraceConfig) GetTimeout() string

func (*TraceConfig) GetTracer 

func (m *TraceConfig) GetTracer() string

func (*TraceConfig) GetTracerConfig 

func (m *TraceConfig) GetTracerConfig() *TracerConfig

func (*TraceConfig) Marshal 

func (m *TraceConfig) Marshal() (dAtA []byte, err error)

func (*TraceConfig) MarshalTo 

func (m *TraceConfig) MarshalTo(dAtA []byte) (int, error)

func (*TraceConfig) MarshalToSizedBuffer 

func (m *TraceConfig) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TraceConfig) ProtoMessage 

func (*TraceConfig) ProtoMessage()

func (*TraceConfig) Reset 

func (m *TraceConfig) Reset()

func (*TraceConfig) Size 

func (m *TraceConfig) Size() (n int)

func (*TraceConfig) String 

func (m *TraceConfig) String() string

func (*TraceConfig) Unmarshal 

func (m *TraceConfig) Unmarshal(dAtA []byte) error

func (*TraceConfig) XXX_DiscardUnknown 

func (m *TraceConfig) XXX_DiscardUnknown()

func (*TraceConfig) XXX_Marshal 

func (m *TraceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TraceConfig) XXX_Merge 

func (m *TraceConfig) XXX_Merge(src proto.Message)

func (*TraceConfig) XXX_Size 

func (m *TraceConfig) XXX_Size() int

func (*TraceConfig) XXX_Unmarshal 

func (m *TraceConfig) XXX_Unmarshal(b []byte) error

type TracerConfig 

type TracerConfig struct {
	OnlyTopCall bool `protobuf:"varint,1,opt,name=only_top_call,json=onlyTopCall,proto3" json:"onlyTopCall"`
}

TracerConfig stores additional tracer args. For geth it's only one attr: onlyTopCall

func (*TracerConfig) Descriptor 

func (*TracerConfig) Descriptor() ([]byte, []int)

func (*TracerConfig) GetOnlyTopCall 

func (m *TracerConfig) GetOnlyTopCall() bool

func (*TracerConfig) Marshal 

func (m *TracerConfig) Marshal() (dAtA []byte, err error)

func (*TracerConfig) MarshalTo 

func (m *TracerConfig) MarshalTo(dAtA []byte) (int, error)

func (*TracerConfig) MarshalToSizedBuffer 

func (m *TracerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TracerConfig) ProtoMessage 

func (*TracerConfig) ProtoMessage()

func (*TracerConfig) Reset 

func (m *TracerConfig) Reset()

func (*TracerConfig) Size 

func (m *TracerConfig) Size() (n int)

func (*TracerConfig) String 

func (m *TracerConfig) String() string

func (*TracerConfig) Unmarshal 

func (m *TracerConfig) Unmarshal(dAtA []byte) error

func (*TracerConfig) XXX_DiscardUnknown 

func (m *TracerConfig) XXX_DiscardUnknown()

func (*TracerConfig) XXX_Marshal 

func (m *TracerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TracerConfig) XXX_Merge 

func (m *TracerConfig) XXX_Merge(src proto.Message)

func (*TracerConfig) XXX_Size 

func (m *TracerConfig) XXX_Size() int

func (*TracerConfig) XXX_Unmarshal 

func (m *TracerConfig) XXX_Unmarshal(b []byte) error

type Tx 

type Tx = *MsgEthereumTx

A type alias to save some typing. An Ethereum transaction an SDK message.

type TxData 

type TxData interface {
	// TxType returns a byte (uint8) identifying the tx as a [LegacyTx] (0),
	// [AccessListTx] (1), or [DynamicFeeTx] (2).
	TxType() byte
	Copy() TxData
	GetChainID() *big.Int
	GetAccessList() gethcore.AccessList
	GetData() []byte

	GetNonce() uint64

	// GetGas returns the gas limit in gas units. Note that this is not a "fee"
	// in wei or micronibi or a price.
	GetGas() uint64

	// Gas price as wei spent per unit gas.
	GetGasPrice() *big.Int

	// GetGasTipCapWei returns a cap on the gas tip in units of wei.
	//
	// Also called "maxPriorityFeePerGas" in Alchemy and Ethers.
	// See [Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas].
	// Base fees are determined by the network, not the end user that broadcasts
	// the transaction. Adding a tip increases one's "priority" in the block.
	//
	// The terminology "fee per gas" essentially means "wei per unit gas".
	// See [Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas] for more info.
	//
	// [Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas]: https://docs.alchemy.com/docs/maxpriorityfeepergas-vs-maxfeepergas.
	GetGasTipCapWei() *big.Int

	// GetGasFeeCapWei returns a cap on the gas fees paid in units of wei, where:
	// feesWithoutCap := effective gas price (wei per gas) * gas units
	// fees -> min(feesWithoutCap, gasFeeCap)
	// Also called "maxFeePerGas" in Alchemy and Ethers.
	//
	// maxFeePerGas := baseFeePerGas + maxPriorityFeePerGas
	//
	// The terminology "fee per gas" essentially means "wei per unit gas".
	// See [Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas] for more info.
	//
	// [Alchemy Docs - maxPriorityFeePerGas vs maxFeePerGas]: https://docs.alchemy.com/docs/maxpriorityfeepergas-vs-maxfeepergas.
	GetGasFeeCapWei() *big.Int
	EffectiveGasFeeCapWei(baseFeeWei *big.Int) *big.Int

	// GetValueWei: amount of ether (wei units) sent in the transaction.
	GetValueWei() *big.Int

	GetTo() *common.Address
	GetToRaw() string

	GetRawSignatureValues() (v, r, s *big.Int)
	SetSignatureValues(chainID, v, r, s *big.Int)

	AsEthereumData() gethcore.TxData
	Validate() error

	// Fee in units of wei := gasPrice (wei per gas)  * gasLimit (gas).
	Fee() *big.Int
	// Cost in units of wei := Fee * Value. Cost is the gas cost of the
	// transaction in wei, accounting for value transferred.
	Cost() *big.Int

	// EffectiveGasPriceWeiPerGas is effective gas price in units of wei per gas.
	// "Effective" means depending on the base fee of the network.
	EffectiveGasPriceWeiPerGas(baseFeeWei *big.Int) *big.Int

	// EffectiveFeeWei := effectiveGasPrice (wei per gas) * gasLimit (gas).
	// "Effective" means depending on the base fee of the network.
	EffectiveFeeWei(baseFeeWei *big.Int) *big.Int

	// EffectiveCostWei is the same as cost, except it uses effective fee in wei
	// rathen than fee. Effective cost is the gas cost of the transaction in wei,
	// accounting for value (wei) transferred and using effective gas price (wei
	// per gas).
	EffectiveCostWei(baseFeeWei *big.Int) *big.Int
}

TxData is the underlying data of a transaction. Its counterpart with private fields, "gethcore.TxData" is implemented by DynamicFeeTx, LegacyTx and AccessListTx from the same package. Each trnsaction type is implemented here for protobuf marshaling.

According to https://github.com/ethereum/go-ethereum/issues/23154: TxData exists for the sole purpose of making it easier to construct a "gethcore.Transaction" more conviently in Go code. The methods of TxData are an internal implementation detail and will never have a stable API.

Because the fields are private in the go-ethereum code, it is impossible to provide custom implementations for these methods without creating a new TxData data structure. Thus, the current interface exists.

func IsZeroGasMsgEthereumTx 

func IsZeroGasMsgEthereumTx(
	ctx sdk.Context,
	sudoKeeper SudoKeeper,
	msg *MsgEthereumTx,
) (bool, TxData, error)

IsZeroGasMsgEthereumTx classifies a signed EVM message without mutating the raw signed transaction data.

func NewTxDataFromTx 

func NewTxDataFromTx(tx *gethcore.Transaction) (TxData, error)

NOTE: All non-protected transactions (i.e. non EIP155 signed) will fail if the AllowUnprotectedTxs parameter is disabled.

func UnpackTxData 

func UnpackTxData(any *codectypes.Any) (TxData, error)

UnpackTxData unpacks an Any into a TxData. It returns an error if the client state can't be unpacked into a TxData.

type TxGasKind 

type TxGasKind string
const (
	TxGasKind_Default TxGasKind = "default"

	// TxGasKind_ZeroGas performs stateless validation for a previously
	// classified zero-gas EVM transaction. It preserves non-fee checks and skips
	// only fee-price checks that are irrelevant once native gas payment is
	// exempt.
	TxGasKind_ZeroGas TxGasKind = "zero_gas"
)

type TxTraceResult 

type TxTraceResult struct {
	TxHash gethcommon.Hash `json:"txHash"`           // transaction hash
	Result any             `json:"result,omitempty"` // Trace results produced by the tracer
	Error  string          `json:"error,omitempty"`  // Trace failure produced by the tracer
}

TxTraceResult is the result of a single transaction trace during a block trace. This is a duplicate of the private result struct from geth in "eth/tracers/api.go".

type UnimplementedMsgServer 

type UnimplementedMsgServer struct {
}

UnimplementedMsgServer can be embedded to have forward compatible implementations.

func (*UnimplementedMsgServer) ConvertCoinToEvm 

func (*UnimplementedMsgServer) ConvertCoinToEvm(ctx context.Context, req *MsgConvertCoinToEvm) (*MsgConvertCoinToEvmResponse, error)

func (*UnimplementedMsgServer) ConvertEvmToCoin 

func (*UnimplementedMsgServer) ConvertEvmToCoin(ctx context.Context, req *MsgConvertEvmToCoin) (*MsgConvertEvmToCoinResponse, error)

func (*UnimplementedMsgServer) CreateFunToken 

func (*UnimplementedMsgServer) CreateFunToken(ctx context.Context, req *MsgCreateFunToken) (*MsgCreateFunTokenResponse, error)

func (*UnimplementedMsgServer) EthereumTx 

func (*UnimplementedMsgServer) EthereumTx(ctx context.Context, req *MsgEthereumTx) (*MsgEthereumTxResponse, error)

func (*UnimplementedMsgServer) UpdateParams 

func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error)

type UnimplementedQueryServer 

type UnimplementedQueryServer struct {
}

UnimplementedQueryServer can be embedded to have forward compatible implementations.

func (*UnimplementedQueryServer) Balance 

func (*UnimplementedQueryServer) Balance(ctx context.Context, req *QueryBalanceRequest) (*QueryBalanceResponse, error)

func (*UnimplementedQueryServer) BaseFee 

func (*UnimplementedQueryServer) BaseFee(ctx context.Context, req *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error)

func (*UnimplementedQueryServer) Code 

func (*UnimplementedQueryServer) Code(ctx context.Context, req *QueryCodeRequest) (*QueryCodeResponse, error)

func (*UnimplementedQueryServer) EstimateGas 

func (*UnimplementedQueryServer) EstimateGas(ctx context.Context, req *EthCallRequest) (*EstimateGasResponse, error)

func (*UnimplementedQueryServer) EthAccount 

func (*UnimplementedQueryServer) EthAccount(ctx context.Context, req *QueryEthAccountRequest) (*QueryEthAccountResponse, error)

func (*UnimplementedQueryServer) EthCall 

func (*UnimplementedQueryServer) EthCall(ctx context.Context, req *EthCallRequest) (*MsgEthereumTxResponse, error)

func (*UnimplementedQueryServer) FunTokenMapping 

func (*UnimplementedQueryServer) FunTokenMapping(ctx context.Context, req *QueryFunTokenMappingRequest) (*QueryFunTokenMappingResponse, error)

func (*UnimplementedQueryServer) Params 

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error)

func (*UnimplementedQueryServer) Storage 

func (*UnimplementedQueryServer) Storage(ctx context.Context, req *QueryStorageRequest) (*QueryStorageResponse, error)

func (*UnimplementedQueryServer) TraceBlock 

func (*UnimplementedQueryServer) TraceBlock(ctx context.Context, req *QueryTraceBlockRequest) (*QueryTraceBlockResponse, error)

func (*UnimplementedQueryServer) TraceCall 

func (*UnimplementedQueryServer) TraceCall(ctx context.Context, req *QueryTraceTxRequest) (*QueryTraceTxResponse, error)

func (*UnimplementedQueryServer) TraceTx 

func (*UnimplementedQueryServer) TraceTx(ctx context.Context, req *QueryTraceTxRequest) (*QueryTraceTxResponse, error)

func (*UnimplementedQueryServer) ValidatorAccount 

func (*UnimplementedQueryServer) ValidatorAccount(ctx context.Context, req *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error)

type WasmPlugin 

type WasmPlugin struct {
	// Name is a human-readable name for the plugin.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Addr is the Wasm smart contract address that defines the plugin
	Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
}

WasmPlugin binds a stable plugin name to a Wasm contract address.

EVM code should look up plugins by name instead of hard-coding Wasm contract addresses. For example, plugin name "x-oracle" can identify the Wasm adapter used by the legacy oracle precompile at 0x0000000000000000000000000000000000000801.

func (*WasmPlugin) Descriptor 

func (*WasmPlugin) Descriptor() ([]byte, []int)

func (*WasmPlugin) Equal 

func (this *WasmPlugin) Equal(that interface{}) bool

func (*WasmPlugin) GetAddr 

func (m *WasmPlugin) GetAddr() string

func (*WasmPlugin) GetName 

func (m *WasmPlugin) GetName() string

func (*WasmPlugin) Marshal 

func (m *WasmPlugin) Marshal() (dAtA []byte, err error)

func (*WasmPlugin) MarshalTo 

func (m *WasmPlugin) MarshalTo(dAtA []byte) (int, error)

func (*WasmPlugin) MarshalToSizedBuffer 

func (m *WasmPlugin) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*WasmPlugin) ProtoMessage 

func (*WasmPlugin) ProtoMessage()

func (*WasmPlugin) Reset 

func (m *WasmPlugin) Reset()

func (*WasmPlugin) Size 

func (m *WasmPlugin) Size() (n int)

func (*WasmPlugin) String 

func (m *WasmPlugin) String() string

func (*WasmPlugin) Unmarshal 

func (m *WasmPlugin) Unmarshal(dAtA []byte) error

func (*WasmPlugin) XXX_DiscardUnknown 

func (m *WasmPlugin) XXX_DiscardUnknown()

func (*WasmPlugin) XXX_Marshal 

func (m *WasmPlugin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WasmPlugin) XXX_Merge 

func (m *WasmPlugin) XXX_Merge(src proto.Message)

func (*WasmPlugin) XXX_Size 

func (m *WasmPlugin) XXX_Size() int

func (*WasmPlugin) XXX_Unmarshal 

func (m *WasmPlugin) XXX_Unmarshal(b []byte) error

type ZeroGasMeta 

type ZeroGasMeta struct{}

ZeroGasMeta is the context payload for zero-gas EVM transactions. Stored under CtxKeyZeroGasMeta. When present, indicates the tx is zero-gas eligible; ante steps skip balance-vs-cost and fee deduction; msg_server skips refund. CanTransfer still runs. Empty struct; only presence (non-nil) matters.

func GetZeroGasMeta 

func GetZeroGasMeta(ctx sdk.Context) *ZeroGasMeta

GetZeroGasMeta returns the ZeroGasMeta stored under CtxKeyZeroGasMeta, or nil if not set or type assertion fails.

Source Files

View all Source files

Directories

Path Synopsis
Package "embeds" adds access to files (smart contracts) embedded in the Go runtime.
 Package "embeds" adds access to files (smart contracts) embedded in the Go runtime.
gen-abi command
Package "evm/evmstate" implements a go-ethereum vm.StateDB for Nibiru's Multi VM stack, implemented as SDB.
 Package "evm/evmstate" implements a go-ethereum vm.StateDB for Nibiru's Multi VM stack, implemented as SDB.
Package precompile implements custom precompiles for the Nibiru EVM.
 Package precompile implements custom precompiles for the Nibiru EVM.
test

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.