keeper

package
v2.0.0-evm.7 Latest Latest
Warning

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

 Go to latest Published: Aug 16, 2024 License: Apache-2.0 Imports: 43 Imported by: 0

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.

Copyright (c) 2023-2024 Nibi, Inc.

Copyright (c) 2023-2024 Nibi, Inc.

Index

Constants

View Source 
const DefaultGethTraceTimeout = 5 * time.Second

Re-export of the default tracer timeout from go-ethereum. See "geth/eth/tracers/api.go".

Variables

This section is empty.

Functions

func CheckSenderBalance 

func CheckSenderBalance(
	balanceWei *big.Int,
	txData evm.TxData,
) error

CheckSenderBalance validates that the tx cost value is positive and that the sender has enough funds to pay for the fees and value of the transaction.

func GasToRefund 

func GasToRefund(availableRefund, gasConsumed, refundQuotient uint64) uint64

GasToRefund calculates the amount of gas the state machine should refund to the sender. It is capped by the refund quotient value. Note: do not pass 0 to refundQuotient

func ParseProposerAddr 

func ParseProposerAddr(
	ctx sdk.Context, proposerAddress sdk.ConsAddress,
) sdk.ConsAddress

ParseProposerAddr returns current block proposer's address when provided proposer address is empty.

func ParseWeiAsMultipleOfMicronibi 

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

func VerifyFee 

func VerifyFee(
	txData evm.TxData,
	denom string,
	baseFee *big.Int,
	isCheckTx bool,
) (sdk.Coins, error)

VerifyFee is used to return the fee for the given transaction data in sdk.Coins. It checks that the gas limit is not reached, the gas limit is higher than the intrinsic gas and that the base fee is lower than the gas fee cap.

Types

type AccStatePrimaryKey 

type AccStatePrimaryKey = collections.Pair[gethcommon.Address, gethcommon.Hash]

type CodeHash 

type CodeHash = []byte

type ERC20BigInt 

type ERC20BigInt struct{ Value *big.Int }

ERC20BigInt: Unpacking type for "uint256" from Solidity.

type ERC20Bool 

type ERC20Bool struct{ Value bool }

type ERC20Metadata 

type ERC20Metadata struct {
	Name     string
	Symbol   string
	Decimals uint8
}

type ERC20String 

type ERC20String struct{ Value string }

type ERC20Uint8 

type ERC20Uint8 struct{ Value uint8 }

ERC20Uint8: Unpacking type for "uint8" from Solidity. This is only used in the "ERC20.decimals" function.

type EvmState 

type EvmState struct {
	ModuleParams collections.Item[evm.Params]

	// ContractBytecode: Map from (byte)code hash -> contract bytecode
	ContractBytecode collections.Map[CodeHash, []byte]

	// AccState: Map from eth address (account) and hash of a state key -> smart
	// contract state. Each contract essentially has its own key-value store.
	//
	//  - primary key (PK): (EthAddr+EthHash). The contract is the primary key
	//  because there's exactly one deployer and withdrawer.
	//  - value (V): State value bytes.
	AccState collections.Map[
		AccStatePrimaryKey,
		[]byte,
	]

	// BlockGasUsed: Gas used by Ethereum txs in the block (transient).
	BlockGasUsed collections.ItemTransient[uint64]
	// BlockLogSize: EVM tx log size for the block (transient).
	BlockLogSize collections.ItemTransient[uint64]
	// BlockTxIndex: EVM tx index for the block (transient).
	BlockTxIndex collections.ItemTransient[uint64]
	// BlockBloom: Bloom filters.
	BlockBloom collections.ItemTransient[[]byte]
}

EvmState isolates the key-value stores (collections) for the x/evm module.

func NewEvmState 

func NewEvmState(
	cdc codec.BinaryCodec,
	storeKey sdkstore.StoreKey,
	storeKeyTransient sdkstore.StoreKey,
) EvmState

func (EvmState) CalcBloomFromLogs 

func (state EvmState) CalcBloomFromLogs(
	ctx sdk.Context, newLogs []*gethcore.Log,
) (bloom gethcore.Bloom)

func (EvmState) GetBlockBloomTransient 

func (state EvmState) GetBlockBloomTransient(ctx sdk.Context) *big.Int

GetBlockBloomTransient returns bloom bytes for the current block height

func (EvmState) GetContractBytecode 

func (state EvmState) GetContractBytecode(
	ctx sdk.Context, codeHash []byte,
) (code []byte)

func (EvmState) SetAccCode 

func (state EvmState) SetAccCode(ctx sdk.Context, codeHash, code []byte)

func (EvmState) SetAccState 

func (state EvmState) SetAccState(
	ctx sdk.Context, addr gethcommon.Address, stateKey gethcommon.Hash, stateValue []byte,
)

SetState updates contract storage and deletes if the value is empty.

type FunTokenState 

type FunTokenState struct {
	collections.IndexedMap[[]byte, evm.FunToken, IndexesFunToken]
}

FunTokenState isolates the key-value stores (collections) for fungible token mappings. This struct is written as an extension of the default indexed map to add utility functions.

func NewFunTokenState 

func NewFunTokenState(
	cdc sdkcodec.BinaryCodec,
	storeKey storetypes.StoreKey,
) FunTokenState

func (FunTokenState) SafeInsert 

func (fun FunTokenState) SafeInsert(
	ctx sdk.Context, erc20 gethcommon.Address, bankDenom string, isMadeFromCoin bool,
) error

Insert adds an evm.FunToken to state with defensive validation. Errors if the given inputs would result in a corrupted evm.FunToken.

type IndexesFunToken 

type IndexesFunToken struct {
	// ERC20Addr (MultiIndex): Index FunToken by ERC-20 contract address.
	//  - indexing key (IK): ERC-20 addr
	//  - primary key (PK): FunToken ID
	//  - value (V): FunToken value
	ERC20Addr collections.MultiIndex[gethcommon.Address, []byte, evm.FunToken]

	// BankDenom (MultiIndex): Index FunToken by coin denomination
	//  - indexing key (IK): Coin denom
	//  - primary key (PK): FunToken ID
	//  - value (V): FunToken value
	BankDenom collections.MultiIndex[string, []byte, evm.FunToken]
}

IndexesFunToken: Abstraction for indexing over the FunToken store.

func (IndexesFunToken) IndexerList 

func (idxs IndexesFunToken) IndexerList() []collections.Indexer[[]byte, evm.FunToken]

type Keeper 

type Keeper struct {

	// EvmState isolates the key-value stores (collections) for the x/evm module.
	EvmState EvmState

	// FunTokens isolates the key-value stores (collections) for fungible token
	// mappings.
	FunTokens FunTokenState
	// contains filtered or unexported fields
}

func NewKeeper 

func NewKeeper(
	cdc codec.BinaryCodec,
	storeKey, transientKey storetypes.StoreKey,
	authority sdk.AccAddress,
	accKeeper evm.AccountKeeper,
	bankKeeper evm.BankKeeper,
	stakingKeeper evm.StakingKeeper,
	tracer string,
) Keeper

NewKeeper is a constructor for an x/evm Keeper. This function is necessary because the Keeper struct has private fields.

func (*Keeper) AddPrecompiles 

func (k *Keeper) AddPrecompiles(
	precompileMap map[gethcommon.Address]vm.PrecompiledContract,
)

func (*Keeper) AddToBlockGasUsed 

func (k *Keeper) AddToBlockGasUsed(
	ctx sdk.Context, gasUsed uint64,
) (uint64, error)

AddToBlockGasUsed accumulate gas used by each eth msgs included in current block tx.

func (*Keeper) ApplyEvmMsg 

func (k *Keeper) ApplyEvmMsg(ctx sdk.Context,
	msg core.Message,
	tracer vm.EVMLogger,
	commit bool,
	evmConfig *statedb.EVMConfig,
	txConfig statedb.TxConfig,
) (*evm.MsgEthereumTxResponse, error)

ApplyEvmMsg computes the new state by applying the given message against the existing state. If the message fails, the VM execution error with the reason will be returned to the client and the transaction won't be committed to the store.

Reverted state

The snapshot and rollback are supported by the `statedb.StateDB`.

Different Callers

It's called in three scenarios: 1. `ApplyTransaction`, in the transaction processing flow. 2. `EthCall/EthEstimateGas` grpc query handler. 3. Called by other native modules directly.

Prechecks and Preprocessing

All relevant state transition prechecks for the MsgEthereumTx are performed on the AnteHandler, prior to running the transaction against the state. The prechecks run are the following:

1. the nonce of the message caller is correct 2. caller has enough balance to cover transaction fee(gaslimit * gasprice) 3. the amount of gas required is available in the block 4. the purchased gas is enough to cover intrinsic usage 5. there is no overflow when calculating intrinsic gas 6. caller has enough balance to cover asset transfer for **topmost** call

The preprocessing steps performed by the AnteHandler are:

1. set up the initial access list

Tracer parameter

It should be a `vm.Tracer` object or nil, if pass `nil`, it'll create a default one based on keeper options.

Commit parameter

If commit is true, the `StateDB` will be committed, otherwise discarded.

func (*Keeper) ApplyEvmTx 

func (k *Keeper) ApplyEvmTx(
	ctx sdk.Context, tx *gethcore.Transaction,
) (*evm.MsgEthereumTxResponse, error)

func (Keeper) Balance 

func (k Keeper) Balance(goCtx context.Context, req *evm.QueryBalanceRequest) (*evm.QueryBalanceResponse, error)

Balance: Implements the gRPC query for "/eth.evm.v1.Query/Balance". Balance retrieves the balance of an Ethereum address in "wei", the smallest unit of "Ether". Ether refers to NIBI tokens on Nibiru EVM.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: The QueryBalanceRequest object containing the Ethereum address.

Returns:

  • A pointer to the QueryBalanceResponse object containing the balance.
  • An error if the balance retrieval process encounters any issues.

func (Keeper) BaseFee 

func (k Keeper) BaseFee(
	goCtx context.Context, _ *evm.QueryBaseFeeRequest,
) (*evm.QueryBaseFeeResponse, error)

BaseFee implements the Query/BaseFee gRPC method

func (*Keeper) BeginBlock 

func (k *Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock)

BeginBlock sets the sdk Context and EIP155 chain id to the Keeper.

func (Keeper) CallContract 

func (k Keeper) CallContract(
	ctx sdk.Context,
	abi *gethabi.ABI,
	fromAcc gethcommon.Address,
	contract *gethcommon.Address,
	commit bool,
	methodName string,
	args ...any,
) (evmResp *evm.MsgEthereumTxResponse, err error)

CallContract invokes a smart contract on the method specified by [methodName] using the given [args].

Parameters:

  • ctx: The SDK context for the transaction.
  • abi: The ABI (Application Binary Interface) of the smart contract.
  • fromAcc: The Ethereum address of the account initiating the contract call.
  • contract: Pointer to the Ethereum address of the contract to be called.
  • commit: Boolean flag indicating whether to commit the transaction (true) or simulate it (false).
  • methodName: The name of the contract method to be called.
  • args: Variadic parameter for the arguments to be passed to the contract method.

Note: This function handles both contract method calls and simulations, depending on the 'commit' parameter. It uses a default gas limit for simulations and estimates gas for actual transactions.

func (Keeper) CallContractWithInput 

func (k Keeper) CallContractWithInput(
	ctx sdk.Context,
	fromAcc gethcommon.Address,
	contract *gethcommon.Address,
	commit bool,
	contractInput []byte,
) (evmResp *evm.MsgEthereumTxResponse, err error)

CallContractWithInput invokes a smart contract with the given [contractInput].

Parameters:

  • ctx: The SDK context for the transaction.
  • fromAcc: The Ethereum address of the account initiating the contract call.
  • contract: Pointer to the Ethereum address of the contract to be called.
  • commit: Boolean flag indicating whether to commit the transaction (true) or simulate it (false).
  • contractInput: Hexadecimal-encoded bytes use as input data to the call.

Note: This function handles both contract method calls and simulations, depending on the 'commit' parameter. It uses a default gas limit for simulations and estimates gas for actual transactions.

func (Keeper) Code 

func (k Keeper) Code(
	goCtx context.Context, req *evm.QueryCodeRequest,
) (*evm.QueryCodeResponse, error)

Code: Implements the gRPC query for "/eth.evm.v1.Query/Code". Code retrieves the smart contract bytecode associated with a given Ethereum address.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: Request with the Ethereum address of the smart contract bytecode.

Returns:

  • Response containing the smart contract bytecode.
  • An error if the code retrieval process encounters any issues.

func (*Keeper) ConvertCoinToEvm 

func (k *Keeper) ConvertCoinToEvm(
	goCtx context.Context, msg *evm.MsgConvertCoinToEvm,
) (resp *evm.MsgConvertCoinToEvmResponse, err error)

ConvertCoinToEvm Sends a coin with a valid "FunToken" mapping to the given recipient address ("to_eth_addr") in the corresponding ERC20 representation.

func (*Keeper) CreateFunToken 

func (k *Keeper) CreateFunToken(
	goCtx context.Context, msg *evm.MsgCreateFunToken,
) (resp *evm.MsgCreateFunTokenResponse, err error)

CreateFunToken is a gRPC transaction message for creating fungible token ("FunToken") a mapping between a bank coin and ERC20 token.

If the mapping is generated from an ERC20, this tx creates a bank coin to go with it, and if the mapping's generated from a coin, the EVM module deploys an ERC20 contract that for which it will be the owner.

func (*Keeper) DeductTxCostsFromUserBalance 

func (k *Keeper) DeductTxCostsFromUserBalance(
	ctx sdk.Context,
	fees sdk.Coins,
	from gethcommon.Address,
) error

DeductTxCostsFromUserBalance deducts the fees from the user balance. Returns an error if the specified sender address does not exist or the account balance is not sufficient.

func (*Keeper) DeleteAccount 

func (k *Keeper) DeleteAccount(ctx sdk.Context, addr gethcommon.Address) error

DeleteAccount handles contract's suicide call, clearing the balance, contract bytecode, contract state, and its native account. Implements the `statedb.Keeper` interface. Only called by `StateDB.Commit()`.

func (Keeper) ERC20 

func (k Keeper) ERC20() erc20Calls

ERC20 returns a mutable reference to the keeper with an ERC20 contract ABI and Go functions corresponding to contract calls in the ERC20 standard like "mint" and "transfer" in the ERC20 standard.

func (*Keeper) EVMState 

func (k *Keeper) EVMState() EvmState

func (*Keeper) EndBlock 

func (k *Keeper) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate

EndBlock also retrieves the bloom filter value from the transient store and commits it to the KVStore. The EVM end block logic doesn't update the validator set, thus it returns an empty slice.

func (Keeper) EstimateGas 

func (k Keeper) EstimateGas(
	goCtx context.Context, req *evm.EthCallRequest,
) (*evm.EstimateGasResponse, error)

EstimateGas: Implements the gRPC query for "/eth.evm.v1.Query/EstimateGas". EstimateGas implements eth_estimateGas rpc api.

func (Keeper) EstimateGasForEvmCallType 

func (k Keeper) EstimateGasForEvmCallType(
	goCtx context.Context, req *evm.EthCallRequest, fromType evm.CallType,
) (*evm.EstimateGasResponse, error)

EstimateGasForEvmCallType estimates the gas cost of a transaction. This can be called with the "eth_estimateGas" JSON-RPC method or smart contract query.

When [EstimateGas] is called from the JSON-RPC client, we need to reset the gas meter before simulating the transaction (tx) to have an accurate gas estimate txs using EVM extensions.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: The EthCallRequest object containing the transaction parameters.

Returns:

  • A response containing the estimated gas cost.
  • An error if the gas estimation process encounters any issues.

func (Keeper) EthAccount 

func (k Keeper) EthAccount(
	goCtx context.Context, req *evm.QueryEthAccountRequest,
) (*evm.QueryEthAccountResponse, error)

EthAccount: Implements the gRPC query for "/eth.evm.v1.Query/EthAccount". EthAccount retrieves the account and balance details for an account with the given address.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: Request containing the address in either Ethereum hexadecimal or Bech32 format.

func (*Keeper) EthCall 

func (k *Keeper) EthCall(
	goCtx context.Context, req *evm.EthCallRequest,
) (*evm.MsgEthereumTxResponse, error)

EthCall: Implements the gRPC query for "/eth.evm.v1.Query/EthCall". EthCall performs a smart contract call using the eth_call JSON-RPC method.

An "eth_call" is a method from the Ethereum JSON-RPC specification that allows one to call a smart contract function without execution a transaction on the blockchain. This is useful for simulating transactions and for reading data from the chain using responses from smart contract calls.

Parameters:

  • goCtx: Request context with information about the current block that serves as the main access point to the blockchain state.
  • req: "eth_call" parameters to interact with a smart contract.

Returns:

  • A pointer to the MsgEthereumTxResponse object containing the result of the eth_call.
  • An error if the eth_call process encounters any issues.

func (Keeper) EthChainID 

func (k Keeper) EthChainID(ctx sdk.Context) *big.Int

func (*Keeper) EthereumTx 

func (k *Keeper) EthereumTx(
	goCtx context.Context, msg *evm.MsgEthereumTx,
) (resp *evm.MsgEthereumTxResponse, err error)

func (Keeper) FeeForCreateFunToken 

func (k Keeper) FeeForCreateFunToken(ctx sdk.Context) sdk.Coins

func (Keeper) FindERC20Metadata 

func (k Keeper) FindERC20Metadata(
	ctx sdk.Context,
	contract gethcommon.Address,
) (info *ERC20Metadata, err error)

FindERC20Metadata retrieves the metadata of an ERC20 token.

Parameters:

  • ctx: The SDK context for the transaction.
  • contract: The Ethereum address of the ERC20 contract.

Returns:

  • info: ERC20Metadata containing name, symbol, and decimals.
  • err: An error if metadata retrieval fails.

func (*Keeper) ForEachStorage 

func (k *Keeper) ForEachStorage(
	ctx sdk.Context,
	addr gethcommon.Address,
	stopIter func(key, value gethcommon.Hash) bool,
)

ForEachStorage: Iterator over contract storage. Implements the `statedb.Keeper` interface.

func (Keeper) FunTokenMapping 

func (k Keeper) FunTokenMapping(
	goCtx context.Context, req *evm.QueryFunTokenMappingRequest,
) (*evm.QueryFunTokenMappingResponse, error)

func (Keeper) GetAccNonce 

func (k Keeper) GetAccNonce(ctx sdk.Context, addr gethcommon.Address) uint64

GetAccNonce returns the sequence number of an account, returns 0 if not exists.

func (*Keeper) GetAccount 

func (k *Keeper) GetAccount(ctx sdk.Context, addr gethcommon.Address) *statedb.Account

GetAccount: Ethereum account getter for a statedb.Account. Implements the `statedb.Keeper` interface. Returns nil if the account does not exist or has the wrong type.

func (*Keeper) GetAccountOrEmpty 

func (k *Keeper) GetAccountOrEmpty(
	ctx sdk.Context, addr gethcommon.Address,
) statedb.Account

GetAccountOrEmpty returns empty account if not exist, returns error if it's not `EthAccount`

func (*Keeper) GetAccountWithoutBalance 

func (k *Keeper) GetAccountWithoutBalance(ctx sdk.Context, addr gethcommon.Address) *statedb.Account

GetAccountWithoutBalance load nonce and codehash without balance, more efficient in cases where balance is not needed.

func (Keeper) GetBaseFee 

func (k Keeper) GetBaseFee(ctx sdk.Context) *big.Int

func (*Keeper) GetCode 

func (k *Keeper) GetCode(ctx sdk.Context, codeHash gethcommon.Hash) []byte

GetCode: Loads smart contract bytecode. Implements the `statedb.Keeper` interface.

func (Keeper) GetCoinbaseAddress 

func (k Keeper) GetCoinbaseAddress(ctx sdk.Context, proposerAddress sdk.ConsAddress) (common.Address, error)

GetCoinbaseAddress returns the block proposer's validator operator address.

func (*Keeper) GetEVMConfig 

func (k *Keeper) GetEVMConfig(
	ctx sdk.Context, proposerAddress sdk.ConsAddress, chainID *big.Int,
) (*statedb.EVMConfig, error)

func (*Keeper) GetEthIntrinsicGas 

func (k *Keeper) GetEthIntrinsicGas(ctx sdk.Context, msg core.Message, cfg *params.ChainConfig, isContractCreation bool) (uint64, error)

GetEthIntrinsicGas returns the intrinsic gas cost for the transaction

func (*Keeper) GetEvmGasBalance 

func (k *Keeper) GetEvmGasBalance(ctx sdk.Context, addr gethcommon.Address) (balance *big.Int)

GetEvmGasBalance: Implements `evm.EVMKeeper` from "github.com/NibiruChain/nibiru/v2/app/ante/evm": Load account's balance of gas tokens for EVM execution in EVM denom units.

func (Keeper) GetHashFn 

func (k Keeper) GetHashFn(ctx sdk.Context) vm.GetHashFunc

GetHashFn implements vm.GetHashFunc for Ethermint. It handles 3 cases:

  1. The requested height matches the current height from context (and thus same epoch number)
  2. The requested height is from a previous height from the same chain epoch
  3. The requested height is from a height greater than the latest one

func (Keeper) GetMinGasMultiplier 

func (k Keeper) GetMinGasMultiplier(ctx sdk.Context) math.LegacyDec

GetMinGasMultiplier returns minimum gas multiplier.

func (Keeper) GetParams 

func (k Keeper) GetParams(ctx sdk.Context) (params evm.Params)

GetParams returns the total set of evm parameters.

func (*Keeper) GetState 

func (k *Keeper) GetState(ctx sdk.Context, addr gethcommon.Address, stateKey gethcommon.Hash) gethcommon.Hash

GetState: Implements `statedb.Keeper` interface: Loads smart contract state.

func (Keeper) IsAvailablePrecompile 

func (k Keeper) IsAvailablePrecompile(address gethcommon.Address) bool

IsAvailablePrecompile returns true if the given precompile address is contained in the EVM keeper's available precompiles map.

func (Keeper) LoadERC20BigInt 

func (k Keeper) LoadERC20BigInt(
	ctx sdk.Context,
	abi *gethabi.ABI,
	contract gethcommon.Address,
	methodName string,
	args ...any,
) (out *big.Int, err error)

func (Keeper) LoadERC20Decimals 

func (k Keeper) LoadERC20Decimals(
	ctx sdk.Context, abi *gethabi.ABI, erc20 gethcommon.Address,
) (out uint8, err error)

func (Keeper) LoadERC20Name 

func (k Keeper) LoadERC20Name(
	ctx sdk.Context, abi *gethabi.ABI, erc20 gethcommon.Address,
) (out string, err error)

func (Keeper) LoadERC20String 

func (k Keeper) LoadERC20String(
	ctx sdk.Context,
	erc20Abi *gethabi.ABI,
	erc20Contract gethcommon.Address,
	methodName string,
) (out string, err error)

func (Keeper) LoadERC20Symbol 

func (k Keeper) LoadERC20Symbol(
	ctx sdk.Context, abi *gethabi.ABI, erc20 gethcommon.Address,
) (out string, err error)

func (Keeper) Logger 

func (k Keeper) Logger(ctx sdk.Context) log.Logger

Logger returns a module-specific logger.

func (*Keeper) NewEVM 

func (k *Keeper) NewEVM(
	ctx sdk.Context,
	msg core.Message,
	evmConfig *statedb.EVMConfig,
	tracer vm.EVMLogger,
	stateDB vm.StateDB,
) *vm.EVM

NewEVM generates a go-ethereum VM.

Args:

  • ctx: Consensus and KV store info for the current block.
  • msg: Ethereum message sent to a contract
  • cfg: Encapsulates params required to construct an EVM.
  • tracer: Collects execution traces for EVM transaction logging.
  • stateDB: Holds the EVM state.

func (Keeper) Params 

func (k Keeper) Params(
	goCtx context.Context, _ *evm.QueryParamsRequest,
) (*evm.QueryParamsResponse, error)

Params: Implements the gRPC query for "/eth.evm.v1.Query/Params". Params retrieves the EVM module parameters.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: The QueryParamsRequest object (unused).

Returns:

  • A pointer to the QueryParamsResponse object containing the EVM module parameters.
  • An error if the parameter retrieval process encounters any issues.

func (*Keeper) RefundGas 

func (k *Keeper) RefundGas(ctx sdk.Context, msg core.Message, leftoverGas uint64, denom string) error

RefundGas transfers the leftover gas to the sender of the message, caped to half of the total gas consumed in the transaction. Additionally, the function sets the total gas consumed to the value returned by the EVM execution, thus ignoring the previous intrinsic gas consumed during in the AnteHandler.

func (*Keeper) ResetGasMeterAndConsumeGas 

func (k *Keeper) ResetGasMeterAndConsumeGas(ctx sdk.Context, gasUsed uint64)

ResetGasMeterAndConsumeGas reset first the gas meter consumed value to zero and set it back to the new value 'gasUsed'

func (*Keeper) ResetTransientGasUsed 

func (k *Keeper) ResetTransientGasUsed(ctx sdk.Context)

ResetTransientGasUsed resets gas to prepare for the next block of execution. Called in an ante handler.

func (*Keeper) SetAccBalance 

func (k *Keeper) SetAccBalance(
	ctx sdk.Context, addr gethcommon.Address, amountEvmDenom *big.Int,
) error

SetAccBalance update account's balance, compare with current balance first, then decide to mint or burn.

func (*Keeper) SetAccount 

func (k *Keeper) SetAccount(
	ctx sdk.Context, addr gethcommon.Address, account statedb.Account,
) error

SetAccount: Updates nonce, balance, and codeHash. Implements the `statedb.Keeper` interface. Only called by `StateDB.Commit()`.

func (*Keeper) SetCode 

func (k *Keeper) SetCode(ctx sdk.Context, codeHash, code []byte)

SetCode: Setter for smart contract bytecode. Delete if code is empty. Implements the `statedb.Keeper` interface. Only called by `StateDB.Commit()`.

func (Keeper) SetParams 

func (k Keeper) SetParams(ctx sdk.Context, params evm.Params)

SetParams: Setter for the module parameters.

func (*Keeper) SetState 

func (k *Keeper) SetState(
	ctx sdk.Context, addr gethcommon.Address, stateKey gethcommon.Hash, stateValue []byte,
)

SetState: Update contract storage, delete if value is empty. Implements the `statedb.Keeper` interface. Only called by `StateDB.Commit()`.

func (Keeper) Storage 

func (k Keeper) Storage(
	goCtx context.Context, req *evm.QueryStorageRequest,
) (*evm.QueryStorageResponse, error)

Storage: Implements the gRPC query for "/eth.evm.v1.Query/Storage". Storage retrieves the storage value for a given Ethereum address and key.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: The QueryStorageRequest object containing the Ethereum address and key.

Returns:

  • A pointer to the QueryStorageResponse object containing the storage value.
  • An error if the storage retrieval process encounters any issues.

func (Keeper) TraceBlock 

func (k Keeper) TraceBlock(
	goCtx context.Context, req *evm.QueryTraceBlockRequest,
) (*evm.QueryTraceBlockResponse, error)

TraceBlock: Implements the gRPC query for "/eth.evm.v1.Query/TraceBlock". Configures a Nibiru EVM tracer that is used to "trace" and analyze the execution of transactions within a given block. Block information is read from the context (goCtx). [TraceBlock] is responsible iterates over each Eth transacion message and calls [TraceEthTxMsg] on it.

func (*Keeper) TraceEthTxMsg 

func (k *Keeper) TraceEthTxMsg(
	ctx sdk.Context,
	cfg *statedb.EVMConfig,
	txConfig statedb.TxConfig,
	signer gethcore.Signer,
	tx *gethcore.Transaction,
	traceConfig *evm.TraceConfig,
	commitMessage bool,
	tracerJSONConfig json.RawMessage,
) (*interface{}, uint, error)

TraceEthTxMsg do trace on one transaction, it returns a tuple: (traceResult, nextLogIndex, error).

func (Keeper) TraceTx 

func (k Keeper) TraceTx(
	goCtx context.Context, req *evm.QueryTraceTxRequest,
) (*evm.QueryTraceTxResponse, error)

TraceTx configures a new tracer according to the provided configuration, and executes the given message in the provided environment. The return value will be tracer dependent.

func (Keeper) Tracer 

func (k Keeper) Tracer(
	ctx sdk.Context, msg core.Message, ethCfg *gethparams.ChainConfig,
) vm.EVMLogger

Tracer return a default vm.Tracer based on current keeper state

func (*Keeper) TxConfig 

func (k *Keeper) TxConfig(
	ctx sdk.Context, txHash common.Hash,
) statedb.TxConfig

TxConfig loads `TxConfig` from current transient storage

func (*Keeper) UpdateParams 

func (k *Keeper) UpdateParams(
	goCtx context.Context, req *evm.MsgUpdateParams,
) (resp *evm.MsgUpdateParamsResponse, err error)

func (Keeper) VMConfig 

func (k Keeper) VMConfig(
	ctx sdk.Context, _ core.Message, cfg *statedb.EVMConfig, tracer vm.EVMLogger,
) vm.Config

VMConfig creates an EVM configuration from the debug setting and the extra EIPs enabled on the module parameters. The config generated uses the default JumpTable from the EVM.

func (Keeper) ValidatorAccount 

func (k Keeper) ValidatorAccount(
	goCtx context.Context, req *evm.QueryValidatorAccountRequest,
) (*evm.QueryValidatorAccountResponse, error)

ValidatorAccount: Implements the gRPC query for "/eth.evm.v1.Query/ValidatorAccount". ValidatorAccount retrieves the account details for a given validator consensus address.

Parameters:

  • goCtx: The context.Context object representing the request context.
  • req: Request containing the validator consensus address.

Returns:

  • Response containing the account details.
  • An error if the account retrieval process encounters any issues.

Source Files

View all Source files

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.