Merge remote-tracking branch 'origin/main' into cosmos_override

Author: mmsqe

CHANGELOG.md

@@ -52,6 +52,7 @@
 - [\#684](https://github.com/cosmos/evm/pull/684) Add unit test cases for EIP-7702
 - [\#685](https://github.com/cosmos/evm/pull/685) Add EIP-7702 e2e test
 - [\#680](https://github.com/cosmos/evm/pull/680) Introduce a `StaticPrecompiles` builder
+- [\#691](https://github.com/cosmos/evm/pull/691) Add debug_traceCall api
 - [\#701](https://github.com/cosmos/evm/pull/701) Add address codec support to ERC20 IBC callbacks to handle hex addresses in addition to bech32 addresses.
 - [\#702](https://github.com/cosmos/evm/pull/702) Fix mempool e2e test
 - [\#704](https://github.com/cosmos/evm/pull/704) Fix EIP-7702 test cases

Makefile

@@ -381,6 +381,7 @@ test-rpc-compat-stop:
 test-system: build-v04 build
 	mkdir -p ./tests/systemtests/binaries/
 	cp $(BUILDDIR)/evmd ./tests/systemtests/binaries/
+	cd tests/systemtests/Counter && forge build
 	$(MAKE) -C tests/systemtests test
 
 build-v04:

api/cosmos/evm/vm/v1/query.pulsar.go

@@ -75,6 +75,11 @@ service Query {
     option (google.api.http).get = "/cosmos/evm/vm/v1/trace_block";
   }
 
+  // TraceCall implements the `debug_traceCall` rpc api
+  rpc TraceCall(QueryTraceCallRequest) returns (QueryTraceCallResponse) {
+    option (google.api.http).get = "/cosmos/evm/vm/v1/trace_call";
+  }
+
   // BaseFee queries the base fee of the parent block of the current block,
   // it's similar to feemarket module's method, but also checks london hardfork
   // status.
@@ -358,6 +363,32 @@ message QueryTraceBlockResponse {
   bytes data = 1;
 }
 
+// QueryTraceCallRequest defines TraceCall request
+message QueryTraceCallRequest {
+  // args uses the same json format as the json rpc api.
+  bytes args = 1;
+  // gas_cap defines the default gas cap to be used
+  uint64 gas_cap = 2;
+  // proposer_address of the requested block in hex format
+  bytes proposer_address = 3 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ConsAddress"];
+  // trace_config holds extra parameters to trace functions.
+  TraceConfig trace_config = 4;
+  // block_number of requested transaction
+  int64 block_number = 5;
+  // block_hash of requested transaction
+  string block_hash = 6;
+  // block_time of requested transaction
+  google.protobuf.Timestamp block_time = 7 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  // chain_id is the the eip155 chain id parsed from the requested block header
+  int64 chain_id = 8;
+}
+
+// QueryTraceCallResponse defines TraceCall response
+message QueryTraceCallResponse {
+  // data is the response serialized in bytes
+  bytes data = 1;
+}
+
 // QueryBaseFeeRequest defines the request type for querying the EIP1559 base
 // fee.
 message QueryBaseFeeRequest {}

api/cosmos/evm/vm/v1/query_grpc.pb.go

@@ -134,6 +134,7 @@ type EVMBackend interface {
 	// Tracing
 	TraceTransaction(hash common.Hash, config *types.TraceConfig) (interface{}, error)
 	TraceBlock(height types.BlockNumber, config *types.TraceConfig, block *tmrpctypes.ResultBlock) ([]*evmtypes.TxTraceResult, error)
+	TraceCall(args evmtypes.TransactionArgs, blockNrOrHash types.BlockNumberOrHash, config *types.TraceConfig) (interface{}, error)
 }
 
 var _ BackendI = (*Backend)(nil)

proto/cosmos/evm/vm/v1/query.proto

@@ -210,6 +210,8 @@ func (b *Backend) FeeHistory(
 
 	thisBaseFee := make([]*hexutil.Big, blocks+1)
 	thisGasUsedRatio := make([]float64, blocks)
+	thisBlobBaseFee := make([]*hexutil.Big, blocks+1)
+	thisBlobGasUsedRatio := make([]float64, blocks)
 
 	// rewards should only be calculated if reward percentiles were included
 	calculateRewards := rewardCount != 0
@@ -274,6 +276,11 @@ func (b *Backend) FeeHistory(
 					thisBaseFee[index+1] = (*hexutil.Big)(oneFeeHistory.NextBaseFee)
 				}
 				thisGasUsedRatio[index] = oneFeeHistory.GasUsedRatio
+				thisBlobBaseFee[index] = (*hexutil.Big)(oneFeeHistory.BlobBaseFee)
+				if int(index) == len(thisBlobBaseFee)-2 {
+					thisBlobBaseFee[index+1] = (*hexutil.Big)(oneFeeHistory.NextBlobBaseFee)
+				}
+				thisBlobGasUsedRatio[index] = oneFeeHistory.BlobGasUsedRatio
 				if calculateRewards {
 					for j := 0; j < rewardCount; j++ {
 						reward[index][j] = (*hexutil.Big)(oneFeeHistory.Reward[j])
@@ -296,9 +303,11 @@ func (b *Backend) FeeHistory(
 	}
 
 	feeHistory := rpctypes.FeeHistoryResult{
-		OldestBlock:  oldestBlock,
-		BaseFee:      thisBaseFee,
-		GasUsedRatio: thisGasUsedRatio,
+		OldestBlock:      oldestBlock,
+		BaseFee:          thisBaseFee,
+		GasUsedRatio:     thisGasUsedRatio,
+		BlobBaseFee:      thisBlobBaseFee,
+		BlobGasUsedRatio: thisBlobGasUsedRatio,
 	}
 
 	if calculateRewards {

rpc/backend/backend.go

@@ -116,7 +116,8 @@ func (b *Backend) TraceTransaction(hash common.Hash, config *rpctypes.TraceConfi
 	// minus one to get the context of block beginning
 	contextHeight := transaction.Height - 1
 	if contextHeight < 1 {
-		// 0 is a special value in `ContextWithHeight`
+		// In Ethereum, the genesis block height is 0, but in CometBFT, the genesis block height is 1.
+		// So here we set the minimum requested height to 1.
 		contextHeight = 1
 	}
 	traceResult, err := b.QueryClient.TraceTx(rpctypes.ContextWithHeight(contextHeight), &traceTxRequest)
@@ -229,3 +230,69 @@ func (b *Backend) TraceBlock(height rpctypes.BlockNumber,
 
 	return decodedResults, nil
 }
+
+// TraceCall executes a call with the given arguments and returns the structured logs
+// created during the execution of EVM. It returns them as a JSON object.
+func (b *Backend) TraceCall(
+	args evmtypes.TransactionArgs,
+	blockNrOrHash rpctypes.BlockNumberOrHash,
+	config *rpctypes.TraceConfig,
+) (interface{}, error) {
+	// Marshal tx args
+	bz, err := json.Marshal(&args)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get block number from blockNrOrHash
+	blockNr, err := b.BlockNumberFromComet(blockNrOrHash)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the block to get necessary context
+	header, err := b.CometHeaderByNumber(blockNr)
+	if err != nil {
+		b.Logger.Debug("block not found", "number", blockNr)
+		return nil, err
+	}
+
+	traceCallRequest := evmtypes.QueryTraceCallRequest{
+		Args:            bz,
+		GasCap:          b.RPCGasCap(),
+		ProposerAddress: sdk.ConsAddress(header.Header.ProposerAddress),
+		BlockNumber:     header.Header.Height,
+		BlockHash:       common.Bytes2Hex(header.Header.Hash()),
+		BlockTime:       header.Header.Time,
+		ChainId:         b.EvmChainID.Int64(),
+	}
+
+	if config != nil {
+		traceCallRequest.TraceConfig = b.convertConfig(config)
+	}
+
+	// get the context of provided block
+	contextHeight := header.Header.Height
+	if contextHeight < 1 {
+		// In Ethereum, the genesis block height is 0, but in CometBFT, the genesis block height is 1.
+		// So here we set the minimum requested height to 1.
+		contextHeight = 1
+	}
+
+	// Use the block height as context for the query
+	ctxWithHeight := rpctypes.ContextWithHeight(contextHeight)
+	traceResult, err := b.QueryClient.TraceCall(ctxWithHeight, &traceCallRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	// Response format is unknown due to custom tracer config param
+	// More information can be found here https://geth.ethereum.org/docs/dapp/tracing-filtered
+	var decodedResult interface{}
+	err = json.Unmarshal(traceResult.Data, &decodedResult)
+	if err != nil {
+		return nil, err
+	}
+
+	return decodedResult, nil
+}