feat(uniond): added wasm bindings for diferredack

uniond/x/diferredack/bindings/message_plugin.go

@@ -0,0 +1,100 @@
+package bindings
+
+import (
+	"encoding/json"
+
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	wasmvmtypes "github.com/CosmWasm/wasmvm/v2/types"
+
+	errorsmod "cosmossdk.io/errors"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	bindingstypes "union/x/diferredack/bindings/types"
+	diferredackkeeper "union/x/diferredack/keeper"
+	diferredacktypes "union/x/diferredack/types"
+)
+
+// CustomMessageDecorator returns decorator for custom CosmWasm bindings messages
+func CustomMessageDecorator(bank *bankkeeper.BaseKeeper, diferredAck *diferredackkeeper.Keeper) func(wasmkeeper.Messenger) wasmkeeper.Messenger {
+	return func(old wasmkeeper.Messenger) wasmkeeper.Messenger {
+		return &CustomMessenger{
+			wrapped:     old,
+			bank:        bank,
+			diferredAck: diferredAck,
+		}
+	}
+}
+
+type CustomMessenger struct {
+	wrapped     wasmkeeper.Messenger
+	bank        *bankkeeper.BaseKeeper
+	diferredAck *diferredackkeeper.Keeper
+}
+
+var _ wasmkeeper.Messenger = (*CustomMessenger)(nil)
+
+// DispatchMsg executes on the contractMsg.
+func (m *CustomMessenger) DispatchMsg(ctx sdk.Context, contractAddr sdk.AccAddress, contractIBCPortID string, msg wasmvmtypes.CosmosMsg) ([]sdk.Event, [][]byte, [][]*codectypes.Any, error) {
+	if msg.Custom != nil {
+		// only handle the happy path where this is really creating / minting / swapping ...
+		// leave everything else for the wrapped version
+		var contractMsg bindingstypes.DiferredAckMsg
+		if err := json.Unmarshal(msg.Custom, &contractMsg); err != nil {
+			return nil, nil, nil, errorsmod.Wrap(err, "diferred ack msg")
+		}
+
+		if contractMsg.WriteDiferredAck != nil {
+			return m.WriteDiferredAck(ctx, contractAddr, contractMsg.WriteDiferredAck)
+		}
+	}
+	return m.wrapped.DispatchMsg(ctx, contractAddr, contractIBCPortID, msg)
+}
+
+// createDenom creates a new token denom
+func (m *CustomMessenger) WriteDiferredAck(ctx sdk.Context, contractAddr sdk.AccAddress, writeDiferredAck *bindingstypes.WriteDiferredAck) ([]sdk.Event, [][]byte, [][]*codectypes.Any, error) {
+	bz, err := PerformWriteDiferredAck(m.diferredAck, ctx, writeDiferredAck)
+
+	if err != nil {
+		return nil, nil, nil, errorsmod.Wrap(err, "failed to process response")
+	}
+
+	return nil, [][]byte{bz}, nil, nil
+}
+
+func PerformWriteDiferredAck(diferredAckKeeper *diferredackkeeper.Keeper, ctx sdk.Context, writeDiferredAck *bindingstypes.WriteDiferredAck) ([]byte, error) {
+	if writeDiferredAck == nil {
+		return nil, wasmvmtypes.InvalidRequest{Err: "write diferred ack request cannot be nil"}
+	}
+
+	msgServer := diferredackkeeper.NewMsgServerImpl(*diferredAckKeeper)
+
+	msgWriteDiferredAck := diferredacktypes.NewMsgWriteDiferredAck(writeDiferredAck.Packet, writeDiferredAck.Data, writeDiferredAck.DiferredPacketInfo, writeDiferredAck.Ack)
+
+	if err := msgWriteDiferredAck.Ack.ValidateBasic(); err != nil {
+		return nil, errorsmod.Wrap(err, "content of write msg diferred ack is invalid")
+	}
+
+	res, err := msgServer.WriteDiferredAck(ctx, msgWriteDiferredAck)
+
+	if err != nil {
+		return nil, errorsmod.Wrap(err, "failed to execute msg write diferred ack")
+	}
+
+	return res.Marshal()
+}
+
+// parseAddress parses address from bech32 string and verifies its format.
+func parseAddress(addr string) (sdk.AccAddress, error) {
+	parsed, err := sdk.AccAddressFromBech32(addr)
+	if err != nil {
+		return nil, errorsmod.Wrap(err, "address from bech32")
+	}
+	err = sdk.VerifyAddressFormat(parsed)
+	if err != nil {
+		return nil, errorsmod.Wrap(err, "verify address format")
+	}
+	return parsed, nil
+}

uniond/x/diferredack/bindings/queries.go

@@ -0,0 +1,31 @@
+package bindings
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	bindingstypes "union/x/diferredack/bindings/types"
+	diferredackkeeper "union/x/diferredack/keeper"
+)
+
+type QueryPlugin struct {
+	bankKeeper        *bankkeeper.BaseKeeper
+	diferredAckKeeper *diferredackkeeper.Keeper
+}
+
+// NewQueryPlugin returns a reference to a new QueryPlugin.
+func NewQueryPlugin(b *bankkeeper.BaseKeeper, tfk *diferredackkeeper.Keeper) *QueryPlugin {
+	return &QueryPlugin{
+		bankKeeper:        b,
+		diferredAckKeeper: tfk,
+	}
+}
+
+func (qp QueryPlugin) GetParams(ctx sdk.Context) (*bindingstypes.ParamsResponse, error) {
+	params := qp.diferredAckKeeper.GetParams(ctx)
+	return &bindingstypes.ParamsResponse{
+		Params: bindingstypes.Params{
+			FeePercentage: params.FeePercentage,
+		},
+	}, nil
+}

uniond/x/diferredack/bindings/query_plugin.go

@@ -0,0 +1,42 @@
+package bindings
+
+import (
+	"encoding/json"
+	"fmt"
+
+	wasmvmtypes "github.com/CosmWasm/wasmvm/types"
+
+	errorsmod "cosmossdk.io/errors"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	bindingstypes "union/x/diferredack/bindings/types"
+)
+
+// CustomQuerier dispatches custom CosmWasm bindings queries.
+func CustomQuerier(qp *QueryPlugin) func(ctx sdk.Context, request json.RawMessage) ([]byte, error) {
+	return func(ctx sdk.Context, request json.RawMessage) ([]byte, error) {
+		var contractQuery bindingstypes.DiferredAckQuery
+		if err := json.Unmarshal(request, &contractQuery); err != nil {
+			return nil, errorsmod.Wrap(err, "diferredack query")
+		}
+
+		switch {
+		case contractQuery.Params != nil:
+			res, err := qp.GetParams(ctx)
+			if err != nil {
+				return nil, err
+			}
+
+			bz, err := json.Marshal(res)
+			if err != nil {
+				return nil, fmt.Errorf("failed to JSON marshal ParamsResponse: %w", err)
+			}
+
+			return bz, nil
+
+		default:
+			return nil, wasmvmtypes.UnsupportedRequest{Kind: "unknown token query variant"}
+		}
+	}
+}

uniond/x/diferredack/bindings/types/msg.go

@@ -0,0 +1,27 @@
+package types
+
+import (
+	transfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+
+	"union/x/diferredack/types"
+)
+
+type DiferredAckMsg struct {
+	/// Write an acknowledgement for a given packet
+	WriteDiferredAck *WriteDiferredAck `json:"write_diferred_ack,omitempty"`
+}
+
+// CreateDenom creates a new factory denom, of denomination:
+// factory/{creating contract address}/{Subdenom}
+// Subdenom can be of length at most 44 characters, in [0-9a-zA-Z./]
+// The (creating contract address, subdenom) pair must be unique.
+// The created denom's admin is the creating contract address,
+// but this admin can be changed using the ChangeAdmin binding.
+type WriteDiferredAck struct {
+	Subdenom           string `json:"subdenom"`
+	Packet             channeltypes.Packet
+	Data               transfertypes.FungibleTokenPacketData
+	DiferredPacketInfo types.DiferredPacketInfo `json:"diferred_packet_info"`
+	Ack                channeltypes.Acknowledgement
+}

uniond/x/diferredack/bindings/types/query.go

@@ -0,0 +1,18 @@
+package types
+
+// See https://github.com/CosmWasm/token-bindings/blob/main/packages/bindings/src/query.rs
+type DiferredAckQuery struct {
+	/// Given a subdenom minted by a contract via `TokenFactoryMsg::MintTokens`,
+	/// returns the full denom as used by `BankMsg::Send`.
+	Params *GetParams `json:"params,omitempty"`
+}
+
+// query types
+
+type GetParams struct{}
+
+// responses
+
+type ParamsResponse struct {
+	Params Params `json:"params"`
+}

uniond/x/diferredack/bindings/types/types.go

@@ -0,0 +1,9 @@
+package types
+
+import (
+	cosmossdk_io_math "cosmossdk.io/math"
+)
+
+type Params struct {
+	FeePercentage cosmossdk_io_math.LegacyDec `json:"denom_creation_fee"`
+}

uniond/x/diferredack/bindings/wasm.go

@@ -0,0 +1,28 @@
+package bindings
+
+import (
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	diferredackkeeper "union/x/diferredack/keeper"
+)
+
+func RegisterCustomPlugins(
+	bank *bankkeeper.BaseKeeper,
+	diferredAck *diferredackkeeper.Keeper,
+) []wasmkeeper.Option {
+	wasmQueryPlugin := NewQueryPlugin(bank, diferredAck)
+
+	queryPluginOpt := wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{
+		Custom: CustomQuerier(wasmQueryPlugin),
+	})
+	messengerDecoratorOpt := wasmkeeper.WithMessageHandlerDecorator(
+		CustomMessageDecorator(bank, diferredAck),
+	)
+
+	return []wasmkeeper.Option{
+		queryPluginOpt,
+		messengerDecoratorOpt,
+	}
+}