@agoric/cosmos 0.35.0-u18.4 → 0.35.0-u18a.0

package/x/vtransfer/keeper/keeper.go

@@ -1,8 +1,10 @@
 package keeper
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store/prefix"
@@ -13,10 +15,12 @@ import (
 	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/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"
+
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/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"
@@ -24,6 +28,7 @@ import (
 )
 
 var _ porttypes.ICS4Wrapper = (*Keeper)(nil)
+var _ porttypes.ICS4Wrapper = (*ics4Wrapper)(nil)
 var _ vibctypes.ReceiverImpl = (*Keeper)(nil)
 var _ vm.PortHandler = (*Keeper)(nil)
 
@@ -32,6 +37,7 @@ var _ vm.PortHandler = (*Keeper)(nil)
 // the address, and its corresponding value is a non-empty but otherwise irrelevant
 // sentinel.
 const (
+	packetDataStoreKeyPrefix     = "originalData/"
 	watchedAddressStoreKeyPrefix = "watchedAddress/"
 	watchedAddressSentinel       = "y"
 )
@@ -52,6 +58,84 @@ type Keeper struct {
 	cdc codec.Codec
 
 	vibcModule porttypes.IBCModule
+
+	// This is a pointer so that copies of the Keeper struct share the same mutable debug options.
+	debug *KeeperDebugOptions
+}
+
+type PacketDataOverrider func(ctx sdk.Context, cdc codec.Codec, data []byte) ([]byte, error)
+type KeeperDebugOptions struct {
+	OverridePacket PacketDataOverrider
+	DoNotStore     bool
+}
+
+type ics4Wrapper struct {
+	porttypes.ICS4Wrapper
+	k Keeper
+}
+
+func (i4 *ics4Wrapper) SendPacket(
+	ctx sdk.Context,
+	chanCap *capabilitytypes.Capability,
+	sourcePort string,
+	sourceChannel string,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+) (sequence uint64, err error) {
+	// Permute the packet data when testing.
+	overridePacket := i4.k.debug.OverridePacket
+	if overridePacket != nil {
+		if data, err = overridePacket(ctx, i4.k.cdc, data); err != nil {
+			return sequence, err
+		}
+	}
+
+	var strippedData []byte
+	_, err = types.ExtractBaseAddressFromData(i4.k.cdc, data, types.RoleSender, &strippedData)
+	if err != nil {
+		return sequence, err
+	}
+
+	// Send the stripped data to the next wrapper.
+	sequence, err = i4.ICS4Wrapper.SendPacket(ctx, chanCap, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, strippedData)
+	if err != nil {
+		return sequence, err
+	}
+
+	// Store the original data if it is hooked for later retrieval by middleware.
+	if !i4.k.debug.DoNotStore && !bytes.Equal(strippedData, data) {
+		packetStore, packetKey := i4.k.PacketStore(ctx, types.PacketSrc, sourcePort, sourceChannel, sequence)
+		packetStore.Set(packetKey, data)
+	}
+
+	return sequence, nil
+}
+
+func (i4 *ics4Wrapper) WriteAcknowledgement(
+	ctx sdk.Context,
+	chanCap *capabilitytypes.Capability,
+	packet ibcexported.PacketI,
+	ack ibcexported.Acknowledgement,
+) error {
+	origPacket := channeltypes.NewPacket(
+		packet.GetData(), packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		clienttypes.MustParseHeight(packet.GetTimeoutHeight().String()),
+		packet.GetTimeoutTimestamp(),
+	)
+	packetStore, packetKey := i4.k.PacketStoreFromOrigin(ctx, types.PacketDst, packet)
+	if packetStore.Has(packetKey) {
+		origPacket.Data = packetStore.Get(packetKey)
+		packetStore.Delete(packetKey)
+	}
+	return i4.ICS4Wrapper.WriteAcknowledgement(ctx, chanCap, origPacket, ack)
+}
+
+// NewICS4Wrapper creates a new ICS4Wrapper instance
+func NewICS4Wrapper(k Keeper, down porttypes.ICS4Wrapper) *ics4Wrapper {
+	return &ics4Wrapper{k: k, ICS4Wrapper: down}
 }
 
 // NewKeeper creates a new vtransfer Keeper instance
@@ -67,15 +151,26 @@ func NewKeeper(
 	// This vibcKeeper is used to send notifications from the vtransfer middleware
 	// to the VM.
 	vibcKeeper := prototypeVibcKeeper.WithScope(nil, scopedTransferKeeper, wrappedPushAction)
-	return Keeper{
-		ICS4Wrapper:  vibcKeeper,
+	k := Keeper{
 		ReceiverImpl: vibcKeeper,
 
 		vibcKeeper: vibcKeeper,
 		key:        key,
 		vibcModule: vibc.NewIBCModule(vibcKeeper),
 		cdc:        cdc,
+
+		debug: &KeeperDebugOptions{
+			OverridePacket: nil,
+			DoNotStore:     false,
+		},
 	}
+	k.ICS4Wrapper = NewICS4Wrapper(k, vibcKeeper)
+	return k
+}
+
+func (k Keeper) SetDebugging(doStore bool, overridePacket PacketDataOverrider) {
+	k.debug.DoNotStore = !doStore
+	k.debug.OverridePacket = overridePacket
 }
 
 // wrapActionPusher wraps an ActionPusher to prefix the action type with
@@ -101,17 +196,54 @@ func (k Keeper) GetReceiverImpl() vibctypes.ReceiverImpl {
 	return k
 }
 
+// Replicated from the 24-host ibc-go package, since it wasn't exported from there.
+func channelPath(portID, channelID string) string {
+	return fmt.Sprintf("%s/%s/%s/%s", host.KeyPortPrefix, portID, host.KeyChannelPrefix, channelID)
+}
+
+// Replicated from the 24-host ibc-go package, since it wasn't exported from there.
+func sequencePath(sequence uint64) string {
+	return fmt.Sprintf("%s/%d", host.KeySequencePrefix, sequence)
+}
+
+// PacketStore returns a new KVStore for storing packet data, and a key for
+// that store.  The KVStore is divided into src or dst PacketOrigins because we
+// need to record separate data for packets travelling in each direction.
+func (k Keeper) PacketStore(ctx sdk.Context, ourOrigin types.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
+}
+
+func (k Keeper) PacketStoreFromOrigin(ctx sdk.Context, ourOrigin types.PacketOrigin, packet ibcexported.PacketI) (storetypes.KVStore, []byte) {
+	var ourPort, ourChannel string
+
+	switch ourOrigin {
+	case types.PacketSrc:
+		ourPort = packet.GetSourcePort()
+		ourChannel = packet.GetSourceChannel()
+	case types.PacketDst:
+		ourPort = packet.GetDestPort()
+		ourChannel = packet.GetDestChannel()
+	default:
+		panic("unknown packet origin " + ourOrigin)
+	}
+
+	return k.PacketStore(ctx, ourOrigin, ourPort, ourChannel, packet.GetSequence())
+}
+
 // 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
+	// 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)
 	}
+
 	portID := packet.GetDestPort()
 	channelID := packet.GetDestChannel()
 	capName := host.ChannelCapabilityPath(portID, channelID)
@@ -120,11 +252,21 @@ func (k Keeper) InterceptOnRecvPacket(ctx sdk.Context, ibcModule porttypes.IBCMo
 		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)
+
+	if !k.debug.DoNotStore && !bytes.Equal(strippedPacket.GetData(), packet.GetData()) {
+		packetStore, packetKey := k.PacketStore(ctx, types.PacketDst, portID, channelID, packet.GetSequence())
+		packetStore.Set(packetKey, packet.GetData())
 	}
-	return nil
+
+	ack := ibcModule.OnRecvPacket(ctx, strippedPacket, relayer)
+	if ack == nil {
+		// Already declared to be an async ack.  Will be cleaned up by ics4Wrapper.WriteAcknowledgement.
+		return nil
+	}
+
+	// Give the VM a chance to write (or override) the ack.
+	syncAck, _ := k.InterceptWriteAcknowledgement(ctx, chanCap, packet, ack)
+	return syncAck
 }
 
 // InterceptOnAcknowledgementPacket checks to see if the packet sender is a
@@ -136,17 +278,27 @@ func (k Keeper) InterceptOnAcknowledgementPacket(
 	acknowledgement []byte,
 	relayer sdk.AccAddress,
 ) error {
-	// Pass every acknowledgement to the wrapped IBC module.
+	baseSender, err := types.ExtractBaseAddressFromData(k.cdc, packet.GetData(), types.RoleSender, nil)
+	if err != nil {
+		return err
+	}
+
+	origPacket := packet
+	packetStore, packetKey := k.PacketStoreFromOrigin(ctx, types.PacketSrc, packet)
+	if packetStore.Has(packetKey) {
+		origPacket.Data = packetStore.Get(packetKey)
+		packetStore.Delete(packetKey)
+	}
+
 	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 == "" {
+	// If the sender is not a watched account, we're done.
+	if !k.targetIsWatched(ctx, baseSender) {
 		return modErr
 	}
 
-	// Trigger VM, regardless of errors in the ibcModule.
-	vmErr := k.vibcKeeper.TriggerOnAcknowledgementPacket(ctx, sender, packet, acknowledgement, relayer)
+	// Trigger VM with the original packet, regardless of errors in the ibcModule.
+	vmErr := k.vibcKeeper.TriggerOnAcknowledgementPacket(ctx, baseSender, origPacket, acknowledgement, relayer)
 
 	// Any error from the VM is trumped by one from the wrapped IBC module.
 	if modErr != nil {
@@ -163,17 +315,28 @@ func (k Keeper) InterceptOnTimeoutPacket(
 	packet channeltypes.Packet,
 	relayer sdk.AccAddress,
 ) error {
-	// Pass every timeout to the wrapped IBC module.
+	baseSender, err := types.ExtractBaseAddressFromData(k.cdc, packet.GetData(), types.RoleSender, nil)
+	if err != nil {
+		return err
+	}
+
+	origPacket := packet
+	packetStore, packetKey := k.PacketStoreFromOrigin(ctx, types.PacketSrc, packet)
+	if packetStore.Has(packetKey) {
+		origPacket.Data = packetStore.Get(packetKey)
+		packetStore.Delete(packetKey)
+	}
+
+	// Pass every stripped-sender 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 == "" {
+	// If the sender is not a watched account, we're done.
+	if !k.targetIsWatched(ctx, baseSender) {
 		return modErr
 	}
 
-	// Trigger VM, regardless of errors in the app.
-	vmErr := k.vibcKeeper.TriggerOnTimeoutPacket(ctx, sender, packet, relayer)
+	// Trigger VM with the original packet, regardless of errors in the app.
+	vmErr := k.vibcKeeper.TriggerOnTimeoutPacket(ctx, baseSender, origPacket, relayer)
 
 	// Any error from the VM is trumped by one from the wrapped IBC module.
 	if modErr != nil {
@@ -184,43 +347,45 @@ func (k Keeper) InterceptOnTimeoutPacket(
 
 // 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)
+func (k Keeper) InterceptWriteAcknowledgement(ctx sdk.Context, chanCap *capabilitytypes.Capability, packet ibcexported.PacketI, ack ibcexported.Acknowledgement) (ibcexported.Acknowledgement, ibcexported.PacketI) {
+	// Get the base receiver from the packet, without computing a stripped packet.
+	baseReceiver, err := types.ExtractBaseAddressFromPacket(k.cdc, packet, types.RoleReceiver, nil)
+
+	origPacket := channeltypes.NewPacket(
+		packet.GetData(), packet.GetSequence(),
+		packet.GetSourcePort(), packet.GetSourceChannel(),
+		packet.GetDestPort(), packet.GetDestChannel(),
+		clienttypes.MustParseHeight(packet.GetTimeoutHeight().String()),
+		packet.GetTimeoutTimestamp(),
+	)
+	packetStore, packetKey := k.PacketStoreFromOrigin(ctx, types.PacketDst, packet)
+	if packetStore.Has(packetKey) {
+		origPacket.Data = packetStore.Get(packetKey)
+		packetStore.Delete(packetKey)
 	}
 
-	// Trigger VM
-	if err = k.vibcKeeper.TriggerWriteAcknowledgement(ctx, receiver, packet, ack); err != nil {
+	if err != nil || !k.targetIsWatched(ctx, baseReceiver) {
+		// We can't parse, or not watching, but that means just to ack directly.
+		return ack, origPacket
+	}
+
+	// Trigger VM with the original packet.
+	if err = k.vibcKeeper.TriggerWriteAcknowledgement(ctx, baseReceiver, origPacket, ack); err != nil {
 		errAck := channeltypes.NewErrorAcknowledgement(err)
-		return k.WriteAcknowledgement(ctx, chanCap, packet, errAck)
+		return errAck, origPacket
 	}
 
-	return nil
+	// The VM has taken over the ack, so we return nil to indicate that the ack is async.
+	return nil, origPacket
 }
 
-// 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
+// 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),
 	)
-	if prefixStore.Has([]byte(transferData.Sender)) {
-		sender = transferData.Sender
-	}
-	if prefixStore.Has([]byte(transferData.Receiver)) {
-		receiver = transferData.Receiver
-	}
-	return sender, receiver, nil
+	return prefixStore.Has([]byte(target))
 }
 
 // GetWatchedAdresses returns the watched addresses from the keeper as a slice

package/x/vtransfer/types/genesis.pb.go

@@ -26,6 +26,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 // The initial and exported module state.
 type GenesisState struct {
+	// The list of account addresses that are being watched by the VM.
 	WatchedAddresses []github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,rep,name=watched_addresses,json=watchedAddresses,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"watched_addresses" yaml:"watched_addresses"`
 }
 

package/x/vtransfer/utils_test.go

@@ -0,0 +1,111 @@
+package vtransfer_test
+
+import (
+	"fmt"
+	"strconv"
+
+	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"
+	host "github.com/cosmos/ibc-go/v6/modules/core/24-host"
+	ibctesting "github.com/cosmos/ibc-go/v6/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) {
+	// get proof of acknowledgement on counterparty
+	packetKey := host.PacketAcknowledgementKey(packet.GetDestPort(), packet.GetDestChannel(), packet.GetSequence())
+	proof, proofHeight := endpoint.Counterparty.QueryProof(packetKey)
+
+	ackMsg := channeltypes.NewMsgAcknowledgement(packet, ack, proof, proofHeight, endpoint.Chain.SenderAccount.GetAddress().String())
+
+	return endpoint.Chain.SendMsgs(ackMsg)
+}
+
+// ParseAckFromEvents parses events emitted from a MsgRecvPacket and returns the
+// acknowledgement.
+// [AGORIC] Signature taken from ibctesting.ParseAckFromEvents
+func ParseAckFromEvents(events sdk.Events) ([]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) {
+	for _, ev := range events {
+		if ev.Type == filteredType {
+			for _, attr := range ev.Attributes {
+				if string(attr.Key) == channeltypes.AttributeKeyAck { //nolint:staticcheck // DEPRECATED
+					return attr.Value, nil
+				}
+			}
+		}
+	}
+	return nil, fmt.Errorf("acknowledgement event attribute not found")
+}
+
+// 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) {
+	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) {
+	for _, ev := range events {
+		if ev.Type == filteredType {
+			packet := channeltypes.Packet{}
+			for _, attr := range ev.Attributes {
+				switch string(attr.Key) {
+				case channeltypes.AttributeKeyData: //nolint:staticcheck // DEPRECATED
+					packet.Data = attr.Value
+
+				case channeltypes.AttributeKeySequence:
+					seq, err := strconv.ParseUint(string(attr.Value), 10, 64)
+					if err != nil {
+						return channeltypes.Packet{}, err
+					}
+
+					packet.Sequence = seq
+
+				case channeltypes.AttributeKeySrcPort:
+					packet.SourcePort = string(attr.Value)
+
+				case channeltypes.AttributeKeySrcChannel:
+					packet.SourceChannel = string(attr.Value)
+
+				case channeltypes.AttributeKeyDstPort:
+					packet.DestinationPort = string(attr.Value)
+
+				case channeltypes.AttributeKeyDstChannel:
+					packet.DestinationChannel = string(attr.Value)
+
+				case channeltypes.AttributeKeyTimeoutHeight:
+					height, err := clienttypes.ParseHeight(string(attr.Value))
+					if err != nil {
+						return channeltypes.Packet{}, err
+					}
+
+					packet.TimeoutHeight = height
+
+				case channeltypes.AttributeKeyTimeoutTimestamp:
+					timestamp, err := strconv.ParseUint(string(attr.Value), 10, 64)
+					if err != nil {
+						return channeltypes.Packet{}, err
+					}
+
+					packet.TimeoutTimestamp = timestamp
+
+				default:
+					continue
+				}
+			}
+
+			return packet, nil
+		}
+	}
+	return channeltypes.Packet{}, fmt.Errorf("filtered event type %s not found", filteredType)
+}