feat: integrate authenticated calls smart contract functionality into…

… protocol (#2904)

* e2e tests and modifications for authenticated call

* extend test with sender check and revert case

* separate tests into separate files

* cleanup

* withdraw and call support and tests

* bump protocol contracts

* split tests into separate files

* small cleanup

* fmt

* generate

* lint

* changelog

* PR  comments

* fix case in proto

* bump vote inbound gas limit in zetaclient

* fix test

* generate

* fixing tests

* call options non empty

* generate

* test fix

* rename gateway caller

* pr comments rename tests

* PR comment

* generate

* tests

* update tests fixes

* tests fixes

* fix

* test fix

changelog.md

@@ -13,6 +13,7 @@
 * [2883](https://github.com/zeta-chain/node/pull/2883) - add chain static information for btc signet testnet
 * [2907](https://github.com/zeta-chain/node/pull/2907) - derive Bitcoin tss address by chain id and added more Signet static info
 * [2911](https://github.com/zeta-chain/node/pull/2911) - add chain static information for btc testnet4
+* [2904](https://github.com/zeta-chain/node/pull/2904) - integrate authenticated calls smart contract functionality into protocol
 
 ### Refactor
 

cmd/zetae2e/local/v2.go

@@ -19,8 +19,12 @@ func startV2Tests(eg *errgroup.Group, conf config.Config, deployerRunner *runner
  e2etests.TestV2ETHDepositName,
  e2etests.TestV2ETHDepositAndCallName,
  e2etests.TestV2ETHWithdrawName,
+ e2etests.TestV2ETHWithdrawAndArbitraryCallName,
  e2etests.TestV2ETHWithdrawAndCallName,
+ e2etests.TestV2ETHWithdrawAndCallThroughContractName,
+ e2etests.TestV2ZEVMToEVMArbitraryCallName,
  e2etests.TestV2ZEVMToEVMCallName,
+ e2etests.TestV2ZEVMToEVMCallThroughContractName,
  e2etests.TestV2EVMToZEVMCallName,
  ))
 

docs/cli/zetacored/cli.md

@@ -9441,7 +9441,7 @@ zetacored tx crosschain vote-gas-price [chain] [price] [priorityFee] [blockNumbe
 Broadcast message to vote an inbound
 
 ```
-zetacored tx crosschain vote-inbound [sender] [senderChainID] [txOrigin] [receiver] [receiverChainID] [amount] [message] [inboundHash] [inBlockHeight] [coinType] [asset] [eventIndex] [protocolContractVersion] [flags]
+zetacored tx crosschain vote-inbound [sender] [senderChainID] [txOrigin] [receiver] [receiverChainID] [amount] [message] [inboundHash] [inBlockHeight] [coinType] [asset] [eventIndex] [protocolContractVersion] [isArbitraryCall] [flags]
 ```
 
 ### Options

docs/openapi/openapi.swagger.yaml

@@ -57066,6 +57066,14 @@ definitions:
  - ERC20: ERC20 token
  - Cmd: no asset, used for admin command
  - NoAssetCall: no asset, used for contract call
+ crosschainCallOptions:
+ type: object
+ properties:
+ gas_limit:
+ type: string
+ format: uint64
+ is_arbitrary_call:
+ type: boolean
  crosschainCctxStatus:
  type: string
  enum:
@@ -57276,6 +57284,7 @@ definitions:
  gas_limit:
  type: string
  format: uint64
+ title: Deprecated (v21), use CallOptions
  gas_price:
  type: string
  gas_priority_fee:
@@ -57302,6 +57311,8 @@ definitions:
  type: string
  tx_finalization_status:
  $ref: '#/definitions/crosschainTxFinalizationStatus'
+ call_options:
+ $ref: '#/definitions/crosschainCallOptions'
  crosschainOutboundTracker:
  type: object
  properties:

docs/spec/crosschain/messages.md

@@ -189,6 +189,7 @@ message MsgVoteInbound {
  uint64 event_index = 15;
  ProtocolContractVersion protocol_contract_version = 16;
  RevertOptions revert_options = 17;
+ CallOptions call_options = 18;
 }
 ```
 

e2e/e2etests/e2etests.go

@@ -131,7 +131,9 @@ const (
  TestV2ETHDepositAndCallRevertName = "v2_eth_deposit_and_call_revert"
  TestV2ETHDepositAndCallRevertWithCallName = "v2_eth_deposit_and_call_revert_with_call"
  TestV2ETHWithdrawName = "v2_eth_withdraw"
+ TestV2ETHWithdrawAndArbitraryCallName = "v2_eth_withdraw_and_arbitrary_call"
  TestV2ETHWithdrawAndCallName = "v2_eth_withdraw_and_call"
+ TestV2ETHWithdrawAndCallThroughContractName = "v2_eth_withdraw_and_call_through_contract"
  TestV2ETHWithdrawAndCallRevertName = "v2_eth_withdraw_and_call_revert"
  TestV2ETHWithdrawAndCallRevertWithCallName = "v2_eth_withdraw_and_call_revert_with_call"
  TestV2ERC20DepositName = "v2_erc20_deposit"
@@ -142,7 +144,9 @@ const (
  TestV2ERC20WithdrawAndCallName = "v2_erc20_withdraw_and_call"
  TestV2ERC20WithdrawAndCallRevertName = "v2_erc20_withdraw_and_call_revert"
  TestV2ERC20WithdrawAndCallRevertWithCallName = "v2_erc20_withdraw_and_call_revert_with_call"
+ TestV2ZEVMToEVMArbitraryCallName = "v2_zevm_to_evm_arbitrary_call"
  TestV2ZEVMToEVMCallName = "v2_zevm_to_evm_call"
+ TestV2ZEVMToEVMCallThroughContractName = "v2_zevm_to_evm_call_through_contract"
  TestV2EVMToZEVMCallName = "v2_evm_to_zevm_call"
 
  /*
@@ -731,13 +735,29 @@ var AllE2ETests = []runner.E2ETest{
  TestV2ETHWithdraw,
  ),
  runner.NewE2ETest(
- TestV2ETHWithdrawAndCallName,
+ TestV2ETHWithdrawAndArbitraryCallName,
  "withdraw Ether from ZEVM and call a contract using V2 contract",
  []runner.ArgDefinition{
  {Description: "amount in wei", DefaultValue: "100000"},
  },
+ TestV2ETHWithdrawAndArbitraryCall,
+ ),
+ runner.NewE2ETest(
+ TestV2ETHWithdrawAndCallName,
+ "withdraw Ether from ZEVM call a contract using V2 contract",
+ []runner.ArgDefinition{
+ {Description: "amount in wei", DefaultValue: "100000"},
+ },
  TestV2ETHWithdrawAndCall,
  ),
+ runner.NewE2ETest(
+ TestV2ETHWithdrawAndCallThroughContractName,
+ "withdraw Ether from ZEVM call a contract using V2 contract through intermediary contract",
+ []runner.ArgDefinition{
+ {Description: "amount in wei", DefaultValue: "100000"},
+ },
+ TestV2ETHWithdrawAndCallThroughContract,
+ ),
  runner.NewE2ETest(
  TestV2ETHWithdrawAndCallRevertName,
  "withdraw Ether from ZEVM and call a contract using V2 contract that reverts",
@@ -818,12 +838,24 @@ var AllE2ETests = []runner.E2ETest{
  },
  TestV2ERC20WithdrawAndCallRevertWithCall,
  ),
+ runner.NewE2ETest(
+ TestV2ZEVMToEVMArbitraryCallName,
+ "zevm -> evm call using V2 contract",
+ []runner.ArgDefinition{},
+ TestV2ZEVMToEVMArbitraryCall,
+ ),
  runner.NewE2ETest(
  TestV2ZEVMToEVMCallName,
  "zevm -> evm call using V2 contract",
  []runner.ArgDefinition{},
  TestV2ZEVMToEVMCall,
  ),
+ runner.NewE2ETest(
+ TestV2ZEVMToEVMCallThroughContractName,
+ "zevm -> evm call using V2 contract through intermediary contract",
+ []runner.ArgDefinition{},
+ TestV2ZEVMToEVMCallThroughContract,
+ ),
  runner.NewE2ETest(
  TestV2EVMToZEVMCallName,
  "evm -> zevm call using V2 contract",

e2e/e2etests/test_v2_eth_withdraw_and_arbitrary_call.go

@@ -0,0 +1,40 @@
+package e2etests
+
+import (
+ "math/big"
+
+ "github.com/stretchr/testify/require"
+ "github.com/zeta-chain/protocol-contracts/v2/pkg/gatewayzevm.sol"
+
+ "github.com/zeta-chain/node/e2e/runner"
+ "github.com/zeta-chain/node/e2e/utils"
+ crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageWithdrawETH = "this is a test ETH withdraw and call payload"
+
+func TestV2ETHWithdrawAndArbitraryCall(r *runner.E2ERunner, args []string) {
+ require.Len(r, args, 1)
+
+ amount, ok := big.NewInt(0).SetString(args[0], 10)
+ require.True(r, ok, "Invalid amount specified for TestV2ETHWithdrawAndCall")
+
+ r.AssertTestDAppEVMCalled(false, payloadMessageWithdrawETH, amount)
+
+ r.ApproveETHZRC20(r.GatewayZEVMAddr)
+
+ // perform the withdraw
+ tx := r.V2ETHWithdrawAndCall(
+ r.TestDAppV2EVMAddr,
+ amount,
+ r.EncodeGasCall(payloadMessageWithdrawETH),
+ gatewayzevm.RevertOptions{OnRevertGasLimit: big.NewInt(0)},
+ )
+
+ // wait for the cctx to be mined
+ cctx := utils.WaitCctxMinedByInboundHash(r.Ctx, tx.Hash().Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+ r.Logger.CCTX(*cctx, "withdraw")
+ require.Equal(r, crosschaintypes.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
+
+ r.AssertTestDAppEVMCalled(true, payloadMessageWithdrawETH, amount)
+}

e2e/e2etests/test_v2_eth_withdraw_and_call.go

@@ -3,6 +3,7 @@ package e2etests
 import (
  "math/big"
 
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
  "github.com/stretchr/testify/require"
  "github.com/zeta-chain/protocol-contracts/v2/pkg/gatewayzevm.sol"
 
@@ -11,23 +12,34 @@ import (
  crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
 )
 
-const payloadMessageWithdrawETH = "this is a test ETH withdraw and call payload"
+const payloadMessageAuthenticatedWithdrawETH = "this is a test ETH withdraw and authenticated call payload"
 
 func TestV2ETHWithdrawAndCall(r *runner.E2ERunner, args []string) {
  require.Len(r, args, 1)
 
+ previousGasLimit := r.ZEVMAuth.GasLimit
+ r.ZEVMAuth.GasLimit = 10000000
+ defer func() {
+ r.ZEVMAuth.GasLimit = previousGasLimit
+ }()
+
  amount, ok := big.NewInt(0).SetString(args[0], 10)
  require.True(r, ok, "Invalid amount specified for TestV2ETHWithdrawAndCall")
 
- r.AssertTestDAppEVMCalled(false, payloadMessageWithdrawETH, amount)
+ r.AssertTestDAppEVMCalled(false, payloadMessageAuthenticatedWithdrawETH, amount)
 
  r.ApproveETHZRC20(r.GatewayZEVMAddr)
 
+ // set expected sender
+ tx, err := r.TestDAppV2EVM.SetExpectedOnCallSender(r.EVMAuth, r.ZEVMAuth.From)
+ require.NoError(r, err)
+ utils.MustWaitForTxReceipt(r.Ctx, r.EVMClient, tx, r.Logger, r.ReceiptTimeout)
+
  // perform the withdraw
- tx := r.V2ETHWithdrawAndCall(
+ tx = r.V2ETHWithdrawAndAuthenticatedCall(
  r.TestDAppV2EVMAddr,
  amount,
- r.EncodeGasCall(payloadMessageWithdrawETH),
+ []byte(payloadMessageAuthenticatedWithdrawETH),
  gatewayzevm.RevertOptions{OnRevertGasLimit: big.NewInt(0)},
  )
 
@@ -36,5 +48,13 @@ func TestV2ETHWithdrawAndCall(r *runner.E2ERunner, args []string) {
  r.Logger.CCTX(*cctx, "withdraw")
  require.Equal(r, crosschaintypes.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
 
- r.AssertTestDAppEVMCalled(true, payloadMessageWithdrawETH, amount)
+ r.AssertTestDAppEVMCalled(true, payloadMessageAuthenticatedWithdrawETH, amount)
+
+ // check expected sender was used
+ senderForMsg, err := r.TestDAppV2EVM.SenderWithMessage(
+ &bind.CallOpts{},
+ []byte(payloadMessageAuthenticatedWithdrawETH),
+ )
+ require.NoError(r, err)
+ require.Equal(r, r.ZEVMAuth.From, senderForMsg)
 }

e2e/e2etests/test_v2_eth_withdraw_and_call_through_contract.go

@@ -0,0 +1,84 @@
+package e2etests
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/stretchr/testify/require"
+
+ "github.com/zeta-chain/node/e2e/runner"
+ "github.com/zeta-chain/node/e2e/utils"
+ gatewayzevmcaller "github.com/zeta-chain/node/pkg/contracts/gatewayzevmcaller"
+ crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageAuthenticatedWithdrawETHThroughContract = "this is a test ETH withdraw and authenticated call payload through contract"
+
+func TestV2ETHWithdrawAndCallThroughContract(r *runner.E2ERunner, args []string) {
+ require.Len(r, args, 1)
+
+ previousGasLimit := r.ZEVMAuth.GasLimit
+ r.ZEVMAuth.GasLimit = 10000000
+ defer func() {
+ r.ZEVMAuth.GasLimit = previousGasLimit
+ }()
+
+ amount, ok := big.NewInt(0).SetString(args[0], 10)
+ require.True(r, ok, "Invalid amount specified for TestV2ETHWithdrawAndCall")
+
+ // deploy caller contract and send it gas zrc20 to pay gas fee
+ gatewayCallerAddr, tx, gatewayCaller, err := gatewayzevmcaller.DeployGatewayZEVMCaller(
+ r.ZEVMAuth,
+ r.ZEVMClient,
+ r.GatewayZEVMAddr,
+ r.WZetaAddr,
+ )
+ require.NoError(r, err)
+ utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+
+ tx, err = r.ETHZRC20.Transfer(r.ZEVMAuth, gatewayCallerAddr, big.NewInt(100000000000000000))
+ require.NoError(r, err)
+ utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+
+ // set expected sender
+ tx, err = r.TestDAppV2EVM.SetExpectedOnCallSender(r.EVMAuth, gatewayCallerAddr)
+ require.NoError(r, err)
+ utils.MustWaitForTxReceipt(r.Ctx, r.EVMClient, tx, r.Logger, r.ReceiptTimeout)
+
+ // perform the authenticated call
+ tx = r.V2ETHWithdrawAndAuthenticatedCallThroughContract(gatewayCaller, r.TestDAppV2EVMAddr,
+ amount,
+ []byte(payloadMessageAuthenticatedWithdrawETHThroughContract),
+ gatewayzevmcaller.RevertOptions{OnRevertGasLimit: big.NewInt(0)})
+
+ utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+ cctx := utils.WaitCctxMinedByInboundHash(r.Ctx, tx.Hash().Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+ r.Logger.CCTX(*cctx, "withdraw")
+ require.Equal(r, crosschaintypes.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
+
+ r.AssertTestDAppEVMCalled(true, payloadMessageAuthenticatedWithdrawETHThroughContract, amount)
+
+ // check expected sender was used
+ senderForMsg, err := r.TestDAppV2EVM.SenderWithMessage(
+ &bind.CallOpts{},
+ []byte(payloadMessageAuthenticatedWithdrawETHThroughContract),
+ )
+ require.NoError(r, err)
+ require.Equal(r, gatewayCallerAddr, senderForMsg)
+
+ // set expected sender to wrong one
+ tx, err = r.TestDAppV2EVM.SetExpectedOnCallSender(r.EVMAuth, r.ZEVMAuth.From)
+ require.NoError(r, err)
+ utils.MustWaitForTxReceipt(r.Ctx, r.EVMClient, tx, r.Logger, r.ReceiptTimeout)
+
+ // repeat authenticated call through contract, should revert because of wrong sender
+ tx = r.V2ETHWithdrawAndAuthenticatedCallThroughContract(gatewayCaller, r.TestDAppV2EVMAddr,
+ amount,
+ []byte(payloadMessageAuthenticatedWithdrawETHThroughContract),
+ gatewayzevmcaller.RevertOptions{OnRevertGasLimit: big.NewInt(0)})
+
+ utils.MustWaitForTxReceipt(r.Ctx, r.ZEVMClient, tx, r.Logger, r.ReceiptTimeout)
+ cctx = utils.WaitCctxMinedByInboundHash(r.Ctx, tx.Hash().Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+ r.Logger.CCTX(*cctx, "withdraw")
+ require.Equal(r, crosschaintypes.CctxStatus_Reverted, cctx.CctxStatus.Status)
+}

e2e/e2etests/test_v2_zevm_to_evm_arbitrary_call.go

@@ -0,0 +1,36 @@
+package e2etests
+
+import (
+ "math/big"
+
+ "github.com/stretchr/testify/require"
+ "github.com/zeta-chain/protocol-contracts/v2/pkg/gatewayzevm.sol"
+
+ "github.com/zeta-chain/node/e2e/runner"
+ "github.com/zeta-chain/node/e2e/utils"
+ crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageEVMCall = "this is a test EVM call payload"
+
+func TestV2ZEVMToEVMArbitraryCall(r *runner.E2ERunner, args []string) {
+ require.Len(r, args, 0)
+
+ r.AssertTestDAppEVMCalled(false, payloadMessageEVMCall, big.NewInt(0))
+
+ // Necessary approval for fee payment
+ r.ApproveETHZRC20(r.GatewayZEVMAddr)
+
+ // perform the call
+ tx := r.V2ZEVMToEMVCall(r.TestDAppV2EVMAddr, r.EncodeSimpleCall(payloadMessageEVMCall), gatewayzevm.RevertOptions{
+ OnRevertGasLimit: big.NewInt(0),
+ })
+
+ // wait for the cctx to be mined
+ cctx := utils.WaitCctxMinedByInboundHash(r.Ctx, tx.Hash().Hex(), r.CctxClient, r.Logger, r.CctxTimeout)
+ r.Logger.CCTX(*cctx, "call")
+ require.Equal(r, crosschaintypes.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
+
+ // check the payload was received on the contract
+ r.AssertTestDAppEVMCalled(true, payloadMessageEVMCall, big.NewInt(0))
+}