feat: initialize cctx gateway interface

app/app.go

@@ -105,6 +105,7 @@
 
 	"github.com/zeta-chain/zetacore/app/ante"
 	"github.com/zeta-chain/zetacore/docs/openapi"
+	"github.com/zeta-chain/zetacore/pkg/chains"
 	zetamempool "github.com/zeta-chain/zetacore/pkg/mempool"
 	srvflags "github.com/zeta-chain/zetacore/server/flags"
 	authoritymodule "github.com/zeta-chain/zetacore/x/authority"
@@ -597,6 +598,12 @@
 		app.LightclientKeeper,
 	)
 
+	cctxGateways := map[chains.CCTXGateway]crosschainkeeper.CCTXGateway{
+		chains.CCTXGateway_observers: crosschainkeeper.NewCCTXGatewayObservers(app.CrosschainKeeper),
+		chains.CCTXGateway_zevm:      crosschainkeeper.NewCCTXGatewayZEVM(app.CrosschainKeeper),
+	}
+	app.CrosschainKeeper.SetCCTXGateways(cctxGateways)
+
 	// initialize ibccrosschain keeper and set it to the crosschain keeper
 	// there is a circular dependency between the two keepers, crosschain keeper must be initialized first
 

changelog.md

@@ -18,6 +18,7 @@
 * [2258](https://github.com/zeta-chain/node/pull/2258) - add Optimism and Base in static chain information
 * [2279](https://github.com/zeta-chain/node/pull/2279) - add a CCTXGateway field to chain static data
 * [2275](https://github.com/zeta-chain/node/pull/2275) - add ChainInfo singleton state variable in authority
+* [2291](https://github.com/zeta-chain/node/pull/2291) - cctx gateway interface
 
 ### Refactor
 

testutil/keeper/crosschain.go

@@ -174,6 +174,13 @@ func CrosschainKeeperWithMocks(
 		lightclientKeeper,
 	)
 
+	cctxGateways := map[chains.CCTXGateway]keeper.CCTXGateway{
+		chains.CCTXGateway_observers: keeper.NewCCTXGatewayObservers(*k),
+		chains.CCTXGateway_zevm:      keeper.NewCCTXGatewayZEVM(*k),
+	}
+
+	k.SetCCTXGateways(cctxGateways)
+
 	// initialize ibccrosschain keeper and set it to the crosschain keeper
 	// there is a circular dependency between the two keepers, crosschain keeper must be initialized first
 

x/crosschain/keeper/cctx_gateway_observers.go

@@ -0,0 +1,53 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+)
+
+type CCTXGatewayObservers struct {
+	crosschainKeeper Keeper
+}
+
+func NewCCTXGatewayObservers(crosschainKeeper Keeper) CCTXGatewayObservers {
+	return CCTXGatewayObservers{
+		crosschainKeeper: crosschainKeeper,
+	}
+}
+
+/*
+InitiateOutbound updates the store so observers can use the PendingCCTX query:
+
+  - If the crosschain message passing is successful, the CCTX status is changed to PendingOutbound.
+
+  - If the crosschain message passing returns an error, the CCTX status is changed to Aborted.
+    We do not return an error from this function, as all changes need to be persisted to the state.
+
+    Instead, we use a temporary context to make changes and then commit the context on for the happy path, i.e cctx is set to PendingOutbound.
+*/
+func (c CCTXGatewayObservers) InitiateOutbound(ctx sdk.Context, cctx *types.CrossChainTx) error {
+	tmpCtx, commit := ctx.CacheContext()
+	outboundReceiverChainID := cctx.GetCurrentOutboundParam().ReceiverChainId
+	err := func() error {
+		err := c.crosschainKeeper.PayGasAndUpdateCctx(
+			tmpCtx,
+			outboundReceiverChainID,
+			cctx,
+			cctx.InboundParams.Amount,
+			false,
+		)
+		if err != nil {
+			return err
+		}
+		return c.crosschainKeeper.UpdateNonce(tmpCtx, outboundReceiverChainID, cctx)
+	}()
+	if err != nil {
+		// do not commit anything here as the CCTX should be aborted
+		cctx.SetAbort(err.Error())
+		return nil
+	}
+	commit()
+	cctx.SetPendingOutbound("")
+	return nil
+}

x/crosschain/keeper/cctx_gateway_zevm.go

@@ -0,0 +1,95 @@
+package keeper
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+)
+
+type CCTXGatewayZEVM struct {
+	crosschainKeeper Keeper
+}
+
+func NewCCTXGatewayZEVM(crosschainKeeper Keeper) CCTXGatewayZEVM {
+	return CCTXGatewayZEVM{
+		crosschainKeeper: crosschainKeeper,
+	}
+}
+
+/*
+InitiateOutbound handles evm deposit and then ValidateOutbound is called.
+TODO: move remaining of this comment to ValidateOutbound once it's added.
+
+  - If the deposit is successful, the CCTX status is changed to OutboundMined.
+
+  - If the deposit returns an internal error i.e if HandleEVMDeposit() returns an error, but isContractReverted is false, the CCTX status is changed to Aborted.
+
+  - If the deposit is reverted, the function tries to create a revert cctx with status PendingRevert.
+
+  - If the creation of revert tx also fails it changes the status to Aborted.
+
+Note : Aborted CCTXs are not refunded in this function. The refund is done using a separate refunding mechanism.
+We do not return an error from this function , as all changes need to be persisted to the state.
+Instead we use a temporary context to make changes and then commit the context on for the happy path ,i.e cctx is set to OutboundMined.
+*/
+func (c CCTXGatewayZEVM) InitiateOutbound(ctx sdk.Context, cctx *types.CrossChainTx) error {
+	tmpCtx, commit := ctx.CacheContext()
+	isContractReverted, err := c.crosschainKeeper.HandleEVMDeposit(tmpCtx, cctx)
+
+	// further processing will be in validateOutbound(...), for now keeping it here
+	if err != nil && !isContractReverted { // exceptional case; internal error; should abort CCTX
+		cctx.SetAbort(err.Error())
+		return err
+	} else if err != nil && isContractReverted { // contract call reverted; should refund via a revert tx
+		revertMessage := err.Error()
+		senderChain := c.crosschainKeeper.zetaObserverKeeper.GetSupportedChainFromChainID(ctx, cctx.InboundParams.SenderChainId)
+		if senderChain == nil {
+			cctx.SetAbort(fmt.Sprintf("invalid sender chain id %d", cctx.InboundParams.SenderChainId))
+			return nil
+		}
+		gasLimit, err := c.crosschainKeeper.GetRevertGasLimit(ctx, *cctx)
+		if err != nil {
+			cctx.SetAbort(fmt.Sprintf("revert gas limit error: %s", err.Error()))
+			return nil
+		}
+		if gasLimit == 0 {
+			// use same gas limit of outbound as a fallback -- should not be required
+			gasLimit = cctx.GetCurrentOutboundParam().GasLimit
+		}
+
+		err = cctx.AddRevertOutbound(gasLimit)
+		if err != nil {
+			cctx.SetAbort(fmt.Sprintf("revert outbound error: %s", err.Error()))
+			return nil
+		}
+		// we create a new cached context, and we don't commit the previous one with EVM deposit
+		tmpCtxRevert, commitRevert := ctx.CacheContext()
+		err = func() error {
+			err := c.crosschainKeeper.PayGasAndUpdateCctx(
+				tmpCtxRevert,
+				senderChain.ChainId,
+				cctx,
+				cctx.InboundParams.Amount,
+				false,
+			)
+			if err != nil {
+				return err
+			}
+			// Update nonce using senderchain id as this is a revert tx and would go back to the original sender
+			return c.crosschainKeeper.UpdateNonce(tmpCtxRevert, senderChain.ChainId, cctx)
+		}()
+		if err != nil {
+			cctx.SetAbort(fmt.Sprintf("deposit revert message: %s err : %s", revertMessage, err.Error()))
+			return nil
+		}
+		commitRevert()
+		cctx.SetPendingRevert(revertMessage)
+		return nil
+	}
+	// successful HandleEVMDeposit;
+	commit()
+	cctx.SetOutBoundMined("Remote omnichain contract call completed")
+	return nil
+}

x/crosschain/keeper/initiate_inbound.go

@@ -0,0 +1,17 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/zeta-chain/zetacore/pkg/chains"
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+)
+
+// InitiateOutbound processes the inbound CCTX.
+// It does a conditional dispatch to correct CCTX gateway based on the receiver chain
+// which handle the state changes and error handling.
+func (k Keeper) InitiateOutbound(ctx sdk.Context, cctx *types.CrossChainTx) error {
+	chainInfo := chains.GetChainFromChainID(cctx.GetCurrentOutboundParam().ReceiverChainId)
+
+	return k.cctxGateways[chainInfo.CctxGateway].InitiateOutbound(ctx, cctx)
+}

x/crosschain/keeper/process_inbound_test.go → x/crosschain/keeper/initiate_inbound_test.go

@@ -18,7 +18,7 @@ import (
 	observertypes "github.com/zeta-chain/zetacore/x/observer/types"
 )
 
-func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
+func TestKeeper_InitiateOutboundZEVMDeposit(t *testing.T) {
 	t.Run("process zevm deposit successfully", func(t *testing.T) {
 		k, ctx, _, _ := keepertest.CrosschainKeeperWithMocks(t, keepertest.CrosschainMockOptions{
 			UseFungibleMock: true,
@@ -34,15 +34,15 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 			mock.Anything,
 			receiver, int64(0), amount, mock.Anything, mock.Anything).Return(nil, nil)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := sample.CrossChainTx(t, "test")
 		cctx.CctxStatus = &types.Status{Status: types.CctxStatus_PendingInbound}
 		cctx.GetCurrentOutboundParam().Receiver = receiver.String()
 		cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
 		cctx.GetInboundParams().Amount = sdkmath.NewUintFromBigInt(amount)
 		cctx.InboundParams.CoinType = coin.CoinType_Zeta
 		cctx.GetInboundParams().SenderChainId = 0
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_OutboundMined, cctx.CctxStatus.Status)
 	})
 
@@ -61,15 +61,15 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 		fungibleMock.On("ZETADepositAndCallContract", mock.Anything, mock.Anything, receiver, int64(0), amount, mock.Anything, mock.Anything).
 			Return(nil, fmt.Errorf("deposit error"))
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := sample.CrossChainTx(t, "test")
 		cctx.CctxStatus = &types.Status{Status: types.CctxStatus_PendingInbound}
 		cctx.GetCurrentOutboundParam().Receiver = receiver.String()
 		cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
 		cctx.GetInboundParams().Amount = sdkmath.NewUintFromBigInt(amount)
 		cctx.InboundParams.CoinType = coin.CoinType_Zeta
 		cctx.GetInboundParams().SenderChainId = 0
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 		require.Equal(t, "deposit error", cctx.CctxStatus.StatusMessage)
 	})
@@ -98,10 +98,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 			observerMock.On("GetSupportedChainFromChainID", mock.Anything, senderChain.ChainId).
 				Return(nil)
 
-			// call ProcessInbound
+			// call InitiateOutbound
 			cctx := GetERC20Cctx(t, receiver, *senderChain, "", amount)
 			cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-			k.ProcessInbound(ctx, cctx)
+			k.InitiateOutbound(ctx, cctx)
 			require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 			require.Equal(
 				t,
@@ -136,10 +136,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 		fungibleMock.On("GetForeignCoinFromAsset", mock.Anything, asset, senderChain.ChainId).
 			Return(fungibletypes.ForeignCoins{}, false)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 		cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 		require.Equal(
 			t,
@@ -179,10 +179,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 			observerMock.On("GetSupportedChainFromChainID", mock.Anything, senderChain.ChainId).
 				Return(nil).Once()
 
-			// call ProcessInbound
+			// call InitiateOutbound
 			cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 			cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-			k.ProcessInbound(ctx, cctx)
+			k.InitiateOutbound(ctx, cctx)
 			require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 			require.Equal(
 				t,
@@ -223,10 +223,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 			observerMock.On("GetSupportedChainFromChainID", mock.Anything, senderChain.ChainId).
 				Return(nil).Once()
 
-			// call ProcessInbound
+			// call InitiateOutbound
 			cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 			cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-			k.ProcessInbound(ctx, cctx)
+			k.InitiateOutbound(ctx, cctx)
 			require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 			require.Equal(
 				t,
@@ -268,10 +268,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 		observerMock.On("GetChainNonces", mock.Anything, senderChain.ChainName.String()).
 			Return(observertypes.ChainNonces{}, false)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 		cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 		require.Contains(t, cctx.CctxStatus.StatusMessage, "cannot find receiver chain nonce")
 	})
@@ -306,10 +306,10 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 		// mock successful UpdateNonce
 		updatedNonce := keepertest.MockUpdateNonce(observerMock, *senderChain)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 		cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_PendingRevert, cctx.CctxStatus.Status)
 		require.Equal(t, errDeposit.Error(), cctx.CctxStatus.StatusMessage)
 		require.Equal(t, updatedNonce, cctx.GetCurrentOutboundParam().TssNonce)
@@ -342,11 +342,11 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 			// mock successful GetRevertGasLimit for ERC20
 			keepertest.MockGetRevertGasLimitForERC20(fungibleMock, asset, *senderChain, 100)
 
-			// call ProcessInbound
+			// call InitiateOutbound
 			cctx := GetERC20Cctx(t, receiver, *senderChain, asset, amount)
 			cctx.GetCurrentOutboundParam().ReceiverChainId = chains.ZetaChainPrivnet.ChainId
 			cctx.OutboundParams = append(cctx.OutboundParams, cctx.GetCurrentOutboundParam())
-			k.ProcessInbound(ctx, cctx)
+			k.InitiateOutbound(ctx, cctx)
 			require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 			require.Contains(
 				t,
@@ -357,7 +357,7 @@ func TestKeeper_ProcessInboundZEVMDeposit(t *testing.T) {
 	)
 }
 
-func TestKeeper_ProcessInboundProcessCrosschainMsgPassing(t *testing.T) {
+func TestKeeper_InitiateOutboundProcessCrosschainMsgPassing(t *testing.T) {
 	t.Run("process crosschain msg passing successfully", func(t *testing.T) {
 		k, ctx, _, _ := keepertest.CrosschainKeeperWithMocks(t, keepertest.CrosschainMockOptions{
 			UseFungibleMock: true,
@@ -377,9 +377,9 @@ func TestKeeper_ProcessInboundProcessCrosschainMsgPassing(t *testing.T) {
 		// mock successful UpdateNonce
 		updatedNonce := keepertest.MockUpdateNonce(observerMock, *receiverChain)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *receiverChain, "", amount)
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_PendingOutbound, cctx.CctxStatus.Status)
 		require.Equal(t, updatedNonce, cctx.GetCurrentOutboundParam().TssNonce)
 	})
@@ -400,9 +400,9 @@ func TestKeeper_ProcessInboundProcessCrosschainMsgPassing(t *testing.T) {
 		observerMock.On("GetSupportedChainFromChainID", mock.Anything, receiverChain.ChainId).
 			Return(nil).Once()
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *receiverChain, "", amount)
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 		require.Equal(t, observertypes.ErrSupportedChains.Error(), cctx.CctxStatus.StatusMessage)
 	})
@@ -427,9 +427,9 @@ func TestKeeper_ProcessInboundProcessCrosschainMsgPassing(t *testing.T) {
 		observerMock.On("GetChainNonces", mock.Anything, receiverChain.ChainName.String()).
 			Return(observertypes.ChainNonces{}, false)
 
-		// call ProcessInbound
+		// call InitiateOutbound
 		cctx := GetERC20Cctx(t, receiver, *receiverChain, "", amount)
-		k.ProcessInbound(ctx, cctx)
+		k.InitiateOutbound(ctx, cctx)
 		require.Equal(t, types.CctxStatus_Aborted, cctx.CctxStatus.Status)
 		require.Contains(t, cctx.CctxStatus.StatusMessage, "cannot find receiver chain nonce")
 	})