feat: integrate authenticated calls smart contract functionality into protocol

cmd/zetae2e/local/v2.go

@@ -20,7 +20,11 @@ func startV2Tests(eg *errgroup.Group, conf config.Config, deployerRunner *runner
 		e2etests.TestV2ETHDepositAndCallName,
 		e2etests.TestV2ETHWithdrawName,
 		e2etests.TestV2ETHWithdrawAndCallName,
+		e2etests.TestV2ETHWithdrawAndAuthenticatedCallName,
+		e2etests.TestV2ETHWithdrawAndAuthenticatedCallThroughContractName,
 		e2etests.TestV2ZEVMToEVMCallName,
+		e2etests.TestV2ZEVMToEVMAuthenticatedCallName,
+		e2etests.TestV2ZEVMToEVMAuthenticatedCallThroughContractName,
 		e2etests.TestV2EVMToZEVMCallName,
 	))
 

e2e/e2etests/e2etests.go

@@ -126,24 +126,28 @@ const (
 	/*
 	 V2 smart contract tests
 	*/
-	TestV2ETHDepositName                         = "v2_eth_deposit"
-	TestV2ETHDepositAndCallName                  = "v2_eth_deposit_and_call"
-	TestV2ETHDepositAndCallRevertName            = "v2_eth_deposit_and_call_revert"
-	TestV2ETHDepositAndCallRevertWithCallName    = "v2_eth_deposit_and_call_revert_with_call"
-	TestV2ETHWithdrawName                        = "v2_eth_withdraw"
-	TestV2ETHWithdrawAndCallName                 = "v2_eth_withdraw_and_call"
-	TestV2ETHWithdrawAndCallRevertName           = "v2_eth_withdraw_and_call_revert"
-	TestV2ETHWithdrawAndCallRevertWithCallName   = "v2_eth_withdraw_and_call_revert_with_call"
-	TestV2ERC20DepositName                       = "v2_erc20_deposit"
-	TestV2ERC20DepositAndCallName                = "v2_erc20_deposit_and_call"
-	TestV2ERC20DepositAndCallRevertName          = "v2_erc20_deposit_and_call_revert"
-	TestV2ERC20DepositAndCallRevertWithCallName  = "v2_erc20_deposit_and_call_revert_with_call"
-	TestV2ERC20WithdrawName                      = "v2_erc20_withdraw"
-	TestV2ERC20WithdrawAndCallName               = "v2_erc20_withdraw_and_call"
-	TestV2ERC20WithdrawAndCallRevertName         = "v2_erc20_withdraw_and_call_revert"
-	TestV2ERC20WithdrawAndCallRevertWithCallName = "v2_erc20_withdraw_and_call_revert_with_call"
-	TestV2ZEVMToEVMCallName                      = "v2_zevm_to_evm_call"
-	TestV2EVMToZEVMCallName                      = "v2_evm_to_zevm_call"
+	TestV2ETHDepositName                                     = "v2_eth_deposit"
+	TestV2ETHDepositAndCallName                              = "v2_eth_deposit_and_call"
+	TestV2ETHDepositAndCallRevertName                        = "v2_eth_deposit_and_call_revert"
+	TestV2ETHDepositAndCallRevertWithCallName                = "v2_eth_deposit_and_call_revert_with_call"
+	TestV2ETHWithdrawName                                    = "v2_eth_withdraw"
+	TestV2ETHWithdrawAndCallName                             = "v2_eth_withdraw_and_call"
+	TestV2ETHWithdrawAndAuthenticatedCallName                = "v2_eth_withdraw_and_authenticated_call"
+	TestV2ETHWithdrawAndAuthenticatedCallThroughContractName = "v2_eth_withdraw_and_authenticated_call_through_contract"
+	TestV2ETHWithdrawAndCallRevertName                       = "v2_eth_withdraw_and_call_revert"
+	TestV2ETHWithdrawAndCallRevertWithCallName               = "v2_eth_withdraw_and_call_revert_with_call"
+	TestV2ERC20DepositName                                   = "v2_erc20_deposit"
+	TestV2ERC20DepositAndCallName                            = "v2_erc20_deposit_and_call"
+	TestV2ERC20DepositAndCallRevertName                      = "v2_erc20_deposit_and_call_revert"
+	TestV2ERC20DepositAndCallRevertWithCallName              = "v2_erc20_deposit_and_call_revert_with_call"
+	TestV2ERC20WithdrawName                                  = "v2_erc20_withdraw"
+	TestV2ERC20WithdrawAndCallName                           = "v2_erc20_withdraw_and_call"
+	TestV2ERC20WithdrawAndCallRevertName                     = "v2_erc20_withdraw_and_call_revert"
+	TestV2ERC20WithdrawAndCallRevertWithCallName             = "v2_erc20_withdraw_and_call_revert_with_call"
+	TestV2ZEVMToEVMCallName                                  = "v2_zevm_to_evm_call"
+	TestV2ZEVMToEVMAuthenticatedCallName                     = "v2_zevm_to_evm_authenticated_call"
+	TestV2ZEVMToEVMAuthenticatedCallThroughContractName      = "v2_zevm_to_evm_authenticated_call_through_contract"
+	TestV2EVMToZEVMCallName                                  = "v2_evm_to_zevm_call"
 
 	/*
 	 Operational tests
@@ -738,6 +742,22 @@ var AllE2ETests = []runner.E2ETest{
 		},
 		TestV2ETHWithdrawAndCall,
 	),
+	runner.NewE2ETest(
+		TestV2ETHWithdrawAndAuthenticatedCallName,
+		"withdraw Ether from ZEVM and authenticated call a contract using V2 contract",
+		[]runner.ArgDefinition{
+			{Description: "amount in wei", DefaultValue: "100000"},
+		},
+		TestV2ETHWithdrawAndAuthenticatedCall,
+	),
+	runner.NewE2ETest(
+		TestV2ETHWithdrawAndAuthenticatedCallThroughContractName,
+		"withdraw Ether from ZEVM and authenticated call a contract using V2 contract through intermediary contract",
+		[]runner.ArgDefinition{
+			{Description: "amount in wei", DefaultValue: "100000"},
+		},
+		TestV2ETHWithdrawAndAuthenticatedCallThroughContract,
+	),
 	runner.NewE2ETest(
 		TestV2ETHWithdrawAndCallRevertName,
 		"withdraw Ether from ZEVM and call a contract using V2 contract that reverts",
@@ -824,6 +844,18 @@ var AllE2ETests = []runner.E2ETest{
 		[]runner.ArgDefinition{},
 		TestV2ZEVMToEVMCall,
 	),
+	runner.NewE2ETest(
+		TestV2ZEVMToEVMAuthenticatedCallName,
+		"zevm -> evm call using V2 contract",
+		[]runner.ArgDefinition{},
+		TestV2ZEVMToEVMAuthenticatedCall,
+	),
+	runner.NewE2ETest(
+		TestV2ZEVMToEVMAuthenticatedCallThroughContractName,
+		"zevm -> evm call using V2 contract through intermediary contract",
+		[]runner.ArgDefinition{},
+		TestV2ZEVMToEVMAuthenticatedCallThroughContract,
+	),
 	runner.NewE2ETest(
 		TestV2EVMToZEVMCallName,
 		"evm -> zevm call using V2 contract",

e2e/e2etests/test_v2_eth_withdraw_and_authenticated_call.go

@@ -0,0 +1,60 @@
+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"
+
+	"github.com/zeta-chain/node/e2e/runner"
+	"github.com/zeta-chain/node/e2e/utils"
+	crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageAuthenticatedWithdrawETH = "this is a test ETH withdraw and authenticated call payload"
+
+func TestV2ETHWithdrawAndAuthenticatedCall(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, 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.V2ETHWithdrawAndAuthenticatedCall(
+		r.TestDAppV2EVMAddr,
+		amount,
+		[]byte(payloadMessageAuthenticatedWithdrawETH),
+		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, 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_authenticated_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"
+	testgatewayzevmcaller "github.com/zeta-chain/node/pkg/contracts/testgatewayzevmcaller"
+	crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageAuthenticatedWithdrawETHThroughContract = "this is a test ETH withdraw and authenticated call payload through contract"
+
+func TestV2ETHWithdrawAndAuthenticatedCallThroughContract(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 := testgatewayzevmcaller.DeployTestGatewayZEVMCaller(
+		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),
+		testgatewayzevmcaller.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),
+		testgatewayzevmcaller.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_authenticated_call.go

@@ -0,0 +1,51 @@
+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"
+
+	"github.com/zeta-chain/node/e2e/runner"
+	"github.com/zeta-chain/node/e2e/utils"
+	crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageEVMAuthenticatedCall = "this is a test EVM authenticated call payload"
+
+func TestV2ZEVMToEVMAuthenticatedCall(r *runner.E2ERunner, args []string) {
+	require.Len(r, args, 0)
+
+	r.AssertTestDAppEVMCalled(false, payloadMessageEVMAuthenticatedCall, big.NewInt(0))
+
+	// necessary approval for fee payment
+	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 authenticated call
+	tx = r.V2ZEVMToEMVAuthenticatedCall(
+		r.TestDAppV2EVMAddr,
+		[]byte(payloadMessageEVMAuthenticatedCall),
+		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, payloadMessageEVMAuthenticatedCall, big.NewInt(0))
+
+	// check expected sender was used
+	senderForMsg, err := r.TestDAppV2EVM.SenderWithMessage(&bind.CallOpts{}, []byte(payloadMessageEVMAuthenticatedCall))
+	require.NoError(r, err)
+	require.Equal(r, r.ZEVMAuth.From, senderForMsg)
+}

e2e/e2etests/test_v2_zevm_to_evm_authenticated_call_through_contract.go

@@ -0,0 +1,83 @@
+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"
+	testgatewayzevmcaller "github.com/zeta-chain/node/pkg/contracts/testgatewayzevmcaller"
+	crosschaintypes "github.com/zeta-chain/node/x/crosschain/types"
+)
+
+const payloadMessageEVMAuthenticatedCallThroughContract = "this is a test EVM authenticated call payload through contract"
+
+func TestV2ZEVMToEVMAuthenticatedCallThroughContract(r *runner.E2ERunner, args []string) {
+	require.Len(r, args, 0)
+
+	r.AssertTestDAppEVMCalled(false, payloadMessageEVMAuthenticatedCallThroughContract, big.NewInt(0))
+
+	// deploy caller contract and send it gas zrc20 to pay gas fee
+	gatewayCallerAddr, tx, gatewayCaller, err := testgatewayzevmcaller.DeployTestGatewayZEVMCaller(
+		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.V2ZEVMToEMVAuthenticatedCallThroughContract(
+		gatewayCaller,
+		r.TestDAppV2EVMAddr,
+		[]byte(payloadMessageEVMAuthenticatedCallThroughContract),
+		testgatewayzevmcaller.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, "call")
+	require.Equal(r, crosschaintypes.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
+
+	r.AssertTestDAppEVMCalled(true, payloadMessageEVMAuthenticatedCallThroughContract, big.NewInt(0))
+
+	// check expected sender was used
+	senderForMsg, err := r.TestDAppV2EVM.SenderWithMessage(
+		&bind.CallOpts{},
+		[]byte(payloadMessageEVMAuthenticatedCallThroughContract),
+	)
+	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.V2ZEVMToEMVAuthenticatedCallThroughContract(
+		gatewayCaller,
+		r.TestDAppV2EVMAddr,
+		[]byte(payloadMessageEVMAuthenticatedCallThroughContract),
+		testgatewayzevmcaller.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, "call")
+	require.Equal(r, crosschaintypes.CctxStatus_Reverted, cctx.CctxStatus.Status)
+}

e2e/e2etests/test_v2_zevm_to_evm_call.go

@@ -21,7 +21,7 @@ func TestV2ZEVMToEVMCall(r *runner.E2ERunner, args []string) {
 	// Necessary approval for fee payment
 	r.ApproveETHZRC20(r.GatewayZEVMAddr)
 
-	// perform the withdraw
+	// perform the call
 	tx := r.V2ZEVMToEMVCall(r.TestDAppV2EVMAddr, r.EncodeSimpleCall(payloadMessageEVMCall), gatewayzevm.RevertOptions{
 		OnRevertGasLimit: big.NewInt(0),
 	})