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

package/x/vtransfer/keeper/keeper.go

@@ -6,27 +6,28 @@ import (
 	"encoding/json"
 	"fmt"
 
+	corestore "cosmossdk.io/core/store"
+	sdkioerrors "cosmossdk.io/errors"
+	"cosmossdk.io/store/prefix"
+	storetypes "cosmossdk.io/store/types"
 	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/store/prefix"
-	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	"github.com/cosmos/cosmos-sdk/runtime"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-
-	sdkioerrors "cosmossdk.io/errors"
 	sdktypeserrors "github.com/cosmos/cosmos-sdk/types/errors"
 
-	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
-	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
+	capabilitykeeper "github.com/cosmos/ibc-go/modules/capability/keeper"
+	capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
 
 	agtypes "github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc"
 	vibctypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/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"
-	host "github.com/cosmos/ibc-go/v7/modules/core/24-host"
-	ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
+	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"
+	host "github.com/cosmos/ibc-go/v8/modules/core/24-host"
+	ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported"
 )
 
 var _ porttypes.ICS4Wrapper = (*Keeper)(nil)
@@ -56,8 +57,8 @@ type Keeper struct {
 
 	vibcKeeper vibc.Keeper
 
-	key storetypes.StoreKey
-	cdc codec.Codec
+	storeService corestore.KVStoreService
+	cdc          codec.Codec
 
 	vibcModule porttypes.IBCModule
 
@@ -137,7 +138,7 @@ func NewICS4Wrapper(k Keeper, down porttypes.ICS4Wrapper) *ics4Wrapper {
 // NewKeeper creates a new vtransfer Keeper instance
 func NewKeeper(
 	cdc codec.Codec,
-	key storetypes.StoreKey,
+	storeService corestore.KVStoreService,
 	prototypeVibcKeeper vibc.Keeper,
 	scopedTransferKeeper capabilitykeeper.ScopedKeeper,
 	pushAction vm.ActionPusher,
@@ -150,10 +151,10 @@ func NewKeeper(
 	k := Keeper{
 		ReceiverImpl: vibcKeeper,
 
-		vibcKeeper: vibcKeeper,
-		key:        key,
-		vibcModule: vibc.NewIBCModule(vibcKeeper),
-		cdc:        cdc,
+		vibcKeeper:   vibcKeeper,
+		storeService: storeService,
+		vibcModule:   vibc.NewIBCModule(vibcKeeper),
+		cdc:          cdc,
 
 		debug: &KeeperDebugOptions{
 			OverridePacket: nil,
@@ -208,7 +209,9 @@ func sequencePath(sequence uint64) string {
 func (k Keeper) PacketStore(ctx sdk.Context, ourOrigin agtypes.PacketOrigin, ourPort string, ourChannel string, sequence uint64) (storetypes.KVStore, []byte) {
 	key := fmt.Sprintf("%s/%s/%s", ourOrigin, channelPath(ourPort, ourChannel), sequencePath(sequence))
 	packetKey := []byte(key)
-	return prefix.NewStore(ctx.KVStore(k.key), []byte(packetDataStoreKeyPrefix)), packetKey
+	kvstore := k.storeService.OpenKVStore(ctx)
+	store := runtime.KVStoreAdapter(kvstore)
+	return prefix.NewStore(store, []byte(packetDataStoreKeyPrefix)), packetKey
 }
 
 func (k Keeper) PacketStoreFromOrigin(ctx sdk.Context, ourOrigin agtypes.PacketOrigin, packet ibcexported.PacketI) (storetypes.KVStore, []byte) {
@@ -371,19 +374,20 @@ func (k Keeper) InterceptWriteAcknowledgement(ctx sdk.Context, chanCap *capabili
 
 // targetIsWatched checks if a target address has been watched by the VM.
 func (k Keeper) targetIsWatched(ctx sdk.Context, target string) bool {
-	prefixStore := prefix.NewStore(
-		ctx.KVStore(k.key),
-		[]byte(watchedAddressStoreKeyPrefix),
-	)
+	kvstore := k.storeService.OpenKVStore(ctx)
+	store := runtime.KVStoreAdapter(kvstore)
+	prefixStore := prefix.NewStore(store, []byte(watchedAddressStoreKeyPrefix))
 	return prefixStore.Has([]byte(target))
 }
 
 // GetWatchedAdresses returns the watched addresses from the keeper as a slice
 // of account addresses.
 func (k Keeper) GetWatchedAddresses(ctx sdk.Context) ([]sdk.AccAddress, error) {
+	kvstore := k.storeService.OpenKVStore(ctx)
+	store := runtime.KVStoreAdapter(kvstore)
 	addresses := make([]sdk.AccAddress, 0)
-	prefixStore := prefix.NewStore(ctx.KVStore(k.key), []byte(watchedAddressStoreKeyPrefix))
-	iterator := sdk.KVStorePrefixIterator(prefixStore, []byte{})
+	prefixStore := prefix.NewStore(store, []byte(watchedAddressStoreKeyPrefix))
+	iterator := storetypes.KVStorePrefixIterator(prefixStore, []byte{})
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
 		addr, err := sdk.AccAddressFromBech32(string(iterator.Key()))
@@ -398,10 +402,9 @@ func (k Keeper) GetWatchedAddresses(ctx sdk.Context) ([]sdk.AccAddress, error) {
 // SetWatchedAddresses sets the watched addresses in the keeper from a slice of
 // SDK account addresses.
 func (k Keeper) SetWatchedAddresses(ctx sdk.Context, addresses []sdk.AccAddress) {
-	prefixStore := prefix.NewStore(
-		ctx.KVStore(k.key),
-		[]byte(watchedAddressStoreKeyPrefix),
-	)
+	kvstore := k.storeService.OpenKVStore(ctx)
+	store := runtime.KVStoreAdapter(kvstore)
+	prefixStore := prefix.NewStore(store, []byte(watchedAddressStoreKeyPrefix))
 	for _, addr := range addresses {
 		prefixStore.Set([]byte(addr.String()), []byte(watchedAddressSentinel))
 	}
@@ -420,10 +423,9 @@ func (k Keeper) Receive(cctx context.Context, jsonRequest string) (jsonReply str
 		return "", err
 	}
 
-	prefixStore := prefix.NewStore(
-		ctx.KVStore(k.key),
-		[]byte(watchedAddressStoreKeyPrefix),
-	)
+	kvstore := k.storeService.OpenKVStore(ctx)
+	store := runtime.KVStoreAdapter(kvstore)
+	prefixStore := prefix.NewStore(store, []byte(watchedAddressStoreKeyPrefix))
 	switch msg.Type {
 	case "BRIDGE_TARGET_REGISTER":
 		prefixStore.Set([]byte(msg.Target), []byte(watchedAddressSentinel))

package/x/vtransfer/module.go

@@ -12,7 +12,6 @@ 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"
 )
 
@@ -20,12 +19,18 @@ import (
 var (
 	_ module.AppModule      = AppModule{}
 	_ module.AppModuleBasic = AppModuleBasic{}
+	_ module.HasGenesis     = AppModule{}
 )
 
 // app module Basics object
 type AppModuleBasic struct {
 }
 
+// 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() {}
 func (AppModuleBasic) Name() string {
 	return ModuleName
 }
@@ -91,18 +96,10 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 
 func (AppModule) ConsensusVersion() uint64 { return 1 }
 
-func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
-}
-
-func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {
-	// Prevent Cosmos SDK internal errors.
-	return []abci.ValidatorUpdate{}
-}
-
-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)
+	InitGenesis(ctx, am.keeper, &genesisState)
 }
 
 func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {

package/x/vtransfer/types/expected_keepers.go

@@ -2,9 +2,9 @@ package types
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
-	channel "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
-	ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
+	capability "github.com/cosmos/ibc-go/modules/capability/types"
+	channel "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported"
 )
 
 // ChannelKeeper defines the expected IBC channel keeper

package/x/vtransfer/utils_test.go

@@ -1,19 +1,20 @@
 package vtransfer_test
 
 import (
+	"encoding/hex"
 	"fmt"
 	"strconv"
 
-	sdk "github.com/cosmos/cosmos-sdk/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"
-	host "github.com/cosmos/ibc-go/v7/modules/core/24-host"
-	ibctesting "github.com/cosmos/ibc-go/v7/testing"
+	abci "github.com/cometbft/cometbft/abci/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"
+	host "github.com/cosmos/ibc-go/v8/modules/core/24-host"
+	ibctesting "github.com/cosmos/ibc-go/v8/testing"
 )
 
 // acknowledgePacketWithResult sends a MsgAcknowledgement to the channel associated with the endpoint.
 // [AGORIC] Would be nice to create a new ibctesting.AcknowledgePacketWithResult
-func acknowledgePacketWithResult(endpoint *ibctesting.Endpoint, packet channeltypes.Packet, ack []byte) (*sdk.Result, error) {
+func acknowledgePacketWithResult(endpoint *ibctesting.Endpoint, packet channeltypes.Packet, ack []byte) (*abci.ExecTxResult, error) {
 	// get proof of acknowledgement on counterparty
 	packetKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
 	proof, proofHeight := endpoint.Counterparty.QueryProof(packetKey)
@@ -26,17 +27,24 @@ func acknowledgePacketWithResult(endpoint *ibctesting.Endpoint, packet channelty
 // ParseAckFromEvents parses events emitted from a MsgRecvPacket and returns the
 // acknowledgement.
 // [AGORIC] Signature taken from ibctesting.ParseAckFromEvents
-func ParseAckFromEvents(events sdk.Events) ([]byte, error) {
+func ParseAckFromEvents(events []abci.Event) ([]byte, error) {
 	return ParseAckFromFilteredEvents(events, channeltypes.EventTypeWriteAck)
 }
 
 // ParseAckFromFilteredEvents parses events emitted matching filteredType and returns the acknowledgement.
 // [AGORIC] Would be nice to improve the implementation and upstream it
-func ParseAckFromFilteredEvents(events sdk.Events, filteredType string) ([]byte, error) {
+func ParseAckFromFilteredEvents(events []abci.Event, filteredType string) ([]byte, error) {
 	for _, ev := range events {
 		if ev.Type == filteredType {
 			for _, attr := range ev.Attributes {
-				if attr.Key == channeltypes.AttributeKeyAck { //nolint:staticcheck // DEPRECATED
+				switch attr.Key {
+				case channeltypes.AttributeKeyAckHex:
+					hexAck, err := hex.DecodeString(attr.Value)
+					if err != nil {
+						return nil, fmt.Errorf("failed to parse hex ack: %w", err)
+					}
+					return hexAck, nil
+				case channeltypes.AttributeKeyAck: //nolint:staticcheck // DEPRECATED
 					return []byte(attr.Value), nil
 				}
 			}
@@ -48,18 +56,25 @@ func ParseAckFromFilteredEvents(events sdk.Events, filteredType string) ([]byte,
 // ParsePacketFromEvents parses the send_packet type events emitted by the IBC
 // module and returns the packet.
 // [AGORIC] Signature taken from ibctesting.ParsePacketFromEvents
-func ParsePacketFromEvents(events sdk.Events) (channeltypes.Packet, error) {
+func ParsePacketFromEvents(events []abci.Event) (channeltypes.Packet, error) {
 	return ParsePacketFromFilteredEvents(events, channeltypes.EventTypeSendPacket)
 }
 
 // ParsePacketFromFilteredEvents parses events emitted matching filteredType and returns the packet.
 // [AGORIC] Would be nice to improve the implementation and upstream it
-func ParsePacketFromFilteredEvents(events sdk.Events, filteredType string) (channeltypes.Packet, error) {
+func ParsePacketFromFilteredEvents(events []abci.Event, filteredType string) (channeltypes.Packet, error) {
 	for _, ev := range events {
 		if ev.Type == filteredType {
 			packet := channeltypes.Packet{}
 			for _, attr := range ev.Attributes {
 				switch attr.Key {
+				case channeltypes.AttributeKeyDataHex:
+					hexData, err := hex.DecodeString(attr.Value)
+					if err != nil {
+						return channeltypes.Packet{}, fmt.Errorf("failed to parse hex data: %w", err)
+					}
+					packet.Data = hexData
+
 				case channeltypes.AttributeKeyData: //nolint:staticcheck // DEPRECATED
 					packet.Data = []byte(attr.Value)