apply

Author: mmsqe

rpc/backend/call_tx.go

@@ -372,19 +372,6 @@ func (b *Backend) DoCall(
 		return nil, errors.New("header not found")
 	}
 
-	var bzOverrides []byte
-	if overrides != nil {
-		bzOverrides = *overrides
-	}
-
-	req := evmtypes.EthCallRequest{
-		Args:            bz,
-		GasCap:          b.RPCGasCap(),
-		ProposerAddress: sdk.ConsAddress(header.Header.ProposerAddress),
-		ChainId:         b.EvmChainID.Int64(),
-		Overrides:       bzOverrides,
-	}
-
 	// From ContextWithHeight: if the provided height is 0,
 	// it will return an empty context and the gRPC query will use
 	// the latest block height for querying.
@@ -404,6 +391,36 @@ func (b *Backend) DoCall(
 	// this makes sure resources are cleaned up.
 	defer cancel()
 
+	var isDynamic bool
+	if args.To != nil {
+		precompileReq := &evmtypes.QueryPrecompileRequest{Address: args.To.Hex()}
+		if res, err := b.QueryClient.Precompile(ctx, precompileReq); err == nil {
+			isDynamic = res.IsPrecompile && !res.IsStatic
+		}
+	}
+
+	evmOverrides, cosmosOverrides, err := rpctypes.ParseOverrides(overrides, isDynamic)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse overrides: %w", err)
+	}
+
+	var bzOverrides []byte
+	if evmOverrides != nil {
+		bzOverrides, err = json.Marshal(evmOverrides)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal EVM overrides: %w", err)
+		}
+	}
+
+	req := evmtypes.EthCallRequest{
+		Args:            bz,
+		GasCap:          b.RPCGasCap(),
+		ProposerAddress: sdk.ConsAddress(header.Header.ProposerAddress),
+		ChainId:         b.EvmChainID.Int64(),
+		Overrides:       bzOverrides,
+		StateOverrides:  cosmosOverrides,
+	}
+
 	res, err := b.QueryClient.EthCall(ctx, &req)
 	if err != nil {
 		return nil, err

rpc/types/types.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"math/big"
@@ -189,3 +190,65 @@ type TraceConfig struct {
 	evmtypes.TraceConfig
 	TracerConfig json.RawMessage `json:"tracerConfig"`
 }
+
+// ParseOverrides attempts to parse overrides as StateOverride
+// If isDynamicPrecompile is true, it will handle aligned cosmos override format for the target dynamic precompile
+func ParseOverrides(overrides *json.RawMessage, isDynamicPrecompile bool) (*StateOverride, []evmtypes.StoreStateDiff, error) {
+	if overrides == nil {
+		return nil, nil, nil
+	}
+
+	if isDynamicPrecompile {
+		var rawOverrides map[string]interface{}
+		if err := json.Unmarshal(*overrides, &rawOverrides); err == nil {
+			for _, encodedData := range rawOverrides {
+				if overrideAccount, ok := encodedData.(map[string]interface{}); ok {
+					if cosmosOverrides := extractFromOverrideAccount(overrideAccount); cosmosOverrides != nil {
+						return nil, cosmosOverrides, nil
+					}
+				}
+				if encodedStr, ok := encodedData.(string); ok {
+					if cosmosOverrides := decodeCosmosOverrides(encodedStr); cosmosOverrides != nil {
+						return nil, cosmosOverrides, nil
+					}
+				}
+			}
+		}
+	}
+
+	var res StateOverride
+	if err := json.Unmarshal(*overrides, &res); err != nil {
+		return nil, nil, fmt.Errorf("failed to parse overrides: %w", err)
+	}
+	if len(res) == 0 {
+		return nil, nil, nil
+	}
+	return &res, nil, nil
+}
+
+// extractFromOverrideAccount extracts cosmos overrides from state/stateDiff fields
+func extractFromOverrideAccount(overrideAccount map[string]interface{}) []evmtypes.StoreStateDiff {
+	for stateType, stateValue := range overrideAccount {
+		if (stateType == "state" || stateType == "stateDiff") && stateValue != nil {
+			if encodedStr, ok := stateValue.(string); ok {
+				if cosmosOverrides := decodeCosmosOverrides(encodedStr); cosmosOverrides != nil {
+					return cosmosOverrides
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// decodeCosmosOverrides decodes base64 string and unmarshals cosmos overrides
+func decodeCosmosOverrides(encodedStr string) []evmtypes.StoreStateDiff {
+	decodedBytes, err := base64.StdEncoding.DecodeString(encodedStr)
+	if err != nil {
+		return nil
+	}
+	var cosmosOverrides []evmtypes.StoreStateDiff
+	if err := json.Unmarshal(decodedBytes, &cosmosOverrides); err != nil {
+		return nil
+	}
+	return cosmosOverrides
+}

x/vm/keeper/grpc_query.go

@@ -239,6 +239,11 @@ func (k Keeper) EthCall(c context.Context, req *types.EthCallRequest) (*types.Ms
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
+	for _, stateOverride := range req.StateOverrides {
+		if err := stateOverride.Apply(ctx, k.storeKeys); err != nil {
+			return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("invalid state override: %s", err.Error()))
+		}
+	}
 
 	var args types.TransactionArgs
 	err := json.Unmarshal(req.Args, &args)
@@ -869,6 +874,37 @@ func (k Keeper) GlobalMinGasPrice(c context.Context, _ *types.QueryGlobalMinGasP
 	return &types.QueryGlobalMinGasPriceResponse{MinGasPrice: minGasPrice}, nil
 }
 
+// Precompile implements the Query/Precompile gRPC method
+func (k Keeper) Precompile(c context.Context, req *types.QueryPrecompileRequest) (*types.QueryPrecompileResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	if !common.IsHexAddress(req.Address) {
+		return nil, status.Error(codes.InvalidArgument, "invalid address")
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+	address := common.HexToAddress(req.Address)
+
+	_, found, err := k.GetPrecompileInstance(ctx, address)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	isStatic := false
+	if found {
+		params := k.GetParams(ctx)
+		_, staticFound, _ := k.GetStaticPrecompileInstance(&params, address)
+		isStatic = staticFound
+	}
+
+	return &types.QueryPrecompileResponse{
+		IsPrecompile: found,
+		IsStatic:     isStatic,
+	}, nil
+}
+
 // Config implements the Query/Config gRPC method
 func (k Keeper) Config(_ context.Context, _ *types.QueryConfigRequest) (*types.QueryConfigResponse, error) {
 	config := types.GetChainConfig()

x/vm/types/query.go

@@ -1,6 +1,35 @@
 package types
 
+import (
+	"fmt"
+
+	storetypes "cosmossdk.io/store/types"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
 // Failed returns if the contract execution failed in vm errors
 func (egr EstimateGasResponse) Failed() bool {
 	return len(egr.VmError) > 0
 }
+
+// Apply applies the state overrides to the given context's KVStore.
+// This allows overriding specific keys in the Cosmos SDK state during EVM calls.
+func (s *StoreStateDiff) Apply(ctx sdk.Context, storeKeys map[string]*storetypes.KVStoreKey) error {
+	if s == nil {
+		return nil
+	}
+	storeKey, exists := storeKeys[s.Name]
+	if !exists {
+		return fmt.Errorf("store key %s not found", s.Name)
+	}
+	kvStore := ctx.KVStore(storeKey)
+	for _, entry := range s.Entries {
+		if entry.Delete {
+			kvStore.Delete(entry.Key)
+		} else {
+			kvStore.Set(entry.Key, entry.Value)
+		}
+	}
+	return nil
+}