implement adr-007

app/app.go

@@ -511,10 +511,11 @@ func New(
 
 	app.EvmKeeper.SetHooks(cronoskeeper.NewLogProcessEvmHook(
 		evmhandlers.NewSendToAccountHandler(app.BankKeeper, app.CronosKeeper),
-		evmhandlers.NewSendToChainHandler(gravitySrv, app.BankKeeper, app.CronosKeeper),
-		evmhandlers.NewCancelSendToChainHandler(gravitySrv, app.CronosKeeper, app.GravityKeeper),
+		evmhandlers.NewSendToEvmChainHandler(gravitySrv, app.BankKeeper, app.CronosKeeper),
+		evmhandlers.NewCancelSendToEvmChainHandler(gravitySrv, app.CronosKeeper, app.GravityKeeper),
 		evmhandlers.NewSendToIbcHandler(app.BankKeeper, app.CronosKeeper),
 		evmhandlers.NewSendCroToIbcHandler(app.BankKeeper, app.CronosKeeper),
+		evmhandlers.NewSendToIbcV2Handler(app.BankKeeper, app.CronosKeeper),
 	))
 
 	// register the staking hooks

contracts/src/ModuleCRC21.sol

@@ -8,9 +8,9 @@ contract ModuleCRC21 is DSToken {
     string denom;
     bool isSource;
 
-    event __CronosSendToIbc(address sender, string recipient, uint256 amount);
-    event __CronosSendToChain(address sender, address recipient, uint256 amount, uint256 bridge_fee, uint256 chain_id);
-    event __CronosCancelSendToChain(address sender, uint256 id);
+    event __CronosSendToIbc(address sender, string recipient, uint256 amount, string channel_id, bytes extraData);
+    event __CronosSendToEvmChain(address sender, address recipient, uint256 chain_id, uint256 amount, uint256 bridge_fee, bytes extraData);
+    event __CronosCancelSendToEvmChain(address sender, uint256 id);
 
     constructor(string memory denom_, uint8 decimals_, bool isSource_) DSToken(denom_) public {
         decimals = decimals_;
@@ -57,28 +57,28 @@ contract ModuleCRC21 is DSToken {
     **/
 
     // send an "amount" of the contract token to recipient through IBC
-    function send_to_ibc(string memory recipient, uint amount) public {
+    function send_to_ibc(string memory recipient, uint amount, string memory channel_id, bytes memory extraData) public {
         if (isSource) {
             transferFrom(msg.sender, module_address, amount);
         } else {
             unsafe_burn(msg.sender, amount);
         }
-        emit __CronosSendToIbc(msg.sender, recipient, amount);
+        emit __CronosSendToIbc(msg.sender, recipient, amount, channel_id, extraData);
     }
 
     // send to another chain through gravity bridge
-    function send_to_chain(address recipient, uint amount, uint bridge_fee, uint chain_id) external {
+    function send_to_evm_chain(address recipient, uint amount, uint chain_id, uint bridge_fee, bytes calldata extraData) external {
         if (isSource) {
             transferFrom(msg.sender, module_address, add(amount, bridge_fee));
         } else {
             unsafe_burn(msg.sender, add(amount, bridge_fee));
         }
-        emit __CronosSendToChain(msg.sender, recipient, amount, bridge_fee, chain_id);
+        emit __CronosSendToEvmChain(msg.sender, recipient, chain_id, amount, bridge_fee, extraData);
     }
 
     // cancel a send to chain transaction considering if it hasnt been batched yet.
-    function cancel_send_to_chain(uint256 id) external {
-        emit __CronosCancelSendToChain(msg.sender, id);
+    function cancel_send_to_evm_chain(uint256 id) external {
+        emit __CronosCancelSendToEvmChain(msg.sender, id);
     }
 
     /**

docs/architecture/README.md

@@ -33,5 +33,5 @@ To suggest an ADR, please make use of the [ADR template](./adr-template.md) prov
 | [004](./adr-004.md) | Tokens conversion in Cronos | Accepted |
 | [005](./adr-005.md) | Cross-chain Validation for Gravity Bridge | Rejected |
 | [006](./adr-006.md) | Migrating CRC20 contract to CRC21 standard | Rejected |
-| [007](./adr-007.md) | Generic event format for evm-hook actions | Proposed |
+| [007](./adr-007.md) | Generic event format for evm-hook actions | Accepted |
 | [008](./adr-008.md) | Denom and Contract Mapping Enhancement for Bi-Directional Token Conversion | Accepted |

docs/architecture/adr-007.md

@@ -4,6 +4,7 @@
 
 * 2022-06-09: Initial Draft
 * 2022-08-03: Update proposal to generic argument option
+* 2022-09-05: Move to accepted
 
 
 ## Context
@@ -31,7 +32,7 @@ In this ADR, we define generic event argument that can be extended to accept new
 event __CronosSendToIbc(address sender, string recipient, uint256 amount);
 
 // Proposal
-event __CronosSendToIbc(address sender, string recipient, uint256 amount, string channelId, bytes extraData);
+event __CronosSendToIbc(address indexed sender, string indexed recipient, uint256 amount, string indexed channelId, bytes extraData);
 ```
 
 #### Description
@@ -58,7 +59,7 @@ event __CronosSendToIbc(address sender, string recipient, uint256 amount, string
 event __CronosSendToChain(address sender, address recipient, uint256 amount, uint256 bridge_fee, uint256 chain_id);
 
 // Proposal
-event __CronosSendToEVMChain(address sender, address recipient, uint256 amount, string chain_id, bytes extraData);
+event __CronosSendToEvmChain(address indexed sender, address indexed recipient, uint256 indexed chain_id, uint256 amount, uint256 bridge_fee, bytes extraData);
 ```
 
 #### Description

x/cronos/keeper/evm_hooks_test.go

@@ -115,19 +115,22 @@ func (suite *KeeperTestSuite) TestEvmHooks() {
 				balance := suite.app.BankKeeper.GetBalance(suite.ctx, sdk.AccAddress(sender.Bytes()), denom)
 				suite.Require().Equal(coin, balance)
 
-				data, err := handlers.SendToChainEvent.Inputs.Pack(
+				data, err := handlers.SendToEvmChainEvent.Inputs.Pack(
 					sender,
 					recipient,
+					big.NewInt(1),
 					coin.Amount.BigInt(),
 					big.NewInt(0),
-					big.NewInt(1),
+					[]byte{},
 				)
 				suite.Require().NoError(err)
 				logs := []*ethtypes.Log{
 					{
 						Address: contract,
-						Topics:  []common.Hash{handlers.SendToChainEvent.ID},
-						Data:    data,
+						Topics: []common.Hash{
+							handlers.SendToEvmChainEvent.ID,
+						},
+						Data: data,
 					},
 				}
 				receipt := &ethtypes.Receipt{
@@ -152,18 +155,19 @@ func (suite *KeeperTestSuite) TestEvmHooks() {
 				balance := suite.app.BankKeeper.GetBalance(suite.ctx, sdk.AccAddress(contract.Bytes()), denom)
 				suite.Require().Equal(coin, balance)
 
-				data, err := handlers.SendToChainEvent.Inputs.Pack(
+				data, err := handlers.SendToEvmChainEvent.Inputs.Pack(
 					sender,
 					recipient,
+					big.NewInt(1),
 					coin.Amount.BigInt(),
 					big.NewInt(0),
-					big.NewInt(1),
+					[]byte{},
 				)
 				suite.Require().NoError(err)
 				logs := []*ethtypes.Log{
 					{
 						Address: contract,
-						Topics:  []common.Hash{handlers.SendToChainEvent.ID},
+						Topics:  []common.Hash{handlers.SendToEvmChainEvent.ID},
 						Data:    data,
 					},
 				}

x/cronos/keeper/evmhandlers/cancel_send_to_chain.go → x/cronos/keeper/evmhandlers/cancel_send_to_evm_chain.go

@@ -14,21 +14,21 @@ import (
 	"github.com/crypto-org-chain/cronos/x/cronos/types"
 )
 
-var _ types.EvmLogHandler = CancelSendToChainHandler{}
+var _ types.EvmLogHandler = CancelSendToEvmChainHandler{}
 
-const CancelSendToChainEventName = "__CronosCancelSendToChain"
+const CancelSendToEvmChainEventName = "__CronosCancelSendToEvmChain"
 
-// CancelSendToChainEvent represent the signature of
-// `event __CronosCancelSendToChain(uint256 id)`
-var CancelSendToChainEvent abi.Event
+// CancelSendToEvmChainEvent represent the signature of
+// `event __CronosCancelSendToEvmChain(uint256 id)`
+var CancelSendToEvmChainEvent abi.Event
 
 func init() {
 	addressType, _ := abi.NewType("address", "", nil)
 	uint256Type, _ := abi.NewType("uint256", "", nil)
 
-	CancelSendToChainEvent = abi.NewEvent(
-		CancelSendToChainEventName,
-		CancelSendToChainEventName,
+	CancelSendToEvmChainEvent = abi.NewEvent(
+		CancelSendToEvmChainEventName,
+		CancelSendToEvmChainEventName,
 		false,
 		abi.Arguments{abi.Argument{
 			Name:    "sender",
@@ -42,41 +42,41 @@ func init() {
 	)
 }
 
-// CancelSendToChainHandler handles `__CronosCancelSendToChain` log
-type CancelSendToChainHandler struct {
+// CancelSendToEvmChainHandler handles `__CronosCancelSendToEvmChain` log
+type CancelSendToEvmChainHandler struct {
 	gravitySrv    gravitytypes.MsgServer
 	cronosKeeper  cronoskeeper.Keeper
 	gravityKeeper types.GravityKeeper
 }
 
-func NewCancelSendToChainHandler(
+func NewCancelSendToEvmChainHandler(
 	gravitySrv gravitytypes.MsgServer,
 	cronosKeeper cronoskeeper.Keeper,
 	gravityKeeper types.GravityKeeper,
-) *CancelSendToChainHandler {
-	return &CancelSendToChainHandler{
+) *CancelSendToEvmChainHandler {
+	return &CancelSendToEvmChainHandler{
 		gravitySrv:    gravitySrv,
 		cronosKeeper:  cronosKeeper,
 		gravityKeeper: gravityKeeper,
 	}
 }
 
-func (h CancelSendToChainHandler) EventID() common.Hash {
-	return CancelSendToChainEvent.ID
+func (h CancelSendToEvmChainHandler) EventID() common.Hash {
+	return CancelSendToEvmChainEvent.ID
 }
 
 // Handle `__CronosCancelSendToChain` log only if gravity is activated.
-func (h CancelSendToChainHandler) Handle(
+func (h CancelSendToEvmChainHandler) Handle(
 	ctx sdk.Context,
 	_ common.Address,
 	data []byte,
 	_ func(contractAddress common.Address, logSig common.Hash, logData []byte),
 ) error {
 	if h.gravitySrv == nil {
-		return fmt.Errorf("native action %s is not implemented", CancelSendToChainEventName)
+		return fmt.Errorf("native action %s is not implemented", CancelSendToEvmChainEventName)
 	}
 
-	unpacked, err := CancelSendToChainEvent.Inputs.Unpack(data)
+	unpacked, err := CancelSendToEvmChainEvent.Inputs.Unpack(data)
 	if err != nil {
 		// log and ignore
 		h.cronosKeeper.Logger(ctx).Info("log signature matches but failed to decode")

x/cronos/keeper/evmhandlers/send_to_chain.go → x/cronos/keeper/evmhandlers/send_to_evm_chain.go

@@ -14,30 +14,31 @@ import (
 	"github.com/crypto-org-chain/cronos/x/cronos/types"
 )
 
-var _ types.EvmLogHandler = SendToChainHandler{}
+var _ types.EvmLogHandler = SendToEvmChainHandler{}
 
 const (
-	SendToChainEventName         = "__CronosSendToChain"
-	SendToChainResponseEventName = "__CronosSendToChainResponse"
+	SendToEvmChainEventName         = "__CronosSendToEvmChain"
+	SendToEvmChainResponseEventName = "__CronosSendToEvmChainResponse"
 )
 
 var (
-	// SendToChainEvent represent the signature of
-	// `event __CronosSendToChain(address recipient, uint256 amount, uint256 bridge_fee)`
-	SendToChainEvent abi.Event
+	// SendToEvmChainEvent represent the signature of
+	// `event __CronosSendToEvmChain(address indexed sender, address indexed recipient, uint256 indexed chain_id, uint256 amount, uint256 bridge_fee, bytes extraData)`
+	SendToEvmChainEvent abi.Event
 
-	// SendToChainResponseEvent represent the signature of
+	// SendToEvmChainResponseEvent represent the signature of
 	// `event __CronosSendToChainResponse(uint256 id)`
-	SendToChainResponseEvent abi.Event
+	SendToEvmChainResponseEvent abi.Event
 )
 
 func init() {
 	addressType, _ := abi.NewType("address", "", nil)
 	uint256Type, _ := abi.NewType("uint256", "", nil)
+	bytesType, _ := abi.NewType("bytes", "", nil)
 
-	SendToChainEvent = abi.NewEvent(
-		SendToChainEventName,
-		SendToChainEventName,
+	SendToEvmChainEvent = abi.NewEvent(
+		SendToEvmChainEventName,
+		SendToEvmChainEventName,
 		false,
 		abi.Arguments{abi.Argument{
 			Name:    "sender",
@@ -47,6 +48,10 @@ func init() {
 			Name:    "recipient",
 			Type:    addressType,
 			Indexed: false,
+		}, abi.Argument{
+			Name:    "chain_id",
+			Type:    uint256Type,
+			Indexed: false,
 		}, abi.Argument{
 			Name:    "amount",
 			Type:    uint256Type,
@@ -56,14 +61,14 @@ func init() {
 			Type:    uint256Type,
 			Indexed: false,
 		}, abi.Argument{
-			Name:    "chain_id",
-			Type:    uint256Type,
+			Name:    "extraData",
+			Type:    bytesType,
 			Indexed: false,
 		}},
 	)
-	SendToChainResponseEvent = abi.NewEvent(
-		SendToChainResponseEventName,
-		SendToChainResponseEventName,
+	SendToEvmChainResponseEvent = abi.NewEvent(
+		SendToEvmChainResponseEventName,
+		SendToEvmChainResponseEventName,
 		false,
 		abi.Arguments{abi.Argument{
 			Name:    "id",
@@ -73,37 +78,37 @@ func init() {
 	)
 }
 
-// SendToChainHandler handles `__CronosSendToChain` log
-type SendToChainHandler struct {
+// SendToEvmChainHandler handles `__CronosSendToEvmChain` log
+type SendToEvmChainHandler struct {
 	gravitySrv   gravitytypes.MsgServer
 	bankKeeper   types.BankKeeper
 	cronosKeeper cronoskeeper.Keeper
 }
 
-func NewSendToChainHandler(gravitySrv gravitytypes.MsgServer, bankKeeper types.BankKeeper, cronosKeeper cronoskeeper.Keeper) *SendToChainHandler {
-	return &SendToChainHandler{
+func NewSendToEvmChainHandler(gravitySrv gravitytypes.MsgServer, bankKeeper types.BankKeeper, cronosKeeper cronoskeeper.Keeper) *SendToEvmChainHandler {
+	return &SendToEvmChainHandler{
 		gravitySrv:   gravitySrv,
 		bankKeeper:   bankKeeper,
 		cronosKeeper: cronosKeeper,
 	}
 }
 
-func (h SendToChainHandler) EventID() common.Hash {
-	return SendToChainEvent.ID
+func (h SendToEvmChainHandler) EventID() common.Hash {
+	return SendToEvmChainEvent.ID
 }
 
 // Handle `__CronosSendToChain` log only if gravity is activated.
-func (h SendToChainHandler) Handle(
+func (h SendToEvmChainHandler) Handle(
 	ctx sdk.Context,
 	contract common.Address,
 	data []byte,
 	addLogToReceipt func(contractAddress common.Address, logSig common.Hash, logData []byte),
 ) error {
 	if h.gravitySrv == nil {
-		return fmt.Errorf("native action %s is not implemented", SendToChainEventName)
+		return fmt.Errorf("native action %s is not implemented", SendToEvmChainEventName)
 	}
 
-	unpacked, err := SendToChainEvent.Inputs.Unpack(data)
+	unpacked, err := SendToEvmChainEvent.Inputs.Unpack(data)
 	if err != nil {
 		// log and ignore
 		h.cronosKeeper.Logger(ctx).Info("log signature matches but failed to decode")
@@ -122,9 +127,9 @@ func (h SendToChainHandler) Handle(
 	contractCosmosAddr := sdk.AccAddress(contract.Bytes())
 	senderCosmosAddr := sdk.AccAddress(unpacked[0].(common.Address).Bytes())
 	ethRecipient := unpacked[1].(common.Address)
-	amount := sdk.NewIntFromBigInt(unpacked[2].(*big.Int))
-	bridgeFee := sdk.NewIntFromBigInt(unpacked[3].(*big.Int))
-	chainID := sdk.NewIntFromBigInt(unpacked[4].(*big.Int))
+	chainID := sdk.NewIntFromBigInt(unpacked[2].(*big.Int))
+	amount := sdk.NewIntFromBigInt(unpacked[3].(*big.Int))
+	bridgeFee := sdk.NewIntFromBigInt(unpacked[4].(*big.Int))
 
 	if !chainID.Equal(sdk.NewInt(1)) && !chainID.Equal(sdk.NewInt(3)) &&
 		!chainID.Equal(sdk.NewInt(4)) && !chainID.Equal(sdk.NewInt(5)) {
@@ -159,7 +164,7 @@ func (h SendToChainHandler) Handle(
 		return err
 	}
 
-	logData, _ := SendToChainResponseEvent.Inputs.Pack(big.NewInt(int64(resp.Id)))
-	addLogToReceipt(contract, SendToChainResponseEvent.ID, logData)
+	logData, _ := SendToEvmChainResponseEvent.Inputs.Pack(big.NewInt(int64(resp.Id)))
+	addLogToReceipt(contract, SendToEvmChainResponseEvent.ID, logData)
 	return nil
 }

x/cronos/keeper/evmhandlers/send_to_ibc.go

@@ -1,3 +1,4 @@
+//nolint
 package evmhandler
 
 import (
@@ -17,7 +18,7 @@ var _ types.EvmLogHandler = SendToIbcHandler{}
 const SendToIbcEventName = "__CronosSendToIbc"
 
 // SendToIbcEvent represent the signature of
-// `event __CronosSendToIbc(string recipient, uint256 amount)`
+// `event __CronosSendToIbc(address sender, string recipient, uint256 amount)`
 var SendToIbcEvent abi.Event
 
 func init() {