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

package/x/vibc/types/ibc_module.go

@@ -0,0 +1,336 @@
+package types
+
+import (
+	sdkioerrors "cosmossdk.io/errors"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	capability "github.com/cosmos/cosmos-sdk/x/capability/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"
+
+	"github.com/cosmos/ibc-go/v6/modules/core/exported"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+	// AsyncVersions is a flag that indicates whether the IBC module supports
+	// asynchronous versions.  If it does, then the VM must supply an empty
+	// version string to indicate that the VM explicitly (possibly async)
+	// performs the Write* method.
+	// This flag is created in anticipation of ibc-go implementing async versions,
+	// see https://github.com/Agoric/agoric-sdk/issues/9358 for more details.
+	AsyncVersions = false
+)
+
+var (
+	_ porttypes.IBCModule = (*IBCModule)(nil)
+)
+
+type IBCModuleImpl interface {
+	ClaimCapability(ctx sdk.Context, channelCap *capability.Capability, path string) error
+	GetChannel(ctx sdk.Context, portID, channelID string) (channeltypes.Channel, bool)
+	PushAction(ctx sdk.Context, action vm.Action) error
+}
+
+type IBCModule struct {
+	impl IBCModuleImpl
+}
+
+func NewIBCModule(impl IBCModuleImpl) IBCModule {
+	return IBCModule{
+		impl: impl,
+	}
+}
+
+type ChannelOpenInitEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string                    `json:"event" default:"channelOpenInit"`
+	Target           string                    `json:"target,omitempty"`
+	Order            string                    `json:"order"`
+	ConnectionHops   []string                  `json:"connectionHops"`
+	PortID           string                    `json:"portID"`
+	ChannelID        string                    `json:"channelID"`
+	Counterparty     channeltypes.Counterparty `json:"counterparty"`
+	Version          string                    `json:"version"`
+	AsyncVersions    bool                      `json:"asyncVersions"`
+}
+
+// Implement IBCModule callbacks
+func (im IBCModule) OnChanOpenInit(
+	ctx sdk.Context,
+	order channeltypes.Order,
+	connectionHops []string,
+	portID string,
+	channelID string,
+	channelCap *capability.Capability,
+	counterparty channeltypes.Counterparty,
+	version string,
+) (string, error) {
+	event := ChannelOpenInitEvent{
+		Order:          orderToString(order),
+		ConnectionHops: connectionHops,
+		PortID:         portID,
+		ChannelID:      channelID,
+		Counterparty:   counterparty,
+		Version:        version,
+		AsyncVersions:  AsyncVersions,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	if err != nil {
+		return "", err
+	}
+
+	// Claim channel capability passed back by IBC module
+	if err := im.impl.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
+		return "", err
+	}
+
+	if !event.AsyncVersions {
+		// We have to supply a synchronous version, so just echo back the one they sent.
+		return event.Version, nil
+	}
+
+	return "", nil
+}
+
+type ChannelOpenTryEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string                    `json:"event" default:"channelOpenTry"`
+	Target           string                    `json:"target,omitempty"`
+	Order            string                    `json:"order"`
+	ConnectionHops   []string                  `json:"connectionHops"`
+	PortID           string                    `json:"portID"`
+	ChannelID        string                    `json:"channelID"`
+	Counterparty     channeltypes.Counterparty `json:"counterparty"`
+	Version          string                    `json:"version"`
+	AsyncVersions    bool                      `json:"asyncVersions"`
+}
+
+func (im IBCModule) OnChanOpenTry(
+	ctx sdk.Context,
+	order channeltypes.Order,
+	connectionHops []string,
+	portID,
+	channelID string,
+	channelCap *capability.Capability,
+	counterparty channeltypes.Counterparty,
+	counterpartyVersion string,
+) (string, error) {
+	event := ChannelOpenTryEvent{
+		Order:          orderToString(order),
+		ConnectionHops: connectionHops,
+		PortID:         portID,
+		ChannelID:      channelID,
+		Counterparty:   counterparty,
+		Version:        counterpartyVersion,
+		AsyncVersions:  AsyncVersions,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	if err != nil {
+		return "", err
+	}
+
+	// Claim channel capability passed back by IBC module
+	if err = im.impl.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
+		return "", sdkioerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, err.Error())
+	}
+
+	if !event.AsyncVersions {
+		// We have to supply a synchronous version, so just echo back the one they sent.
+		return event.Version, nil
+	}
+
+	// Use an empty version string to indicate that the VM explicitly (possibly
+	// async) performs the WriteOpenTryChannel.
+	return "", nil
+}
+
+type ChannelOpenAckEvent struct {
+	*vm.ActionHeader    `actionType:"IBC_EVENT"`
+	Event               string                    `json:"event" default:"channelOpenAck"`
+	PortID              string                    `json:"portID"`
+	ChannelID           string                    `json:"channelID"`
+	CounterpartyVersion string                    `json:"counterpartyVersion"`
+	Counterparty        channeltypes.Counterparty `json:"counterparty"`
+	ConnectionHops      []string                  `json:"connectionHops"`
+}
+
+func (im IBCModule) OnChanOpenAck(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+	counterpartyChannelID string,
+	counterpartyVersion string,
+) error {
+	// We don't care if the channel was found.  If it wasn't then GetChannel
+	// returns an empty channel object that we can still use without crashing.
+	channel, _ := im.impl.GetChannel(ctx, portID, channelID)
+
+	channel.Counterparty.ChannelId = counterpartyChannelID
+	event := ChannelOpenAckEvent{
+		PortID:              portID,
+		ChannelID:           channelID,
+		CounterpartyVersion: counterpartyVersion,
+		Counterparty:        channel.Counterparty,
+		ConnectionHops:      channel.ConnectionHops,
+	}
+
+	return im.impl.PushAction(ctx, event)
+}
+
+type ChannelOpenConfirmEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string `json:"event" default:"channelOpenConfirm"`
+	Target           string `json:"target,omitempty"`
+	PortID           string `json:"portID"`
+	ChannelID        string `json:"channelID"`
+}
+
+func (im IBCModule) OnChanOpenConfirm(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	event := ChannelOpenConfirmEvent{
+		PortID:    portID,
+		ChannelID: channelID,
+	}
+
+	return im.impl.PushAction(ctx, event)
+}
+
+type ChannelCloseInitEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string `json:"event" default:"channelCloseInit"`
+	Target           string `json:"target,omitempty"`
+	PortID           string `json:"portID"`
+	ChannelID        string `json:"channelID"`
+}
+
+func (im IBCModule) OnChanCloseInit(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	event := ChannelCloseInitEvent{
+		PortID:    portID,
+		ChannelID: channelID,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	return err
+}
+
+type ChannelCloseConfirmEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string `json:"event" default:"channelCloseConfirm"`
+	Target           string `json:"target,omitempty"`
+	PortID           string `json:"portID"`
+	ChannelID        string `json:"channelID"`
+}
+
+func (im IBCModule) OnChanCloseConfirm(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	event := ChannelCloseConfirmEvent{
+		PortID:    portID,
+		ChannelID: channelID,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	return err
+}
+
+type ReceivePacketEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string              `json:"event" default:"receivePacket"`
+	Target           string              `json:"target,omitempty"`
+	Packet           channeltypes.Packet `json:"packet"`
+	Relayer          sdk.AccAddress      `json:"relayer"`
+}
+
+func (im IBCModule) OnRecvPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	relayer sdk.AccAddress,
+) exported.Acknowledgement {
+	// Sometimes we receive duplicate packets, just with a
+	// missing packet.TimeoutTimestamp.  This causes duplicate
+	// acks, with one of them being rejected.
+	//
+	// This turns out to happen when you run both "rly start"
+	// and also "rly tx xfer"-- they both are trying to relay
+	// the same packets.
+
+	event := ReceivePacketEvent{
+		Packet:  packet,
+		Relayer: relayer,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	if err != nil {
+		return channeltypes.NewErrorAcknowledgement(err)
+	}
+
+	return nil
+}
+
+type AcknowledgementPacketEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string              `json:"event" default:"acknowledgementPacket"`
+	Target           string              `json:"target,omitempty"`
+	Packet           channeltypes.Packet `json:"packet"`
+	Acknowledgement  []byte              `json:"acknowledgement"`
+	Relayer          sdk.AccAddress      `json:"relayer"`
+}
+
+func (im IBCModule) OnAcknowledgementPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	acknowledgement []byte,
+	relayer sdk.AccAddress,
+) error {
+	event := AcknowledgementPacketEvent{
+		Packet:          packet,
+		Acknowledgement: acknowledgement,
+		Relayer:         relayer,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type TimeoutPacketEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string              `json:"event" default:"timeoutPacket"`
+	Target           string              `json:"target,omitempty"`
+	Packet           channeltypes.Packet `json:"packet"`
+	Relayer          sdk.AccAddress      `json:"relayer"`
+}
+
+func (im IBCModule) OnTimeoutPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	relayer sdk.AccAddress,
+) error {
+	event := TimeoutPacketEvent{
+		Packet:  packet,
+		Relayer: relayer,
+	}
+
+	err := im.impl.PushAction(ctx, event)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

package/x/vibc/types/receiver.go

@@ -0,0 +1,170 @@
+package types
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+
+	"github.com/cosmos/ibc-go/v6/modules/core/exported"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	_ vm.PortHandler           = (*Receiver)(nil)
+	_ exported.Acknowledgement = (*rawAcknowledgement)(nil)
+)
+
+type ReceiverImpl interface {
+	ReceiveSendPacket(ctx sdk.Context, packet exported.PacketI) (uint64, error)
+	ReceiveWriteAcknowledgement(ctx sdk.Context, packet exported.PacketI, ack exported.Acknowledgement) error
+	ReceiveChanOpenInit(ctx sdk.Context, order channeltypes.Order, hops []string, sourcePort, destinationPort, version string) error
+	ReceiveWriteOpenTryChannel(ctx sdk.Context, packet exported.PacketI, order channeltypes.Order, connectionHops []string, version string) error
+	ReceiveChanCloseInit(ctx sdk.Context, sourcePort, sourceChannel string) error
+	ReceiveBindPort(ctx sdk.Context, sourcePort string) error
+	ReceiveTimeoutExecuted(ctx sdk.Context, packet exported.PacketI) error
+}
+
+type Receiver struct {
+	impl ReceiverImpl
+}
+
+func NewReceiver(impl ReceiverImpl) Receiver {
+	return Receiver{
+		impl: impl,
+	}
+}
+
+type portMessage struct { // comes from swingset's IBC handler
+	Type              string              `json:"type"` // IBC_METHOD
+	Method            string              `json:"method"`
+	Packet            channeltypes.Packet `json:"packet"`
+	RelativeTimeoutNs uint64              `json:"relativeTimeoutNs,string"`
+	Order             string              `json:"order"`
+	Hops              []string            `json:"hops"`
+	Version           string              `json:"version"`
+	Ack               []byte              `json:"ack"`
+}
+
+func stringToOrder(order string) channeltypes.Order {
+	switch order {
+	case "ORDERED":
+		return channeltypes.ORDERED
+	case "UNORDERED":
+		return channeltypes.UNORDERED
+	default:
+		return channeltypes.NONE
+	}
+}
+
+func orderToString(order channeltypes.Order) string {
+	switch order {
+	case channeltypes.ORDERED:
+		return "ORDERED"
+	case channeltypes.UNORDERED:
+		return "UNORDERED"
+	default:
+		return "NONE"
+	}
+}
+
+type rawAcknowledgement struct {
+	data []byte
+}
+
+func (r rawAcknowledgement) Acknowledgement() []byte {
+	return r.data
+}
+
+func (r rawAcknowledgement) Success() bool {
+	return true
+}
+
+// Receive implements vm.PortHandler.  It unmarshals the string as JSON text
+// representing an IBC portMessage object.  If the resulting type is
+// "IBC_METHOD" it dispatches on method ("sendPacket"/"receiveExecuted"/etc.)
+// and calls the corresponding method of the wrapped ReceiverImpl.
+//
+// Otherwise, it requires the wrapped ReceiverImpl to be a vm.PortHandler
+// and delegates to the Receive method of that PortHandler.
+func (ir Receiver) Receive(cctx context.Context, jsonRequest string) (jsonReply string, err error) {
+	ctx := sdk.UnwrapSDKContext(cctx)
+	impl := ir.impl
+
+	msg := new(portMessage)
+	err = json.Unmarshal([]byte(jsonRequest), &msg)
+	if err != nil {
+		return "", err
+	}
+
+	if msg.Type != "IBC_METHOD" {
+		if receiver, ok := impl.(vm.PortHandler); ok {
+			return receiver.Receive(cctx, jsonRequest)
+		}
+		return "", fmt.Errorf(`channel handler only accepts messages of "type": "IBC_METHOD"; got %q`, msg.Type)
+	}
+
+	switch msg.Method {
+	case "sendPacket":
+		timeoutTimestamp := msg.Packet.TimeoutTimestamp
+		if msg.Packet.TimeoutHeight.IsZero() && timeoutTimestamp == 0 {
+			// Use the relative timeout if no absolute timeout is specifiied.
+			timeoutTimestamp = uint64(ctx.BlockTime().UnixNano()) + msg.RelativeTimeoutNs
+		}
+
+		packet := channeltypes.NewPacket(
+			msg.Packet.Data, 0,
+			msg.Packet.SourcePort, msg.Packet.SourceChannel,
+			msg.Packet.DestinationPort, msg.Packet.DestinationChannel,
+			msg.Packet.TimeoutHeight, timeoutTimestamp,
+		)
+		seq, err := impl.ReceiveSendPacket(ctx, packet)
+		if err == nil {
+			packet.Sequence = seq
+			bytes, err := json.Marshal(&packet)
+			if err == nil {
+				jsonReply = string(bytes)
+			}
+		}
+
+	case "tryOpenExecuted":
+		err = impl.ReceiveWriteOpenTryChannel(
+			ctx, msg.Packet,
+			stringToOrder(msg.Order), msg.Hops, msg.Version,
+		)
+
+	case "receiveExecuted":
+		ack := rawAcknowledgement{
+			data: msg.Ack,
+		}
+		err = impl.ReceiveWriteAcknowledgement(ctx, msg.Packet, ack)
+
+	case "startChannelOpenInit":
+		err = impl.ReceiveChanOpenInit(
+			ctx, stringToOrder(msg.Order), msg.Hops,
+			msg.Packet.SourcePort,
+			msg.Packet.DestinationPort,
+			msg.Version,
+		)
+
+	case "startChannelCloseInit":
+		err = impl.ReceiveChanCloseInit(ctx, msg.Packet.SourcePort, msg.Packet.SourceChannel)
+
+	case "bindPort":
+		err = impl.ReceiveBindPort(ctx, msg.Packet.SourcePort)
+
+	case "timeoutExecuted":
+		err = impl.ReceiveTimeoutExecuted(ctx, msg.Packet)
+
+	default:
+		err = fmt.Errorf("unrecognized method %s", msg.Method)
+	}
+
+	if jsonReply == "" && err == nil {
+		jsonReply = "true"
+	}
+	return
+}

package/x/vlocalchain/alias.go

@@ -0,0 +1,19 @@
+package vlocalchain
+
+import (
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+)
+
+const (
+	ModuleName = types.ModuleName
+	StoreKey   = types.StoreKey
+)
+
+var (
+	NewKeeper = keeper.NewKeeper
+)
+
+type (
+	Keeper = keeper.Keeper
+)

package/x/vlocalchain/handler.go

@@ -0,0 +1,21 @@
+package vlocalchain
+
+import (
+	"fmt"
+
+	sdkioerrors "cosmossdk.io/errors"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// NewHandler returns a handler for "vlocalchain" type messages.
+func NewHandler(keeper keeper.Keeper) sdk.Handler {
+	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
+		switch msg := msg.(type) {
+		default:
+			errMsg := fmt.Sprintf("Unrecognized vlocalchain Msg type: %T", msg)
+			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+		}
+	}
+}