@agoric/cosmos 0.35.0-u18.4 → 0.35.0-u18a.0

package/x/vtransfer/ibc_middleware_test.go

@@ -1,6 +1,7 @@
 package vtransfer_test
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -11,26 +12,37 @@ import (
 
 	app "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	"github.com/iancoleman/orderedmap"
 	"github.com/stretchr/testify/suite"
 	"github.com/tendermint/tendermint/libs/log"
 	dbm "github.com/tendermint/tm-db"
 
+	"github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	swingsettesting "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/testing"
 	swingsettypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 	vibckeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/keeper"
+	vibctypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	packetforwardtypes "github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v6/packetforward/types"
 	ibctransfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
 	ibctesting "github.com/cosmos/ibc-go/v6/testing"
 	"github.com/cosmos/ibc-go/v6/testing/simapp"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 )
 
+const (
+	StorePacketData = true
+)
+
 type IntegrationTestSuite struct {
 	suite.Suite
 
@@ -39,17 +51,42 @@ type IntegrationTestSuite struct {
 	// testing chains used for convenience and readability
 	chainA *ibctesting.TestChain
 	chainB *ibctesting.TestChain
+	chainC *ibctesting.TestChain
+
+	lastChannelOffset map[int]int
+	endpoints         map[int]map[int]*ibctesting.Endpoint
 
 	queryClient ibctransfertypes.QueryClient
 }
 
+type TestingAppMaker func() (ibctesting.TestingApp, map[string]json.RawMessage)
+
+func TestTransferTestSuite(t *testing.T) {
+	s := new(IntegrationTestSuite)
+	suite.Run(t, s)
+}
+
 // interBlockCacheOpt returns a BaseApp option function that sets the persistent
 // inter-block write-through cache.
 func interBlockCacheOpt() func(*baseapp.BaseApp) {
 	return baseapp.SetInterBlockCache(store.NewCommitKVStoreCacheManager())
 }
 
-type TestingAppMaker func() (ibctesting.TestingApp, map[string]json.RawMessage)
+func (s *IntegrationTestSuite) getEndpoint(a, b int) *ibctesting.Endpoint {
+	amap := s.endpoints[a]
+	if amap == nil {
+		return nil
+	}
+	return amap[b]
+}
+
+func (s *IntegrationTestSuite) cacheEndpoint(a, b int, endpoint *ibctesting.Endpoint) {
+	amap := s.endpoints[a]
+	if amap == nil {
+		amap = make(map[int]*ibctesting.Endpoint)
+	}
+	amap[b] = endpoint
+}
 
 // Each instance has unique IBC genesis state with deterministic
 // client/connection/channel initial sequence numbers
@@ -61,6 +98,15 @@ func computeSequences(instance int) (clientSeq, connectionSeq, channelSeq int) {
 	return baseSequence, baseSequence + 10, baseSequence + 50
 }
 
+func (s *IntegrationTestSuite) nextChannelOffset(instance int) int {
+	offset, ok := s.lastChannelOffset[instance]
+	if ok {
+		offset += 1
+	}
+	s.lastChannelOffset[instance] = offset
+	return offset
+}
+
 func SetupAgoricTestingApp(instance int) TestingAppMaker {
 	return func() (ibctesting.TestingApp, map[string]json.RawMessage) {
 		db := dbm.NewMemDB()
@@ -131,17 +177,15 @@ func SetupAgoricTestingApp(instance int) TestingAppMaker {
 	}
 }
 
-func TestKeeperTestSuite(t *testing.T) {
-	suite.Run(t, new(IntegrationTestSuite))
-}
-
-// SetupTest initializes an IntegrationTestSuite with two similar chains, a
+// SetupTest initializes an IntegrationTestSuite with three similar chains, a
 // shared coordinator, and a query client that happens to point at chainA.
 func (s *IntegrationTestSuite) SetupTest() {
+	s.lastChannelOffset = make(map[int]int)
+	s.endpoints = make(map[int]map[int]*ibctesting.Endpoint)
 	s.coordinator = ibctesting.NewCoordinator(s.T(), 0)
 
 	chains := make(map[string]*ibctesting.TestChain)
-	for i := 0; i < 2; i++ {
+	for i := 0; i < 3; i++ {
 		ibctesting.DefaultTestingAppInit = SetupAgoricTestingApp(i)
 
 		chainID := ibctesting.GetChainID(i)
@@ -182,6 +226,7 @@ func (s *IntegrationTestSuite) SetupTest() {
 	s.coordinator.Chains = chains
 	s.chainA = s.coordinator.GetChain(ibctesting.GetChainID(0))
 	s.chainB = s.coordinator.GetChain(ibctesting.GetChainID(1))
+	s.chainC = s.coordinator.GetChain(ibctesting.GetChainID(2))
 
 	agoricApp := s.GetApp(s.chainA)
 
@@ -190,6 +235,10 @@ func (s *IntegrationTestSuite) SetupTest() {
 	s.queryClient = ibctransfertypes.NewQueryClient(queryHelper)
 }
 
+func (s *IntegrationTestSuite) GetChainByIndex(index int) *ibctesting.TestChain {
+	return s.coordinator.GetChain(ibctesting.GetChainID(index))
+}
+
 func (s *IntegrationTestSuite) GetApp(chain *ibctesting.TestChain) *app.GaiaApp {
 	app, ok := chain.App.(*app.GaiaApp)
 	if !ok {
@@ -199,30 +248,53 @@ func (s *IntegrationTestSuite) GetApp(chain *ibctesting.TestChain) *app.GaiaApp
 	return app
 }
 
-func (s *IntegrationTestSuite) NewTransferPath() *ibctesting.Path {
-	path := ibctesting.NewPath(s.chainA, s.chainB)
-	_, _, channelASeq := computeSequences(0)
-	_, _, channelBSeq := computeSequences(1)
-	path.EndpointA.ChannelID = fmt.Sprintf("channel-%d", channelASeq)
-	path.EndpointB.ChannelID = fmt.Sprintf("channel-%d", channelBSeq)
+func (s *IntegrationTestSuite) NewTransferPath(endpointAChainIdx, endpointBChainIdx int) *ibctesting.Path {
+	endpointAChain := s.coordinator.GetChain(ibctesting.GetChainID(endpointAChainIdx))
+	endpointBChain := s.coordinator.GetChain(ibctesting.GetChainID(endpointBChainIdx))
+
+	chAOffset := s.nextChannelOffset(endpointAChainIdx)
+	chBOffset := s.nextChannelOffset(endpointBChainIdx)
+	path := ibctesting.NewPath(endpointAChain, endpointBChain)
+	_, _, channelASeq := computeSequences(endpointAChainIdx)
+	_, _, channelBSeq := computeSequences(endpointBChainIdx)
+	path.EndpointA.ChannelID = fmt.Sprintf("channel-%d", channelASeq+chAOffset)
+	path.EndpointB.ChannelID = fmt.Sprintf("channel-%d", channelBSeq+chBOffset)
 	path.EndpointA.ChannelConfig.PortID = ibctesting.TransferPort
 	path.EndpointB.ChannelConfig.PortID = ibctesting.TransferPort
 	path.EndpointA.ChannelConfig.Version = "ics20-1"
 	path.EndpointB.ChannelConfig.Version = "ics20-1"
 
-	s.coordinator.Setup(path)
+	endpoint := s.getEndpoint(endpointAChainIdx, endpointBChainIdx)
+	if endpoint == nil {
+		s.coordinator.SetupConnections(path)
+		s.cacheEndpoint(endpointAChainIdx, endpointBChainIdx, path.EndpointA)
+		s.cacheEndpoint(endpointBChainIdx, endpointAChainIdx, path.EndpointB)
+	} else {
+		path.EndpointA.ClientID = endpoint.ClientID
+		path.EndpointA.ConnectionID = endpoint.ConnectionID
+
+		path.EndpointB.ClientID = endpoint.Counterparty.ClientID
+		path.EndpointB.ConnectionID = endpoint.Counterparty.ConnectionID
+	}
+	s.coordinator.CreateChannels(path)
 
-	s.coordinator.CommitBlock(s.chainA, s.chainB)
+	s.coordinator.CommitBlock(endpointAChain, endpointBChain)
 
 	return path
 }
 
+func (s *IntegrationTestSuite) resetActionQueue(chain *ibctesting.TestChain) {
+	err := swingsettesting.ResetActionQueue(s.T(), chain.GetContext(), s.GetApp(chain).SwingSetKeeper)
+	s.Require().NoError(err)
+}
+
 func (s *IntegrationTestSuite) assertActionQueue(chain *ibctesting.TestChain, expectedRecords []swingsettypes.InboundQueueRecord) {
 	actualRecords, err := swingsettesting.GetActionQueueRecords(
 		s.T(),
 		chain.GetContext(),
 		s.GetApp(chain).SwingSetKeeper,
 	)
+	s.resetActionQueue(chain)
 	s.Require().NoError(err)
 
 	exLen := len(expectedRecords)
@@ -262,44 +334,86 @@ func (s *IntegrationTestSuite) RegisterBridgeTarget(chain *ibctesting.TestChain,
 	agdServer := s.GetApp(chain).AgdServer
 	defer agdServer.SetControllerContext(chain.GetContext())()
 	var reply string
-	err := agdServer.ReceiveMessage(
+	bz, err := json.Marshal(struct {
+		Type   string
+		Target string
+	}{"BRIDGE_TARGET_REGISTER", target})
+	s.Require().NoError(err)
+	err = agdServer.ReceiveMessage(
 		&vm.Message{
 			Port: agdServer.GetPort("vtransfer"),
-			Data: `{"type":"BRIDGE_TARGET_REGISTER","target":"` + target + `"}`,
+			Data: string(bz),
 		},
 		&reply,
 	)
 	s.Require().NoError(err)
-	s.Require().Equal(reply, "true")
+	s.Require().Equal("true", reply)
 }
 
-func (s *IntegrationTestSuite) TransferFromSourceChain(
-	srcChain *ibctesting.TestChain,
+func (s *IntegrationTestSuite) TransferFromEndpoint(
+	srcContext sdk.Context,
+	src *ibctesting.Endpoint,
 	data ibctransfertypes.FungibleTokenPacketData,
-	src, dst *ibctesting.Endpoint,
-) (channeltypes.Packet, error) {
+) error {
 	tokenAmt, ok := sdk.NewIntFromString(data.Amount)
 	s.Require().True(ok)
 
-	timeoutHeight := srcChain.GetTimeoutHeight()
-	packet := channeltypes.NewPacket(data.GetBytes(), 0, src.ChannelConfig.PortID, src.ChannelID, dst.ChannelConfig.PortID, dst.ChannelID, timeoutHeight, 0)
+	timeoutHeight := src.Counterparty.Chain.GetTimeoutHeight()
 
 	// send a transfer packet from src
-	imt := ibctransfertypes.MsgTransfer{
-		SourcePort:       packet.SourcePort,
-		SourceChannel:    packet.SourceChannel,
-		Memo:             data.Memo,
-		Token:            sdk.NewCoin(data.Denom, tokenAmt),
-		Sender:           data.Sender,
-		Receiver:         data.Receiver,
-		TimeoutHeight:    packet.TimeoutHeight,
-		TimeoutTimestamp: packet.TimeoutTimestamp,
+	imt := ibctransfertypes.NewMsgTransfer(
+		src.ChannelConfig.PortID,
+		src.ChannelID,
+		sdk.NewCoin(data.Denom, tokenAmt),
+		data.Sender,
+		data.Receiver,
+		timeoutHeight,
+		0,
+		data.Memo,
+	)
+
+	tk := s.GetApp(src.Chain).TransferKeeper
+	_, err := tk.Transfer(srcContext, imt)
+	return err
+}
+
+func (s *IntegrationTestSuite) prependDenomTrace(sender *ibctesting.Endpoint, trace string) string {
+	return fmt.Sprintf("%s/%s/%s", sender.ChannelConfig.PortID, sender.ChannelID, trace)
+}
+
+func (s *IntegrationTestSuite) overrideSendPacketData(cdc codec.Codec, data []byte, hookedSender string) ([]byte, error) {
+	var ftpd ibctransfertypes.FungibleTokenPacketData
+	err := json.Unmarshal(data, &ftpd)
+	if err != nil {
+		return nil, err
+	}
+
+	// XXX: This is a hack to get around the fact that `TransferKeeper.Transfer`
+	// doesn't understand hooked senders.  We need to put the hooked sender back
+	// in so that the vtransfer keeper can strip it out as if it had been there
+	// all along.
+	newFtpd := ftpd
+	newFtpd.Sender = hookedSender
+
+	// Permute the encoded data to ensure that it is different that what the TransferKeeper.Transfer specified.
+	if bz := ftpd.GetBytes(); !bytes.Equal(data, bz) {
+		return newFtpd.GetBytes(), nil
+	}
+
+	bz, err := cdc.MarshalJSON(&ftpd)
+	if err != nil {
+		return nil, err
+	}
+
+	if !bytes.Equal(data, bz) {
+		newBz, err := cdc.MarshalJSON(&newFtpd)
+		if err != nil {
+			return nil, err
+		}
+		return newBz, nil
 	}
-	imr, err := s.GetApp(srcChain).TransferKeeper.Transfer(srcChain.GetContext(), &imt)
-	s.Require().NoError(err)
-	packet.Sequence = imr.Sequence
 
-	return packet, nil
+	return nil, fmt.Errorf("failed to find a way to permute packet data: %s", string(data))
 }
 
 func (s *IntegrationTestSuite) mintToAddress(chain *ibctesting.TestChain, addr sdk.AccAddress, denom, amount string) {
@@ -313,136 +427,388 @@ func (s *IntegrationTestSuite) mintToAddress(chain *ibctesting.TestChain, addr s
 	s.Require().NoError(err)
 	err = app.BankKeeper.SendCoinsFromModuleToAccount(chain.GetContext(), ibctransfertypes.ModuleName, addr, coins)
 	s.Require().NoError(err)
-
-	// Verify success.
-	balances := app.BankKeeper.GetAllBalances(chain.GetContext(), addr)
-	s.Require().Equal(coins[0], balances[1])
 }
 
-// TestTransferFromAgdToAgd relays an IBC transfer initiated from a chain A to a
-// chain B, and relays the chain B's resulting acknowledgement in return. It
-// verifies that the source and destination accounts' bridge targets are called
-// by inspecting their resulting actionQueue records.  By committing blocks
-// between actions, the test verifies that the VM results are permitted to be
-// async across blocks.
-func (s *IntegrationTestSuite) TestTransferFromAgdToAgd() {
-	path := s.NewTransferPath()
-	s.Require().Equal(path.EndpointA.ChannelID, "channel-1050")
-
-	s.Run("TransferFromAgdToAgd", func() {
-		// create a transfer packet's data contents
-		transferData := ibctransfertypes.NewFungibleTokenPacketData(
-			"uosmo",
-			"1000000",
-			s.chainA.SenderAccount.GetAddress().String(),
-			s.chainB.SenderAccounts[1].SenderAccount.GetAddress().String(),
-			`"This is a JSON memo"`,
-		)
+// TestHops relays an IBC transfer initiated from a chain A to a chain B, via 0
+// or more intermediate chains' PacketForwardMiddleware, and relays the chain
+// B's resulting acknowledgement back through the intermediate chains to chain A
+// in return. It verifies that the source and destination accounts' bridge
+// targets are called by inspecting their resulting actionQueue records.  By
+// committing blocks between actions, the test verifies that the VM results are
+// permitted to be async across blocks.
+func (s *IntegrationTestSuite) TestHops() {
+	testCases := []struct {
+		name             string
+		senderIsTarget   bool
+		receiverIsTarget bool
+		senderHookData   []byte
+		receiverHookData []byte
+	}{
+		{"NoTargetsNoHooks", false, false, nil, nil},
+		{"NoTargetsReceiverHook", false, false, nil, []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"NoTargetsSenderHook", false, false, []byte("?name=alice&peer=bob"), nil},
+		{"NoTargetsBothHooks", false, false, []byte("?name=alice&peer=bob"), []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"SenderTargetNoHooks", true, false, nil, nil},
+		{"SenderTargetReceiverHook", true, false, nil, []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"SenderTargetSenderHook", true, false, []byte("?name=alice&peer=bob"), nil},
+		{"SenderTargetBothHooks", true, false, []byte("?name=alice&peer=bob"), []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"ReceiverTargetNoHooks", false, true, nil, nil},
+		{"ReceiverTargetReceiverHook", false, true, nil, []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"ReceiverTargetSenderHook", false, true, []byte("?name=alice&peer=bob"), nil},
+		{"ReceiverTargetBothHooks", false, true, []byte("?name=alice&peer=bob"), []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"BothTargetsNoHooks", true, true, nil, nil},
+		{"BothTargetsReceiverHook", true, true, nil, []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+		{"BothTargetsSenderHook", true, true, []byte("?name=alice&peer=bob"), nil},
+		{"BothTargetsBothHooks", true, true, []byte("?name=alice&peer=bob"), []byte("?what=arbitrary-data&why=to-test-bridge-targets")},
+	}
 
-		// Register the sender and receiver as bridge targets on their specific
-		// chain.
-		s.RegisterBridgeTarget(s.chainA, transferData.Sender)
-		s.RegisterBridgeTarget(s.chainB, transferData.Receiver)
+	for hops := 1; hops <= 2; hops += 1 {
+		for _, tc := range testCases {
+			tc := tc
+			name := fmt.Sprintf("%s_%dHop", tc.name, hops)
+			s.Run(name, func() {
+				_, _, baseSenderAddr := testdata.KeyTestPubAddr()
+				baseSender := baseSenderAddr.String()
+
+				_, _, baseReceiverAddr := testdata.KeyTestPubAddr()
+				baseReceiver := baseReceiverAddr.String()
+
+				var receiver, sender string
+				var err error
+				if tc.senderHookData != nil {
+					sender, err = types.JoinHookedAddress(baseSender, tc.senderHookData)
+					s.Require().NoError(err)
+				} else {
+					sender = baseSender
+				}
 
-		s.mintToAddress(s.chainA, s.chainA.SenderAccount.GetAddress(), transferData.Denom, transferData.Amount)
+				if tc.receiverHookData != nil {
+					receiver, err = types.JoinHookedAddress(baseReceiver, tc.receiverHookData)
+					s.Require().NoError(err)
+				} else {
+					receiver = baseReceiver
+				}
 
-		// Initiate the transfer
-		packet, err := s.TransferFromSourceChain(s.chainA, transferData, path.EndpointA, path.EndpointB)
-		s.Require().NoError(err)
+				var overriddenPacketData []byte
+				overrideSendPacketData := func(ctx sdk.Context, cdc codec.Codec, data []byte) ([]byte, error) {
+					newData, err := s.overrideSendPacketData(cdc, data, sender)
+					overriddenPacketData = newData
+					return overriddenPacketData, err
+				}
+				// Reset the chain state.
+				for i := 0; i <= hops; i += 1 {
+					chain := s.GetChainByIndex(i)
+					s.resetActionQueue(chain)
+					s.GetApp(chain).VtransferKeeper.SetDebugging(StorePacketData, overrideSendPacketData)
+
+					// Only the first chain is the sender, so don't override any other packets.
+					overrideSendPacketData = nil
+				}
 
-		// Relay the packet
-		s.coordinator.CommitBlock(s.chainA)
-		err = path.EndpointB.UpdateClient()
-		s.Require().NoError(err)
-		s.coordinator.CommitBlock(s.chainB)
+				// Construct the transfer path from chainA=0, [chainC=2, [chainD=3...]], and finally chainB=1.
+				// This guarantees that the first and last chains are s.chainA and s.chainB.
+				paths := make([]*ibctesting.Path, hops)
+				{
+					endpointAChainIndex := 0 // s.chainA
+					endpointBChainIndex := 2 // s.chainC
+					for i := 0; i < hops; i += 1 {
+						if i == hops-1 {
+							// Final path's endpointB is s.chainB=1.
+							endpointBChainIndex = 1
+						}
+						// Each path is an endpointA->endpointB pair.  We specify them by index.
+						paths[i] = s.NewTransferPath(endpointAChainIndex, endpointBChainIndex)
+						// The next path's A is the current path's B...
+						endpointAChainIndex = endpointBChainIndex
+						// and the next path's B is the next chain in the sequence.
+						endpointBChainIndex += 1
+					}
+				}
 
-		writeAcknowledgementHeight := s.chainB.CurrentHeader.Height
-		writeAcknowledgementTime := s.chainB.CurrentHeader.Time.Unix()
+				// create a transfer packet's data contents
+				hopReceiver := receiver
+				var memoBytes []byte
+				for pathIdx := hops - 1; pathIdx > 0; pathIdx -= 1 {
+					m := struct {
+						Forward packetforwardtypes.ForwardMetadata `json:"forward"`
+					}{}
+					if memoBytes != nil {
+						m.Forward.Next = packetforwardtypes.NewJSONObject(false, memoBytes, *orderedmap.New())
+					}
+					m.Forward.Receiver = hopReceiver
+
+					// Previous hops should not have a bech32 address in the receiver field,
+					// or tokens may get stuck en route rather than returned on error.
+					hopReceiver = "pfm"
+					m.Forward.Port = paths[pathIdx].EndpointA.ChannelConfig.PortID
+					m.Forward.Channel = paths[pathIdx].EndpointA.ChannelID
+
+					memoBytes, err = json.Marshal(m)
+					s.Require().NoError(err)
+				}
 
-		err = path.EndpointB.RecvPacket(packet)
-		s.Require().NoError(err)
+				var memo string
+				if memoBytes != nil {
+					memo = string(memoBytes)
+				} else {
+					memo = `This is not a JSON memo`
+				}
 
-		// Create a success ack as defined by ICS20.
-		ack := channeltypes.NewResultAcknowledgement([]byte{1})
-		// Create a different ack to show that a contract can change it.
-		contractAck := channeltypes.NewResultAcknowledgement([]byte{5})
+				denomTrace := "uosmo"
+				transferData := ibctransfertypes.NewFungibleTokenPacketData(
+					denomTrace,
+					"1000000",
+					baseSender, // TODO: ideally this would just be sender, and `TransferKeeper.Transfer` would accept address hooks.
+					hopReceiver,
+					memo,
+				)
+
+				// Register the sender and receiver as bridge targets on their specific
+				// chain.
+				if tc.senderIsTarget {
+					s.RegisterBridgeTarget(s.chainA, baseSender)
+				}
+				if tc.receiverIsTarget {
+					s.RegisterBridgeTarget(s.chainB, baseReceiver)
+				}
 
-		s.coordinator.CommitBlock(s.chainA, s.chainB)
+				s.mintToAddress(s.chainA, baseSenderAddr, transferData.Denom, transferData.Amount)
 
-		{
-			expectedRecords := []swingsettypes.InboundQueueRecord{}
-			s.assertActionQueue(s.chainA, expectedRecords)
-		}
+				// Initiate the transfer
+				sendContext := s.chainA.GetContext()
+				err = s.TransferFromEndpoint(sendContext, paths[0].EndpointA, transferData)
+				s.Require().NoError(err)
+
+				sendPacket, err := ParsePacketFromEvents(sendContext.EventManager().Events())
+				s.Require().NoError(err)
+
+				s.coordinator.CommitBlock(s.chainA)
+
+				// Relay the packet through the intermediaries to the final destination.
+				var packetRes *sdk.Result
+				var writeAcknowledgementHeight, writeAcknowledgementTime int64
+				for pathIdx := 0; pathIdx < hops; pathIdx += 1 {
+					nextPath := paths[pathIdx]
+					err = nextPath.EndpointB.UpdateClient()
+					s.Require().NoError(err)
+					s.coordinator.CommitBlock(nextPath.EndpointB.Chain)
+
+					writeAcknowledgementHeight = nextPath.EndpointB.Chain.CurrentHeader.Height
+					writeAcknowledgementTime = nextPath.EndpointB.Chain.CurrentHeader.Time.Unix()
+
+					packetRes, err = nextPath.EndpointB.RecvPacketWithResult(sendPacket)
+					s.Require().NoError(err)
+
+					s.coordinator.CommitBlock(nextPath.EndpointA.Chain, nextPath.EndpointB.Chain)
+
+					denomTrace = s.prependDenomTrace(nextPath.EndpointB, denomTrace)
+
+					{
+						expectedRecords := []swingsettypes.InboundQueueRecord{}
+						s.assertActionQueue(nextPath.EndpointA.Chain, expectedRecords)
+					}
+
+					if pathIdx >= hops-1 {
+						break
+					}
+
+					// The PFM should have received the packet and advertised a send toward the last path.
+					sendPacket, err = ParsePacketFromEvents(packetRes.GetEvents())
+					s.Require().NoError(err)
+				}
+
+				var ack ibcexported.Acknowledgement
+				var ackedPacket channeltypes.Packet
+
+				expectedAck := channeltypes.NewResultAcknowledgement([]byte{1})
 
-		{
-			expectedRecords := []swingsettypes.InboundQueueRecord{
 				{
-					Action: &vibckeeper.WriteAcknowledgementEvent{
-						ActionHeader: &vm.ActionHeader{
-							Type:        "VTRANSFER_IBC_EVENT",
-							BlockHeight: writeAcknowledgementHeight,
-							BlockTime:   writeAcknowledgementTime,
-						},
-						Event:           "writeAcknowledgement",
-						Target:          transferData.Receiver,
-						Packet:          packet,
-						Acknowledgement: ack.Acknowledgement(),
-					},
-					Context: swingsettypes.ActionContext{
-						BlockHeight: writeAcknowledgementHeight,
-						// TxHash is filled in below
-						MsgIdx: 0,
-					},
-				},
-			}
+					var events sdk.Events
+					var ackData []byte
+					if packetRes != nil {
+						events = packetRes.GetEvents()
+						ackData, err = ParseAckFromEvents(events)
+					}
+					if tc.receiverIsTarget {
+						s.Require().Nil(ackData)
+						// The packet was not yet acknowledged, so write out an ack from the VM, one block later
+						s.coordinator.CommitBlock(s.chainB)
+
+						vmAckContext := s.chainB.GetContext()
+						err = s.GetApp(s.chainB).VtransferKeeper.ReceiveWriteAcknowledgement(vmAckContext, sendPacket, expectedAck)
+						s.Require().NoError(err)
+
+						events = vmAckContext.EventManager().Events()
+						ackData, err = ParseAckFromEvents(events)
+					}
+
+					s.Require().NoError(err)
+
+					ackedPacket, err = ParsePacketFromFilteredEvents(events, channeltypes.EventTypeWriteAck)
+					s.Require().NoError(err)
+					ack = vibctypes.NewRawAcknowledgement(ackData)
+
+					s.coordinator.CommitBlock(s.chainB)
+
+					expectedRecords := []swingsettypes.InboundQueueRecord{}
+					if tc.receiverIsTarget {
+						expectedRecords = append(expectedRecords, swingsettypes.InboundQueueRecord{
+							Action: &vibckeeper.WriteAcknowledgementEvent{
+								ActionHeader: &vm.ActionHeader{
+									Type:        "VTRANSFER_IBC_EVENT",
+									BlockHeight: writeAcknowledgementHeight,
+									BlockTime:   writeAcknowledgementTime,
+								},
+								Event:           "writeAcknowledgement",
+								Target:          baseReceiver,
+								Packet:          sendPacket,
+								Acknowledgement: expectedAck.Acknowledgement(),
+							},
+							Context: swingsettypes.ActionContext{
+								BlockHeight: writeAcknowledgementHeight,
+								// TxHash is filled in below
+								MsgIdx: 0,
+							},
+						})
+					}
+
+					s.assertActionQueue(s.chainB, expectedRecords)
+				}
 
-			s.assertActionQueue(s.chainB, expectedRecords)
+				// Send the acks back.
+				for pathIdx := hops - 1; pathIdx > 0; pathIdx -= 1 {
+					priorPath := paths[pathIdx]
 
-			// write out a different acknowledgement from the "contract", one block later.
-			s.coordinator.CommitBlock(s.chainB)
-			err = s.GetApp(s.chainB).VtransferKeeper.ReceiveWriteAcknowledgement(s.chainB.GetContext(), packet, contractAck)
-			s.Require().NoError(err)
+					// Update Client
+					err = priorPath.EndpointA.UpdateClient()
+					s.Require().NoError(err)
 
-			s.coordinator.CommitBlock(s.chainB)
-		}
+					// Prove the PFM packet's acknowledgement.
+					ackRes, err := acknowledgePacketWithResult(priorPath.EndpointA, ackedPacket, ack.Acknowledgement())
+					s.Require().NoError(err)
 
-		// Update Client
-		err = path.EndpointA.UpdateClient()
-		s.Require().NoError(err)
+					ackedPacket, err = ParsePacketFromFilteredEvents(ackRes.GetEvents(), channeltypes.EventTypeWriteAck)
+					s.Require().NoError(err)
 
-		acknowledgementHeight := s.chainA.CurrentHeader.Height
-		acknowledgementTime := s.chainA.CurrentHeader.Time.Unix()
+					ackData, err := ParseAckFromEvents(ackRes.GetEvents())
+					s.Require().NoError(err)
+					ack = vibctypes.NewRawAcknowledgement(ackData)
 
-		// Prove the packet's acknowledgement.
-		err = path.EndpointA.AcknowledgePacket(packet, contractAck.Acknowledgement())
-		s.Require().NoError(err)
+					s.coordinator.CommitBlock(priorPath.EndpointA.Chain, priorPath.EndpointB.Chain)
+				}
 
-		s.coordinator.CommitBlock(s.chainA, s.chainB)
+				// Update Client
+				err = paths[0].EndpointA.UpdateClient()
+				s.Require().NoError(err)
+
+				acknowledgementHeight := s.chainA.CurrentHeader.Height
+				acknowledgementTime := s.chainA.CurrentHeader.Time.Unix()
+
+				// Prove the initial packet's acknowledgement.
+				ackRes, err := acknowledgePacketWithResult(paths[0].EndpointA, ackedPacket, ack.Acknowledgement())
+				s.Require().NoError(err)
+
+				// Commit the block to finalize the acknowledgement.
+				s.coordinator.CommitBlock(s.chainA, s.chainB)
+
+				// Verify the resulting events.
+				gotEvents := 0
+				expectedEvents := 2
+				for _, event := range ackRes.GetEvents() {
+					if event.Type == ibctransfertypes.EventTypePacket {
+						gotEvents += 1
+						if gotEvents == 2 && len(event.Attributes) == 1 {
+							// We get a trailing event with a single "success" attribute.
+							s.Require().Equal(ibctransfertypes.AttributeKeyAckSuccess, string(event.Attributes[0].Key))
+							s.Require().Equal("\x01", string(event.Attributes[0].Value))
+							continue
+						}
+						expectedAttrs := 6
+						gotAttrs := 0
+						for _, attr := range event.Attributes {
+							switch string(attr.Key) {
+							case "module":
+								s.Require().Equal(ibctransfertypes.ModuleName, string(attr.Value))
+								gotAttrs += 1
+							case ibctransfertypes.AttributeKeyAckSuccess:
+								s.Require().Equal("\x01", string(attr.Value))
+								gotAttrs += 1
+							case ibctransfertypes.AttributeKeyMemo:
+								s.Require().Equal(transferData.Memo, string(attr.Value))
+								gotAttrs += 1
+							case ibctransfertypes.AttributeKeyReceiver:
+								s.Require().Equal(transferData.Receiver, string(attr.Value))
+								gotAttrs += 1
+							case "sender": // ibctransfertypes.AttributeKeySender:
+								s.Require().Equal(transferData.Sender, string(attr.Value))
+								gotAttrs += 1
+							case ibctransfertypes.AttributeKeyDenom:
+								s.Require().Equal(transferData.Denom, string(attr.Value))
+								gotAttrs += 1
+							case ibctransfertypes.AttributeKeyAmount:
+								s.Require().Equal(transferData.Amount, string(attr.Value))
+								gotAttrs += 1
+							}
+						}
+						s.Require().Equal(expectedAttrs, gotAttrs, `expected %d %s type attributes, got %d`, expectedAttrs, ibctransfertypes.EventTypePacket, gotAttrs)
+					}
+				}
+
+				// The resulting IBC packet event should be what we expected.
+				s.Require().Equal(expectedEvents, gotEvents, `expected %d %s type events, got %d`, expectedEvents, ibctransfertypes.EventTypePacket, gotEvents)
 
-		{
-			expectedRecords := []swingsettypes.InboundQueueRecord{
 				{
-					Action: &vibckeeper.WriteAcknowledgementEvent{
-						ActionHeader: &vm.ActionHeader{
-							Type:        "VTRANSFER_IBC_EVENT",
-							BlockHeight: acknowledgementHeight,
-							BlockTime:   acknowledgementTime,
-						},
-						Event:           "acknowledgementPacket",
-						Target:          transferData.Sender,
-						Packet:          packet,
-						Acknowledgement: contractAck.Acknowledgement(),
-						Relayer:         s.chainA.SenderAccount.GetAddress(),
-					},
-					Context: swingsettypes.ActionContext{
-						BlockHeight: acknowledgementHeight,
-						// TxHash is filled in below
-						MsgIdx: 0,
-					},
-				},
-			}
+					// Undo the sender data override.
+					expectedPacket := ackedPacket
+					expectedPacket.Data = overriddenPacketData
+
+					expectedRecords := []swingsettypes.InboundQueueRecord{}
+					if tc.senderIsTarget {
+						expectedRecords = append(expectedRecords, swingsettypes.InboundQueueRecord{
+							Action: &vibckeeper.WriteAcknowledgementEvent{
+								ActionHeader: &vm.ActionHeader{
+									Type:        "VTRANSFER_IBC_EVENT",
+									BlockHeight: acknowledgementHeight,
+									BlockTime:   acknowledgementTime,
+								},
+								Event:           "acknowledgementPacket",
+								Target:          baseSender,
+								Packet:          expectedPacket,
+								Acknowledgement: ack.Acknowledgement(),
+								Relayer:         s.chainA.SenderAccount.GetAddress(),
+							},
+							Context: swingsettypes.ActionContext{
+								BlockHeight: acknowledgementHeight,
+								// TxHash is filled in below
+								MsgIdx: 0,
+							},
+						})
+					}
+
+					s.assertActionQueue(s.chainA, expectedRecords)
+				}
 
-			s.assertActionQueue(s.chainA, expectedRecords)
+				// Verify the resulting received coin balance.
+				req := &banktypes.QueryAllBalancesRequest{
+					Address: baseReceiver,
+				}
+				res, err := s.GetApp(s.chainB).BankKeeper.AllBalances(s.chainB.GetContext(), req)
+				s.Require().NoError(err)
+
+				amt, ok := sdk.NewIntFromString(transferData.Amount)
+				s.Require().True(ok)
+
+				// Decode the denom trace to get the denom hash.
+				hashReq := &ibctransfertypes.QueryDenomHashRequest{
+					Trace: denomTrace,
+				}
+				hashRes, err := s.GetApp(s.chainB).TransferKeeper.DenomHash(s.chainB.GetContext(), hashReq)
+				s.Require().NoError(err)
+				receivedDenom := `ibc/` + hashRes.Hash
+
+				coins := sdk.NewCoins(sdk.NewCoin(receivedDenom, amt))
+				s.Require().True(coins.IsEqual(res.Balances))
+			})
 		}
-	})
+	}
 }