Merge branch 'main' into ducnt/add_test

.github/workflows/interchaintest.yml

@@ -33,18 +33,18 @@ jobs:
 
       - run: make ictest-start-polkadot
 
-  test-ibc-transfer:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Go 1.19
-        uses: actions/setup-go@v3
-        with:
-          go-version: 1.19
-
-      - name: checkout code
-        uses: actions/checkout@v3
-
-      - run: make ictest-ibc
+  # test-ibc-transfer:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - name: Set up Go 1.19
+  #       uses: actions/setup-go@v3
+  #       with:
+  #         go-version: 1.19
+
+  #     - name: checkout code
+  #       uses: actions/checkout@v3
+
+  #     - run: make ictest-ibc
 
   test-push-wasm:
     runs-on: ubuntu-latest

x/transfermiddleware/keeper/ics4wrapper.go

@@ -51,14 +51,13 @@ func (keeper Keeper) handleOverrideSendPacketTransferLogic(
 	nativeTransferToken := sdk.NewCoin(fungibleTokenPacketData.Denom, transferAmount)
 	ibcTransferToken := sdk.NewCoin(parachainInfo.IbcDenom, transferAmount)
 
-	escrowAddress := transfertypes.GetEscrowAddress(transfertypes.PortID, parachainInfo.ChannelId)
-	escrowToken := keeper.bankKeeper.GetAllBalances(ctx, escrowAddress)
-
+	escrowAddress := transfertypes.GetEscrowAddress(sourcePort, sourceChannel)
 	err = keeper.bankKeeper.SendCoinsFromAccountToModule(ctx, escrowAddress, transfertypes.ModuleName, sdk.NewCoins(nativeTransferToken))
 	if err != nil {
 		return 0, err
 	}
 	// burn native token
+	// Get Coin from excrow address
 	keeper.bankKeeper.BurnCoins(ctx, transfertypes.ModuleName, sdk.NewCoins(nativeTransferToken))
 
 	// release lock IBC token and send it to sender
@@ -67,8 +66,6 @@ func (keeper Keeper) handleOverrideSendPacketTransferLogic(
 	if err != nil {
 		return 0, err
 	}
-	escrowToken = keeper.bankKeeper.GetAllBalances(ctx, escrowAddress)
-	fmt.Println(escrowToken)
 
 	// new msg transfer from transfer to parachain
 	transferMsg := transfertypes.MsgTransfer{

x/transfermiddleware/relay_test.go

@@ -1,11 +1,14 @@
 package transfermiddleware_test
 
 import (
+	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"testing"
 	"time"
 
+	"github.com/cometbft/cometbft/crypto"
+	"github.com/cometbft/cometbft/crypto/ed25519"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	ibctransfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
 	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
@@ -49,6 +52,143 @@ func TestKeeperTestSuite(t *testing.T) {
 	suite.Run(t, new(TransferMiddlewareTestSuite))
 }
 
+var keyCounter uint64
+
+// we need to make this deterministic (same every test run), as encoded address size and thus gas cost,
+// depends on the actual bytes (due to ugly CanonicalAddress encoding)
+func keyPubAddr() (crypto.PrivKey, crypto.PubKey, sdk.AccAddress) {
+	keyCounter++
+	seed := make([]byte, 8)
+	binary.BigEndian.PutUint64(seed, keyCounter)
+
+	key := ed25519.GenPrivKeyFromSecret(seed)
+	pub := key.PubKey()
+	addr := sdk.AccAddress(pub.Address())
+	return key, pub, addr
+}
+
+func RandomAccountAddress(_ testing.TB) sdk.AccAddress {
+	_, _, addr := keyPubAddr()
+	return addr
+}
+
+func RandomBech32AccountAddress(t testing.TB) string {
+	return RandomAccountAddress(t).String()
+}
+
+func (suite *TransferMiddlewareTestSuite) TestSendTransfer() {
+	var (
+		transferAmount = sdk.NewInt(1000000000)
+		// when transfer via sdk transfer from A (module) -> B (contract)
+		timeoutHeight = clienttypes.NewHeight(1, 110)
+		pathAtoB      *customibctesting.Path
+		pathCtoB      *customibctesting.Path
+		path          *customibctesting.Path
+		srcPort       string
+		srcChannel    string
+		chain         *customibctesting.TestChain
+		expDenom      string
+		// pathBtoC      = NewTransferPath(suite.chainB, suite.chainC)
+	)
+
+	testCases := []struct {
+		name     string
+		malleate func()
+	}{
+		{
+			"Receiver is Parachain chain",
+			func() {
+				path = pathAtoB
+				srcPort = pathAtoB.EndpointB.ChannelConfig.PortID
+				srcChannel = pathAtoB.EndpointB.ChannelID
+				chain = suite.chainA
+				expDenom = sdk.DefaultBondDenom
+			},
+		},
+		{
+			"Receiver is cosmos chain chain",
+			func() {
+				path = pathCtoB
+				srcPort = pathCtoB.EndpointB.ChannelConfig.PortID
+				srcChannel = pathCtoB.EndpointB.ChannelID
+				chain = suite.chainC
+				expDenom = "ibc/C053D637CCA2A2BA030E2C5EE1B28A16F71CCB0E45E8BE52766DC1B241B77878"
+			},
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			suite.SetupTest()
+			pathAtoB = NewTransferPath(suite.chainA, suite.chainB)
+			suite.coordinator.Setup(pathAtoB)
+			pathCtoB = NewTransferPath(suite.chainC, suite.chainB)
+			suite.coordinator.Setup(pathCtoB)
+			// Add parachain token info
+			chainBtransMiddleware := suite.chainB.TransferMiddleware()
+			err := chainBtransMiddleware.AddParachainIBCInfo(suite.chainB.GetContext(), "ibc/C053D637CCA2A2BA030E2C5EE1B28A16F71CCB0E45E8BE52766DC1B241B77878", pathAtoB.EndpointB.ChannelID, sdk.DefaultBondDenom)
+			suite.Require().NoError(err)
+			// send coin from A to B
+
+			msg := ibctransfertypes.NewMsgTransfer(
+				pathAtoB.EndpointA.ChannelConfig.PortID,
+				pathAtoB.EndpointA.ChannelID,
+				sdk.NewCoin(sdk.DefaultBondDenom, transferAmount),
+				suite.chainA.SenderAccount.GetAddress().String(),
+				suite.chainB.SenderAccount.GetAddress().String(),
+				timeoutHeight,
+				0,
+				"",
+			)
+			_, err = suite.chainA.SendMsgs(msg)
+			suite.Require().NoError(err)
+			suite.Require().NoError(err, pathAtoB.EndpointB.UpdateClient())
+
+			// then
+			suite.Require().Equal(1, len(suite.chainA.PendingSendPackets))
+			suite.Require().Equal(0, len(suite.chainB.PendingSendPackets))
+
+			// and when relay to chain A and handle Ack on chain B
+			err = suite.coordinator.RelayAndAckPendingPackets(pathAtoB)
+			suite.Require().NoError(err)
+
+			// then
+			suite.Require().Equal(0, len(suite.chainA.PendingSendPackets))
+			suite.Require().Equal(0, len(suite.chainB.PendingSendPackets))
+
+			tc.malleate()
+
+			testAcc2 := RandomAccountAddress(suite.T())
+			msg = ibctransfertypes.NewMsgTransfer(
+				srcPort,
+				srcChannel,
+				sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(500000)),
+				suite.chainB.SenderAccount.GetAddress().String(),
+				testAcc2.String(),
+				timeoutHeight,
+				0,
+				"",
+			)
+			_, err = suite.chainB.SendMsgs(msg)
+			suite.Require().NoError(err)
+			suite.Require().NoError(err, path.EndpointB.UpdateClient())
+
+			suite.Require().Equal(1, len(suite.chainB.PendingSendPackets))
+			suite.Require().Equal(0, len(chain.PendingSendPackets))
+
+			// and when relay to chain B and handle Ack on chain A
+			err = suite.coordinator.RelayAndAckPendingPacketsReverse(path)
+			suite.Require().NoError(err)
+
+			suite.Require().Equal(0, len(suite.chainB.PendingSendPackets))
+			suite.Require().Equal(0, len(chain.PendingSendPackets))
+
+			balance := chain.AllBalances(testAcc2)
+			expBalance := sdk.NewCoins(sdk.NewCoin(expDenom, sdk.NewInt(500000)))
+			suite.Require().Equal(expBalance, balance)
+		})
+	}
+}
+
 // TODO: use testsuite here.
 func (suite *TransferMiddlewareTestSuite) TestOnrecvPacket() {
 	var (