Vm

vm/├── client│   └── cli│       ├── query.go      # CLI query commands for the module│       └── tx.go         # CLI transaction commands for the module├── keeper│   ├── keeper.go         # ABCI BeginBlock and EndBlock logic│   ├── keeper.go         # Store keeper that handles the business logic of the module and has access to a specific subtree of the state tree.│   ├── params.go         # Parameter getter and setter│   ├── querier.go        # State query functions│   └── statedb.go        # Functions from types/statedb with a passed in sdk.Context├── types│   ├── chain_config.go│   ├── codec.go          # Type registration for encoding│   ├── errors.go         # Module-specific errors│   ├── events.go         # Events exposed to the CometBFT PubSub/Websocket│   ├── genesis.go        # Genesis state for the module│   ├── journal.go        # Ethereum Journal of state transitions│   ├── keys.go           # Store keys and utility functions│   ├── logs.go           # Types for persisting Ethereum tx logs on state after chain upgrades│   ├── msg.go            # EVM module transaction messages│   ├── params.go         # Module parameters that can be customized with governance parameter change proposals│   ├── state_object.go   # EVM state object│   ├── statedb.go        # Implementation of the StateDb interface│   ├── storage.go        # Implementation of the Ethereum state storage map using arrays to prevent non-determinism│   └── tx_data.go        # Ethereum transaction data types├── genesis.go            # ABCI InitGenesis and ExportGenesis functionality├── handler.go            # Message routing└── module.go             # Module setup for the module manager

// github.com/ethereum/go-ethereum/core/vm/interface.gotype StateDB interface { CreateAccount(common.Address) SubBalance(common.Address, *big.Int) AddBalance(common.Address, *big.Int) GetBalance(common.Address) *big.Int GetNonce(common.Address) uint64 SetNonce(common.Address, uint64) GetCodeHash(common.Address) common.Hash GetCode(common.Address) []byte SetCode(common.Address, []byte) GetCodeSize(common.Address) int AddRefund(uint64) SubRefund(uint64) GetRefund() uint64 GetCommittedState(common.Address, common.Hash) common.Hash GetState(common.Address, common.Hash) common.Hash SetState(common.Address, common.Hash, common.Hash) Suicide(common.Address) bool HasSuicided(common.Address) bool // Exist reports whether the given account exists in state. // Notably this should also return true for suicided accounts. Exist(common.Address) bool // Empty returns whether the given account is empty. Empty // is defined according to EIP161 (balance = nonce = code = 0). Empty(common.Address) bool PrepareAccessList(sender common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList) AddressInAccessList(addr common.Address) bool SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool) // AddAddressToAccessList adds the given address to the access list. This operation is safe to perform // even if the feature/fork is not active yet AddAddressToAccessList(addr common.Address) // AddSlotToAccessList adds the given (address,slot) to the access list. This operation is safe to perform // even if the feature/fork is not active yet AddSlotToAccessList(addr common.Address, slot common.Hash) RevertToSnapshot(int) Snapshot() int AddLog(*types.Log) AddPreimage(common.Hash, []byte) ForEachStorage(common.Address, func(common.Hash, common.Hash) bool) error}

type Keeper struct { // Protobuf codec cdc codec.BinaryCodec // Store key required for the EVM Prefix KVStore. It is required by: // - storing account's Storage State // - storing account's Code // - storing Bloom filters by block height. Needed for the Web3 API. // For the full list, check the module specification storeKey sdk.StoreKey // key to access the transient store, which is reset on every block during Commit transientKey sdk.StoreKey // module specific parameter space that can be configured through governance paramSpace paramtypes.Subspace // access to account state accountKeeper types.AccountKeeper // update balance and accounting operations with coins bankKeeper types.BankKeeper // access historical headers for EVM state transition execution stakingKeeper types.StakingKeeper // fetch EIP1559 base fee and parameters feeMarketKeeper types.FeeMarketKeeper // chain ID number obtained from the context's chain id eip155ChainID *big.Int // Tracer used to collect execution traces from the EVM transaction execution tracer string // trace EVM state transition execution. This value is obtained from the `--trace` flag. // For more info check https://geth.ethereum.org/docs/dapp/tracing debug bool // EVM Hooks for tx post-processing hooks types.EvmHooks}

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"`}

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"`}

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

// AsTransaction creates an Ethereum Transaction type from the msg fieldsfunc (msg MsgEthereumTx) AsTransaction() *ethtypes.Transaction { txData, err := UnpackTxData(msg.Data) if err != nil {  return nil } return ethtypes.NewTx(txData.AsEthereumData())}// AsMessage returns the transaction as a core.Message.func (tx *Transaction) AsMessage(s Signer, baseFee *big.Int) (Message, error) { msg := Message{  nonce:      tx.Nonce(),  gasLimit:   tx.Gas(),  gasPrice:   new(big.Int).Set(tx.GasPrice()),  gasFeeCap:  new(big.Int).Set(tx.GasFeeCap()),  gasTipCap:  new(big.Int).Set(tx.GasTipCap()),  to:         tx.To(),  amount:     tx.Value(),  data:       tx.Data(),  accessList: tx.AccessList(),  isFake:     false, } // If baseFee provided, set gasPrice to effectiveGasPrice. if baseFee != nil {  msg.gasPrice = math.BigMin(msg.gasPrice.Add(msg.gasTipCap, baseFee), msg.gasFeeCap) } var err error msg.from, err = Sender(s, tx) return msg, err}

// 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// EIP-155 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 keyringfunc (msg *MsgEthereumTx) Sign(ethSigner ethtypes.Signer, keyringSigner keyring.Signer) error { from := msg.GetFrom() if from.Empty() {  return fmt.Errorf("sender address not defined for message") } tx := msg.AsTransaction() txHash := ethSigner.Hash(tx) sig, _, err := keyringSigner.SignByAddress(from, txHash.Bytes()) if err != nil {  return err } tx, err = tx.WithSignature(ethSigner, sig) if err != nil {  return err } msg.FromEthereumTx(tx) return nil}

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 *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.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"` // 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 *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` // input defines the data payload bytes of the transaction. Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` // v defines the signature value V []byte `protobuf:"bytes,7,opt,name=v,proto3" json:"v,omitempty"` // r defines the signature value R []byte `protobuf:"bytes,8,opt,name=r,proto3" json:"r,omitempty"` // s define the signature value S []byte `protobuf:"bytes,9,opt,name=s,proto3" json:"s,omitempty"`}

type DynamicFeeTx struct { // destination EVM chain ID ChainID *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/cosmos/cosmos-sdk/types.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 *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=gas_tip_cap,json=gasTipCap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"gas_tip_cap,omitempty"` // gas fee cap defines the max value for the gas fee GasFeeCap *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=gas_fee_cap,json=gasFeeCap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.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"` // 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 *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` // input defines the data payload bytes of the transaction. Data     []byte     `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"` Accesses AccessList `protobuf:"bytes,9,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"` // v defines the signature value V []byte `protobuf:"bytes,10,opt,name=v,proto3" json:"v,omitempty"` // r defines the signature value R []byte `protobuf:"bytes,11,opt,name=r,proto3" json:"r,omitempty"` // s define the signature value S []byte `protobuf:"bytes,12,opt,name=s,proto3" json:"s,omitempty"`}

type AccessListTx struct { // destination EVM chain ID ChainID *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/cosmos/cosmos-sdk/types.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 *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.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"` // hex formatted address of the recipient To string `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"` // value defines the unsigned integer value of the transaction amount. Amount *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` // input defines the data payload bytes of the transaction. Data     []byte     `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` Accesses AccessList `protobuf:"bytes,8,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"` // v defines the signature value V []byte `protobuf:"bytes,9,opt,name=v,proto3" json:"v,omitempty"` // r defines the signature value R []byte `protobuf:"bytes,10,opt,name=r,proto3" json:"r,omitempty"` // s define the signature value S []byte `protobuf:"bytes,11,opt,name=s,proto3" json:"s,omitempty"`}

type EvmHooks interface { // Must be called after tx is processed successfully, if return an error, the whole transaction is reverted. PostTxProcessing(ctx sdk.Context, msg core.Message, receipt *ethtypes.Receipt) error}

func (k *Keeper) PostTxProcessing(ctx sdk.Context, msg core.Message, receipt *ethtypes.Receipt) error { if k.hooks == nil {  return nil } return k.hooks.PostTxProcessing(k.Ctx(), msg, receipt)}

event Transfer(address indexed from, address indexed to, uint256 value);function _transfer(address sender, address recipient, uint256 amount) internal virtual {  require(sender != address(0), "ERC20: transfer from the zero address");  require(recipient != address(0), "ERC20: transfer to the zero address");  _beforeTokenTransfer(sender, recipient, amount);  _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");  _balances[recipient] = _balances[recipient].add(amount);  emit Transfer(sender, recipient, amount);}

const ERC20EventTransfer = "Transfer"// PostTxProcessing implements EvmHooks.PostTxProcessingfunc (k Keeper) PostTxProcessing( ctx sdk.Context, msg core.Message, receipt *ethtypes.Receipt,) error { params := h.k.GetParams(ctx) if !params.EnableErc20 || !params.EnableEVMHook {  // no error is returned to allow for other post-processing txs  // to pass  return nil } erc20 := contracts.ERC20BurnableContract.ABI for i, log := range receipt.Logs {  if len(log.Topics) < 3 {   continue  }  eventID := log.Topics[0] // event ID  event, err := erc20.EventByID(eventID)  if err != nil {   // invalid event for ERC20   continue  }  if event.Name != types.ERC20EventTransfer {   h.k.Logger(ctx).Info("emitted event", "name", event.Name, "signature", event.Sig)   continue  }  transferEvent, err := erc20.Unpack(event.Name, log.Data)  if err != nil {   h.k.Logger(ctx).Error("failed to unpack transfer event", "error", err.Error())   continue  }  if len(transferEvent) == 0 {   continue  }  tokens, ok := transferEvent[0].(*big.Int)  // safety check and ignore if amount not positive  if !ok || tokens == nil || tokens.Sign() != 1 {   continue  }  // check that the contract is a registered token pair  contractAddr := log.Address  id := h.k.GetERC20Map(ctx, contractAddr)  if len(id) == 0 {   // no token is registered for the caller contract   continue  }  pair, found := h.k.GetTokenPair(ctx, id)  if !found {   continue  }  // check that conversion for the pair is enabled  if !pair.Enabled {   // continue to allow transfers for the ERC20 in case the token pair is disabled   h.k.Logger(ctx).Debug(    "ERC20 token -> Cosmos coin conversion is disabled for pair",    "coin", pair.Denom, "contract", pair.Erc20Address,   )   continue  }  // ignore as the burning always transfers to the zero address  to := common.BytesToAddress(log.Topics[2].Bytes())  if !bytes.Equal(to.Bytes(), types.ModuleAddress.Bytes()) {   continue  }  // check that the event is Burn from the ERC20Burnable interface  // NOTE: assume that if they are burning the token that has been registered as a pair, they want to mint a Cosmos coin  // create the corresponding sdk.Coin that is paired with ERC20  coins := sdk.Coins{{Denom: pair.Denom, Amount: sdk.NewIntFromBigInt(tokens)}}  // Mint the coin only if ERC20 is external  switch pair.ContractOwner {  case types.OWNER_MODULE:   _, err = h.k.CallEVM(ctx, erc20, types.ModuleAddress, contractAddr, true, "burn", tokens)  case types.OWNER_EXTERNAL:   err = h.k.bankKeeper.MintCoins(ctx, types.ModuleName, coins)  default:   err = types.ErrUndefinedOwner  }  if err != nil {   h.k.Logger(ctx).Debug(    "failed to process EVM hook for ER20 -> coin conversion",    "coin", pair.Denom, "contract", pair.Erc20Address, "error", err.Error(),   )   continue  }  // Only need last 20 bytes from log.topics  from := common.BytesToAddress(log.Topics[1].Bytes())  recipient := sdk.AccAddress(from.Bytes())  // transfer the tokens from ModuleAccount to sender address  if err := h.k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipient, coins); err != nil {   h.k.Logger(ctx).Debug(    "failed to process EVM hook for ER20 -> coin conversion",    "tx-hash", receipt.TxHash.Hex(), "log-idx", i,    "coin", pair.Denom, "contract", pair.Erc20Address, "error", err.Error(),   )   continue  } } return nil

app.EvmKeeper = app.EvmKeeper.SetHooks(app.Erc20Keeper)

appd query evm code ADDRESS [flags]

# Example$ appd query evm code 0x7bf7b17da59880d9bcca24915679668db75f9397# Outputcode: "0xef616c92f3cfc9e92dc270d6acff9cea213cecc7020a76ee4395af09bdceb4837a1ebdb5735e11e7d3adb6104e0c3ac55180b4ddf5e54d022cc5e8837f6a4f971b"

appd query evm storage ADDRESS KEY [flags]

# Example$ appd query evm storage 0x0f54f47bf9b8e317b214ccd6a7c3e38b893cd7f0 0 --height 0# Outputvalue: "0x0000000000000000000000000000000000000000000000000000000000000000"

appd tx evm raw TX_HEX [flags]

# Example$ appd tx evm raw 0xf9ff74c86aefeb5f6019d77280bbb44fb695b4d45cfe97e6eed7acd62905f4a85034d5c68ed25a2e7a8eeb9baf1b84# Outputvalue: "0x0000000000000000000000000000000000000000000000000000000000000000"