Problem: no register support for payee and counterpartyPayee

Author: mmsqe

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## UNRELEASED
+
+### Features
+
+* [#1665](https://github.com/crypto-org-chain/cronos/pull/1665) Support register for payee and counterpartyPayee in relayer precompile.
+
 *Oct 24, 2024*
 
 ## v1.4.0-rc2

app/app.go

@@ -680,7 +680,7 @@ func New(
 		evmS,
 		[]evmkeeper.CustomContractFn{
 			func(_ sdk.Context, rules ethparams.Rules) vm.PrecompiledContract {
-				return cronosprecompiles.NewRelayerContract(app.IBCKeeper, appCodec, rules, app.Logger())
+				return cronosprecompiles.NewRelayerContract(app.IBCKeeper, app.IBCFeeKeeper, appCodec, rules, app.Logger())
 			},
 			func(ctx sdk.Context, rules ethparams.Rules) vm.PrecompiledContract {
 				return cronosprecompiles.NewIcaContract(ctx, app.ICAControllerKeeper, &app.CronosKeeper, appCodec, gasConfig)

integration_tests/contracts/contracts/TestRelayer.sol

@@ -1,13 +1,32 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.4;
 
+import {IRelayerFunctions} from "./src/RelayerFunctions.sol";
+
 contract TestRelayer {
-    address constant relayer = 0x0000000000000000000000000000000000000065;
+    address constant relayerContract = 0x0000000000000000000000000000000000000065;
+    IRelayerFunctions relayer = IRelayerFunctions(relayerContract);
+    address payee;
+    address counterpartyPayee;
 
     function batchCall(bytes[] memory payloads) public {
         for (uint256 i = 0; i < payloads.length; i++) {
-            (bool success,) = relayer.call(payloads[i]);
+            (bool success,) = relayerContract.call(payloads[i]);
             require(success);
         }
     }
+
+    function callRegisterPayee(string calldata portID, string calldata channelID, address relayerAddr) public returns (bool) {
+        require(payee == address(0) || payee == msg.sender, "register fail");
+        bool result = relayer.registerPayee(portID, channelID, relayerAddr);
+        require(result, "call failed");
+        payee = msg.sender;
+    }
+
+    function callRegisterCounterpartyPayee(string calldata portID, string calldata channelID, address relayerAddr) public returns (bool) {
+        require(counterpartyPayee == address(0) || counterpartyPayee == msg.sender, "register fail");
+        bool result = relayer.registerCounterpartyPayee(portID, channelID, relayerAddr);
+        require(result, "call failed");
+        counterpartyPayee = msg.sender;
+    }
 }

integration_tests/ibc_utils.py

@@ -189,7 +189,8 @@ def prepare_network(
             tx = {"to": sender, "value": fund, "gasPrice": w3.eth.gas_price}
             send_transaction(w3, tx)
             assert w3.eth.get_balance(sender, "latest") == fund
-        caller = deploy_contract(w3, CONTRACTS["TestRelayer"], key=acc.key).address
+        contract = deploy_contract(w3, CONTRACTS["TestRelayer"], key=acc.key)
+        caller = contract.address
         assert caller == RELAYER_CALLER, caller
         if is_hermes:
             hermes = Hermes(path.with_suffix(".toml"))
@@ -203,7 +204,17 @@ def prepare_network(
             call_rly_cmd(path, connection_only, version)
 
         if incentivized:
-            register_fee_payee(cronos.cosmos_cli(), chainmain.cosmos_cli())
+            port_id = "transfer"
+            channel_id = "channel-0"
+            register_fee_payee(
+                cronos.cosmos_cli(), chainmain.cosmos_cli(), port_id, channel_id
+            )
+            data = {"from": acc.address}
+            tx = contract.functions.callRegisterPayee(
+                port_id, channel_id, ADDRS["signer1"]
+            ).build_transaction(data)
+            receipt = send_transaction(w3, tx, acc.key)
+            assert receipt.status == 1, receipt
 
         port = None
         if is_relay:
@@ -217,10 +228,10 @@ def prepare_network(
             wait_for_port(port)
 
 
-def register_fee_payee(src_chain, dst_chain):
+def register_fee_payee(src_chain, dst_chain, port_id, channel_id):
     rsp = dst_chain.register_counterparty_payee(
-        "transfer",
-        "channel-0",
+        port_id,
+        channel_id,
         dst_chain.address("relayer"),
         src_chain.address("signer1"),
         from_="relayer",

x/cronos/events/bindings/cosmos/precompile/relayer/i_relayer_functions.abigen.go

@@ -20,17 +20,6 @@ interface IRelayerFunctions {
     function acknowledgement(bytes calldata data) external payable returns (bytes calldata);
     function timeout(bytes calldata data) external payable returns (bytes calldata);
     function timeoutOnClose(bytes calldata data) external payable returns (bytes calldata);
-    function updateClientAndConnectionOpenInit(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndConnectionOpenTry(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndConnectionOpenAck(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndConnectionOpenConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelOpenInit(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelOpenTry(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelOpenAck(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelOpenConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndRecvPacket(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndAcknowledgement(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndTimeout(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelCloseInit(bytes calldata data1, bytes calldata data2) external payable returns (bool);
-    function updateClientAndChannelCloseConfirm(bytes calldata data1, bytes calldata data2) external payable returns (bool);
+    function registerPayee(string calldata portID, string calldata channelID, address relayerAddr) external payable returns (bool);
+    function registerCounterpartyPayee(string calldata portID, string calldata channelID, address relayerAddr) external payable returns (bool);
 }

x/cronos/events/bindings/src/RelayerFunctions.sol

@@ -1,7 +1,6 @@
 package precompiles
 
 import (
-	"context"
 	"errors"
 	"fmt"
 
@@ -15,6 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	ibcfeetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types"
 	ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	cronosevents "github.com/crypto-org-chain/cronos/v2/x/cronos/events"
@@ -48,7 +48,9 @@ const (
 	Acknowledgement       = "acknowledgement"
 	Timeout               = "timeout"
 	TimeoutOnClose        = "timeoutOnClose"
-
+	// ibc fee
+	RegisterPayee                   = "registerPayee"
+	RsegisterCounterpartyPayee      = "registerCounterpartyPayee"
 	GasWhenReceiverChainIsSource    = 51705
 	GasWhenReceiverChainIsNotSource = 144025
 )
@@ -101,18 +103,20 @@ func init() {
 type RelayerContract struct {
 	BaseContract
 
-	cdc         codec.Codec
-	ibcKeeper   types.IbcKeeper
-	logger      log.Logger
-	isHomestead bool
-	isIstanbul  bool
-	isShanghai  bool
+	cdc          codec.Codec
+	ibcKeeper    types.IbcKeeper
+	ibcFeeKeeper types.IbcFeeKeeper
+	logger       log.Logger
+	isHomestead  bool
+	isIstanbul   bool
+	isShanghai   bool
 }
 
-func NewRelayerContract(ibcKeeper types.IbcKeeper, cdc codec.Codec, rules params.Rules, logger log.Logger) vm.PrecompiledContract {
+func NewRelayerContract(ibcKeeper types.IbcKeeper, ibcFeeKeeper types.IbcFeeKeeper, cdc codec.Codec, rules params.Rules, logger log.Logger) vm.PrecompiledContract {
 	return &RelayerContract{
 		BaseContract: NewBaseContract(relayerContractAddress),
 		ibcKeeper:    ibcKeeper,
+		ibcFeeKeeper: ibcFeeKeeper,
 		cdc:          cdc,
 		isHomestead:  rules.IsHomestead,
 		isIstanbul:   rules.IsIstanbul,
@@ -191,8 +195,33 @@ func (bc *RelayerContract) Run(evm *vm.EVM, contract *vm.Contract, readonly bool
 	if err != nil {
 		return nil, errors.New("fail to unpack input arguments")
 	}
-	input := args[0].([]byte)
 	converter := cronosevents.RelayerConvertEvent
+	if method.Name == RegisterPayee || method.Name == RsegisterCounterpartyPayee {
+		execErr := stateDB.ExecuteNativeAction(precompileAddr, converter, func(ctx sdk.Context) error {
+			portID := args[0].(string)
+			channelID := args[1].(string)
+			relayerAddr := sdk.AccAddress(args[2].(common.Address).Bytes()).String()
+			caller := sdk.AccAddress(contract.CallerAddress.Bytes()).String()
+			if method.Name == RegisterPayee {
+				_, err := bc.ibcFeeKeeper.RegisterPayee(
+					ctx,
+					ibcfeetypes.NewMsgRegisterPayee(portID, channelID, caller, relayerAddr),
+				)
+				return err
+			} else {
+				_, err = bc.ibcFeeKeeper.RegisterCounterpartyPayee(
+					ctx,
+					ibcfeetypes.NewMsgRegisterCounterpartyPayee(portID, channelID, caller, relayerAddr),
+				)
+				return err
+			}
+		})
+		if execErr != nil {
+			return nil, execErr
+		}
+		return method.Outputs.Pack(true)
+	}
+	input := args[0].([]byte)
 	e := &Executor{
 		cdc:       bc.cdc,
 		stateDB:   stateDB,
@@ -231,15 +260,9 @@ func (bc *RelayerContract) Run(evm *vm.EVM, contract *vm.Contract, readonly bool
 	case RecvPacket:
 		res, err = exec(e, bc.ibcKeeper.RecvPacket)
 	case Acknowledgement:
-		res, err = exec(e, func(goCtx context.Context, msg *channeltypes.MsgAcknowledgement) (*channeltypes.MsgAcknowledgementResponse, error) {
-			msg.Signer = sdk.AccAddress(evm.TxContext.Origin.Bytes()).String()
-			return bc.ibcKeeper.Acknowledgement(goCtx, msg)
-		})
+		res, err = exec(e, bc.ibcKeeper.Acknowledgement)
 	case Timeout:
-		res, err = exec(e, func(goCtx context.Context, msg *channeltypes.MsgTimeout) (*channeltypes.MsgTimeoutResponse, error) {
-			msg.Signer = sdk.AccAddress(evm.TxContext.Origin.Bytes()).String()
-			return bc.ibcKeeper.Timeout(goCtx, msg)
-		})
+		res, err = exec(e, bc.ibcKeeper.Timeout)
 	case TimeoutOnClose:
 		res, err = exec(e, bc.ibcKeeper.TimeoutOnClose)
 	default:

x/cronos/keeper/precompiles/relayer.go

@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	evmtypes "github.com/evmos/ethermint/x/evm/types"
 
+	ibcfeetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types"
 	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
 	connectiontypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types"
 	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
@@ -94,3 +95,8 @@ type IbcKeeper interface {
 	Timeout(goCtx context.Context, msg *channeltypes.MsgTimeout) (*channeltypes.MsgTimeoutResponse, error)
 	TimeoutOnClose(goCtx context.Context, msg *channeltypes.MsgTimeoutOnClose) (*channeltypes.MsgTimeoutOnCloseResponse, error)
 }
+
+type IbcFeeKeeper interface {
+	RegisterPayee(goCtx context.Context, msg *ibcfeetypes.MsgRegisterPayee) (*ibcfeetypes.MsgRegisterPayeeResponse, error)
+	RegisterCounterpartyPayee(goCtx context.Context, msg *ibcfeetypes.MsgRegisterCounterpartyPayee) (*ibcfeetypes.MsgRegisterCounterpartyPayeeResponse, error)
+}