@agoric/cosmos 0.34.2-dev-3c8aafe.0 → 0.34.2-dev-74fbe43.0.74fbe43

package/x/vstorage/module.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
+	"cosmossdk.io/core/appmodule"
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/spf13/cobra"
 
@@ -15,14 +16,16 @@ import (
 	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 
-	abci "github.com/cometbft/cometbft/abci/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 // type check to ensure the interface is properly implemented
 var (
-	_ module.AppModule      = AppModule{}
-	_ module.AppModuleBasic = AppModuleBasic{}
+	_ module.AppModule          = AppModule{}
+	_ module.HasGenesis         = AppModule{}
+	_ module.AppModuleBasic     = AppModuleBasic{}
+	_ appmodule.HasBeginBlocker = AppModule{}
+	_ appmodule.HasEndBlocker   = AppModule{}
 )
 
 // app module Basics object
@@ -75,6 +78,12 @@ type AppModule struct {
 	keeper Keeper
 }
 
+// IsAppModule implements the appmodule.AppModule interface.
+func (am AppModule) IsAppModule() {}
+
+// IsOnePerModuleType is a marker function just indicates that this is a one-per-module type.
+func (am AppModule) IsOnePerModuleType() {}
+
 // NewAppModule creates a new AppModule Object
 func NewAppModule(k Keeper) AppModule {
 	am := AppModule{
@@ -97,23 +106,28 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 
 func (AppModule) ConsensusVersion() uint64 { return 1 }
 
-func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
-	am.keeper.NewChangeBatch(ctx)
+func (am AppModule) BeginBlock(ctx context.Context) error {
+	return am.keeper.NewChangeBatch(sdk.UnwrapSDKContext(ctx))
 }
 
-func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {
-	am.keeper.FlushChangeEvents(ctx)
-	// Prevent Cosmos SDK internal errors.
-	return []abci.ValidatorUpdate{}
+func (am AppModule) EndBlock(ctx context.Context) error {
+	return am.keeper.FlushChangeEvents(sdk.UnwrapSDKContext(ctx))
 }
 
-func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
+func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) {
 	var genesisState types.GenesisState
-	cdc.MustUnmarshalJSON(data, &genesisState)
-	return InitGenesis(ctx, am.keeper, &genesisState)
+	if err := cdc.UnmarshalJSON(data, &genesisState); err != nil {
+		panic(err)
+	}
+	if err := InitGenesis(ctx, am.keeper, &genesisState); err != nil {
+		panic(err)
+	}
 }
 
 func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
-	gs := ExportGenesis(ctx, am.keeper)
+	gs, err := ExportGenesis(ctx, am.keeper)
+	if err != nil {
+		panic(err)
+	}
 	return cdc.MustMarshalJSON(gs)
 }

package/x/vstorage/testing/queue.go

@@ -3,12 +3,14 @@ package testing
 import (
 	"fmt"
 
+	sdkmath "cosmossdk.io/math"
+	storetypes "cosmossdk.io/store/types"
 	keeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 func GetQueueItems(ctx sdk.Context, vstorageKeeper keeper.Keeper, queuePath string) ([]string, error) {
-	unlimitedCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
+	unlimitedCtx := ctx.WithGasMeter(storetypes.NewInfiniteGasMeter())
 	head, err := vstorageKeeper.GetIntValue(unlimitedCtx, queuePath+".head")
 	if err != nil {
 		return nil, err
@@ -21,14 +23,14 @@ func GetQueueItems(ctx sdk.Context, vstorageKeeper keeper.Keeper, queuePath stri
 	values := make([]string, length)
 	var i int64
 	for i = 0; i < length; i++ {
-		path := fmt.Sprintf("%s.%s", queuePath, head.Add(sdk.NewInt(i)).String())
+		path := fmt.Sprintf("%s.%s", queuePath, head.Add(sdkmath.NewInt(i)).String())
 		values[i] = vstorageKeeper.GetEntry(unlimitedCtx, path).StringValue()
 	}
 	return values, nil
 }
 
 func ResetQueue(ctx sdk.Context, vstorageKeeper keeper.Keeper, queuePath string) error {
-	unlimitedCtx := ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
+	unlimitedCtx := ctx.WithGasMeter(storetypes.NewInfiniteGasMeter())
 	vstorageKeeper.RemoveEntriesWithPrefix(unlimitedCtx, queuePath)
 	return nil
 }

package/x/vstorage/vstorage.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 
+	storetypes "cosmossdk.io/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	agoric "github.com/Agoric/agoric-sdk/golang/cosmos/types"
@@ -54,7 +55,7 @@ func (sh vstorageHandler) Receive(cctx context.Context, str string) (ret string,
 	defer func() {
 		if r := recover(); r != nil {
 			switch rType := r.(type) {
-			case sdk.ErrorOutOfGas:
+			case storetypes.ErrorOutOfGas:
 				err = fmt.Errorf(
 					"out of gas in location: %v; gasUsed: %d",
 					rType.Descriptor, ctx.GasMeter().GasConsumed(),
@@ -176,10 +177,10 @@ func (sh vstorageHandler) Receive(cctx context.Context, str string) (ret string,
 			return
 		}
 		children := keeper.GetChildren(ctx, path)
-		if children.Children == nil {
+		if children == nil {
 			return "[]", nil
 		}
-		bytes, err := json.Marshal(children.Children)
+		bytes, err := json.Marshal(children)
 		if err != nil {
 			return "", err
 		}
@@ -192,8 +193,8 @@ func (sh vstorageHandler) Receive(cctx context.Context, str string) (ret string,
 			return
 		}
 		children := keeper.GetChildren(ctx, path)
-		entries := make([]agoric.KVEntry, len(children.Children))
-		for i, child := range children.Children {
+		entries := make([]agoric.KVEntry, len(children))
+		for i, child := range children {
 			entry := keeper.GetEntry(ctx, fmt.Sprintf("%s.%s", path, child))
 			if !entry.HasValue() {
 				entries[i] = agoric.NewKVEntryWithNoValue(child)
@@ -214,8 +215,8 @@ func (sh vstorageHandler) Receive(cctx context.Context, str string) (ret string,
 			return
 		}
 		children := keeper.GetChildren(ctx, path)
-		vals := make([]*string, len(children.Children))
-		for i, child := range children.Children {
+		vals := make([]*string, len(children))
+		for i, child := range children {
 			vals[i] = keeper.GetEntry(ctx, fmt.Sprintf("%s.%s", path, child)).Value()
 		}
 		bytes, err := json.Marshal(vals)
@@ -231,10 +232,10 @@ func (sh vstorageHandler) Receive(cctx context.Context, str string) (ret string,
 			return
 		}
 		children := keeper.GetChildren(ctx, path)
-		if children.Children == nil {
+		if children == nil {
 			return "0", nil
 		}
-		return fmt.Sprint(len(children.Children)), nil
+		return fmt.Sprint(len(children)), nil
 	}
 
 	return "", errors.New("Unrecognized msg.Method " + msg.Method)

package/x/vstorage/vstorage_test.go

@@ -8,16 +8,19 @@ import (
 	"strings"
 	"testing"
 
+	storemetrics "cosmossdk.io/store/metrics"
+
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/types"
 
-	"github.com/cosmos/cosmos-sdk/store"
-	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	"cosmossdk.io/store"
+	storetypes "cosmossdk.io/store/types"
+	"github.com/cosmos/cosmos-sdk/runtime"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"cosmossdk.io/log"
 	agorictypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
-	dbm "github.com/cometbft/cometbft-db"
-	"github.com/cometbft/cometbft/libs/log"
 	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	dbm "github.com/cosmos/cosmos-db"
 )
 
 var (
@@ -32,22 +35,23 @@ type testKit struct {
 	keeper  Keeper
 	handler vstorageHandler
 	ctx     sdk.Context
-	cctx    context.Context
 }
 
 func makeTestKit() testKit {
-	keeper := NewKeeper(storeKey)
+	kvStoreService := runtime.NewKVStoreService(storeKey)
+
+	keeper := NewKeeper(storeKey.Name(), kvStoreService)
 	db := dbm.NewMemDB()
-	ms := store.NewCommitMultiStore(db)
+	logger := log.NewNopLogger()
+	ms := store.NewCommitMultiStore(db, logger, storemetrics.NewNoOpMetrics())
 	ms.MountStoreWithDB(storeKey, storetypes.StoreTypeIAVL, db)
 	err := ms.LoadLatestVersion()
 	if err != nil {
 		panic(err)
 	}
 	ctx := sdk.NewContext(ms, tmproto.Header{}, false, log.NewNopLogger())
-	cctx := sdk.WrapSDKContext(ctx)
 	handler := vstorageHandler{keeper}
-	return testKit{keeper, handler, ctx, cctx}
+	return testKit{keeper, handler, ctx}
 }
 
 func callReceive(
@@ -68,7 +72,7 @@ func callReceive(
 
 func TestGetAndHas(t *testing.T) {
 	kit := makeTestKit()
-	keeper, handler, ctx, cctx := kit.keeper, kit.handler, kit.ctx, kit.cctx
+	keeper, handler, ctx := kit.keeper, kit.handler, kit.ctx
 
 	keeper.SetStorage(ctx, agorictypes.NewKVEntry("foo", "bar"))
 	keeper.SetStorage(ctx, agorictypes.NewKVEntry("empty", ""))
@@ -92,8 +96,8 @@ func TestGetAndHas(t *testing.T) {
 		{label: "extra args", args: []interface{}{"foo", "bar"}, errContains: ptr(`extra`)},
 	}
 	for _, desc := range cases {
-		got, err := callReceive(handler, cctx, "get", desc.args)
-		has, hasErr := callReceive(handler, cctx, "has", desc.args)
+		got, err := callReceive(handler, ctx, "get", desc.args)
+		has, hasErr := callReceive(handler, ctx, "has", desc.args)
 
 		// Verify get/has error agreement.
 		if (err == nil) != (hasErr == nil) {
@@ -125,7 +129,7 @@ func TestGetAndHas(t *testing.T) {
 
 func doTestSet(t *testing.T, method string, expectNotify bool) {
 	kit := makeTestKit()
-	keeper, handler, ctx, cctx := kit.keeper, kit.handler, kit.ctx, kit.cctx
+	keeper, handler, ctx := kit.keeper, kit.handler, kit.ctx
 
 	type testCase struct {
 		label        string
@@ -183,7 +187,7 @@ func doTestSet(t *testing.T, method string, expectNotify bool) {
 		stateChangeEvent("qux", "A"),
 	}
 	for _, desc := range cases {
-		got, err := callReceive(handler, cctx, method, desc.args)
+		got, err := callReceive(handler, ctx, method, desc.args)
 
 		if desc.errContains == nil {
 			if err != nil {
@@ -208,7 +212,7 @@ func doTestSet(t *testing.T, method string, expectNotify bool) {
 				}
 				wantBackBytes, _ := json.Marshal(value)
 				wantBack := string(wantBackBytes)
-				gotBack, err := callReceive(handler, cctx, "get", []interface{}{path})
+				gotBack, err := callReceive(handler, ctx, "get", []interface{}{path})
 				if err != nil {
 					t.Errorf("%s %s read back %q: got unexpected error %v", method, desc.label, path, err)
 				} else if gotBack != wantBack {
@@ -226,7 +230,9 @@ func doTestSet(t *testing.T, method string, expectNotify bool) {
 	if got := ctx.EventManager().Events(); !reflect.DeepEqual(got, sdk.Events{}) {
 		t.Errorf("%s got unexpected events before flush %#v", method, got)
 	}
-	keeper.FlushChangeEvents(ctx)
+	if err := keeper.FlushChangeEvents(ctx); err != nil {
+		t.Errorf("%s got unexpected flush error %v", method, err)
+	}
 	if !expectNotify {
 		if got := ctx.EventManager().Events(); !reflect.DeepEqual(got, sdk.Events{}) {
 			t.Errorf("%s got unexpected events after flush %#v", method, got)
@@ -257,7 +263,7 @@ func TestSetWithoutNotify(t *testing.T) {
 
 func TestEntries(t *testing.T) {
 	kit := makeTestKit()
-	keeper, handler, ctx, cctx := kit.keeper, kit.handler, kit.ctx, kit.cctx
+	keeper, handler, ctx := kit.keeper, kit.handler, kit.ctx
 
 	keeper.SetStorage(ctx, agorictypes.NewKVEntry("key1", "value1"))
 	keeper.SetStorage(ctx, agorictypes.NewKVEntry("key1.child1.grandchild1", "value1grandchild"))
@@ -286,7 +292,7 @@ func TestEntries(t *testing.T) {
 		{path: "nosuchkey", want: `[]`},
 	}
 	for _, desc := range cases {
-		got, err := callReceive(handler, cctx, "entries", []interface{}{desc.path})
+		got, err := callReceive(handler, ctx, "entries", []interface{}{desc.path})
 		if got != desc.want {
 			t.Errorf("%s: got %q; want %q", desc.path, got, desc.want)
 		}

package/x/vtransfer/genesis.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/types"
-	abci "github.com/cometbft/cometbft/abci/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
@@ -23,9 +22,8 @@ func DefaultGenesisState() *types.GenesisState {
 	return &types.GenesisState{}
 }
 
-func InitGenesis(ctx sdk.Context, keeper Keeper, data *types.GenesisState) []abci.ValidatorUpdate {
+func InitGenesis(ctx sdk.Context, keeper Keeper, data *types.GenesisState) {
 	keeper.SetWatchedAddresses(ctx, data.GetWatchedAddresses())
-	return []abci.ValidatorUpdate{}
 }
 
 func ExportGenesis(ctx sdk.Context, k Keeper) *types.GenesisState {

package/x/vtransfer/handler.go

@@ -3,15 +3,16 @@ package vtransfer
 import (
 	"fmt"
 
+	sdkioerrors "cosmossdk.io/errors"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	sdkioerrors "cosmossdk.io/errors"
 	sdktypeserrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // NewHandler returns a handler for "vtransfer" type messages.
-func NewHandler(keeper keeper.Keeper) sdk.Handler {
+func NewHandler(keeper keeper.Keeper) baseapp.MsgServiceHandler {
 	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		switch msg := msg.(type) {
 		default:

package/x/vtransfer/ibc_middleware.go

@@ -3,11 +3,11 @@ package vtransfer
 import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
-	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
-	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
-	porttypes "github.com/cosmos/ibc-go/v7/modules/core/05-port/types"
-	"github.com/cosmos/ibc-go/v7/modules/core/exported"
+	capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
+	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v8/modules/core/05-port/types"
+	"github.com/cosmos/ibc-go/v8/modules/core/exported"
 )
 
 // IBCMiddleware (https://ibc.cosmos.network/main/ibc/apps/ibcmodule) forwards

package/x/vtransfer/ibc_middleware_test.go

@@ -10,12 +10,12 @@ import (
 	"testing"
 	"text/template"
 
+	"cosmossdk.io/log"
+	"cosmossdk.io/store"
 	app "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
-	dbm "github.com/cometbft/cometbft-db"
-	"github.com/cometbft/cometbft/libs/log"
+	dbm "github.com/cosmos/cosmos-db"
 	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/store"
 	"github.com/cosmos/cosmos-sdk/testutil/sims"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	"github.com/iancoleman/orderedmap"
@@ -26,16 +26,18 @@ import (
 	swingsettypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 	vibctypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
 
+	sdkmath "cosmossdk.io/math"
+	abci "github.com/cometbft/cometbft/abci/types"
 	tmproto "github.com/cometbft/cometbft/proto/tendermint/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/v7/packetforward/types"
-	ibctransfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
-	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
-	ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
-	ibctesting "github.com/cosmos/ibc-go/v7/testing"
+	packetforwardtypes "github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v8/packetforward/types"
+	ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported"
+	ibctesting "github.com/cosmos/ibc-go/v8/testing"
 )
 
 const (
@@ -106,7 +108,7 @@ func (s *IntegrationTestSuite) nextChannelOffset(instance int) int {
 	return offset
 }
 
-func SetupAgoricTestingApp(instance int) TestingAppMaker {
+func SetupAgoricTestingApp(t *testing.T, instance int) TestingAppMaker {
 	return func() (ibctesting.TestingApp, map[string]json.RawMessage) {
 		db := dbm.NewMemDB()
 		mockController := func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
@@ -122,9 +124,9 @@ func SetupAgoricTestingApp(instance int) TestingAppMaker {
 			jsonReply = `true`
 			return jsonReply, nil
 		}
-		appd := app.NewAgoricApp(mockController, vm.NewAgdServer(), log.TestingLogger(), db, nil,
+		appd := app.NewAgoricApp(mockController, vm.NewAgdServer(), log.NewTestLogger(t), db, nil,
 			true, sims.EmptyAppOptions{}, interBlockCacheOpt())
-		genesisState := app.NewDefaultGenesisState()
+		genesisState := app.NewDefaultGenesisState(appd.AppCodec(), appd.BasicModuleManager)
 
 		t := template.Must(template.New("").Parse(`
 		{
@@ -146,7 +148,7 @@ func SetupAgoricTestingApp(instance int) TestingAppMaker {
 						"connections": [],
 						"next_connection_sequence": "{{.nextConnectionSequence}}",
 						"params": {
-								"max_expected_time_per_block": "30000000000"
+							"max_expected_time_per_block": "30000000000"
 						}
 				},
 				"channel_genesis": {
@@ -155,6 +157,15 @@ func SetupAgoricTestingApp(instance int) TestingAppMaker {
 						"channels": [],
 						"commitments": [],
 						"next_channel_sequence": "{{.nextChannelSequence}}",
+						"params": {
+							"upgrade_timeout": {
+								"height": {
+									"revision_number": "0",
+									"revision_height": "0"
+								},
+								"timestamp": "600000000000"
+							}
+						},
 						"receipts": [],
 						"recv_sequences": [],
 						"send_sequences": []
@@ -184,14 +195,14 @@ func (s *IntegrationTestSuite) SetupTest() {
 
 	chains := make(map[string]*ibctesting.TestChain)
 	for i := 0; i < 3; i++ {
-		ibctesting.DefaultTestingAppInit = SetupAgoricTestingApp(i)
+		ibctesting.DefaultTestingAppInit = SetupAgoricTestingApp(s.T(), i)
 
 		chainID := ibctesting.GetChainID(i)
 		chain := ibctesting.NewTestChain(s.T(), s.coordinator, chainID)
 
 		balance := banktypes.Balance{
 			Address: chain.SenderAccount.GetAddress().String(),
-			Coins:   sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000000000000))),
+			Coins:   sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
 		}
 
 		// create application and override files in the IBC test chain
@@ -353,7 +364,7 @@ func (s *IntegrationTestSuite) TransferFromEndpoint(
 	src *ibctesting.Endpoint,
 	data ibctransfertypes.FungibleTokenPacketData,
 ) error {
-	tokenAmt, ok := sdk.NewIntFromString(data.Amount)
+	tokenAmt, ok := sdkmath.NewIntFromString(data.Amount)
 	s.Require().True(ok)
 
 	timeoutHeight := src.Counterparty.Chain.GetTimeoutHeight()
@@ -416,11 +427,11 @@ func (s *IntegrationTestSuite) overrideSendPacketData(cdc codec.Codec, data []by
 
 func (s *IntegrationTestSuite) mintToAddress(chain *ibctesting.TestChain, addr sdk.AccAddress, denom, amount string) {
 	app := s.GetApp(chain)
-	tokenAmt, ok := sdk.NewIntFromString(amount)
+	tokenAmt, ok := sdkmath.NewIntFromString(amount)
 	s.Require().True(ok)
 	intAmt, err := strconv.ParseInt(amount, 10, 64)
 	s.Require().NoError(err)
-	coins := sdk.NewCoins(sdk.NewCoin(denom, tokenAmt.Mul(sdk.NewInt(intAmt))))
+	coins := sdk.NewCoins(sdk.NewCoin(denom, tokenAmt.Mul(sdkmath.NewInt(intAmt))))
 	err = app.BankKeeper.MintCoins(chain.GetContext(), ibctransfertypes.ModuleName, coins)
 	s.Require().NoError(err)
 	err = app.BankKeeper.SendCoinsFromModuleToAccount(chain.GetContext(), ibctransfertypes.ModuleName, addr, coins)
@@ -577,13 +588,13 @@ func (s *IntegrationTestSuite) TestHops() {
 				err = s.TransferFromEndpoint(sendContext, paths[0].EndpointA, transferData)
 				s.Require().NoError(err)
 
-				sendPacket, err := ParsePacketFromEvents(sendContext.EventManager().Events())
+				sendPacket, err := ParsePacketFromEvents(sendContext.EventManager().ABCIEvents())
 				s.Require().NoError(err)
 
 				s.coordinator.CommitBlock(s.chainA)
 
 				// Relay the packet through the intermediaries to the final destination.
-				var packetRes *sdk.Result
+				var packetRes *abci.ExecTxResult
 				var writeAcknowledgementHeight, writeAcknowledgementTime int64
 				for pathIdx := 0; pathIdx < hops; pathIdx += 1 {
 					nextPath := paths[pathIdx]
@@ -611,7 +622,8 @@ func (s *IntegrationTestSuite) TestHops() {
 					}
 
 					// The PFM should have received the packet and advertised a send toward the last path.
-					sendPacket, err = ParsePacketFromEvents(packetRes.GetEvents())
+
+					sendPacket, err = ParsePacketFromEvents(packetRes.Events)
 					s.Require().NoError(err)
 				}
 
@@ -621,10 +633,10 @@ func (s *IntegrationTestSuite) TestHops() {
 				expectedAck := channeltypes.NewResultAcknowledgement([]byte{1})
 
 				{
-					var events sdk.Events
+					var events []abci.Event
 					var ackData []byte
 					if packetRes != nil {
-						events = packetRes.GetEvents()
+						events = packetRes.Events
 						ackData, err = ParseAckFromEvents(events)
 					}
 					if tc.receiverIsTarget {
@@ -636,7 +648,7 @@ func (s *IntegrationTestSuite) TestHops() {
 						err = s.GetApp(s.chainB).VtransferKeeper.ReceiveWriteAcknowledgement(vmAckContext, sendPacket, expectedAck)
 						s.Require().NoError(err)
 
-						events = vmAckContext.EventManager().Events()
+						events = vmAckContext.EventManager().ABCIEvents()
 						ackData, err = ParseAckFromEvents(events)
 					}
 
@@ -685,10 +697,10 @@ func (s *IntegrationTestSuite) TestHops() {
 					ackRes, err := acknowledgePacketWithResult(priorPath.EndpointA, ackedPacket, ack.Acknowledgement())
 					s.Require().NoError(err)
 
-					ackedPacket, err = ParsePacketFromFilteredEvents(ackRes.GetEvents(), channeltypes.EventTypeWriteAck)
+					ackedPacket, err = ParsePacketFromFilteredEvents(ackRes.Events, channeltypes.EventTypeWriteAck)
 					s.Require().NoError(err)
 
-					ackData, err := ParseAckFromEvents(ackRes.GetEvents())
+					ackData, err := ParseAckFromEvents(ackRes.Events)
 					s.Require().NoError(err)
 					ack = vibctypes.NewRawAcknowledgement(ackData)
 
@@ -712,13 +724,15 @@ func (s *IntegrationTestSuite) TestHops() {
 				// Verify the resulting events.
 				gotEvents := 0
 				expectedEvents := 2
-				for _, event := range ackRes.GetEvents() {
+				for _, event := range ackRes.Events {
 					if event.Type == ibctransfertypes.EventTypePacket {
 						gotEvents += 1
-						if gotEvents == 2 && len(event.Attributes) == 1 {
+						if gotEvents == 2 && len(event.Attributes) == 2 {
 							// 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))
+							s.Require().Equal("msg_index", string(event.Attributes[1].Key))
+							s.Require().Equal("0", string(event.Attributes[1].Value))
 							continue
 						}
 						expectedAttrs := 6
@@ -793,7 +807,7 @@ func (s *IntegrationTestSuite) TestHops() {
 				res, err := s.GetApp(s.chainB).BankKeeper.AllBalances(s.chainB.GetContext(), req)
 				s.Require().NoError(err)
 
-				amt, ok := sdk.NewIntFromString(transferData.Amount)
+				amt, ok := sdkmath.NewIntFromString(transferData.Amount)
 				s.Require().True(ok)
 
 				// Decode the denom trace to get the denom hash.
@@ -805,7 +819,7 @@ func (s *IntegrationTestSuite) TestHops() {
 				receivedDenom := `ibc/` + hashRes.Hash
 
 				coins := sdk.NewCoins(sdk.NewCoin(receivedDenom, amt))
-				s.Require().True(coins.IsEqual(res.Balances))
+				s.Require().True(coins.Equal(res.Balances))
 			})
 		}
 	}