refactor: cctx validate inbound

app/app.go

@@ -105,7 +105,6 @@ import (
 
 	"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"
@@ -598,14 +597,6 @@ func New(
 		app.LightclientKeeper,
 	)
 
-	// initializing map of cctx gateways so crosschain module can decide which one to use
-	// based on chain info of destination chain
-	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

@@ -46,6 +46,8 @@
 * [2269](https://github.com/zeta-chain/node/pull/2269) - refactor MsgUpdateCrosschainFlags into MsgEnableCCTX, MsgDisableCCTX and MsgUpdateGasPriceIncreaseFlags
 * [2306](https://github.com/zeta-chain/node/pull/2306) - refactor zetaclient outbound transaction signing logic
 * [2296](https://github.com/zeta-chain/node/pull/2296) - move `testdata` package to `testutil` to organize test-related utilities
+* [2317](https://github.com/zeta-chain/node/pull/2317) - add ValidateOutbound method for cctx orchestrator
+* [2340](https://github.com/zeta-chain/node/pull/2340) - add ValidateInbound method for cctx orchestrator
 
 ### Tests
 

testutil/keeper/crosschain.go

@@ -174,16 +174,8 @@ 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
-
 	var ibcCrosschainKeeperTmp types.IBCCrosschainKeeper = initIBCCrosschainKeeper(
 		cdc,
 		db,

x/crosschain/keeper/cctx_gateway_observers.go

@@ -1,8 +1,11 @@
 package keeper
 
 import (
+	"fmt"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/zeta-chain/zetacore/pkg/chains"
 	"github.com/zeta-chain/zetacore/x/crosschain/types"
 )
 
@@ -32,29 +35,45 @@ InitiateOutbound updates the store so observers can use the PendingCCTX query:
 */
 func (c CCTXGatewayObservers) InitiateOutbound(
 	ctx sdk.Context,
-	cctx *types.CrossChainTx,
-) (newCCTXStatus types.CctxStatus) {
+	config InitiateOutboundConfig,
+) (newCCTXStatus types.CctxStatus, err 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
+	outboundReceiverChainID := config.CCTX.GetCurrentOutboundParam().ReceiverChainId
+	// TODO (https://github.com/zeta-chain/node/issues/1010): workaround for this bug
+	noEthereumTxEvent := false
+	if chains.IsZetaChain(config.CCTX.InboundParams.SenderChainId) {
+		noEthereumTxEvent = true
+	}
+
+	err = func() error {
+		// If ShouldPayGas flag is set during ValidateInbound PayGasAndUpdateCctx should be called
+		// which will set GasPrice and Amount. Otherwise, use median gas price and InboundParams amount.
+		if config.ShouldPayGas {
+			err := c.crosschainKeeper.PayGasAndUpdateCctx(
+				tmpCtx,
+				outboundReceiverChainID,
+				config.CCTX,
+				config.CCTX.InboundParams.Amount,
+				noEthereumTxEvent,
+			)
+			if err != nil {
+				return err
+			}
+		} else {
+			gasPrice, found := c.crosschainKeeper.GetMedianGasPriceInUint(ctx, config.CCTX.GetCurrentOutboundParam().ReceiverChainId)
+			if !found {
+				return fmt.Errorf("gasprice not found for %d", config.CCTX.GetCurrentOutboundParam().ReceiverChainId)
+			}
+			config.CCTX.GetCurrentOutboundParam().GasPrice = gasPrice.String()
+			config.CCTX.GetCurrentOutboundParam().Amount = config.CCTX.InboundParams.Amount
 		}
-		return c.crosschainKeeper.UpdateNonce(tmpCtx, outboundReceiverChainID, cctx)
+		return c.crosschainKeeper.SetObserverOutboundInfo(tmpCtx, outboundReceiverChainID, config.CCTX)
 	}()
 	if err != nil {
 		// do not commit anything here as the CCTX should be aborted
-		cctx.SetAbort(err.Error())
-		return types.CctxStatus_Aborted
+		config.CCTX.SetAbort(err.Error())
+		return types.CctxStatus_Aborted, err
 	}
 	commit()
-	cctx.SetPendingOutbound("")
-	return types.CctxStatus_PendingOutbound
+	return types.CctxStatus_PendingOutbound, nil
 }

x/crosschain/keeper/cctx_gateway_zevm.go

@@ -1,8 +1,6 @@
 package keeper
 
 import (
-	"fmt"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/zeta-chain/zetacore/x/crosschain/types"
@@ -20,81 +18,24 @@ func NewCCTXGatewayZEVM(crosschainKeeper Keeper) CCTXGatewayZEVM {
 	}
 }
 
-/*
-InitiateOutbound handles evm deposit and call ValidateOutbound.
-TODO (https://github.com/zeta-chain/node/issues/2278): 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.
-New CCTX status after preprocessing is returned.
-*/
-func (c CCTXGatewayZEVM) InitiateOutbound(ctx sdk.Context, cctx *types.CrossChainTx) (newCCTXStatus types.CctxStatus) {
+// InitiateOutbound handles evm deposit and immediately validates pending outbound
+func (c CCTXGatewayZEVM) InitiateOutbound(
+	ctx sdk.Context,
+	config InitiateOutboundConfig,
+) (newCCTXStatus types.CctxStatus, err error) {
 	tmpCtx, commit := ctx.CacheContext()
-	isContractReverted, err := c.crosschainKeeper.HandleEVMDeposit(tmpCtx, cctx)
+	isContractReverted, err := c.crosschainKeeper.HandleEVMDeposit(tmpCtx, config.CCTX)
 
-	// TODO (https://github.com/zeta-chain/node/issues/2278): 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 types.CctxStatus_Aborted
-	} 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 types.CctxStatus_Aborted
-		}
-		gasLimit, err := c.crosschainKeeper.GetRevertGasLimit(ctx, *cctx)
-		if err != nil {
-			cctx.SetAbort(fmt.Sprintf("revert gas limit error: %s", err.Error()))
-			return types.CctxStatus_Aborted
-		}
-		if gasLimit == 0 {
-			// use same gas limit of outbound as a fallback -- should not be required
-			gasLimit = cctx.GetCurrentOutboundParam().GasLimit
-		}
+		config.CCTX.SetAbort(err.Error())
+		return types.CctxStatus_Aborted, err
+	}
 
-		err = cctx.AddRevertOutbound(gasLimit)
-		if err != nil {
-			cctx.SetAbort(fmt.Sprintf("revert outbound error: %s", err.Error()))
-			return types.CctxStatus_Aborted
-		}
-		// 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 types.CctxStatus_Aborted
-		}
-		commitRevert()
-		cctx.SetPendingRevert(revertMessage)
-		return types.CctxStatus_PendingRevert
+	newCCTXStatus = c.crosschainKeeper.ValidateOutboundZEVM(ctx, config.CCTX, err, isContractReverted)
+	if newCCTXStatus == types.CctxStatus_OutboundMined {
+		commit()
 	}
-	// successful HandleEVMDeposit;
-	commit()
-	cctx.SetOutboundMined("Remote omnichain contract call completed")
-	return types.CctxStatus_OutboundMined
+
+	return newCCTXStatus, nil
 }

x/crosschain/keeper/cctx_gateways.go

@@ -0,0 +1,29 @@
+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"
+)
+
+// CCTXGateway is interface implemented by every gateway. It is one of interfaces used for communication
+// between CCTX gateways and crosschain module, and it is called by crosschain module.
+type CCTXGateway interface {
+	// Initiate a new outbound, this tells the CCTXGateway to carry out the action to execute the outbound.
+	// It is the only entry point to initiate an outbound and it returns new CCTX status after it is completed.
+	InitiateOutbound(ctx sdk.Context, config InitiateOutboundConfig) (newCCTXStatus types.CctxStatus, err error)
+}
+
+var cctxGateways map[chains.CCTXGateway]CCTXGateway
+
+// ResolveCCTXGateway respolves cctx gateway implementation based on provided cctx gateway
+func ResolveCCTXGateway(c chains.CCTXGateway, keeper Keeper) (CCTXGateway, bool) {
+	cctxGateways = map[chains.CCTXGateway]CCTXGateway{
+		chains.CCTXGateway_observers: NewCCTXGatewayObservers(keeper),
+		chains.CCTXGateway_zevm:      NewCCTXGatewayZEVM(keeper),
+	}
+
+	cctxGateway, ok := cctxGateways[c]
+	return cctxGateway, ok
+}

x/crosschain/keeper/cctx_orchestrator_validate_inbound.go

@@ -0,0 +1,50 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+	observertypes "github.com/zeta-chain/zetacore/x/observer/types"
+)
+
+// ValidateInbound is the only entry-point to create new CCTX (eg. when observers voting is done or new inbound event is detected).
+// It creates new CCTX object and calls InitiateOutbound method.
+func (k Keeper) ValidateInbound(
+	ctx sdk.Context,
+	msg *types.MsgVoteInbound,
+	shouldPayGas bool,
+) (*types.CrossChainTx, error) {
+	tss, tssFound := k.zetaObserverKeeper.GetTSS(ctx)
+	if !tssFound {
+		return nil, types.ErrCannotFindTSSKeys
+	}
+
+	// Do not process if inbound is disabled
+	if !k.zetaObserverKeeper.IsInboundEnabled(ctx) {
+		return nil, observertypes.ErrInboundDisabled
+	}
+
+	// create a new CCTX from the inbound message. The status of the new CCTX is set to PendingInbound.
+	cctx, err := types.NewCCTX(ctx, *msg, tss.TssPubkey)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initiate outbound, the process function manages the state commit and cctx status change.
+	// If the process fails, the changes to the evm state are rolled back.
+	_, err = k.InitiateOutbound(ctx, InitiateOutboundConfig{
+		CCTX:         &cctx,
+		ShouldPayGas: shouldPayGas,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	inCctxIndex, ok := ctx.Value("inCctxIndex").(string)
+	if ok {
+		cctx.InboundParams.ObservedHash = inCctxIndex
+	}
+	k.SetCctxAndNonceToCctxAndInboundHashToCctx(ctx, cctx)
+
+	return &cctx, nil
+}