@agoric/cosmos 0.34.2-orchestration-dev-096c4e8.0 → 0.34.2-other-dev-3eb1a1d.0

package/x/vtransfer/keeper/keeper.go

@@ -0,0 +1,282 @@
+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"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/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 {
+	// Pass every (stripped-receiver) inbound packet to the wrapped IBC module.
+	var strippedPacket channeltypes.Packet
+	_, err := types.ExtractBaseAddressFromPacket(k.cdc, packet, types.RoleReceiver, &strippedPacket)
+	if err != nil {
+		return channeltypes.NewErrorAcknowledgement(err)
+	}
+	ack := ibcModule.OnRecvPacket(ctx, strippedPacket, 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 (stripped-sender) acknowledgement to the wrapped IBC module.
+	var strippedPacket channeltypes.Packet
+	baseSender, err := types.ExtractBaseAddressFromPacket(k.cdc, packet, types.RoleSender, &strippedPacket)
+	if err != nil {
+		return err
+	}
+	modErr := ibcModule.OnAcknowledgementPacket(ctx, strippedPacket, acknowledgement, relayer)
+
+	// If the sender is not a watched account, we're done.
+	if !k.targetIsWatched(ctx, baseSender) {
+		return modErr
+	}
+
+	// Trigger VM with the original packet, regardless of errors in the ibcModule.
+	vmErr := k.vibcKeeper.TriggerOnAcknowledgementPacket(ctx, baseSender, 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 (stripped-sender) timeout to the wrapped IBC module.
+	var strippedPacket channeltypes.Packet
+	baseSender, err := types.ExtractBaseAddressFromPacket(k.cdc, packet, types.RoleSender, &strippedPacket)
+	if err != nil {
+		return err
+	}
+	modErr := ibcModule.OnTimeoutPacket(ctx, strippedPacket, relayer)
+
+	// If the sender is not a watched account, we're done.
+	if !k.targetIsWatched(ctx, baseSender) {
+		return modErr
+	}
+
+	// Trigger VM with the original packet, regardless of errors in the app.
+	vmErr := k.vibcKeeper.TriggerOnTimeoutPacket(ctx, baseSender, 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 {
+	// Get the base baseReceiver from the packet, without computing a stripped packet.
+	baseReceiver, err := types.ExtractBaseAddressFromPacket(k.cdc, packet, types.RoleReceiver, nil)
+	if err != nil || !k.targetIsWatched(ctx, baseReceiver) {
+		// We can't parse, or not watching, but that means just to ack directly.
+		return k.WriteAcknowledgement(ctx, chanCap, packet, ack)
+	}
+
+	// Trigger VM with the original packet.
+	if err = k.vibcKeeper.TriggerWriteAcknowledgement(ctx, baseReceiver, packet, ack); err != nil {
+		errAck := channeltypes.NewErrorAcknowledgement(err)
+		return k.WriteAcknowledgement(ctx, chanCap, packet, errAck)
+	}
+
+	return nil
+}
+
+// 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),
+	)
+	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) {
+	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/baseaddr.go

@@ -0,0 +1,156 @@
+package types
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/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"
+)
+
+type AddressRole string
+
+const (
+	RoleSender   AddressRole = "Sender"
+	RoleReceiver AddressRole = "Receiver"
+)
+
+func trimSlashPrefix(s string) string {
+	return strings.TrimPrefix(s, "/")
+}
+
+// ExtractBaseAddress extracts the base address from a parameterized address.
+// It removes all subpath and query components from addr.
+func ExtractBaseAddress(addr string) (string, error) {
+	parsed, err := url.Parse(addr)
+	if err != nil {
+		return "", err
+	}
+
+	// Specify the fields and values we expect.  Unspecified fields will only
+	// match if they are zero values in order to be robust against extensions to
+	// the url.URL struct.
+	//
+	// Remove leading slashes from the path fields so that only parsed relative
+	// paths match the expected test.
+	expected := url.URL{
+		Path:        trimSlashPrefix(parsed.Path),
+		RawPath:     trimSlashPrefix(parsed.RawPath),
+		RawQuery:    parsed.RawQuery,
+		Fragment:    parsed.Fragment,
+		RawFragment: parsed.RawFragment,
+
+		// Skip over parsing control flags.
+		ForceQuery: parsed.ForceQuery,
+		OmitHost:   parsed.OmitHost,
+	}
+
+	if *parsed != expected {
+		return "", fmt.Errorf("address must be relative path with optional query and fragment, got %s", addr)
+	}
+
+	baseAddr, _, _ := strings.Cut(expected.Path, "/")
+	if baseAddr == "" {
+		return "", fmt.Errorf("base address cannot be empty")
+	}
+
+	return baseAddr, nil
+}
+
+// extractBaseTransferData returns the base address from the transferData.Sender
+// (if RoleSender) or transferData.Receiver (if RoleReceiver). Errors in
+// determining the base address are ignored... we then assume the base address
+// is exactly the original address.  If newTransferData is not nil, it will be
+// populated with a new FungibleTokenPacketData consisting of the role replaced
+// with its base address.
+func extractBaseTransferData(transferData transfertypes.FungibleTokenPacketData, role AddressRole, newTransferData *transfertypes.FungibleTokenPacketData) (string, error) {
+	var target string
+	sender := transferData.Sender
+	receiver := transferData.Receiver
+
+	switch role {
+	case RoleSender:
+		baseSender, err := ExtractBaseAddress(sender)
+		if err == nil {
+			sender = baseSender
+		}
+		target = sender
+
+	case RoleReceiver:
+		baseReceiver, err := ExtractBaseAddress(receiver)
+		if err == nil {
+			receiver = baseReceiver
+		}
+		target = receiver
+
+	default:
+		err := fmt.Errorf("invalid address role: %s", role)
+		return target, err
+	}
+
+	if newTransferData == nil {
+		return target, nil
+	}
+
+	// Create the new transfer data.
+	*newTransferData = transfertypes.NewFungibleTokenPacketData(
+		transferData.Denom,
+		transferData.Amount,
+		sender, receiver,
+		transferData.Memo,
+	)
+
+	return target, nil
+}
+
+// ExtractBaseAddressFromPacket returns the base address from a transfer
+// packet's data, either Sender (if role is RoleSender) or Receiver (if role is
+// RoleReceiver).
+// Errors in determining the base address are ignored... we then assume the base
+// address is exactly the original address.
+// If newPacket is not nil, it is populated with a new transfer packet whose
+// corresponding Sender or Receiver is replaced with the extracted base address.
+func ExtractBaseAddressFromPacket(cdc codec.Codec, packet ibcexported.PacketI, role AddressRole, newPacket *channeltypes.Packet) (string, error) {
+	transferData := transfertypes.FungibleTokenPacketData{}
+	if err := cdc.UnmarshalJSON(packet.GetData(), &transferData); err != nil {
+		return "", err
+	}
+
+	var newTransferData *transfertypes.FungibleTokenPacketData
+	if newPacket != nil {
+		// Capture the transfer data for the new packet.
+		newTransferData = &transfertypes.FungibleTokenPacketData{}
+	}
+	target, err := extractBaseTransferData(transferData, role, newTransferData)
+	if err != nil {
+		return target, err
+	}
+
+	if newPacket == nil {
+		return target, nil
+	}
+
+	// Create a new packet with the new transfer packet data.
+	// Re-serialize the packet data with the base addresses.
+	newData, err := cdc.MarshalJSON(newTransferData)
+	if err != nil {
+		return target, err
+	}
+
+	// Create the new packet.
+	th := packet.GetTimeoutHeight()
+	*newPacket = channeltypes.NewPacket(
+		newData, packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		clienttypes.NewHeight(th.GetRevisionNumber(), th.GetRevisionHeight()),
+		packet.GetTimeoutTimestamp(),
+	)
+
+	return target, nil
+}