Alex ibc spike2

app/app.go

@@ -161,6 +161,7 @@ type WasmApp struct {
 	// make scoped keepers public for test purposes
 	ScopedIBCKeeper      capabilitykeeper.ScopedKeeper
 	ScopedTransferKeeper capabilitykeeper.ScopedKeeper
+	ScopedWasmKeeper     capabilitykeeper.ScopedKeeper
 
 	// the module manager
 	mm *module.Manager
@@ -414,6 +415,7 @@ func NewWasmApp(
 
 	app.ScopedIBCKeeper = scopedIBCKeeper
 	app.ScopedTransferKeeper = scopedTransferKeeper
+	app.ScopedWasmKeeper = scopedWasmKeeper
 
 	return app
 }

x/wasm/alias.go

@@ -88,34 +88,32 @@ var (
 )
 
 type (
-	GenesisState                         = types.GenesisState
-	Code                                 = types.Code
-	Contract                             = types.Contract
-	MsgStoreCode                         = types.MsgStoreCode
-	MsgInstantiateContract               = types.MsgInstantiateContract
-	MsgExecuteContract                   = types.MsgExecuteContract
-	MsgMigrateContract                   = types.MsgMigrateContract
-	MsgUpdateAdmin                       = types.MsgUpdateAdmin
-	MsgClearAdmin                        = types.MsgClearAdmin
-	MsgWasmIBCCall                       = types.MsgWasmIBCCall
-	Model                                = types.Model
-	CodeInfo                             = types.CodeInfo
-	ContractInfo                         = types.ContractInfo
-	CreatedAt                            = types.AbsoluteTxPosition
-	WasmConfig                           = types.WasmConfig
-	WasmIBCContractPacketAcknowledgement = types.WasmIBCContractPacketAcknowledgement
-	WasmIBCContractPacketData            = types.WasmIBCContractPacketData
-	MessageHandler                       = keeper.MessageHandler
-	BankEncoder                          = keeper.BankEncoder
-	CustomEncoder                        = keeper.CustomEncoder
-	StakingEncoder                       = keeper.StakingEncoder
-	WasmEncoder                          = keeper.WasmEncoder
-	MessageEncoders                      = keeper.MessageEncoders
-	Keeper                               = keeper.Keeper
-	ContractInfoWithAddress              = keeper.ContractInfoWithAddress
-	GetCodeResponse                      = keeper.GetCodeResponse
-	ListCodeResponse                     = keeper.ListCodeResponse
-	QueryHandler                         = keeper.QueryHandler
-	CustomQuerier                        = keeper.CustomQuerier
-	QueryPlugins                         = keeper.QueryPlugins
+	GenesisState            = types.GenesisState
+	Code                    = types.Code
+	Contract                = types.Contract
+	MsgStoreCode            = types.MsgStoreCode
+	MsgInstantiateContract  = types.MsgInstantiateContract
+	MsgExecuteContract      = types.MsgExecuteContract
+	MsgMigrateContract      = types.MsgMigrateContract
+	MsgUpdateAdmin          = types.MsgUpdateAdmin
+	MsgClearAdmin           = types.MsgClearAdmin
+	MsgWasmIBCCall          = types.MsgWasmIBCCall
+	Model                   = types.Model
+	CodeInfo                = types.CodeInfo
+	ContractInfo            = types.ContractInfo
+	CreatedAt               = types.AbsoluteTxPosition
+	WasmConfig              = types.WasmConfig
+	MessageHandler          = keeper.MessageHandler
+	BankEncoder             = keeper.BankEncoder
+	CustomEncoder           = keeper.CustomEncoder
+	StakingEncoder          = keeper.StakingEncoder
+	WasmEncoder             = keeper.WasmEncoder
+	MessageEncoders         = keeper.MessageEncoders
+	Keeper                  = keeper.Keeper
+	ContractInfoWithAddress = keeper.ContractInfoWithAddress
+	GetCodeResponse         = keeper.GetCodeResponse
+	ListCodeResponse        = keeper.ListCodeResponse
+	QueryHandler            = keeper.QueryHandler
+	CustomQuerier           = keeper.CustomQuerier
+	QueryPlugins            = keeper.QueryPlugins
 )

x/wasm/handler.go

@@ -180,10 +180,7 @@ func handleClearContractAdmin(ctx sdk.Context, k Keeper, msg *MsgClearAdmin) (*s
 }
 
 func handleIBCCall(ctx sdk.Context, k Keeper, msg *MsgWasmIBCCall) (*sdk.Result, error) {
-	if err := k.IBCCallContract(ctx, msg.SourcePort, msg.SourceChannel,
-		msg.Sender, msg.DestContractAddr, msg.TimeoutHeight,
-		msg.TimeoutTimestamp, msg.Msg,
-	); err != nil {
+	if err := k.IBCCallFromContract(ctx, msg.SourcePort, msg.SourceChannel, msg.Sender, msg.TimeoutHeight, msg.TimeoutTimestamp, msg.Msg); err != nil {
 		return nil, err
 	}
 

x/wasm/ibc.go

@@ -1,10 +1,13 @@
 package wasm
 
 import (
+	"github.com/CosmWasm/wasmd/x/wasm/internal/keeper/cosmwasm"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
-	"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
+	"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
+	channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
+	host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
 )
 
 type IBCHandler struct {
@@ -15,54 +18,102 @@ func NewIBCHandler(keeper Keeper) IBCHandler {
 	return IBCHandler{keeper: keeper}
 }
 
-func (i IBCHandler) OnChanOpenInit(ctx sdk.Context, order types.Order, connectionHops []string, portID string, channelID string, channelCap *capabilitytypes.Capability, counterParty types.Counterparty, version string) error {
+func (i IBCHandler) OnChanOpenInit(ctx sdk.Context, order channeltypes.Order, connectionHops []string, portID string, channelID string, channelCap *capabilitytypes.Capability, counterParty channeltypes.Counterparty, version string) error {
 	// ensure port, version, capability
-	panic("implement me")
+
+	contractAddr, err := ContractFromPortID(portID)
+	if err != nil {
+		return sdkerrors.Wrapf(err, "contract port id")
+	}
+
+	_, err = i.keeper.AcceptChannel(ctx, contractAddr, order, version, connectionHops, cosmwasm.IBCInfo{
+		PortID:    portID,
+		ChannelID: channelID,
+	})
+	if err != nil {
+		return err
+	}
+	// Claim channel capability passed back by IBC module
+	if err := i.keeper.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
+		return sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, err.Error())
+	}
+	return nil
 }
 
-func (i IBCHandler) OnChanOpenTry(ctx sdk.Context, order types.Order, connectionHops []string, portID, channelID string, channelCap *capabilitytypes.Capability, counterparty types.Counterparty, version, counterpartyVersion string) error {
+func (i IBCHandler) OnChanOpenTry(ctx sdk.Context, order channeltypes.Order, connectionHops []string, portID, channelID string, channelCap *capabilitytypes.Capability, counterParty channeltypes.Counterparty, version, counterpartyVersion string) error {
 	// ensure port, version, capability
-	// do we require an ORDERED channel?
-	panic("implement me")
+	contractAddr, err := ContractFromPortID(portID)
+	if err != nil {
+		return sdkerrors.Wrapf(err, "contract port id")
+	}
+
+	restrictCounterpartyVersions, err := i.keeper.AcceptChannel(ctx, contractAddr, order, version, connectionHops, cosmwasm.IBCInfo{
+		PortID:    portID,
+		ChannelID: channelID,
+	})
+	if err != nil {
+		return err
+	}
+	if len(restrictCounterpartyVersions) != 0 {
+		var found bool
+		for _, accept := range restrictCounterpartyVersions {
+			if accept == counterpartyVersion {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return sdkerrors.Wrapf(types.ErrInvalidCounterparty, "not in supported versions: %q", restrictCounterpartyVersions)
+		}
+	}
+
+	// Claim channel capability passed back by IBC module
+	if err := i.keeper.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
+		return sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, err.Error())
+	}
+	return nil
 }
 
 func (i IBCHandler) OnChanOpenAck(ctx sdk.Context, portID, channelID string, counterpartyVersion string) error {
-	// ensure port, version, capability
-	panic("implement me")
+	// anything to do? We are not opening channels from wasm contracts
+	return nil
 }
 
 func (i IBCHandler) OnChanOpenConfirm(ctx sdk.Context, portID, channelID string) error {
-	// anything to do?
-	panic("implement me")
+	//contractAddr, err := ContractFromPortID(portID)
+	//if err != nil {
+	//	return sdkerrors.Wrapf(err, "contract port id")
+	//}
+	//return i.keeper.OnChannelOpen(ctx, contractAddr, cosmwasm.IBCInfo{PortID: portID, ChannelID: channelID})
+	// any events to send?
+	panic("not implemented")
 }
 
 func (i IBCHandler) OnChanCloseInit(ctx sdk.Context, portID, channelID string) error {
-	// we better not close a channel
-	panic("implement me")
+	// we can let contracts close channels so we can play back this to the contract
+	panic("not implemented")
 }
 
 func (i IBCHandler) OnChanCloseConfirm(ctx sdk.Context, portID, channelID string) error {
-	// anything to do
-	panic("implement me")
-}
+	// counterparty has closed the channel
 
-func (i IBCHandler) OnRecvPacket(ctx sdk.Context, packet types.Packet) (*sdk.Result, []byte, error) {
-	// start calling keeper
-	var data WasmIBCContractPacketData
-	if err := ModuleCdc.UnmarshalJSON(packet.GetData(), &data); err != nil {
-		return nil, nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "cannot unmarshal ICS-20 transfer packet data: %s", err.Error())
-	}
-	acknowledgement := WasmIBCContractPacketAcknowledgement{Success: true}
+	//contractAddr, err := ContractFromPortID(portID)
+	//if err != nil {
+	//	return sdkerrors.Wrapf(err, "contract port id")
+	//}
+	//return i.keeper.OnChannelClose(ctx, contractAddr, cosmwasm.IBCInfo{PortID: portID, ChannelID: channelID})
+	// any events to send?
+	panic("not implemented")
+}
 
+func (i IBCHandler) OnRecvPacket(ctx sdk.Context, packet channeltypes.Packet) (*sdk.Result, []byte, error) {
 	contractAddr, err := ContractFromPortID(packet.DestinationPort)
 	if err != nil {
 		return nil, nil, sdkerrors.Wrapf(err, "contract port id")
 	}
-	if err := i.keeper.OnRecvPacket(ctx, contractAddr, data); err != nil {
-		acknowledgement = WasmIBCContractPacketAcknowledgement{
-			Success: false,
-			Error:   err.Error(),
-		}
+	msgBz, err := i.keeper.OnRecvPacket(ctx, contractAddr, packet.Data, ibcInfoFromPacket(packet))
+	if err != nil {
+		return nil, nil, err
 	}
 
 	// todo: send proper events
@@ -77,13 +128,74 @@ func (i IBCHandler) OnRecvPacket(ctx sdk.Context, packet types.Packet) (*sdk.Res
 
 	return &sdk.Result{
 		Events: ctx.EventManager().Events().ToABCIEvents(),
-	}, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(acknowledgement)), nil
+	}, msgBz, nil
 }
 
-func (i IBCHandler) OnAcknowledgementPacket(ctx sdk.Context, packet types.Packet, acknowledgement []byte) (*sdk.Result, error) {
-	panic("implement me")
+func (i IBCHandler) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Packet, acknowledgement []byte) (*sdk.Result, error) {
+	contractAddr, err := ContractFromPortID(packet.DestinationPort)
+	if err != nil {
+		return nil, sdkerrors.Wrapf(err, "contract port id")
+	}
+
+	err = i.keeper.OnAckPacket(ctx, contractAddr, packet.Data, acknowledgement, ibcInfoFromPacket(packet))
+	if err != nil {
+		return nil, err
+	}
+
+	//ctx.EventManager().EmitEvent(
+	//	sdk.NewEvent(
+	//		types.EventTypePacket,
+	//		sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
+	//		sdk.NewAttribute(types.AttributeKeyReceiver, data.Receiver),
+	//		sdk.NewAttribute(types.AttributeKeyValue, data.Amount.String()),
+	//		sdk.NewAttribute(types.AttributeKeyAckSuccess, fmt.Sprintf("%t", ack.Success)),
+	//	),
+	//)
+
+	//if !ack.Success {
+	//	ctx.EventManager().EmitEvent(
+	//		sdk.NewEvent(
+	//			types.EventTypePacket,
+	//			sdk.NewAttribute(types.AttributeKeyAckError, ack.Error),
+	//		),
+	//	)
+	//}
+
+	return &sdk.Result{
+		Events: ctx.EventManager().Events().ToABCIEvents(),
+	}, nil
+
+}
+
+func (i IBCHandler) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) (*sdk.Result, error) {
+	contractAddr, err := ContractFromPortID(packet.DestinationPort)
+	if err != nil {
+		return nil, sdkerrors.Wrapf(err, "contract port id")
+	}
+	err = i.keeper.OnTimeoutPacket(ctx, contractAddr, packet.Data, ibcInfoFromPacket(packet))
+	if err != nil {
+		return nil, err
+	}
+
+	//ctx.EventManager().EmitEvent(
+	//	sdk.NewEvent(
+	//		types.EventTypeTimeout,
+	//		sdk.NewAttribute(types.AttributeKeyRefundReceiver, data.Sender),
+	//		sdk.NewAttribute(types.AttributeKeyRefundValue, data.Amount.String()),
+	//		sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
+	//	),
+	//)
+
+	return &sdk.Result{
+		Events: ctx.EventManager().Events().ToABCIEvents(),
+	}, nil
+
 }
 
-func (i IBCHandler) OnTimeoutPacket(ctx sdk.Context, packet types.Packet) (*sdk.Result, error) {
-	panic("implement me")
+func ibcInfoFromPacket(packet channeltypes.Packet) cosmwasm.IBCInfo {
+	return cosmwasm.IBCInfo{
+		PortID:    packet.DestinationPort,
+		ChannelID: packet.DestinationChannel,
+		Packet:    cosmwasm.NewIBCPacketInfo(packet.Sequence, packet.SourcePort, packet.SourceChannel, packet.TimeoutHeight, packet.TimeoutTimestamp),
+	}
 }

x/wasm/internal/keeper/cosmwasm/README.md

@@ -0,0 +1 @@
+types that belong to go-cosmwasm. copied here temporary for faster dev feedback.

x/wasm/internal/keeper/cosmwasm/contract.go

@@ -0,0 +1,35 @@
+package cosmwasm
+
+import (
+	"encoding/json"
+
+	wasmTypes "github.com/CosmWasm/go-cosmwasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type OnReceiveIBCResponse struct {
+	Messages []sdk.Msg `json:"messages"`
+
+	Acknowledgement json.RawMessage
+	// log message to return over abci interface
+	Log []wasmTypes.LogAttribute `json:"log"`
+}
+
+type OnAcknowledgeIBCResponse struct {
+	Messages []sdk.Msg `json:"messages"`
+
+	// log message to return over abci interface
+	Log []wasmTypes.LogAttribute `json:"log"`
+}
+type OnTimeoutIBCResponse struct {
+	Messages []sdk.Msg `json:"messages"`
+
+	// log message to return over abci interface
+	Log []wasmTypes.LogAttribute `json:"log"`
+}
+
+type AcceptChannelResponse struct {
+	Result                       bool     `json:"result"`
+	Reason                       string   `json:"reason"`
+	RestrictCounterpartyVersions []string `json:"accepted_counterpary_versions"`
+}