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

package/x/vibc/handler.go

@@ -3,42 +3,49 @@ package vibc
 import (
 	"fmt"
 
+	sdkioerrors "cosmossdk.io/errors"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // NewHandler returns a handler for "vibc" type messages.
-func NewHandler(keeper Keeper) sdk.Handler {
+func NewHandler(keeper Keeper, bankKeeper types.BankKeeper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		switch msg := msg.(type) {
 		case *MsgSendPacket:
-			return handleMsgSendPacket(ctx, keeper, msg)
+			return handleMsgSendPacket(ctx, keeper, bankKeeper, msg)
 
 		default:
 			errMsg := fmt.Sprintf("Unrecognized vibc Msg type: %T", msg)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 		}
 	}
 }
 
 type sendPacketAction struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string `json:"event" default:"sendPacket"`
 	*MsgSendPacket
-	vm.ActionHeader `actionType:"IBC_EVENT"`
-	Event           string `json:"event" default:"sendPacket"`
 }
 
-func handleMsgSendPacket(ctx sdk.Context, keeper Keeper, msg *MsgSendPacket) (*sdk.Result, error) {
+func handleMsgSendPacket(
+	ctx sdk.Context,
+	keeper Keeper,
+	bankKeeper types.BankKeeper,
+	msg *MsgSendPacket,
+) (*sdk.Result, error) {
 	onePass := sdk.NewInt64Coin("sendpacketpass", 1)
-	balance := keeper.GetBalance(ctx, msg.Sender, onePass.Denom)
+	balance := bankKeeper.GetBalance(ctx, msg.Sender, onePass.Denom)
 	if balance.IsLT(onePass) {
-		return nil, sdkerrors.Wrap(
+		return nil, sdkioerrors.Wrap(
 			sdkerrors.ErrInsufficientFee,
 			fmt.Sprintf("sender %s needs at least %s", msg.Sender, onePass.String()),
 		)
 	}
 
-	action := &sendPacketAction{
+	action := sendPacketAction{
 		MsgSendPacket: msg,
 	}
 	// fmt.Fprintf(os.Stderr, "Context is %+v\n", ctx)

package/x/vibc/keeper/keeper.go

@@ -7,8 +7,7 @@ import (
 	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"
+	sdkioerrors "cosmossdk.io/errors"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/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"
@@ -16,47 +15,66 @@ import (
 	host "github.com/cosmos/ibc-go/v6/modules/core/24-host"
 	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
 
-	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
-
-	vm "github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
 )
 
+var (
+	_ porttypes.ICS4Wrapper = Keeper{}
+	_ types.IBCModuleImpl   = Keeper{}
+	_ types.ReceiverImpl    = Keeper{}
+)
+
 // Keeper maintains the link to data storage and exposes getter/setter methods for the various parts of the state machine
 type Keeper struct {
-	storeKey storetypes.StoreKey
-	cdc      codec.Codec
+	cdc codec.Codec
 
 	channelKeeper types.ChannelKeeper
 	portKeeper    types.PortKeeper
-	scopedKeeper  capabilitykeeper.ScopedKeeper
-	bankKeeper    bankkeeper.Keeper
 
-	PushAction vm.ActionPusher
+	// Filled out by `WithScope`
+	scopedKeeper types.ScopedKeeper
+	storeKey     storetypes.StoreKey
+	pushAction   vm.ActionPusher
 }
 
-// NewKeeper creates a new dIBC Keeper instance
+// NewKeeper creates a new vibc Keeper instance
 func NewKeeper(
-	cdc codec.Codec, key storetypes.StoreKey,
-	channelKeeper types.ChannelKeeper, portKeeper types.PortKeeper,
-	bankKeeper bankkeeper.Keeper,
-	scopedKeeper capabilitykeeper.ScopedKeeper,
-	pushAction vm.ActionPusher,
+	cdc codec.Codec,
+	channelKeeper types.ChannelKeeper,
+	portKeeper types.PortKeeper,
 ) Keeper {
 
 	return Keeper{
-		storeKey:      key,
 		cdc:           cdc,
-		bankKeeper:    bankKeeper,
 		channelKeeper: channelKeeper,
 		portKeeper:    portKeeper,
-		scopedKeeper:  scopedKeeper,
-		PushAction:    pushAction,
 	}
 }
 
-func (k Keeper) GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin {
-	return k.bankKeeper.GetBalance(ctx, addr, denom)
+// WithScope returns a new Keeper copied from the receiver, but with the given
+// store key, scoped keeper, and push action.
+func (k Keeper) WithScope(storeKey storetypes.StoreKey, scopedKeeper types.ScopedKeeper, pushAction vm.ActionPusher) Keeper {
+	k.storeKey = storeKey
+	k.scopedKeeper = scopedKeeper
+	k.pushAction = pushAction
+	return k
+}
+
+// PushAction sends a vm.Action to the VM controller.
+func (k Keeper) PushAction(ctx sdk.Context, action vm.Action) error {
+	return k.pushAction(ctx, action)
+}
+
+// GetICS4Wrapper returns the ICS4Wrapper interface for the keeper.
+func (k Keeper) GetICS4Wrapper() porttypes.ICS4Wrapper {
+	return k
+}
+
+// GetAppVersion defines a wrapper function for the channel Keeper's function
+// in order to expose it to the vibc IBC handler.
+func (k Keeper) GetAppVersion(ctx sdk.Context, portID, channelID string) (string, bool) {
+	return k.channelKeeper.GetAppVersion(ctx, portID, channelID)
 }
 
 // GetChannel defines a wrapper function for the channel Keeper's function
@@ -65,15 +83,14 @@ func (k Keeper) GetChannel(ctx sdk.Context, portID, channelID string) (channelty
 	return k.channelKeeper.GetChannel(ctx, portID, channelID)
 }
 
-// ChanOpenInit defines a wrapper function for the channel Keeper's function
-// in order to expose it to the vibc IBC handler.
-func (k Keeper) ChanOpenInit(ctx sdk.Context, order channeltypes.Order, connectionHops []string,
+// ReceiveChanOpenInit wraps the keeper's ChanOpenInit function.
+func (k Keeper) ReceiveChanOpenInit(ctx sdk.Context, order channeltypes.Order, connectionHops []string,
 	portID, rPortID, version string,
 ) error {
 	capName := host.PortPath(portID)
 	portCap, ok := k.GetCapability(ctx, capName)
 	if !ok {
-		return sdkerrors.Wrapf(porttypes.ErrInvalidPort, "could not retrieve port capability at: %s", capName)
+		return sdkioerrors.Wrapf(porttypes.ErrInvalidPort, "could not retrieve port capability at: %s", capName)
 	}
 	counterparty := channeltypes.Counterparty{
 		PortId: rPortID,
@@ -92,61 +109,79 @@ func (k Keeper) ChanOpenInit(ctx sdk.Context, order channeltypes.Order, connecti
 	return nil
 }
 
+// ReceiveSendPacket wraps the keeper's SendPacket function.
+func (k Keeper) ReceiveSendPacket(ctx sdk.Context, packet ibcexported.PacketI) (uint64, error) {
+	sourcePort := packet.GetSourcePort()
+	sourceChannel := packet.GetSourceChannel()
+	timeoutHeight := packet.GetTimeoutHeight()
+	timeoutRevisionNumber := timeoutHeight.GetRevisionNumber()
+	timeoutRevisionHeight := timeoutHeight.GetRevisionHeight()
+	clientTimeoutHeight := clienttypes.NewHeight(timeoutRevisionNumber, timeoutRevisionHeight)
+	timeoutTimestamp := packet.GetTimeoutTimestamp()
+	data := packet.GetData()
+
+	capName := host.ChannelCapabilityPath(sourcePort, sourceChannel)
+	chanCap, ok := k.GetCapability(ctx, capName)
+	if !ok {
+		return 0, sdkioerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
+	}
+	return k.SendPacket(ctx, chanCap, sourcePort, sourceChannel, clientTimeoutHeight, timeoutTimestamp, data)
+}
+
 // SendPacket defines a wrapper function for the channel Keeper's function
 // in order to expose it to the vibc IBC handler.
 func (k Keeper) SendPacket(
 	ctx sdk.Context,
+	chanCap *capability.Capability,
 	sourcePort string,
 	sourceChannel string,
 	timeoutHeight clienttypes.Height,
 	timeoutTimestamp uint64,
 	data []byte,
 ) (uint64, error) {
-	capName := host.ChannelCapabilityPath(sourcePort, sourceChannel)
-	chanCap, ok := k.GetCapability(ctx, capName)
-	if !ok {
-		return 0, sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
-	}
 	return k.channelKeeper.SendPacket(ctx, chanCap, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, data)
 }
 
-var _ ibcexported.Acknowledgement = (*rawAcknowledgement)(nil)
-
-type rawAcknowledgement struct {
-	data []byte
-}
-
-func (r rawAcknowledgement) Acknowledgement() []byte {
-	return r.data
-}
-
-func (r rawAcknowledgement) Success() bool {
-	return true
-}
-
-// WriteAcknowledgement defines a wrapper function for the channel Keeper's function
-// in order to expose it to the vibc IBC handler.
-func (k Keeper) WriteAcknowledgement(ctx sdk.Context, packet ibcexported.PacketI, acknowledgement []byte) error {
+// ReceiveWriteAcknowledgement wraps the keeper's WriteAcknowledgment function.
+func (k Keeper) ReceiveWriteAcknowledgement(ctx sdk.Context, packet ibcexported.PacketI, ack ibcexported.Acknowledgement) error {
 	portID := packet.GetDestPort()
 	channelID := packet.GetDestChannel()
 	capName := host.ChannelCapabilityPath(portID, channelID)
 	chanCap, ok := k.GetCapability(ctx, capName)
 	if !ok {
-		return sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
-	}
-	ack := rawAcknowledgement{
-		data: acknowledgement,
+		return sdkioerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
 	}
+	return k.WriteAcknowledgement(ctx, chanCap, packet, ack)
+}
+
+// WriteAcknowledgement defines a wrapper function for the channel Keeper's function
+// in order to expose it to the vibc IBC handler.
+func (k Keeper) WriteAcknowledgement(ctx sdk.Context, chanCap *capability.Capability, packet ibcexported.PacketI, ack ibcexported.Acknowledgement) error {
 	return k.channelKeeper.WriteAcknowledgement(ctx, chanCap, packet, ack)
 }
 
-// ChanCloseInit defines a wrapper function for the channel Keeper's function
+// ReceiveWriteOpenTryChannel wraps the keeper's WriteOpenTryChannel function.
+func (k Keeper) ReceiveWriteOpenTryChannel(ctx sdk.Context, packet ibcexported.PacketI, order channeltypes.Order, connectionHops []string, version string) error {
+	portID := packet.GetDestPort()
+	channelID := packet.GetDestChannel()
+	counterparty := channeltypes.NewCounterparty(packet.GetSourcePort(), packet.GetSourceChannel())
+	k.WriteOpenTryChannel(ctx, portID, channelID, order, connectionHops, counterparty, version)
+	return nil
+}
+
+// WriteOpenTryChannel is a wrapper function for the channel Keeper's function
+func (k Keeper) WriteOpenTryChannel(ctx sdk.Context, portID, channelID string, order channeltypes.Order,
+	connectionHops []string, counterparty channeltypes.Counterparty, version string) {
+	k.channelKeeper.WriteOpenTryChannel(ctx, portID, channelID, order, connectionHops, counterparty, version)
+}
+
+// ReceiveChanCloseInit is a wrapper function for the channel Keeper's function
 // in order to expose it to the vibc IBC handler.
-func (k Keeper) ChanCloseInit(ctx sdk.Context, portID, channelID string) error {
+func (k Keeper) ReceiveChanCloseInit(ctx sdk.Context, portID, channelID string) error {
 	capName := host.ChannelCapabilityPath(portID, channelID)
 	chanCap, ok := k.GetCapability(ctx, capName)
 	if !ok {
-		return sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
+		return sdkioerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
 	}
 	err := k.channelKeeper.ChanCloseInit(ctx, portID, channelID, chanCap)
 	if err != nil {
@@ -155,36 +190,38 @@ func (k Keeper) ChanCloseInit(ctx sdk.Context, portID, channelID string) error {
 	return nil
 }
 
-// BindPort defines a wrapper function for the port Keeper's function in
-// order to expose it to the vibc IBC handler.
-func (k Keeper) BindPort(ctx sdk.Context, portID string) error {
-	_, ok := k.scopedKeeper.GetCapability(ctx, host.PortPath(portID))
+// ReceiveBindPort is a wrapper function for the port Keeper's function in order
+// to expose it to the vibc IBC handler.
+func (k Keeper) ReceiveBindPort(ctx sdk.Context, portID string) error {
+	portPath := host.PortPath(portID)
+	_, ok := k.GetCapability(ctx, portPath)
 	if ok {
 		return fmt.Errorf("port %s is already bound", portID)
 	}
 	cap := k.portKeeper.BindPort(ctx, portID)
-	return k.ClaimCapability(ctx, cap, host.PortPath(portID))
+	return k.ClaimCapability(ctx, cap, portPath)
 }
 
-// TimeoutExecuted defines a wrapper function for the channel Keeper's function
-// in order to expose it to the vibc IBC handler.
-func (k Keeper) TimeoutExecuted(ctx sdk.Context, packet ibcexported.PacketI) error {
+// ReceiveTimeoutExecuted is a wrapper function for the channel Keeper's
+// function in order to expose it to the vibc IBC handler.
+func (k Keeper) ReceiveTimeoutExecuted(ctx sdk.Context, packet ibcexported.PacketI) error {
 	portID := packet.GetSourcePort()
 	channelID := packet.GetSourceChannel()
 	capName := host.ChannelCapabilityPath(portID, channelID)
 	chanCap, ok := k.GetCapability(ctx, capName)
 	if !ok {
-		return sdkerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
+		return sdkioerrors.Wrapf(channeltypes.ErrChannelCapabilityNotFound, "could not retrieve channel capability at: %s", capName)
 	}
 	return k.channelKeeper.TimeoutExecuted(ctx, chanCap, packet)
 }
 
 // ClaimCapability allows the vibc module to claim a capability that IBC module
-// passes to it
+// passes to it.
 func (k Keeper) ClaimCapability(ctx sdk.Context, cap *capability.Capability, name string) error {
 	return k.scopedKeeper.ClaimCapability(ctx, cap, name)
 }
 
+// GetCapability allows the vibc module to retrieve a capability.
 func (k Keeper) GetCapability(ctx sdk.Context, name string) (*capability.Capability, bool) {
 	return k.scopedKeeper.GetCapability(ctx, name)
 }

package/x/vibc/keeper/triggers.go

@@ -0,0 +1,101 @@
+package keeper
+
+import (
+	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"
+	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vibc/types"
+)
+
+func reifyPacket(packet ibcexported.PacketI) channeltypes.Packet {
+	height := packet.GetTimeoutHeight()
+	ctHeight := clienttypes.Height{
+		RevisionHeight: height.GetRevisionHeight(),
+		RevisionNumber: height.GetRevisionNumber(),
+	}
+	return channeltypes.Packet{
+		Sequence:           packet.GetSequence(),
+		SourcePort:         packet.GetSourcePort(),
+		SourceChannel:      packet.GetSourceChannel(),
+		DestinationPort:    packet.GetDestPort(),
+		DestinationChannel: packet.GetDestChannel(),
+		Data:               packet.GetData(),
+		TimeoutHeight:      ctHeight,
+		TimeoutTimestamp:   packet.GetTimeoutTimestamp(),
+	}
+}
+
+type WriteAcknowledgementEvent struct {
+	*vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event            string              `json:"event" default:"writeAcknowledgement"`
+	Target           string              `json:"target"`
+	Packet           channeltypes.Packet `json:"packet"`
+	Acknowledgement  []byte              `json:"acknowledgement"`
+	Relayer          sdk.AccAddress      `json:"relayer"`
+}
+
+func (k Keeper) TriggerWriteAcknowledgement(
+	ctx sdk.Context,
+	target string,
+	packet ibcexported.PacketI,
+	acknowledgement ibcexported.Acknowledgement,
+) error {
+	event := WriteAcknowledgementEvent{
+		Target:          target,
+		Packet:          reifyPacket(packet),
+		Acknowledgement: acknowledgement.Acknowledgement(),
+	}
+
+	err := k.PushAction(ctx, event)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k Keeper) TriggerOnAcknowledgementPacket(
+	ctx sdk.Context,
+	target string,
+	packet ibcexported.PacketI,
+	acknowledgement []byte,
+	relayer sdk.AccAddress,
+) error {
+	event := types.AcknowledgementPacketEvent{
+		Target:          target,
+		Packet:          reifyPacket(packet),
+		Acknowledgement: acknowledgement,
+		Relayer:         relayer,
+	}
+
+	err := k.PushAction(ctx, event)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k Keeper) TriggerOnTimeoutPacket(
+	ctx sdk.Context,
+	target string,
+	packet ibcexported.PacketI,
+	relayer sdk.AccAddress,
+) error {
+	event := types.TimeoutPacketEvent{
+		Target:  target,
+		Packet:  reifyPacket(packet),
+		Relayer: relayer,
+	}
+
+	err := k.PushAction(ctx, event)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

package/x/vibc/module.go

@@ -3,7 +3,6 @@ package vibc
 import (
 	"encoding/json"
 
-	"github.com/gorilla/mux"
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/spf13/cobra"
 
@@ -51,10 +50,6 @@ func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncod
 	return nil
 }
 
-// Register rest routes
-func (AppModuleBasic) RegisterRESTRoutes(ctx client.Context, rtr *mux.Router) {
-}
-
 func (AppModuleBasic) RegisterGRPCGatewayRoutes(_ client.Context, _ *runtime.ServeMux) {
 }
 
@@ -70,14 +65,16 @@ func (AppModuleBasic) GetQueryCmd() *cobra.Command {
 
 type AppModule struct {
 	AppModuleBasic
-	keeper Keeper
+	keeper     Keeper
+	bankKeeper types.BankKeeper
 }
 
 // NewAppModule creates a new AppModule Object
-func NewAppModule(k Keeper) AppModule {
+func NewAppModule(k Keeper, bankKeeper types.BankKeeper) AppModule {
 	am := AppModule{
 		AppModuleBasic: AppModuleBasic{},
 		keeper:         k,
+		bankKeeper:     bankKeeper,
 	}
 	return am
 }
@@ -104,7 +101,7 @@ func (AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {
 
 // Route implements the AppModule interface
 func (am AppModule) Route() sdk.Route {
-	return sdk.NewRoute(RouterKey, NewHandler(am.keeper))
+	return sdk.NewRoute(RouterKey, NewHandler(am.keeper, am.bankKeeper))
 }
 
 // QuerierRoute implements the AppModule interface

package/x/vibc/types/expected_keepers.go

@@ -9,8 +9,13 @@ import (
 	ibcexported "github.com/cosmos/ibc-go/v6/modules/core/exported"
 )
 
+type BankKeeper interface {
+	GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin
+}
+
 // ChannelKeeper defines the expected IBC channel keeper
 type ChannelKeeper interface {
+	GetAppVersion(ctx sdk.Context, portID, channelID string) (string, bool)
 	GetChannel(ctx sdk.Context, srcPort, srcChan string) (channel channel.Channel, found bool)
 	SendPacket(
 		ctx sdk.Context,
@@ -26,6 +31,8 @@ type ChannelKeeper interface {
 		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)
+	WriteOpenTryChannel(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
 }
@@ -44,3 +51,9 @@ type ConnectionKeeper interface {
 type PortKeeper interface {
 	BindPort(ctx sdk.Context, portID string) *capability.Capability
 }
+
+// ScopedKeeper defines the expected scoped capability keeper
+type ScopedKeeper interface {
+	ClaimCapability(ctx sdk.Context, cap *capability.Capability, name string) error
+	GetCapability(ctx sdk.Context, name string) (*capability.Capability, bool)
+}