test: trackers

testutil/keeper/config.go

@@ -0,0 +1,25 @@
+package keeper
+
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+const (
+	AccountAddressPrefix = "zeta"
+)
+
+var (
+	AccountPubKeyPrefix    = AccountAddressPrefix + "pub"
+	ValidatorAddressPrefix = AccountAddressPrefix + "valoper"
+	ValidatorPubKeyPrefix  = AccountAddressPrefix + "valoperpub"
+	ConsNodeAddressPrefix  = AccountAddressPrefix + "valcons"
+	ConsNodePubKeyPrefix   = AccountAddressPrefix + "valconspub"
+)
+
+func SetConfig(seal bool) {
+	config := sdk.GetConfig()
+	config.SetBech32PrefixForAccount(AccountAddressPrefix, AccountPubKeyPrefix)
+	config.SetBech32PrefixForValidator(ValidatorAddressPrefix, ValidatorPubKeyPrefix)
+	config.SetBech32PrefixForConsensusNode(ConsNodeAddressPrefix, ConsNodePubKeyPrefix)
+	if seal {
+		config.Seal()
+	}
+}

testutil/keeper/crosschain.go

@@ -37,6 +37,7 @@ func CrosschainKeeperWithMocks(
 	t testing.TB,
 	mockOptions CrosschainMockOptions,
 ) (*keeper.Keeper, sdk.Context, SDKKeepers, ZetaKeepers) {
+	SetConfig(false)
 	storeKey := sdk.NewKVStoreKey(types.StoreKey)
 	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
 

testutil/sample/common.go

@@ -5,10 +5,12 @@ import (
 	"math/big"
 
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 	"github.com/zeta-chain/zetacore/common"
+	"github.com/zeta-chain/zetacore/common/ethereum"
 )
 
 func Chain(chainID int64) *common.Chain {
@@ -42,3 +44,33 @@ func EthHeader() (headerRLP []byte, err error) {
 	headerRLP, _ = rlp.EncodeToBytes(block.Header())
 	return
 }
+
+func Proof() (txIndex int64, block *ethtypes.Block, header ethtypes.Header, headerRLP []byte, proof *common.Proof, tx *ethtypes.Transaction, err error) {
+	txIndex = int64(9)
+	url := "https://rpc.ankr.com/eth_goerli"
+	client, err := ethclient.Dial(url)
+	if err != nil {
+		return
+	}
+	bn := int64(9889649)
+	block, err = client.BlockByNumber(context.Background(), big.NewInt(bn))
+	if err != nil {
+		return
+	}
+	headerRLP, _ = rlp.EncodeToBytes(block.Header())
+	err = rlp.DecodeBytes(headerRLP, &header)
+	if err != nil {
+		return
+	}
+	tr := ethereum.NewTrie(block.Transactions())
+	var b []byte
+	ib := rlp.AppendUint64(b, uint64(txIndex))
+	p := ethereum.NewProof()
+	err = tr.Prove(ib, 0, p)
+	if err != nil {
+		return
+	}
+	proof = common.NewEthereumProof(p)
+	tx = block.Transactions()[txIndex]
+	return
+}

x/crosschain/keeper/keeper_cross_chain_tx_vote_inbound_tx.go

@@ -238,6 +238,7 @@ func (k msgServer) VoteOnObservedInboundTx(goCtx context.Context, msg *types.Msg
 		}
 		commit()
 		cctx.CctxStatus.ChangeStatus(types.CctxStatus_PendingOutbound, "")
+		k.RemoveInTxTrackerIfExists(ctx, cctx.InboundTxParams.SenderChainId, cctx.InboundTxParams.InboundTxObservedHash)
 		return &types.MsgVoteOnObservedInboundTxResponse{}, nil
 	}
 }

x/crosschain/keeper/msg_server_add_to_intx_tracker.go

@@ -6,8 +6,6 @@ import (
 
 	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	eth "github.com/ethereum/go-ethereum/common"
-	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/zeta-chain/zetacore/common"
 	"github.com/zeta-chain/zetacore/x/crosschain/types"
 	observertypes "github.com/zeta-chain/zetacore/x/observer/types"
@@ -29,11 +27,16 @@ func (k msgServer) AddToInTxTracker(goCtx context.Context, msg *types.MsgAddToIn
 	if !(isAdmin || isObserver) && msg.Proof != nil {
 		txBytes, err := k.VerifyProof(ctx, msg.Proof, msg.ChainId, msg.BlockHash, msg.TxIndex)
 		if err != nil {
-			return nil, types.ErrCannotVerifyProof.Wrapf(err.Error())
+			return nil, types.ErrProofVerificationFail.Wrapf(err.Error())
 		}
-		err = k.VerifyInTxBody(ctx, msg, txBytes)
-		if err != nil {
-			return nil, types.ErrCannotVerifyProof.Wrapf(err.Error())
+
+		if common.IsEVMChain(msg.ChainId) {
+			err = k.VerifyEVMInTxBody(ctx, msg, txBytes)
+			if err != nil {
+				return nil, types.ErrTxBodyVerificationFail.Wrapf(err.Error())
+			}
+		} else {
+			return nil, types.ErrTxBodyVerificationFail.Wrapf(fmt.Sprintf("cannot verify inTx body for chain %d", msg.ChainId))
 		}
 		isProven = true
 	}
@@ -43,63 +46,10 @@ func (k msgServer) AddToInTxTracker(goCtx context.Context, msg *types.MsgAddToIn
 		return nil, errorsmod.Wrap(observertypes.ErrNotAuthorized, fmt.Sprintf("Creator %s", msg.Creator))
 	}
 
-	k.Keeper.SetInTxTracker(ctx, types.InTxTracker{
+	k.SetInTxTracker(ctx, types.InTxTracker{
 		ChainId:  msg.ChainId,
 		TxHash:   msg.TxHash,
 		CoinType: msg.CoinType,
 	})
 	return &types.MsgAddToInTxTrackerResponse{}, nil
 }
-
-// https://github.com/zeta-chain/node/issues/1254
-func (k Keeper) VerifyInTxBody(ctx sdk.Context, msg *types.MsgAddToInTxTracker, txBytes []byte) error {
-	// get core params and tss address
-	coreParams, found := k.zetaObserverKeeper.GetCoreParamsByChainID(ctx, msg.ChainId)
-	if !found {
-		return types.ErrUnsupportedChain.Wrapf("core params not found for chain %d", msg.ChainId)
-	}
-	tss, err := k.GetTssAddress(ctx, &types.QueryGetTssAddressRequest{})
-	if err != nil {
-		return err
-	}
-
-	// verify message against transaction body
-	if common.IsEVMChain(msg.ChainId) {
-		err = VerifyEVMInTxBody(coreParams, msg, txBytes, tss.Eth)
-	} else {
-		return fmt.Errorf("cannot verify inTx body for chain %d", msg.ChainId)
-	}
-	return err
-}
-
-func VerifyEVMInTxBody(coreParams *observertypes.CoreParams, msg *types.MsgAddToInTxTracker, txBytes []byte, tssEth string) error {
-	var txx ethtypes.Transaction
-	err := txx.UnmarshalBinary(txBytes)
-	if err != nil {
-		return err
-	}
-	tssAddr := eth.HexToAddress(tssEth)
-	if tssAddr == (eth.Address{}) {
-		return fmt.Errorf("tss address not found")
-	}
-
-	switch msg.CoinType {
-	case common.CoinType_Zeta:
-		if txx.To().Hex() != coreParams.ConnectorContractAddress {
-			return fmt.Errorf("receiver is not connector contract for coin type %s", msg.CoinType)
-		}
-		return nil
-	case common.CoinType_ERC20:
-		if txx.To().Hex() != coreParams.Erc20CustodyContractAddress {
-			return fmt.Errorf("receiver is not erc20Custory contract for coin type %s", msg.CoinType)
-		}
-		return nil
-	case common.CoinType_Gas:
-		if txx.To().Hex() != tssAddr.Hex() {
-			return fmt.Errorf("receiver is not tssAddress contract for coin type %s", msg.CoinType)
-		}
-		return nil
-	default:
-		return fmt.Errorf("coin type %s not supported", msg.CoinType)
-	}
-}

x/crosschain/keeper/msg_server_add_to_intx_tracker_test.go

@@ -0,0 +1,176 @@
+//go:build TESTNET
+// +build TESTNET
+
+package keeper_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/require"
+	"github.com/zeta-chain/zetacore/common"
+	keepertest "github.com/zeta-chain/zetacore/testutil/keeper"
+	"github.com/zeta-chain/zetacore/testutil/sample"
+	"github.com/zeta-chain/zetacore/x/crosschain/keeper"
+	"github.com/zeta-chain/zetacore/x/crosschain/types"
+	observerTypes "github.com/zeta-chain/zetacore/x/observer/types"
+)
+
+func TestMsgServer_AddToInTxTracker(t *testing.T) {
+	t.Run("add proof based tracker with correct proof", func(t *testing.T) {
+		k, ctx, _, zk := keepertest.CrosschainKeeper(t)
+		chainID := int64(5)
+		txIndex, block, header, headerRLP, proof, tx, err := sample.Proof()
+		require.NoError(t, err)
+		setupVerificationParams(zk, ctx, txIndex, chainID, header, headerRLP, block)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err = msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   sample.AccAddress(),
+			ChainId:   chainID,
+			TxHash:    tx.Hash().Hex(),
+			CoinType:  common.CoinType_Zeta,
+			Proof:     proof,
+			BlockHash: block.Hash().Hex(),
+			TxIndex:   txIndex,
+		})
+		require.NoError(t, err)
+		_, found := k.GetInTxTracker(ctx, chainID, tx.Hash().Hex())
+		require.True(t, found)
+	})
+
+	t.Run("fail to add proof based tracker with wrong tx hash", func(t *testing.T) {
+		k, ctx, _, zk := keepertest.CrosschainKeeper(t)
+		chainID := int64(5)
+		txIndex, block, header, headerRLP, proof, tx, err := sample.Proof()
+		require.NoError(t, err)
+		setupVerificationParams(zk, ctx, txIndex, chainID, header, headerRLP, block)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err = msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   sample.AccAddress(),
+			ChainId:   chainID,
+			TxHash:    "fake_hash",
+			CoinType:  common.CoinType_Zeta,
+			Proof:     proof,
+			BlockHash: block.Hash().Hex(),
+			TxIndex:   txIndex,
+		})
+		require.ErrorIs(t, types.ErrTxBodyVerificationFail, err)
+		_, found := k.GetInTxTracker(ctx, chainID, tx.Hash().Hex())
+		require.False(t, found)
+	})
+
+	t.Run("fail to add proof based tracker with wrong chain id", func(t *testing.T) {
+		k, ctx, _, zk := keepertest.CrosschainKeeper(t)
+		chainID := int64(5)
+		txIndex, block, header, headerRLP, proof, tx, err := sample.Proof()
+		require.NoError(t, err)
+		setupVerificationParams(zk, ctx, txIndex, chainID, header, headerRLP, block)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err = msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   sample.AccAddress(),
+			ChainId:   97,
+			TxHash:    tx.Hash().Hex(),
+			CoinType:  common.CoinType_Zeta,
+			Proof:     proof,
+			BlockHash: block.Hash().Hex(),
+			TxIndex:   txIndex,
+		})
+		require.ErrorIs(t, types.ErrTxBodyVerificationFail, err)
+		_, found := k.GetInTxTracker(ctx, chainID, tx.Hash().Hex())
+		require.False(t, found)
+	})
+	t.Run("fail normal user submit without proof", func(t *testing.T) {
+		k, ctx, _, _ := keepertest.CrosschainKeeper(t)
+		tx_hash := "string"
+		chainID := int64(5)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err := msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   sample.AccAddress(),
+			ChainId:   chainID,
+			TxHash:    tx_hash,
+			CoinType:  common.CoinType_Zeta,
+			Proof:     nil,
+			BlockHash: "",
+			TxIndex:   0,
+		})
+		require.ErrorIs(t, observerTypes.ErrNotAuthorized, err)
+		_, found := k.GetInTxTracker(ctx, chainID, tx_hash)
+		require.False(t, found)
+	})
+	t.Run("admin add  tx tracker", func(t *testing.T) {
+		k, ctx, _, zk := keepertest.CrosschainKeeper(t)
+		admin := sample.AccAddress()
+		setAdminPolicies(ctx, zk, admin)
+		tx_hash := "string"
+		chainID := int64(5)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err := msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   admin,
+			ChainId:   chainID,
+			TxHash:    tx_hash,
+			CoinType:  common.CoinType_Zeta,
+			Proof:     nil,
+			BlockHash: "",
+			TxIndex:   0,
+		})
+		require.NoError(t, err)
+		_, found := k.GetInTxTracker(ctx, chainID, tx_hash)
+		require.True(t, found)
+	})
+	t.Run("admin submit fake tracker", func(t *testing.T) {
+		k, ctx, _, zk := keepertest.CrosschainKeeper(t)
+		admin := sample.AccAddress()
+		setAdminPolicies(ctx, zk, admin)
+		tx_hash := "string"
+		chainID := int64(5)
+		msgServer := keeper.NewMsgServerImpl(*k)
+		_, err := msgServer.AddToInTxTracker(ctx, &types.MsgAddToInTxTracker{
+			Creator:   admin,
+			ChainId:   chainID,
+			TxHash:    "Malicious TX HASH",
+			CoinType:  common.CoinType_Zeta,
+			Proof:     nil,
+			BlockHash: "",
+			TxIndex:   0,
+		})
+		require.NoError(t, err)
+		_, found := k.GetInTxTracker(ctx, chainID, "Malicious TX HASH")
+		require.True(t, found)
+		_, found = k.GetInTxTracker(ctx, chainID, tx_hash)
+		require.False(t, found)
+	})
+}
+
+func setupVerificationParams(zk keepertest.ZetaKeepers, ctx sdk.Context, tx_index int64, chainID int64, header ethtypes.Header, headerRLP []byte, block *ethtypes.Block) {
+	params := zk.ObserverKeeper.GetParams(ctx)
+	params.ObserverParams = append(params.ObserverParams, &observerTypes.ObserverParams{
+		Chain: &common.Chain{
+			ChainId:   chainID,
+			ChainName: common.ChainName_goerli_testnet,
+		},
+		BallotThreshold:       sdk.OneDec(),
+		MinObserverDelegation: sdk.OneDec(),
+		IsSupported:           true,
+	})
+	zk.ObserverKeeper.SetParams(ctx, params)
+	zk.ObserverKeeper.SetBlockHeader(ctx, common.BlockHeader{
+		Height:     block.Number().Int64(),
+		Hash:       block.Hash().Bytes(),
+		ParentHash: header.ParentHash.Bytes(),
+		ChainId:    chainID,
+		Header:     common.NewEthereumHeader(headerRLP),
+	})
+	zk.ObserverKeeper.SetCoreParams(ctx, observerTypes.CoreParamsList{CoreParams: []*observerTypes.CoreParams{
+		{
+			ChainId:                  chainID,
+			ConnectorContractAddress: block.Transactions()[tx_index].To().Hex(),
+		},
+	}})
+	zk.ObserverKeeper.SetCrosschainFlags(ctx, observerTypes.CrosschainFlags{
+		BlockHeaderVerificationFlags: &observerTypes.BlockHeaderVerificationFlags{
+			IsEthTypeChainEnabled: true,
+			IsBtcTypeChainEnabled: false,
+		},
+	})
+}