feat: set no-op router to EvidenceKeeper for evmd (cosmos#271)

* add default router for evidence keeper

* fix type handling

When calling submitEvidence through hardhat(ethers.js), type conversion from args[1] into Equivocation doesn't work.

* fix lint

* enable evidence precompile at local_node.sh

* implement no-op evidence handler

* remove un-used code

---------

Co-authored-by: Vlad J <[email protected]>

Author: zsystm

contracts/solidity/precompiles/evidence/IEvidence.sol

@@ -33,7 +33,7 @@ interface IEvidence {
     /// @dev Submit evidence of misbehavior (equivocation)
     /// @param evidence The evidence of misbehavior
     /// @return success True if the evidence was submitted successfully
-    function submitEvidence(Equivocation calldata evidence) external returns (bool success);
+    function submitEvidence(address submitter, Equivocation calldata evidence) external returns (bool success);
 
     /// @dev Query evidence by hash
     /// @param evidenceHash The hash of the evidence to query

evmd/app.go

@@ -1,6 +1,7 @@
 package evmd
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -30,7 +31,6 @@ import (
 	feemarketkeeper "github.com/cosmos/evm/x/feemarket/keeper"
 	feemarkettypes "github.com/cosmos/evm/x/feemarket/types"
 	ibccallbackskeeper "github.com/cosmos/evm/x/ibc/callbacks/keeper"
-
 	// NOTE: override ICS20 keeper to support IBC transfers of ERC20 tokens
 	"github.com/cosmos/evm/x/ibc/transfer"
 	transferkeeper "github.com/cosmos/evm/x/ibc/transfer/keeper"
@@ -62,6 +62,7 @@ import (
 	"cosmossdk.io/log"
 	storetypes "cosmossdk.io/store/types"
 	"cosmossdk.io/x/evidence"
+	"cosmossdk.io/x/evidence/exported"
 	evidencekeeper "cosmossdk.io/x/evidence/keeper"
 	evidencetypes "cosmossdk.io/x/evidence/types"
 	"cosmossdk.io/x/feegrant"
@@ -447,6 +448,13 @@ func NewExampleApp(
 		app.AccountKeeper.AddressCodec(),
 		runtime.ProvideCometInfoService(),
 	)
+	// Initialize a router for the evidence keeper.
+	// This prevents nil panic when submitEvidence is called.
+	// See precompiles/evidence/tx.go for more details.
+	router := evidencetypes.NewRouter()
+	router = router.AddRoute(evidencetypes.RouteEquivocation, noOpEquivocationHandler(evidenceKeeper))
+	evidenceKeeper.SetRouter(router)
+
 	// If evidence needs to be handled for the app, set routes in router here and seal
 	app.EvidenceKeeper = *evidenceKeeper
 
@@ -1133,3 +1141,23 @@ func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino
 
 	return paramsKeeper
 }
+
+// testEquivocationHandler is a no-op equivocation handler for testing purposes.
+// You should not use this in production code, as it does not handle equivocation properly.
+func noOpEquivocationHandler(_ interface{}) evidencetypes.Handler {
+	return func(_ context.Context, e exported.Evidence) error {
+		if err := e.ValidateBasic(); err != nil {
+			return err
+		}
+
+		ee, ok := e.(*evidencetypes.Equivocation)
+		if !ok {
+			return fmt.Errorf("unexpected evidence type: %T", e)
+		}
+		if ee.Height%2 == 0 {
+			return fmt.Errorf("unexpected even evidence height: %d", ee.Height)
+		}
+
+		return nil
+	}
+}

local_node.sh

@@ -136,7 +136,7 @@ if [[ $overwrite == "y" || $overwrite == "Y" ]]; then
 	jq '.app_state["bank"]["denom_metadata"]=[{"description":"The native staking token for evmd.","denom_units":[{"denom":"atest","exponent":0,"aliases":["attotest"]},{"denom":"test","exponent":18,"aliases":[]}],"base":"atest","display":"test","name":"Test Token","symbol":"TEST","uri":"","uri_hash":""}]' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS"
 
 	# Enable precompiles in EVM params
-	jq '.app_state["evm"]["params"]["active_static_precompiles"]=["0x0000000000000000000000000000000000000100","0x0000000000000000000000000000000000000400","0x0000000000000000000000000000000000000800","0x0000000000000000000000000000000000000801","0x0000000000000000000000000000000000000802","0x0000000000000000000000000000000000000803","0x0000000000000000000000000000000000000804","0x0000000000000000000000000000000000000805"]' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS"
+	jq '.app_state["evm"]["params"]["active_static_precompiles"]=["0x0000000000000000000000000000000000000100","0x0000000000000000000000000000000000000400","0x0000000000000000000000000000000000000800","0x0000000000000000000000000000000000000801","0x0000000000000000000000000000000000000802","0x0000000000000000000000000000000000000803","0x0000000000000000000000000000000000000804","0x0000000000000000000000000000000000000805", "0x0000000000000000000000000000000000000806", "0x0000000000000000000000000000000000000807"]' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS"
 
 	# Set EVM config
 	jq '.app_state["evm"]["params"]["evm_denom"]="atest"' "$GENESIS" >"$TMP_GENESIS" && mv "$TMP_GENESIS" "$GENESIS"

precompiles/evidence/IEvidence.sol

@@ -33,7 +33,7 @@ interface IEvidence {
     /// @dev Submit evidence of misbehavior (equivocation)
     /// @param evidence The evidence of misbehavior
     /// @return success True if the evidence was submitted successfully
-    function submitEvidence(Equivocation calldata evidence) external returns (bool success);
+    function submitEvidence(address submitter, Equivocation calldata evidence) external returns (bool success);
 
     /// @dev Query evidence by hash
     /// @param evidenceHash The hash of the evidence to query

precompiles/evidence/abi.json

@@ -150,6 +150,11 @@
     },
     {
       "inputs": [
+        {
+          "internalType": "address",
+          "name": "submitter",
+          "type": "address"
+        },
         {
           "components": [
             {

precompiles/evidence/tx.go

@@ -21,11 +21,19 @@ func (p Precompile) SubmitEvidence(
 	method *abi.Method,
 	args []interface{},
 ) ([]byte, error) {
-	msg, submitterHexAddr, err := NewMsgSubmitEvidence(args)
+	msg, submitterHexAddr, err := NewMsgSubmitEvidence(method, args)
 	if err != nil {
 		return nil, err
 	}
 
+	handler, err := p.evidenceKeeper.GetEvidenceHandler(msg.GetEvidence().Route())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get evidence handler: %w", err)
+	}
+	if handler == nil {
+		return nil, fmt.Errorf("no evidence handler found for route: %s", msg.GetEvidence().Route())
+	}
+
 	msgSender := contract.Caller()
 	if msgSender != submitterHexAddr {
 		return nil, fmt.Errorf(cmn.ErrRequesterIsNotMsgSender, msgSender.String(), submitterHexAddr.String())

precompiles/evidence/types.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 
 	cmn "github.com/cosmos/evm/precompiles/common"
 
 	evidencetypes "cosmossdk.io/x/evidence/types"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/query"
 )
 
@@ -59,8 +59,12 @@ func (e EquivocationData) ToEquivocation() *evidencetypes.Equivocation {
 	}
 }
 
+type SubmitEquivocationInput struct {
+	Equivocation EquivocationData
+}
+
 // NewMsgSubmitEvidence creates a new MsgSubmitEvidence instance.
-func NewMsgSubmitEvidence(args []interface{}) (*evidencetypes.MsgSubmitEvidence, common.Address, error) {
+func NewMsgSubmitEvidence(method *abi.Method, args []interface{}) (*evidencetypes.MsgSubmitEvidence, common.Address, error) {
 	emptyAddr := common.Address{}
 	if len(args) != 2 {
 		return nil, emptyAddr, fmt.Errorf(cmn.ErrInvalidNumberOfArgs, 2, len(args))
@@ -71,18 +75,21 @@ func NewMsgSubmitEvidence(args []interface{}) (*evidencetypes.MsgSubmitEvidence,
 		return nil, emptyAddr, fmt.Errorf("invalid submitter address")
 	}
 
-	equivocation, ok := args[1].(EquivocationData)
-	if !ok {
-		return nil, emptyAddr, fmt.Errorf("invalid equivocation evidence")
+	inputs := method.Inputs[1:] // Skip the first input which is the submitter address
+	args = args[1:]
+	var input SubmitEquivocationInput
+	if err := inputs.Copy(&input, args); err != nil {
+		return nil, emptyAddr, fmt.Errorf("failed to copy inputs: %w", err)
 	}
 
-	// Convert the EquivocationData to a types.Equivocation
-	evidence := equivocation.ToEquivocation()
+	equivocation := input.Equivocation.ToEquivocation()
+	if equivocation == nil {
+		return nil, emptyAddr, fmt.Errorf("invalid equivocation evidence")
+	}
 
-	// Create the MsgSubmitEvidence using the SDK msg builder
 	msg, err := evidencetypes.NewMsgSubmitEvidence(
-		sdk.AccAddress(submitterAddress.Bytes()),
-		evidence,
+		submitterAddress.Bytes(),
+		equivocation,
 	)
 	if err != nil {
 		return nil, emptyAddr, fmt.Errorf("failed to create evidence message: %w", err)

tests/integration/precompiles/evidence/test_setup.go

@@ -1,19 +1,13 @@
 package evidence
 
 import (
-	"context"
-	"fmt"
-
 	"github.com/stretchr/testify/suite"
 
 	"github.com/cosmos/evm/precompiles/evidence"
 	"github.com/cosmos/evm/testutil/integration/evm/factory"
 	"github.com/cosmos/evm/testutil/integration/evm/grpc"
 	"github.com/cosmos/evm/testutil/integration/evm/network"
 	testkeyring "github.com/cosmos/evm/testutil/keyring"
-
-	"cosmossdk.io/x/evidence/exported"
-	"cosmossdk.io/x/evidence/types"
 )
 
 type PrecompileTestSuite struct {
@@ -45,10 +39,6 @@ func (s *PrecompileTestSuite) SetupTest() {
 	grpcHandler := grpc.NewIntegrationHandler(nw)
 	txFactory := factory.New(nw, grpcHandler)
 
-	router := types.NewRouter()
-	router = router.AddRoute(types.RouteEquivocation, testEquivocationHandler(nw.App.GetEvidenceKeeper()))
-	nw.App.GetEvidenceKeeper().SetRouter(router)
-
 	s.network = nw
 	s.factory = txFactory
 	s.grpcHandler = grpcHandler
@@ -60,21 +50,3 @@ func (s *PrecompileTestSuite) SetupTest() {
 		panic(err)
 	}
 }
-
-func testEquivocationHandler(_ interface{}) types.Handler {
-	return func(_ context.Context, e exported.Evidence) error {
-		if err := e.ValidateBasic(); err != nil {
-			return err
-		}
-
-		ee, ok := e.(*types.Equivocation)
-		if !ok {
-			return fmt.Errorf("unexpected evidence type: %T", e)
-		}
-		if ee.Height%2 == 0 {
-			return fmt.Errorf("unexpected even evidence height: %d", ee.Height)
-		}
-
-		return nil
-	}
-}