				switch oldStatus {
				case types.CctxStatus_PendingOutbound:

					gasLimit, err := k.GetRevertGasLimit(ctx, cctx)
					if err != nil {
						return errors.New("can't get revert tx gas limit" + err.Error())
					}
					if gasLimit == 0 {
						// use same gas limit of outbound as a fallback -- should not happen
						gasLimit = cctx.OutboundTxParams[0].OutboundTxGasLimit
					}

					// create new OutboundTxParams for the revert
					revertTxParams := &types.OutboundTxParams{
						Receiver:           cctx.InboundTxParams.Sender,
						ReceiverChainId:    cctx.InboundTxParams.SenderChainId,
						Amount:             cctx.InboundTxParams.Amount,
						CoinType:           cctx.InboundTxParams.CoinType,
						OutboundTxGasLimit: gasLimit,
					}
					cctx.OutboundTxParams = append(cctx.OutboundTxParams, revertTxParams)

					err = k.PayGasAndUpdateCctx(
						tmpCtx,
						cctx.InboundTxParams.SenderChainId,
						&cctx,
						cctx.OutboundTxParams[0].Amount,
						false,
					)
	// get the gas price
	gasPrice, isFound := k.GetMedianGasPriceInUint(ctx, chainID)
	if !isFound {
		return cosmoserrors.Wrap(types.ErrUnableToGetGasPrice, fmt.Sprintf(" chain %d | Identifiers : %s ",
			chainID,
			cctx.LogIdentifierForCCTX()),
		)
	}
	gasPrice = gasPrice.MulUint64(2) // overpays gas price by 2x

	gasLimit := sdk.NewUint(cctx.GetCurrentOutTxParam().OutboundTxGasLimit)
	outTxGasFee := gasLimit.Mul(gasPrice)

	// get the gas fee in Zeta using system uniswapv2 pool wzeta/gasZRC20 and adding the protocol fee
	outTxGasFeeInZeta, err := k.fungibleKeeper.QueryUniswapV2RouterGetZetaAmountsIn(ctx, outTxGasFee.BigInt(), gasZRC20)
	if err != nil {
		return cosmoserrors.Wrap(err, "PayGasInZetaAndUpdateCctx: unable to QueryUniswapv2RouterGetAmountsIn")
	}
	feeInZeta := types.GetProtocolFee().Add(math.NewUintFromBigInt(outTxGasFeeInZeta))

	// reduce the amount of the outbound tx
	if feeInZeta.GT(zetaBurnt) {
		return cosmoserrors.Wrap(types.ErrNotEnoughZetaBurnt, fmt.Sprintf("feeInZeta(%s) more than zetaBurnt (%s) | Identifiers : %s ",
			feeInZeta,
			zetaBurnt,
			cctx.LogIdentifierForCCTX()),
		)
	}
	gasLimit, err := k.GetRevertGasLimit(ctx, cctx)
-	if err != nil {
+	if err != nil || gasLimit == 0 {
	    cctx.CctxStatus.ChangeStatus(types.CctxStatus_Aborted, "can't get revert tx gas limit"+err.Error())
	    return &types.MsgVoteOnObservedInboundTxResponse{}, nil
	}
-	if gasLimit == 0 {
-    	    // use same gas limit of outbound as a fallback -- should not happen
-	    gasLimit = msg.GasLimit
-	}
func (k Keeper) GetRevertGasLimit(ctx sdk.Context, cctx types.CrossChainTx) (uint64, error) {
	if cctx.InboundTxParams == nil {
		return 0, nil
	}

-	if cctx.InboundTxParams.CoinType == common.CoinType_Gas {
+	if cctx.InboundTxParams.CoinType == common.CoinType_Gas || cctx.InboundTxParams.CoinType == common.CoinType_Zeta {
		// get the gas limit of the gas token
		fc, found := k.fungibleKeeper.GetGasCoinForForeignCoin(ctx, cctx.InboundTxParams.SenderChainId)
		if !found {
			return 0, types.ErrForeignCoinNotFound
		}
		gasLimit, err := k.fungibleKeeper.QueryGasLimit(ctx, ethcommon.HexToAddress(fc.Zrc20ContractAddress))
		if err != nil {
			return 0, errors.Wrap(fungibletypes.ErrContractCall, err.Error())
		}
		return gasLimit.Uint64(), nil
	} else if cctx.InboundTxParams.CoinType == common.CoinType_ERC20 {
		// get the gas limit of the associated asset
	gasLimit, err := k.GetRevertGasLimit(ctx, cctx)
	if err != nil || gasLimit == 0 {
    	   return errors.New("can't get revert tx gas limit" + err.Error())
	}
-	if gasLimit == 0 {
-	   // use same gas limit of outbound as a fallback -- should not happen
-	   gasLimit = cctx.OutboundTxParams[0].OutboundTxGasLimit
-	}
