From d9e40363e0d3b4c0d43a188b82408447e55273bc Mon Sep 17 00:00:00 2001 From: GNaD Date: Fri, 26 May 2023 23:57:03 +0700 Subject: [PATCH 1/4] add test sucess case --- x/transfermiddleware/pfm_test.go | 232 +++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) diff --git a/x/transfermiddleware/pfm_test.go b/x/transfermiddleware/pfm_test.go index 9e974ae4a..9c257c8f3 100644 --- a/x/transfermiddleware/pfm_test.go +++ b/x/transfermiddleware/pfm_test.go @@ -351,3 +351,235 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM() { }) } } + +func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { + var ( + transferAmount = sdk.NewInt(1000000000) + // when transfer via sdk transfer from A (module) -> B (contract) + timeoutHeight = clienttypes.NewHeight(1, 110) + pathAtoB *customibctesting.Path + pathBtoC *customibctesting.Path + expDenom = "ibc/C053D637CCA2A2BA030E2C5EE1B28A16F71CCB0E45E8BE52766DC1B241B77878" + ) + + testCases := []struct { + name string + }{ + { + "Success case Picasso -> Composable -> Osmosis and reverse from Osmosis -> Composable -> Picasso", + }, + } + for _, tc := range testCases { + suite.Run(tc.name, func() { + suite.SetupTest() + pathAtoB = NewTransferPath(suite.chainA, suite.chainB) + suite.coordinator.Setup(pathAtoB) + pathBtoC = NewTransferPath(suite.chainB, suite.chainC) + suite.coordinator.Setup(pathBtoC) + senderAOriginalBalance := suite.chainA.AllBalances(suite.chainA.SenderAccount.GetAddress()) + senderBOriginalBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + senderCOriginalBalance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + // Add parachain token info + chainBtransMiddleware := suite.chainB.TransferMiddleware() + err := chainBtransMiddleware.AddParachainIBCInfo(suite.chainB.GetContext(), expDenom, pathAtoB.EndpointB.ChannelID, sdk.DefaultBondDenom) + suite.Require().NoError(err) + + timeOut := 10 * time.Minute + retries := uint8(0) + // Build MEMO + memo := PacketMetadata{ + Forward: &ForwardMetadata{ + Receiver: suite.chainC.SenderAccount.GetAddress().String(), + Port: pathBtoC.EndpointA.ChannelConfig.PortID, + Channel: pathBtoC.EndpointA.ChannelID, + Timeout: timeOut, + Retries: &retries, + Next: "", + }, + } + memo_marshalled, err := json.Marshal(&memo) + suite.Require().NoError(err) + + 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, + string(memo_marshalled), + ) + _, 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)) + // relay packet + sendingPacket := suite.chainA.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainA) + err = pathAtoB.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointB.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainA.PendingSendPackets = nil + // then should have a packet from B to C + suite.Require().Equal(1, len(suite.chainB.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainC.PendingSendPackets)) + + // relay packet + sendingPacket = suite.chainB.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathBtoC.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointB.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainB.PendingSendPackets = nil + + // relay ack C to B + suite.Require().Equal(1, len(suite.chainC.PendingAckPackets)) + ack := suite.chainC.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainC) + err = pathBtoC.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointA.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainC.PendingAckPackets = nil + + // relay ack B to A + suite.Require().Equal(1, len(suite.chainB.PendingAckPackets)) + ack = suite.chainB.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathAtoB.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointA.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainB.PendingAckPackets = nil + + senderBCurrentBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + suite.Require().Equal(senderBOriginalBalance, senderBCurrentBalance) + + escrowIbcDenomAddress := transfertypes.GetEscrowAddress(pathAtoB.EndpointB.ChannelConfig.PortID, pathAtoB.EndpointB.ChannelID) + escrowIbcDenomAddressBalance := suite.chainB.AllBalances(escrowIbcDenomAddress) + expBalance := sdk.NewCoins(sdk.NewCoin(expDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowIbcDenomAddressBalance) + + escrowNativeDenomAddress := transfertypes.GetEscrowAddress(pathBtoC.EndpointA.ChannelConfig.PortID, pathBtoC.EndpointA.ChannelID) + escrowNativeDenomAddressBalance := suite.chainB.AllBalances(escrowNativeDenomAddress) + expBalance = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowNativeDenomAddressBalance) + + balance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + receiveBalance := balance.AmountOf(expDenom) + suite.Require().Equal(transferAmount, receiveBalance) + + // transfer back from osmosis to picasso + memo = PacketMetadata{ + Forward: &ForwardMetadata{ + Receiver: suite.chainA.SenderAccount.GetAddress().String(), + Port: pathAtoB.EndpointB.ChannelConfig.PortID, + Channel: pathAtoB.EndpointB.ChannelID, + Timeout: timeOut, + Retries: &retries, + Next: "", + }, + } + + memo_marshalled, err = json.Marshal(&memo) + suite.Require().NoError(err) + + msg = ibctransfertypes.NewMsgTransfer( + pathBtoC.EndpointB.ChannelConfig.PortID, + pathBtoC.EndpointB.ChannelID, + sdk.NewCoin(expDenom, transferAmount), + suite.chainC.SenderAccount.GetAddress().String(), + suite.chainB.SenderAccount.GetAddress().String(), + timeoutHeight, + 0, + string(memo_marshalled), + ) + + _, err = suite.chainC.SendMsgs(msg) + suite.Require().NoError(err) + suite.Require().NoError(err, pathBtoC.EndpointA.UpdateClient()) + + // then + suite.Require().Equal(1, len(suite.chainC.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainB.PendingSendPackets)) + // relay packet + sendingPacket = suite.chainC.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainC) + err = pathBtoC.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointA.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainC.PendingSendPackets = nil + + // then should have a packet from B to A + suite.Require().Equal(1, len(suite.chainB.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainA.PendingSendPackets)) + + // relay packet + sendingPacket = suite.chainB.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathAtoB.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointA.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainB.PendingSendPackets = nil + + // relay ack A to B + suite.Require().Equal(1, len(suite.chainA.PendingAckPackets)) + ack = suite.chainA.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainA) + err = pathAtoB.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointB.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainA.PendingAckPackets = nil + + // relay ack B to C + suite.Require().Equal(1, len(suite.chainB.PendingAckPackets)) + ack = suite.chainB.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathBtoC.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointB.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainB.PendingAckPackets = nil + + senderACurrentBalance := suite.chainA.AllBalances(suite.chainA.SenderAccount.GetAddress()) + suite.Require().Equal(senderAOriginalBalance, senderACurrentBalance) + + senderBCurrentBalance = suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + suite.Require().Equal(senderBOriginalBalance, senderBCurrentBalance) + + senderCCurrentBalance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + suite.Require().Equal(senderCOriginalBalance, senderCCurrentBalance) + + escrowIbcDenomAddressBalance = suite.chainB.AllBalances(escrowIbcDenomAddress) + suite.Require().Empty(escrowIbcDenomAddressBalance) + + escrowNativeDenomAddressBalance = suite.chainB.AllBalances(escrowNativeDenomAddress) + suite.Require().Empty(escrowNativeDenomAddressBalance) + }) + } +} From 994bc758e5391a6ca8a4ccc8ecfa7005b9bc5a33 Mon Sep 17 00:00:00 2001 From: GNaD Date: Sat, 27 May 2023 01:07:47 +0700 Subject: [PATCH 2/4] add test reverse error ack --- go.mod | 2 +- go.sum | 4 +- x/transfermiddleware/keeper/ics4wrapper.go | 3 +- x/transfermiddleware/pfm_test.go | 250 +++++++++++++++++++++ 4 files changed, 255 insertions(+), 4 deletions(-) diff --git a/go.mod b/go.mod index b3f2d6b69..11481ead6 100644 --- a/go.mod +++ b/go.mod @@ -177,7 +177,7 @@ replace ( // ibc-go with wasm client github.com/cosmos/ibc-go/v7 => github.com/strangelove-ventures/ibc-go/v7 v7.0.0-20230410223156-8c202c556f82 - github.com/strangelove-ventures/packet-forward-middleware/v7 => github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230517054520-e1958ca2830e + github.com/strangelove-ventures/packet-forward-middleware/v7 => github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230526180458-68520c6b500d github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 diff --git a/go.sum b/go.sum index 228bf08e7..0b21d2efb 100644 --- a/go.sum +++ b/go.sum @@ -755,8 +755,8 @@ github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxzi github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230517054520-e1958ca2830e h1:VnV20PYZsHoApnSNdxgM9E8f3Xxsk8yx8lL7WZZs1Ls= -github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230517054520-e1958ca2830e/go.mod h1:ZqzpgUUK75BHIttNMs2ANFUNGEmi+aFij6gYmiDjdqc= +github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230526180458-68520c6b500d h1:1O+4lgWVLMXaXPmn5hYBpf4dFansC80mnSeS4KhZWrc= +github.com/notional-labs/packet-forward-middleware/v7 v7.0.0-20230526180458-68520c6b500d/go.mod h1:ZqzpgUUK75BHIttNMs2ANFUNGEmi+aFij6gYmiDjdqc= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs= diff --git a/x/transfermiddleware/keeper/ics4wrapper.go b/x/transfermiddleware/keeper/ics4wrapper.go index 6e1cd8a7c..59cdbcb08 100644 --- a/x/transfermiddleware/keeper/ics4wrapper.go +++ b/x/transfermiddleware/keeper/ics4wrapper.go @@ -108,6 +108,7 @@ func (keeper Keeper) SendPacket( if err != nil { return 0, err } + // check if denom in fungibleTokenPacketData is native denom in parachain info and parachainInfo := keeper.GetParachainIBCTokenInfo(ctx, fungibleTokenPacketData.Denom) @@ -173,7 +174,6 @@ func (keeper Keeper) refundToken(ctx sdk.Context, packet channeltypes.Packet, da if err != nil { return err } - if transfertypes.SenderChainIsSource(packet.GetSourcePort(), packet.GetSourceChannel(), data.Denom) { // Do nothing // This case should never happened @@ -181,6 +181,7 @@ func (keeper Keeper) refundToken(ctx sdk.Context, packet channeltypes.Packet, da } nativeDenom := keeper.GetNativeDenomByIBCDenomSecondaryIndex(ctx, trace.IBCDenom()) paraTokenInfo := keeper.GetParachainIBCTokenInfo(ctx, nativeDenom) + // only trigger if source channel is from parachain. if !keeper.hasParachainIBCTokenInfo(ctx, nativeDenom) { return nil diff --git a/x/transfermiddleware/pfm_test.go b/x/transfermiddleware/pfm_test.go index 9c257c8f3..c0dc37c27 100644 --- a/x/transfermiddleware/pfm_test.go +++ b/x/transfermiddleware/pfm_test.go @@ -352,6 +352,256 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM() { } } +func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() { + var ( + transferAmount = sdk.NewInt(1000000000) + // when transfer via sdk transfer from A (module) -> B (contract) + timeoutHeight = clienttypes.NewHeight(1, 110) + pathAtoB *customibctesting.Path + pathBtoC *customibctesting.Path + expDenom = "ibc/C053D637CCA2A2BA030E2C5EE1B28A16F71CCB0E45E8BE52766DC1B241B77878" + ) + + testCases := []struct { + name string + }{ + { + "Success case Picasso -> Composable -> Osmosis and reverse from Osmosis -> Composable -> Picasso", + }, + } + for _, tc := range testCases { + suite.Run(tc.name, func() { + suite.SetupTest() + pathAtoB = NewTransferPath(suite.chainA, suite.chainB) + suite.coordinator.Setup(pathAtoB) + pathBtoC = NewTransferPath(suite.chainB, suite.chainC) + suite.coordinator.Setup(pathBtoC) + senderAOriginalBalance := suite.chainA.AllBalances(suite.chainA.SenderAccount.GetAddress()) + senderBOriginalBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + senderCOriginalBalance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + _ = senderAOriginalBalance + _ = senderBOriginalBalance + _ = senderCOriginalBalance + // Add parachain token info + chainBtransMiddleware := suite.chainB.TransferMiddleware() + err := chainBtransMiddleware.AddParachainIBCInfo(suite.chainB.GetContext(), expDenom, pathAtoB.EndpointB.ChannelID, sdk.DefaultBondDenom) + suite.Require().NoError(err) + + // Disable receiveEnabled on chain A so it will return error ack + params := transfertypes.Params{ + SendEnabled: true, + ReceiveEnabled: false, + } + // set send params + suite.chainA.GetTestSupport().TransferKeeper().SetParams(suite.chainA.GetContext(), params) + + timeOut := 10 * time.Minute + retries := uint8(0) + // Build MEMO + memo := PacketMetadata{ + Forward: &ForwardMetadata{ + Receiver: suite.chainC.SenderAccount.GetAddress().String(), + Port: pathBtoC.EndpointA.ChannelConfig.PortID, + Channel: pathBtoC.EndpointA.ChannelID, + Timeout: timeOut, + Retries: &retries, + Next: "", + }, + } + memo_marshalled, err := json.Marshal(&memo) + suite.Require().NoError(err) + + 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, + string(memo_marshalled), + ) + _, 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)) + // relay packet + sendingPacket := suite.chainA.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainA) + err = pathAtoB.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointB.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainA.PendingSendPackets = nil + // then should have a packet from B to C + suite.Require().Equal(1, len(suite.chainB.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainC.PendingSendPackets)) + + // relay packet + sendingPacket = suite.chainB.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathBtoC.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointB.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainB.PendingSendPackets = nil + + // relay ack C to B + suite.Require().Equal(1, len(suite.chainC.PendingAckPackets)) + ack := suite.chainC.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainC) + err = pathBtoC.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointA.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainC.PendingAckPackets = nil + + // relay ack B to A + suite.Require().Equal(1, len(suite.chainB.PendingAckPackets)) + ack = suite.chainB.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathAtoB.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointA.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainB.PendingAckPackets = nil + + senderBCurrentBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + suite.Require().Equal(senderBOriginalBalance, senderBCurrentBalance) + + escrowIbcDenomAddress := transfertypes.GetEscrowAddress(pathAtoB.EndpointB.ChannelConfig.PortID, pathAtoB.EndpointB.ChannelID) + escrowIbcDenomAddressBalance := suite.chainB.AllBalances(escrowIbcDenomAddress) + expBalance := sdk.NewCoins(sdk.NewCoin(expDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowIbcDenomAddressBalance) + + escrowNativeDenomAddress := transfertypes.GetEscrowAddress(pathBtoC.EndpointA.ChannelConfig.PortID, pathBtoC.EndpointA.ChannelID) + escrowNativeDenomAddressBalance := suite.chainB.AllBalances(escrowNativeDenomAddress) + expBalance = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowNativeDenomAddressBalance) + + balance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + receiveBalance := balance.AmountOf(expDenom) + suite.Require().Equal(transferAmount, receiveBalance) + + senderAOriginalBalance = suite.chainA.AllBalances(suite.chainA.SenderAccount.GetAddress()) + senderBOriginalBalance = suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + senderCOriginalBalance = suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + // transfer back from osmosis to picasso + memo = PacketMetadata{ + Forward: &ForwardMetadata{ + Receiver: suite.chainA.SenderAccount.GetAddress().String(), + Port: pathAtoB.EndpointB.ChannelConfig.PortID, + Channel: pathAtoB.EndpointB.ChannelID, + Timeout: timeOut, + Retries: &retries, + Next: "", + }, + } + + memo_marshalled, err = json.Marshal(&memo) + suite.Require().NoError(err) + + msg = ibctransfertypes.NewMsgTransfer( + pathBtoC.EndpointB.ChannelConfig.PortID, + pathBtoC.EndpointB.ChannelID, + sdk.NewCoin(expDenom, transferAmount), + suite.chainC.SenderAccount.GetAddress().String(), + suite.chainB.SenderAccount.GetAddress().String(), + timeoutHeight, + 0, + string(memo_marshalled), + ) + + _, err = suite.chainC.SendMsgs(msg) + suite.Require().NoError(err) + suite.Require().NoError(err, pathBtoC.EndpointA.UpdateClient()) + + // then + suite.Require().Equal(1, len(suite.chainC.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainB.PendingSendPackets)) + // relay packet + sendingPacket = suite.chainC.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainC) + err = pathBtoC.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointA.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainC.PendingSendPackets = nil + + // then should have a packet from B to A + suite.Require().Equal(1, len(suite.chainB.PendingSendPackets)) + suite.Require().Equal(0, len(suite.chainA.PendingSendPackets)) + + // relay packet + sendingPacket = suite.chainB.PendingSendPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathAtoB.EndpointA.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointA.RecvPacket(sendingPacket) + suite.Require().NoError(err) + suite.chainB.PendingSendPackets = nil + + // relay error ack A to B + suite.Require().Equal(1, len(suite.chainA.PendingAckPackets)) + ack = suite.chainA.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainA) + err = pathAtoB.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathAtoB.EndpointB.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainA.PendingAckPackets = nil + + // relay error ack B to C + suite.Require().Equal(1, len(suite.chainB.PendingAckPackets)) + ack = suite.chainB.PendingAckPackets[0] + suite.coordinator.IncrementTime() + suite.coordinator.CommitBlock(suite.chainB) + err = pathBtoC.EndpointB.UpdateClient() + suite.Require().NoError(err) + + err = pathBtoC.EndpointB.AcknowledgePacket(ack.Packet, ack.Ack) + suite.Require().NoError(err) + suite.chainB.PendingAckPackets = nil + + senderACurrentBalance := suite.chainA.AllBalances(suite.chainA.SenderAccount.GetAddress()) + suite.Require().Equal(senderAOriginalBalance, senderACurrentBalance) + + senderBCurrentBalance = suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) + suite.Require().Equal(senderBOriginalBalance, senderBCurrentBalance) + + senderCCurrentBalance := suite.chainC.AllBalances(suite.chainC.SenderAccount.GetAddress()) + suite.Require().Equal(senderCOriginalBalance, senderCCurrentBalance) + + escrowIbcDenomAddress = transfertypes.GetEscrowAddress(pathAtoB.EndpointB.ChannelConfig.PortID, pathAtoB.EndpointB.ChannelID) + escrowIbcDenomAddressBalance = suite.chainB.AllBalances(escrowIbcDenomAddress) + expBalance = sdk.NewCoins(sdk.NewCoin(expDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowIbcDenomAddressBalance) + + escrowNativeDenomAddress = transfertypes.GetEscrowAddress(pathBtoC.EndpointA.ChannelConfig.PortID, pathBtoC.EndpointA.ChannelID) + escrowNativeDenomAddressBalance = suite.chainB.AllBalances(escrowNativeDenomAddress) + expBalance = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, transferAmount)) + suite.Require().Equal(expBalance, escrowNativeDenomAddressBalance) + }) + } +} + func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { var ( transferAmount = sdk.NewInt(1000000000) From cae9fac5a4c9953f1c22756dc406b2477347f206 Mon Sep 17 00:00:00 2001 From: GNaD Date: Sat, 27 May 2023 01:13:52 +0700 Subject: [PATCH 3/4] lint --- x/transfermiddleware/pfm_test.go | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/x/transfermiddleware/pfm_test.go b/x/transfermiddleware/pfm_test.go index c0dc37c27..9c9bc8f97 100644 --- a/x/transfermiddleware/pfm_test.go +++ b/x/transfermiddleware/pfm_test.go @@ -9,7 +9,6 @@ import ( "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" transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types" clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types" customibctesting "github.com/notional-labs/banksy/v2/app/ibctesting" @@ -52,8 +51,8 @@ func NewTransferPath(chainA, chainB *customibctesting.TestChain) *customibctesti path := customibctesting.NewPath(chainA, chainB) path.EndpointA.ChannelConfig.PortID = customibctesting.TransferPort path.EndpointB.ChannelConfig.PortID = customibctesting.TransferPort - path.EndpointA.ChannelConfig.Version = ibctransfertypes.Version - path.EndpointB.ChannelConfig.Version = ibctransfertypes.Version + path.EndpointA.ChannelConfig.Version = transfertypes.Version + path.EndpointB.ChannelConfig.Version = transfertypes.Version return path } @@ -131,7 +130,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM_ErrorAck() { memo_marshalled, err := json.Marshal(&memo) suite.Require().NoError(err) - msg := ibctransfertypes.NewMsgTransfer( + msg := transfertypes.NewMsgTransfer( pathAtoB.EndpointA.ChannelConfig.PortID, pathAtoB.EndpointA.ChannelID, sdk.NewCoin(sdk.DefaultBondDenom, transferAmount), @@ -276,7 +275,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM() { intermediaryOriginalBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) - msg := ibctransfertypes.NewMsgTransfer( + msg := transfertypes.NewMsgTransfer( pathAtoB.EndpointA.ChannelConfig.PortID, pathAtoB.EndpointA.ChannelID, sdk.NewCoin(sdk.DefaultBondDenom, transferAmount), @@ -411,7 +410,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() memo_marshalled, err := json.Marshal(&memo) suite.Require().NoError(err) - msg := ibctransfertypes.NewMsgTransfer( + msg := transfertypes.NewMsgTransfer( pathAtoB.EndpointA.ChannelConfig.PortID, pathAtoB.EndpointA.ChannelID, sdk.NewCoin(sdk.DefaultBondDenom, transferAmount), @@ -512,7 +511,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() memo_marshalled, err = json.Marshal(&memo) suite.Require().NoError(err) - msg = ibctransfertypes.NewMsgTransfer( + msg = transfertypes.NewMsgTransfer( pathBtoC.EndpointB.ChannelConfig.PortID, pathBtoC.EndpointB.ChannelID, sdk.NewCoin(expDenom, transferAmount), @@ -650,7 +649,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { memo_marshalled, err := json.Marshal(&memo) suite.Require().NoError(err) - msg := ibctransfertypes.NewMsgTransfer( + msg := transfertypes.NewMsgTransfer( pathAtoB.EndpointA.ChannelConfig.PortID, pathAtoB.EndpointA.ChannelID, sdk.NewCoin(sdk.DefaultBondDenom, transferAmount), @@ -748,7 +747,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { memo_marshalled, err = json.Marshal(&memo) suite.Require().NoError(err) - msg = ibctransfertypes.NewMsgTransfer( + msg = transfertypes.NewMsgTransfer( pathBtoC.EndpointB.ChannelConfig.PortID, pathBtoC.EndpointB.ChannelID, sdk.NewCoin(expDenom, transferAmount), From 485b8d0b1dd1cdcffbf1ac534cd833782a1cec38 Mon Sep 17 00:00:00 2001 From: GNaD Date: Sat, 27 May 2023 01:15:08 +0700 Subject: [PATCH 4/4] lint --- x/transfermiddleware/pfm_test.go | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/x/transfermiddleware/pfm_test.go b/x/transfermiddleware/pfm_test.go index 9c9bc8f97..4be07d3f2 100644 --- a/x/transfermiddleware/pfm_test.go +++ b/x/transfermiddleware/pfm_test.go @@ -127,7 +127,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM_ErrorAck() { Next: "", }, } - memo_marshalled, err := json.Marshal(&memo) + memoMarshalled, err := json.Marshal(&memo) suite.Require().NoError(err) msg := transfertypes.NewMsgTransfer( @@ -138,7 +138,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM_ErrorAck() { testAcc.String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainA.SendMsgs(msg) suite.Require().NoError(err) @@ -270,7 +270,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM() { Next: "", }, } - memo_marshalled, err := json.Marshal(&memo) + memoMarshalled, err := json.Marshal(&memo) suite.Require().NoError(err) intermediaryOriginalBalance := suite.chainB.AllBalances(suite.chainB.SenderAccount.GetAddress()) @@ -283,7 +283,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFM() { suite.chainB.SenderAccount.GetAddress().String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainA.SendMsgs(msg) suite.Require().NoError(err) @@ -407,7 +407,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() Next: "", }, } - memo_marshalled, err := json.Marshal(&memo) + memoMarshalled, err := json.Marshal(&memo) suite.Require().NoError(err) msg := transfertypes.NewMsgTransfer( @@ -418,7 +418,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() suite.chainB.SenderAccount.GetAddress().String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainA.SendMsgs(msg) suite.Require().NoError(err) @@ -508,7 +508,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() }, } - memo_marshalled, err = json.Marshal(&memo) + memoMarshalled, err = json.Marshal(&memo) suite.Require().NoError(err) msg = transfertypes.NewMsgTransfer( @@ -519,7 +519,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse_ErrorAck() suite.chainB.SenderAccount.GetAddress().String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainC.SendMsgs(msg) @@ -646,7 +646,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { Next: "", }, } - memo_marshalled, err := json.Marshal(&memo) + memoMarshalled, err := json.Marshal(&memo) suite.Require().NoError(err) msg := transfertypes.NewMsgTransfer( @@ -657,7 +657,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { suite.chainB.SenderAccount.GetAddress().String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainA.SendMsgs(msg) suite.Require().NoError(err) @@ -744,7 +744,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { }, } - memo_marshalled, err = json.Marshal(&memo) + memoMarshalled, err = json.Marshal(&memo) suite.Require().NoError(err) msg = transfertypes.NewMsgTransfer( @@ -755,7 +755,7 @@ func (suite *TransferMiddlewareTestSuite) TestTransferWithPFMReverse() { suite.chainB.SenderAccount.GetAddress().String(), timeoutHeight, 0, - string(memo_marshalled), + string(memoMarshalled), ) _, err = suite.chainC.SendMsgs(msg)