@agoric/cosmos 0.35.0-upgrade-14-dev-c8f9e7b.0 → 0.35.0-upgrade-16a-dev-fb592e4.0

package/x/vtransfer/keeper/keeper.go

@@ -0,0 +1,281 @@
+package keeper
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "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"
+
+	"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"
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v6/modules/core/05-port/types"
+	host "github.com/cosmos/ibc-go/v6/modules/core/24-host"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+var _ porttypes.ICS4Wrapper = (*Keeper)(nil)
+var _ vibctypes.ReceiverImpl = (*Keeper)(nil)
+var _ vm.PortHandler = (*Keeper)(nil)
+
+// "watched addresses" is logically a set and physically a collection of
+// KVStore entries in which each key is a concatenation of a fixed prefix and
+// the address, and its corresponding value is a non-empty but otherwise irrelevant
+// sentinel.
+const (
+	watchedAddressStoreKeyPrefix = "watchedAddress/"
+	watchedAddressSentinel       = "y"
+)
+
+// Keeper handles the interceptions from the vtransfer IBC middleware, passing
+// them to the embedded vibc keeper if they involve a targeted address (which is
+// an address associated with a VM listener). The embedded vibc keeper is used
+// to bridge calls to swingset, but with a special wrapper on the bridge
+// controller to use distinct action types. The keeper keeps a store of
+// "targeted addresses", managed from Swingset by bridge messages.
+type Keeper struct {
+	porttypes.ICS4Wrapper
+	vibctypes.ReceiverImpl
+
+	vibcKeeper vibc.Keeper
+
+	key storetypes.StoreKey
+	cdc codec.Codec
+
+	vibcModule porttypes.IBCModule
+}
+
+// NewKeeper creates a new vtransfer Keeper instance
+func NewKeeper(
+	cdc codec.Codec,
+	key storetypes.StoreKey,
+	prototypeVibcKeeper vibc.Keeper,
+	scopedTransferKeeper capabilitykeeper.ScopedKeeper,
+	pushAction vm.ActionPusher,
+) Keeper {
+	wrappedPushAction := wrapActionPusher(pushAction)
+
+	// This vibcKeeper is used to send notifications from the vtransfer middleware
+	// to the VM.
+	vibcKeeper := prototypeVibcKeeper.WithScope(nil, scopedTransferKeeper, wrappedPushAction)
+	return Keeper{
+		ICS4Wrapper:  vibcKeeper,
+		ReceiverImpl: vibcKeeper,
+
+		vibcKeeper: vibcKeeper,
+		key:        key,
+		vibcModule: vibc.NewIBCModule(vibcKeeper),
+		cdc:        cdc,
+	}
+}
+
+// wrapActionPusher wraps an ActionPusher to prefix the action type with
+// "VTRANSFER_".
+func wrapActionPusher(pusher vm.ActionPusher) vm.ActionPusher {
+	return func(ctx sdk.Context, action vm.Action) error {
+		action = vm.PopulateAction(ctx, action)
+
+		// Prefix the action type.
+		ah := action.GetActionHeader()
+		ah.Type = "VTRANSFER_" + ah.Type
+
+		// fmt.Println("@@@ vtransfer action", action)
+		return pusher(ctx, action)
+	}
+}
+
+func (k Keeper) GetICS4Wrapper() porttypes.ICS4Wrapper {
+	return k
+}
+
+func (k Keeper) GetReceiverImpl() vibctypes.ReceiverImpl {
+	return k
+}
+
+// InterceptOnRecvPacket runs the ibcModule and eventually acknowledges a packet.
+// Many error acknowledgments are sent synchronously, but most cases instead return nil
+// to tell the IBC system that acknowledgment is async (i.e., that WriteAcknowledgement
+// will be called later, after the VM has dealt with the packet).
+func (k Keeper) InterceptOnRecvPacket(ctx sdk.Context, ibcModule porttypes.IBCModule, packet channeltypes.Packet, relayer sdk.AccAddress) ibcexported.Acknowledgement {
+	ack := ibcModule.OnRecvPacket(ctx, packet, relayer)
+
+	if ack == nil {
+		// Already declared to be an async ack.
+		return nil
+	}
+	portID := packet.GetDestPort()
+	channelID := packet.GetDestChannel()
+	capName := host.ChannelCapabilityPath(portID, channelID)
+	chanCap, ok := k.vibcKeeper.GetCapability(ctx, capName)
+	if !ok {
+		err := sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
+		return channeltypes.NewErrorAcknowledgement(err)
+	}
+	// Give the VM a chance to write (or override) the ack.
+	if err := k.InterceptWriteAcknowledgement(ctx, chanCap, packet, ack); err != nil {
+		return channeltypes.NewErrorAcknowledgement(err)
+	}
+	return nil
+}
+
+// InterceptOnAcknowledgementPacket checks to see if the packet sender is a
+// targeted account, and if so, delegates to the VM.
+func (k Keeper) InterceptOnAcknowledgementPacket(
+	ctx sdk.Context,
+	ibcModule porttypes.IBCModule,
+	packet channeltypes.Packet,
+	acknowledgement []byte,
+	relayer sdk.AccAddress,
+) error {
+	// Pass every acknowledgement to the wrapped IBC module.
+	modErr := ibcModule.OnAcknowledgementPacket(ctx, packet, acknowledgement, relayer)
+
+	// If the sender is not a targeted account, we're done.
+	sender, _, err := k.parseTransfer(ctx, packet)
+	if err != nil || sender == "" {
+		return modErr
+	}
+
+	// Trigger VM, regardless of errors in the ibcModule.
+	vmErr := k.vibcKeeper.TriggerOnAcknowledgementPacket(ctx, sender, packet, acknowledgement, relayer)
+
+	// Any error from the VM is trumped by one from the wrapped IBC module.
+	if modErr != nil {
+		return modErr
+	}
+	return vmErr
+}
+
+// InterceptOnTimeoutPacket checks to see if the packet sender is a targeted
+// account, and if so, delegates to the VM.
+func (k Keeper) InterceptOnTimeoutPacket(
+	ctx sdk.Context,
+	ibcModule porttypes.IBCModule,
+	packet channeltypes.Packet,
+	relayer sdk.AccAddress,
+) error {
+	// Pass every timeout to the wrapped IBC module.
+	modErr := ibcModule.OnTimeoutPacket(ctx, packet, relayer)
+
+	// If the sender is not a targeted account, we're done.
+	sender, _, err := k.parseTransfer(ctx, packet)
+	if err != nil || sender == "" {
+		return modErr
+	}
+
+	// Trigger VM, regardless of errors in the app.
+	vmErr := k.vibcKeeper.TriggerOnTimeoutPacket(ctx, sender, packet, relayer)
+
+	// Any error from the VM is trumped by one from the wrapped IBC module.
+	if modErr != nil {
+		return modErr
+	}
+	return vmErr
+}
+
+// InterceptWriteAcknowledgement checks to see if the packet's receiver is a
+// targeted account, and if so, delegates to the VM.
+func (k Keeper) InterceptWriteAcknowledgement(ctx sdk.Context, chanCap *capabilitytypes.Capability, packet ibcexported.PacketI, ack ibcexported.Acknowledgement) error {
+	_, receiver, err := k.parseTransfer(ctx, packet)
+	if err != nil || receiver == "" {
+		// We can't parse, but that means just to ack directly.
+		return k.WriteAcknowledgement(ctx, chanCap, packet, ack)
+	}
+
+	// Trigger VM
+	if err = k.vibcKeeper.TriggerWriteAcknowledgement(ctx, receiver, packet, ack); err != nil {
+		errAck := channeltypes.NewErrorAcknowledgement(err)
+		return k.WriteAcknowledgement(ctx, chanCap, packet, errAck)
+	}
+
+	return nil
+}
+
+// parseTransfer checks if a packet's sender and/or receiver are targeted accounts.
+func (k Keeper) parseTransfer(ctx sdk.Context, packet ibcexported.PacketI) (string, string, error) {
+	var transferData transfertypes.FungibleTokenPacketData
+	err := k.cdc.UnmarshalJSON(packet.GetData(), &transferData)
+	if err != nil {
+		return "", "", err
+	}
+
+	var sender string
+	var receiver string
+	prefixStore := prefix.NewStore(
+		ctx.KVStore(k.key),
+		[]byte(watchedAddressStoreKeyPrefix),
+	)
+	if prefixStore.Has([]byte(transferData.Sender)) {
+		sender = transferData.Sender
+	}
+	if prefixStore.Has([]byte(transferData.Receiver)) {
+		receiver = transferData.Receiver
+	}
+	return sender, receiver, nil
+}
+
+// GetWatchedAdresses returns the watched addresses from the keeper as a slice
+// of account addresses.
+func (k Keeper) GetWatchedAddresses(ctx sdk.Context) ([]sdk.AccAddress, error) {
+	addresses := make([]sdk.AccAddress, 0)
+	prefixStore := prefix.NewStore(ctx.KVStore(k.key), []byte(watchedAddressStoreKeyPrefix))
+	iterator := sdk.KVStorePrefixIterator(prefixStore, []byte{})
+	defer iterator.Close()
+	for ; iterator.Valid(); iterator.Next() {
+		addr, err := sdk.AccAddressFromBech32(string(iterator.Key()))
+		if err != nil {
+			return nil, err
+		}
+		addresses = append(addresses, addr)
+	}
+	return addresses, nil
+}
+
+// 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),
+	)
+	for _, addr := range addresses {
+		prefixStore.Set([]byte(addr.String()), []byte(watchedAddressSentinel))
+	}
+}
+
+type registrationAction struct {
+	Type   string `json:"type"` // BRIDGE_TARGET_REGISTER or BRIDGE_TARGET_UNREGISTER
+	Target string `json:"target"`
+}
+
+// Receive implements the vm.PortHandler interface.
+func (k Keeper) Receive(cctx context.Context, jsonRequest string) (jsonReply string, err error) {
+	ctx := sdk.UnwrapSDKContext(cctx)
+	var msg registrationAction
+	if err := json.Unmarshal([]byte(jsonRequest), &msg); err != nil {
+		return "", err
+	}
+
+	prefixStore := prefix.NewStore(
+		ctx.KVStore(k.key),
+		[]byte(watchedAddressStoreKeyPrefix),
+	)
+	switch msg.Type {
+	case "BRIDGE_TARGET_REGISTER":
+		prefixStore.Set([]byte(msg.Target), []byte(watchedAddressSentinel))
+	case "BRIDGE_TARGET_UNREGISTER":
+		prefixStore.Delete([]byte(msg.Target))
+	default:
+		return "", sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown action type: %s", msg.Type)
+	}
+	return "true", nil
+}

package/x/vtransfer/module.go

@@ -0,0 +1,124 @@
+package vtransfer
+
+import (
+	"encoding/json"
+
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"github.com/spf13/cobra"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/types"
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	abci "github.com/tendermint/tendermint/abci/types"
+)
+
+// type check to ensure the interface is properly implemented
+var (
+	_ module.AppModule      = AppModule{}
+	_ module.AppModuleBasic = AppModuleBasic{}
+)
+
+// app module Basics object
+type AppModuleBasic struct {
+}
+
+func (AppModuleBasic) Name() string {
+	return ModuleName
+}
+
+func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+}
+
+// RegisterInterfaces registers the module's interface types
+func (b AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+}
+
+// DefaultGenesis returns default genesis state as raw bytes for the deployment
+func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
+	return cdc.MustMarshalJSON(DefaultGenesisState())
+}
+
+// Validation check of the Genesis
+func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error {
+	var data types.GenesisState
+	err := cdc.UnmarshalJSON(bz, &data)
+	if err != nil {
+		return err
+	}
+	// Once json successfully marshalled, passes along to genesis.go
+	return ValidateGenesis(&data)
+}
+
+func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {
+}
+
+// Get the root query command of this module
+func (AppModuleBasic) GetQueryCmd() *cobra.Command {
+	return nil
+}
+
+// Get the root tx command of this module
+func (AppModuleBasic) GetTxCmd() *cobra.Command {
+	return nil
+}
+
+type AppModule struct {
+	AppModuleBasic
+	keeper Keeper
+}
+
+// NewAppModule creates a new AppModule Object
+func NewAppModule(k Keeper) AppModule {
+	am := AppModule{
+		AppModuleBasic: AppModuleBasic{},
+		keeper:         k,
+	}
+	return am
+}
+
+func (AppModule) Name() string {
+	return ModuleName
+}
+
+func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {}
+
+func (am AppModule) Route() sdk.Route {
+	return sdk.NewRoute(types.RouterKey, NewHandler(am.keeper))
+}
+
+func (am AppModule) QuerierRoute() string {
+	return ModuleName
+}
+
+// LegacyQuerierHandler returns the sdk.Querier for module
+func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
+	return nil
+}
+
+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 {
+	var genesisState types.GenesisState
+	cdc.MustUnmarshalJSON(data, &genesisState)
+	return InitGenesis(ctx, am.keeper, &genesisState)
+}
+
+func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
+	gs := ExportGenesis(ctx, am.keeper)
+	return cdc.MustMarshalJSON(gs)
+}

package/x/vtransfer/types/expected_keepers.go

@@ -0,0 +1,38 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
+	connection "github.com/cosmos/ibc-go/v6/modules/core/03-connection/types"
+	channel "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+// ChannelKeeper defines the expected IBC channel keeper
+type ChannelKeeper interface {
+	GetChannel(ctx sdk.Context, srcPort, srcChan string) (channel channel.Channel, found bool)
+	GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (uint64, bool)
+	SendPacket(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI) error
+	WriteAcknowledgement(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI, acknowledgement ibcexported.Acknowledgement) error
+	ChanOpenInit(ctx sdk.Context, order channel.Order, connectionHops []string, portID string,
+		portCap *capability.Capability, counterparty channel.Counterparty, version string) (string, *capability.Capability, error)
+	WriteOpenInitChannel(ctx sdk.Context, portID, channelID string, order channel.Order,
+		connectionHops []string, counterparty channel.Counterparty, version string)
+	ChanCloseInit(ctx sdk.Context, portID, channelID string, chanCap *capability.Capability) error
+	TimeoutExecuted(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI) error
+}
+
+// ClientKeeper defines the expected IBC client keeper
+type ClientKeeper interface {
+	GetClientConsensusState(ctx sdk.Context, clientID string) (connection ibcexported.ConsensusState, found bool)
+}
+
+// ConnectionKeeper defines the expected IBC connection keeper
+type ConnectionKeeper interface {
+	GetConnection(ctx sdk.Context, connectionID string) (connection connection.ConnectionEnd, found bool)
+}
+
+// PortKeeper defines the expected IBC port keeper
+type PortKeeper interface {
+	BindPort(ctx sdk.Context, portID string) *capability.Capability
+}