@agoric/cosmos 0.35.0-u19.2 → 0.35.0-u20.0

package/types/ibc_packet_test.go

@@ -0,0 +1,117 @@
+package types_test
+
+import (
+	"bytes"
+	"encoding/json"
+	fmt "fmt"
+	"reflect"
+	"testing"
+
+	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+func CreateTestChannelPacket() channeltypes.Packet {
+	return channeltypes.NewPacket(
+		[]byte("data"),
+		987654321098765432,
+		"port-src", "channel-13",
+		"port-dst", "channel-42",
+		clienttypes.Height{},
+		123456789012345678,
+	)
+}
+
+func TestPacket(t *testing.T) {
+	testCases := []struct {
+		name   string
+		packet ibcexported.PacketI
+	}{
+		{
+			name:   "ibc-go channel Packet",
+			packet: CreateTestChannelPacket(),
+		},
+		{
+			name:   "agoric-sdk IBCPacket",
+			packet: agtypes.CopyToIBCPacket(CreateTestChannelPacket()),
+		},
+	}
+
+	// Check that the packets have the expected values
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			pi := tc.packet
+			assert.Equal(t, "port-src", pi.GetSourcePort())
+			assert.Equal(t, "channel-13", pi.GetSourceChannel())
+			assert.Equal(t, "port-dst", pi.GetDestPort())
+			assert.Equal(t, "channel-42", pi.GetDestChannel())
+			assert.Equal(t, uint64(987654321098765432), pi.GetSequence())
+			assert.Equal(t, uint64(123456789012345678), pi.GetTimeoutTimestamp())
+			assert.Equal(t, []byte("data"), pi.GetData())
+			assert.Equal(t, clienttypes.Height{}, pi.GetTimeoutHeight())
+		})
+	}
+}
+
+func TestPacketJSON(t *testing.T) {
+	testCases := []struct {
+		name   string
+		packet ibcexported.PacketI
+		quoted bool
+	}{
+		{
+			name:   "ibc-go channel Packet",
+			packet: CreateTestChannelPacket(),
+			quoted: false,
+		},
+		{
+			name:   "agoric-sdk IBCPacket",
+			packet: agtypes.CopyToIBCPacket(CreateTestChannelPacket()),
+			quoted: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			bz, err := json.Marshal(tc.packet)
+			require.NoError(t, err)
+
+			seqStr := fmt.Sprintf("%d", tc.packet.GetSequence())
+			if !bytes.Contains(bz, []byte(seqStr)) {
+				assert.Failf(t, "packet sequence should be present in JSON", "sequence %s, json %s", seqStr, string(bz))
+			}
+
+			if bytes.Contains(bz, []byte(`"`+seqStr+`"`)) != tc.quoted {
+				if tc.quoted {
+					assert.Failf(t, "packet sequence should be quoted in JSON", "sequence %s, json %s", seqStr, string(bz))
+				} else {
+					assert.Failf(t, "packet sequence should not be quoted in JSON", "sequence %s, json %s", seqStr, string(bz))
+				}
+			}
+
+			var packet2 ibcexported.PacketI
+			switch p := tc.packet.(type) {
+			case channeltypes.Packet:
+				var p2 channeltypes.Packet
+				err = json.Unmarshal(bz, &p2)
+				packet2 = p2
+			case agtypes.IBCPacket:
+				var p2 agtypes.IBCPacket
+				err = json.Unmarshal(bz, &p2)
+				packet2 = p2
+			default:
+				t.Fatalf("unexpected packet type %T", p)
+			}
+
+			require.NoError(t, err)
+			if !reflect.DeepEqual(tc.packet, packet2) {
+				assert.Failf(t, "nested packet not equal after JSON round trip", "src %q, dst %q", tc.packet, packet2)
+			}
+		})
+	}
+}

package/x/vibc/keeper/triggers.go

@@ -3,47 +3,21 @@ package keeper
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
-	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
 	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
 )
 
-func reifyPacket(packet ibcexported.PacketI) channeltypes.Packet {
-
-	timeoutHeight := clienttypes.MustParseHeight(packet.GetTimeoutHeight().String())
-	return channeltypes.Packet{
-		Sequence:           packet.GetSequence(),
-		SourcePort:         packet.GetSourcePort(),
-		SourceChannel:      packet.GetSourceChannel(),
-		DestinationPort:    packet.GetDestPort(),
-		DestinationChannel: packet.GetDestChannel(),
-		Data:               packet.GetData(),
-		TimeoutHeight:      timeoutHeight,
-		TimeoutTimestamp:   packet.GetTimeoutTimestamp(),
-	}
-}
-
-type WriteAcknowledgementEvent struct {
-	*vm.ActionHeader `actionType:"IBC_EVENT"`
-	Event            string              `json:"event" default:"writeAcknowledgement"`
-	Target           string              `json:"target"`
-	Packet           channeltypes.Packet `json:"packet"`
-	Acknowledgement  []byte              `json:"acknowledgement"`
-	Relayer          sdk.AccAddress      `json:"relayer"`
-}
-
 func (k Keeper) TriggerWriteAcknowledgement(
 	ctx sdk.Context,
 	target string,
 	packet ibcexported.PacketI,
 	acknowledgement ibcexported.Acknowledgement,
 ) error {
-	event := WriteAcknowledgementEvent{
+	event := types.WriteAcknowledgementEvent{
 		Target:          target,
-		Packet:          reifyPacket(packet),
+		Packet:          agtypes.CopyToIBCPacket(packet),
 		Acknowledgement: acknowledgement.Acknowledgement(),
 	}
 
@@ -64,7 +38,7 @@ func (k Keeper) TriggerOnAcknowledgementPacket(
 ) error {
 	event := types.AcknowledgementPacketEvent{
 		Target:          target,
-		Packet:          reifyPacket(packet),
+		Packet:          agtypes.CopyToIBCPacket(packet),
 		Acknowledgement: acknowledgement,
 		Relayer:         relayer,
 	}
@@ -85,7 +59,7 @@ func (k Keeper) TriggerOnTimeoutPacket(
 ) error {
 	event := types.TimeoutPacketEvent{
 		Target:  target,
-		Packet:  reifyPacket(packet),
+		Packet:  agtypes.CopyToIBCPacket(packet),
 		Relayer: relayer,
 	}
 

package/x/vibc/types/expected_keepers.go

@@ -33,6 +33,7 @@ type ChannelKeeper interface {
 		connectionHops []string, counterparty channel.Counterparty, version string)
 	WriteOpenTryChannel(ctx sdk.Context, portID, channelID string, order channel.Order,
 		connectionHops []string, counterparty channel.Counterparty, version string)
+	WriteOpenAckChannel(ctx sdk.Context, portID, channelID, counterpartyVersion, counterpartyChannelID string)
 	ChanCloseInit(ctx sdk.Context, portID, channelID string, chanCap *capability.Capability) error
 	TimeoutExecuted(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI) error
 }

package/x/vibc/types/ibc_module.go

@@ -4,6 +4,7 @@ import (
 	fmt "fmt"
 
 	sdkioerrors "cosmossdk.io/errors"
+	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
@@ -45,6 +46,15 @@ func NewIBCModule(impl IBCModuleImpl) IBCModule {
 	}
 }
 
+type WriteAcknowledgementEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string            `json:"event" default:"writeAcknowledgement"`
+	Target           string            `json:"target"`
+	Packet           agtypes.IBCPacket `json:"packet"`
+	Acknowledgement  []byte            `json:"acknowledgement"`
+	Relayer          sdk.AccAddress    `json:"relayer"`
+}
+
 type ChannelOpenInitEvent struct {
 	*vm.ActionHeader `actionType:"IBC_EVENT"`
 	Event            string                    `json:"event" default:"channelOpenInit"`
@@ -253,10 +263,10 @@ func (im IBCModule) OnChanCloseConfirm(
 
 type ReceivePacketEvent struct {
 	*vm.ActionHeader `actionType:"IBC_EVENT"`
-	Event            string              `json:"event" default:"receivePacket"`
-	Target           string              `json:"target,omitempty"`
-	Packet           channeltypes.Packet `json:"packet"`
-	Relayer          sdk.AccAddress      `json:"relayer"`
+	Event            string            `json:"event" default:"receivePacket"`
+	Target           string            `json:"target,omitempty"`
+	Packet           agtypes.IBCPacket `json:"packet"`
+	Relayer          sdk.AccAddress    `json:"relayer"`
 }
 
 func (im IBCModule) OnRecvPacket(
@@ -273,7 +283,7 @@ func (im IBCModule) OnRecvPacket(
 	// the same packets.
 
 	event := ReceivePacketEvent{
-		Packet:  packet,
+		Packet:  agtypes.CopyToIBCPacket(packet),
 		Relayer: relayer,
 	}
 
@@ -287,11 +297,11 @@ func (im IBCModule) OnRecvPacket(
 
 type AcknowledgementPacketEvent struct {
 	*vm.ActionHeader `actionType:"IBC_EVENT"`
-	Event            string              `json:"event" default:"acknowledgementPacket"`
-	Target           string              `json:"target,omitempty"`
-	Packet           channeltypes.Packet `json:"packet"`
-	Acknowledgement  []byte              `json:"acknowledgement"`
-	Relayer          sdk.AccAddress      `json:"relayer"`
+	Event            string            `json:"event" default:"acknowledgementPacket"`
+	Target           string            `json:"target,omitempty"`
+	Packet           agtypes.IBCPacket `json:"packet"`
+	Acknowledgement  []byte            `json:"acknowledgement"`
+	Relayer          sdk.AccAddress    `json:"relayer"`
 }
 
 func (im IBCModule) OnAcknowledgementPacket(
@@ -301,7 +311,7 @@ func (im IBCModule) OnAcknowledgementPacket(
 	relayer sdk.AccAddress,
 ) error {
 	event := AcknowledgementPacketEvent{
-		Packet:          packet,
+		Packet:          agtypes.CopyToIBCPacket(packet),
 		Acknowledgement: acknowledgement,
 		Relayer:         relayer,
 	}
@@ -316,10 +326,10 @@ func (im IBCModule) OnAcknowledgementPacket(
 
 type TimeoutPacketEvent struct {
 	*vm.ActionHeader `actionType:"IBC_EVENT"`
-	Event            string              `json:"event" default:"timeoutPacket"`
-	Target           string              `json:"target,omitempty"`
-	Packet           channeltypes.Packet `json:"packet"`
-	Relayer          sdk.AccAddress      `json:"relayer"`
+	Event            string            `json:"event" default:"timeoutPacket"`
+	Target           string            `json:"target,omitempty"`
+	Packet           agtypes.IBCPacket `json:"packet"`
+	Relayer          sdk.AccAddress    `json:"relayer"`
 }
 
 func (im IBCModule) OnTimeoutPacket(
@@ -328,7 +338,7 @@ func (im IBCModule) OnTimeoutPacket(
 	relayer sdk.AccAddress,
 ) error {
 	event := TimeoutPacketEvent{
-		Packet:  packet,
+		Packet:  agtypes.CopyToIBCPacket(packet),
 		Relayer: relayer,
 	}
 

package/x/vibc/types/receiver.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
 
@@ -39,14 +40,14 @@ func NewReceiver(impl ReceiverImpl) Receiver {
 }
 
 type portMessage struct { // comes from swingset's IBC handler
-	Type              string              `json:"type"` // IBC_METHOD
-	Method            string              `json:"method"`
-	Packet            channeltypes.Packet `json:"packet"`
-	RelativeTimeoutNs uint64              `json:"relativeTimeoutNs,string"`
-	Order             string              `json:"order"`
-	Hops              []string            `json:"hops"`
-	Version           string              `json:"version"`
-	Ack               []byte              `json:"ack"`
+	Type              string          `json:"type"` // IBC_METHOD
+	Method            string          `json:"method"`
+	Packet            types.IBCPacket `json:"packet"`
+	RelativeTimeoutNs uint64          `json:"relativeTimeoutNs,string"`
+	Order             string          `json:"order"`
+	Hops              []string        `json:"hops"`
+	Version           string          `json:"version"`
+	Ack               []byte          `json:"ack"`
 }
 
 func stringToOrder(order string) channeltypes.Order {
@@ -121,21 +122,20 @@ func (ir Receiver) Receive(cctx context.Context, jsonRequest string) (jsonReply
 			timeoutTimestamp = uint64(ctx.BlockTime().UnixNano()) + msg.RelativeTimeoutNs
 		}
 
-		packet := channeltypes.NewPacket(
-			msg.Packet.Data, 0,
-			msg.Packet.SourcePort, msg.Packet.SourceChannel,
-			msg.Packet.DestinationPort, msg.Packet.DestinationChannel,
-			msg.Packet.TimeoutHeight, timeoutTimestamp,
-		)
+		packet := types.CopyToIBCPacket(msg.Packet)
+		packet.TimeoutTimestamp = timeoutTimestamp
 		seq, err := impl.ReceiveSendPacket(ctx, packet)
 		if err == nil {
 			packet.Sequence = seq
-			bytes, err := json.Marshal(&packet)
+			bytes, err := json.Marshal(packet)
 			if err == nil {
 				jsonReply = string(bytes)
 			}
 		}
 
+	case "initOpenExecuted":
+		err = fmt.Errorf("initOpenExecuted not yet implemented")
+
 	case "tryOpenExecuted":
 		err = impl.ReceiveWriteOpenTryChannel(
 			ctx, msg.Packet,

package/x/vstorage/README.md

@@ -128,11 +128,3 @@ $ curl -sS 'https://main.api.agoric.net/agoric/vstorage/children/published.commi
   "pagination": null
 }
 ```
-
-## Arbitrary-response HTTP interface
-
-This depends upon appModule `LegacyQuerierHandler` functionality that is [removed from cosmos-sdk as of v0.47](https://github.com/cosmos/cosmos-sdk/blob/fa4d87ef7e6d87aaccc94c337ffd2fe90fcb7a9d/CHANGELOG.md#api-breaking-changes-3)
-
-[legacy querier](./keeper/querier.go)
-* /custom/vstorage/children/$path
-* /custom/vstorage/data/$path

package/x/vstorage/keeper/keeper.go

@@ -11,7 +11,9 @@ import (
 	"strings"
 
 	sdkmath "cosmossdk.io/math"
+	metrics "github.com/armon/go-metrics"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	db "github.com/tendermint/tm-db"
 
@@ -117,6 +119,27 @@ func NewKeeper(storeKey storetypes.StoreKey) Keeper {
 	}
 }
 
+// size_increase and size_decrease metrics represent total writes and deletes *issued*
+// respectively, which may differ from the total number of bytes committed/freed
+// to/from the store due to the store's internal implementation.
+var MetricKeyStoreSizeIncrease = []string{"store", "size_increase"}
+var MetricKeyStoreSizeDecrease = []string{"store", "size_decrease"}
+const MetricLabelStoreKey = "storeKey"
+
+// reportStoreSizeMetrics exports store size increase/decrease metrics
+// when Cosmos telemetry is enabled.
+func (k Keeper) reportStoreSizeMetrics(increase int, decrease int) {
+	metricsLabel := []metrics.Label{
+		telemetry.NewLabel(MetricLabelStoreKey, k.storeKey.Name()),
+	}
+	if increase > 0 {
+		telemetry.IncrCounterWithLabels(MetricKeyStoreSizeIncrease, float32(increase), metricsLabel)
+	}
+	if decrease > 0 {
+		telemetry.IncrCounterWithLabels(MetricKeyStoreSizeDecrease, float32(decrease), metricsLabel)
+	}
+}
+
 // ExportStorage fetches all storage
 func (k Keeper) ExportStorage(ctx sdk.Context) []*types.DataEntry {
 	return k.ExportStorageFromPrefix(ctx, "")
@@ -215,6 +238,8 @@ func (k Keeper) RemoveEntriesWithPrefix(ctx sdk.Context, pathPrefix string) {
 	keys := getEncodedKeysWithPrefixFromIterator(iterator, descendantPrefix)
 
 	for _, key := range keys {
+		rawValue := store.Get(key)
+		k.reportStoreSizeMetrics(0, len(key) + len(rawValue))
 		store.Delete(key)
 	}
 
@@ -366,18 +391,23 @@ func (k Keeper) SetStorage(ctx sdk.Context, entry agoric.KVEntry) {
 	store := ctx.KVStore(k.storeKey)
 	path := entry.Key()
 	encodedKey := types.PathToEncodedKey(path)
+	oldRawValue := store.Get(encodedKey)
 
 	if !entry.HasValue() {
 		if !k.HasChildren(ctx, path) {
 			// We have no children, can delete.
+			k.reportStoreSizeMetrics(0, len(encodedKey) + len(oldRawValue))
 			store.Delete(encodedKey)
 		} else {
+			// We have children, mark as an empty placeholder without deleting.
+			k.reportStoreSizeMetrics(len(types.EncodedNoDataValue), len(oldRawValue))
 			store.Set(encodedKey, types.EncodedNoDataValue)
 		}
 	} else {
 		// Update the value.
-		bz := bytes.Join([][]byte{types.EncodedDataPrefix, []byte(entry.StringValue())}, []byte{})
-		store.Set(encodedKey, bz)
+		newRawValue := bytes.Join([][]byte{types.EncodedDataPrefix, []byte(entry.StringValue())}, []byte{})
+		k.reportStoreSizeMetrics(len(newRawValue), len(oldRawValue))
+		store.Set(encodedKey, newRawValue)
 	}
 
 	// Update our other parent children.
@@ -390,7 +420,9 @@ func (k Keeper) SetStorage(ctx sdk.Context, entry agoric.KVEntry) {
 				// this and further ancestors are needed, skip out
 				break
 			}
-			store.Delete(types.PathToEncodedKey(ancestor))
+			encodedAncestor := types.PathToEncodedKey(ancestor)
+			k.reportStoreSizeMetrics(0, len(encodedAncestor) + len(types.EncodedNoDataValue))
+			store.Delete(encodedAncestor)
 		}
 	} else {
 		// add placeholders as needed
@@ -400,7 +432,9 @@ func (k Keeper) SetStorage(ctx sdk.Context, entry agoric.KVEntry) {
 				// The ancestor exists, implying all further ancestors exist, so we can break.
 				break
 			}
-			store.Set(types.PathToEncodedKey(ancestor), types.EncodedNoDataValue)
+			encodedAncestor := types.PathToEncodedKey(ancestor)
+			k.reportStoreSizeMetrics(len(encodedAncestor) + len(types.EncodedNoDataValue), 0)
+			store.Set(encodedAncestor, types.EncodedNoDataValue)
 		}
 	}
 }

package/x/vstorage/types/path_keys.go

@@ -10,14 +10,13 @@ import (
 // - A "path" is a sequence of zero or more dot-separated nonempty segments
 // using a restricted alphabet of ASCII alphanumerics plus underscore and dash,
 // consistent with packages/internal/src/lib-chainStorage.js but not currently
-// enforcing a length restriction on path segments.
-// So `""`, `"foo"`, and `"foo.bar__baz.qux--quux"` are paths but `"."`,
-// `"foo/bar"`, `"fo\to"`, and `"foö"` are not.
-// This alphabet might be expanded in the future, but such expansion SHOULD NOT
-// include control characters (including those that are not ASCII, such as
-// U+202E RIGHT-TO-LEFT OVERRIDE), slash `/` (which separates ABCI request path
-// segments in e.g. `custom/vstorage/data/foo`), or backslash `\` (which should
-// be reserved for adding escape sequences).
+// enforcing a length restriction on path segments.  So `""`, `"foo"`, and
+// `"foo.bar__baz.qux--quux"` are paths but `"."`, `"foo/bar"`, `"fo\to"`, and
+// `"foö"` are not.  This alphabet might be expanded in the future, but such
+// expansion SHOULD NOT include control characters (including those that are not
+// ASCII, such as U+202E RIGHT-TO-LEFT OVERRIDE), slash `/` (which separates
+// ABCI request path segments in e.g. `/agoric.vstorage.Query/Data`), or
+// backslash `\` (which should be reserved for adding escape sequences).
 //
 // - An encoded key for a path is the path prefixed with its length (in ASCII
 // digits), separated by nul, followed by the path with dots replaced with nul.

package/x/vtransfer/handler.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
+	sdkioerrors "cosmossdk.io/errors"
+	sdktypeserrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // NewHandler returns a handler for "vtransfer" type messages.
@@ -14,7 +16,7 @@ func NewHandler(keeper keeper.Keeper) sdk.Handler {
 		switch msg := msg.(type) {
 		default:
 			errMsg := fmt.Sprintf("Unrecognized vtransfer Msg type: %T", msg)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+			return nil, sdkioerrors.Wrap(sdktypeserrors.ErrUnknownRequest, errMsg)
 		}
 	}
 }

package/x/vtransfer/ibc_middleware_test.go

@@ -23,7 +23,6 @@ import (
 	"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"
@@ -653,7 +652,7 @@ func (s *IntegrationTestSuite) TestHops() {
 					expectedRecords := []swingsettypes.InboundQueueRecord{}
 					if tc.receiverIsTarget {
 						expectedRecords = append(expectedRecords, swingsettypes.InboundQueueRecord{
-							Action: &vibckeeper.WriteAcknowledgementEvent{
+							Action: &vibctypes.WriteAcknowledgementEvent{
 								ActionHeader: &vm.ActionHeader{
 									Type:        "VTRANSFER_IBC_EVENT",
 									BlockHeight: writeAcknowledgementHeight,
@@ -661,7 +660,7 @@ func (s *IntegrationTestSuite) TestHops() {
 								},
 								Event:           "writeAcknowledgement",
 								Target:          baseReceiver,
-								Packet:          sendPacket,
+								Packet:          types.CopyToIBCPacket(sendPacket),
 								Acknowledgement: expectedAck.Acknowledgement(),
 							},
 							Context: swingsettypes.ActionContext{
@@ -765,7 +764,7 @@ func (s *IntegrationTestSuite) TestHops() {
 					expectedRecords := []swingsettypes.InboundQueueRecord{}
 					if tc.senderIsTarget {
 						expectedRecords = append(expectedRecords, swingsettypes.InboundQueueRecord{
-							Action: &vibckeeper.WriteAcknowledgementEvent{
+							Action: &vibctypes.AcknowledgementPacketEvent{
 								ActionHeader: &vm.ActionHeader{
 									Type:        "VTRANSFER_IBC_EVENT",
 									BlockHeight: acknowledgementHeight,
@@ -773,7 +772,7 @@ func (s *IntegrationTestSuite) TestHops() {
 								},
 								Event:           "acknowledgementPacket",
 								Target:          baseSender,
-								Packet:          expectedPacket,
+								Packet:          types.CopyToIBCPacket(expectedPacket),
 								Acknowledgement: ack.Acknowledgement(),
 								Relayer:         s.chainA.SenderAccount.GetAddress(),
 							},