feat: add the custom handlers for cosmwasm

.gitignore

@@ -47,3 +47,4 @@ private*
 
 #IntelliJ
 .idea/
+.vscode

app/app.go

@@ -140,6 +140,7 @@ import (
 	ugovmodule "github.com/umee-network/umee/v4/x/ugov/module"
 
 	// umee ibc-transfer and quota for ibc-transfer
+	uwasm "github.com/umee-network/umee/v4/app/wasm"
 	"github.com/umee-network/umee/v4/x/uibc"
 	uibcmodule "github.com/umee-network/umee/v4/x/uibc/module"
 	uibcoracle "github.com/umee-network/umee/v4/x/uibc/oracle"
@@ -648,6 +649,10 @@ func New(
 	// The last arguments can contain custom message handlers, and custom query handlers,
 	// if we want to allow any custom callbacks
 	availableCapabilities := "iterator,staking,stargate,cosmwasm_1_1,umee"
+
+	// Register umee custom plugin to wasm
+	wasmOpts = append(uwasm.RegisterCustomPlugins(app.LeverageKeeper, app.OracleKeeper), wasmOpts...)
+
 	app.WasmKeeper = wasm.NewKeeper(
 		appCodec,
 		keys[wasm.StoreKey],

app/wasm/custom_plugins.go

@@ -0,0 +1,29 @@
+package wasm
+
+import (
+	"github.com/CosmWasm/wasmd/x/wasm"
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+
+	"github.com/umee-network/umee/v4/app/wasm/msg"
+	"github.com/umee-network/umee/v4/app/wasm/query"
+	leveragekeeper "github.com/umee-network/umee/v4/x/leverage/keeper"
+	oraclekeeper "github.com/umee-network/umee/v4/x/oracle/keeper"
+)
+
+// RegisterCustomPlugins expose the queries and msgs of native modules to wasm.
+func RegisterCustomPlugins(
+	leverageKeeper leveragekeeper.Keeper,
+	oracleKeeper oraclekeeper.Keeper,
+) []wasmkeeper.Option {
+	wasmQueryPlugin := query.NewQueryPlugin(leverageKeeper, oracleKeeper)
+	queryPluginOpt := wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{
+		Custom: wasmQueryPlugin.CustomQuerier(),
+	})
+
+	messagePluginOpt := wasmkeeper.WithMessageHandlerDecorator(msg.NewMessagePlugin(leverageKeeper))
+
+	return []wasm.Option{
+		queryPluginOpt,
+		messagePluginOpt,
+	}
+}

app/wasm/msg/handler_leverage.go

@@ -0,0 +1,106 @@
+package msg
+
+import (
+	"context"
+
+	"github.com/gogo/protobuf/proto"
+
+	lvtypes "github.com/umee-network/umee/v4/x/leverage/types"
+)
+
+// HandleSupply handles the Supply value of an address.
+func (m UmeeMsg) HandleSupply(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgSupply{Supplier: sender, Asset: m.Supply.Asset}
+	return s.Supply(ctx, req)
+}
+
+// HandleWithdraw handles the Withdraw value of an address.
+func (m UmeeMsg) HandleWithdraw(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgWithdraw{Supplier: sender, Asset: m.Withdraw.Asset}
+	return s.Withdraw(ctx, req)
+}
+
+// HandleMaxWithdraw handles the maximum withdraw value of an address.
+func (m UmeeMsg) HandleMaxWithdraw(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgMaxWithdraw{Supplier: sender, Denom: m.MaxWithdraw.Denom}
+	return s.MaxWithdraw(ctx, req)
+}
+
+// HandleCollateralize handles the enable selected uTokens as collateral.
+func (m UmeeMsg) HandleCollateralize(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgCollateralize{Borrower: sender, Asset: m.Collateralize.Asset}
+	return s.Collateralize(ctx, req)
+}
+
+// HandleDecollateralize handles the disable amount of an selected uTokens
+// as collateral.
+func (m UmeeMsg) HandleDecollateralize(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgDecollateralize{Borrower: sender, Asset: m.Decollateralize.Asset}
+	return s.Decollateralize(ctx, req)
+}
+
+// HandleBorrow handles the borrowing coins from the capital facility.
+func (m UmeeMsg) HandleBorrow(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgBorrow{Borrower: sender, Asset: m.Borrow.Asset}
+	return s.Borrow(ctx, req)
+}
+
+// HandleMaxBorrow handles the borrowing maximum coins from the capital facility.
+func (m UmeeMsg) HandleMaxBorrow(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgMaxBorrow{Borrower: sender, Denom: m.MaxBorrow.Denom}
+	return s.MaxBorrow(ctx, req)
+}
+
+// HandleRepay handles repaying borrowed coins to the capital facility.
+func (m UmeeMsg) HandleRepay(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgRepay{Borrower: sender, Asset: m.Repay.Asset}
+	return s.Repay(ctx, req)
+}
+
+// HandleLiquidate handles the repaying a different user's borrowed coins
+// to the capital facility in exchange for some of their collateral.
+func (m UmeeMsg) HandleLiquidate(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgLiquidate{
+		Liquidator:  sender,
+		Borrower:    m.Liquidate.Borrower,
+		Repayment:   m.Liquidate.Repayment,
+		RewardDenom: m.Liquidate.RewardDenom,
+	}
+	return s.Liquidate(ctx, req)
+}
+
+// HandleSupplyCollateral handles the supply the assets and collateral their assets.
+func (m UmeeMsg) HandleSupplyCollateral(
+	ctx context.Context, sender string,
+	s lvtypes.MsgServer,
+) (proto.Message, error) {
+	req := &lvtypes.MsgSupplyCollateral{Supplier: sender, Asset: m.SupplyCollateral.Asset}
+	return s.SupplyCollateral(ctx, req)
+}

app/wasm/msg/plugin.go

@@ -0,0 +1,82 @@
+package msg
+
+import (
+	"encoding/json"
+
+	sdkerrors "cosmossdk.io/errors"
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	wasmvmtypes "github.com/CosmWasm/wasmvm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	lvkeeper "github.com/umee-network/umee/v4/x/leverage/keeper"
+	lvtypes "github.com/umee-network/umee/v4/x/leverage/types"
+)
+
+// Plugin wraps the msg plugin with Messengers.
+type Plugin struct {
+	lvMsgServer lvtypes.MsgServer
+	wrapped     wasmkeeper.Messenger
+}
+
+var _ wasmkeeper.Messenger = (*Plugin)(nil)
+
+// CustomMessageDecorator returns decorator for custom CosmWasm bindings messages
+func NewMessagePlugin(leverageKeeper lvkeeper.Keeper) func(wasmkeeper.Messenger) wasmkeeper.Messenger {
+	return func(old wasmkeeper.Messenger) wasmkeeper.Messenger {
+		return &Plugin{
+			wrapped:     old,
+			lvMsgServer: lvkeeper.NewMsgServerImpl(leverageKeeper),
+		}
+	}
+}
+
+// DispatchCustomMsg responsible for handling custom messages (umee native messages).
+func (plugin *Plugin) DispatchCustomMsg(ctx sdk.Context, contractAddr sdk.AccAddress, rawMsg json.RawMessage) error {
+	var smartcontractMessage UmeeMsg
+	if err := json.Unmarshal(rawMsg, &smartcontractMessage); err != nil {
+		return sdkerrors.Wrap(err, "invalid umee custom msg")
+	}
+
+	sender := contractAddr.String()
+	var err error
+	sdkCtx := sdk.WrapSDKContext(ctx)
+	switch {
+	case smartcontractMessage.Supply != nil:
+		_, err = smartcontractMessage.HandleSupply(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Withdraw != nil:
+		_, err = smartcontractMessage.HandleWithdraw(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.MaxWithdraw != nil:
+		_, err = smartcontractMessage.HandleMaxWithdraw(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Collateralize != nil:
+		_, err = smartcontractMessage.HandleCollateralize(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Decollateralize != nil:
+		_, err = smartcontractMessage.HandleDecollateralize(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Borrow != nil:
+		_, err = smartcontractMessage.HandleBorrow(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.MaxBorrow != nil:
+		_, err = smartcontractMessage.HandleMaxBorrow(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Repay != nil:
+		_, err = smartcontractMessage.HandleRepay(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.Liquidate != nil:
+		_, err = smartcontractMessage.HandleLiquidate(sdkCtx, sender, plugin.lvMsgServer)
+	case smartcontractMessage.SupplyCollateral != nil:
+		_, err = smartcontractMessage.HandleSupplyCollateral(sdkCtx, sender, plugin.lvMsgServer)
+	default:
+		err = wasmvmtypes.UnsupportedRequest{Kind: "invalid assigned umee msg"}
+	}
+
+	return err
+}
+
+// DispatchMsg encodes the wasmVM message and dispatches it.
+func (plugin *Plugin) DispatchMsg(
+	ctx sdk.Context,
+	contractAddr sdk.AccAddress,
+	contractIBCPortID string,
+	msg wasmvmtypes.CosmosMsg,
+) (events []sdk.Event, data [][]byte, err error) {
+	if msg.Custom != nil {
+		return nil, nil, plugin.DispatchCustomMsg(ctx, contractAddr, msg.Custom)
+	}
+	return plugin.wrapped.DispatchMsg(ctx, contractAddr, contractIBCPortID, msg)
+}

app/wasm/msg/types.go

@@ -0,0 +1,30 @@
+package msg
+
+import (
+	lvtypes "github.com/umee-network/umee/v4/x/leverage/types"
+)
+
+// UmeeMsg wraps all the messages availables for cosmwasm smartcontracts.
+type UmeeMsg struct {
+	// Used to supply coins to the capital facility.
+	Supply *lvtypes.MsgSupply `json:"supply,omitempty"`
+	// Used to withdraw previously loaned coins from the capital facility.
+	Withdraw *lvtypes.MsgWithdraw `json:"withdraw,omitempty"`
+	// Used to do withdraw maximum assets by supplier.
+	MaxWithdraw *lvtypes.MsgMaxWithdraw `json:"max_withdraw,omitempty"`
+	// Used to enable an amount of selected uTokens as collateral.
+	Collateralize *lvtypes.MsgCollateralize `json:"collateralize,omitempty"`
+	// Used to disable amount of an selected uTokens as collateral.
+	Decollateralize *lvtypes.MsgDecollateralize `json:"decollateralize,omitempty"`
+	// Used to borrowing coins from the capital facility.
+	Borrow *lvtypes.MsgBorrow `json:"borrow,omitempty"`
+	// Used to borrowing coins from the capital facility.
+	MaxBorrow *lvtypes.MsgMaxBorrow `json:"max_borrow,omitempty"`
+	// Used to repaying borrowed coins to the capital facility.
+	Repay *lvtypes.MsgRepay `json:"repay,omitempty"`
+	// Used to repaying a different user's borrowed coins
+	// to the capital facility in exchange for some of their collateral.
+	Liquidate *lvtypes.MsgLiquidate `json:"liquidate,omitempty"`
+	// Used to do supply and collateralize their assets.
+	SupplyCollateral *lvtypes.MsgSupplyCollateral `json:"supply_collateral,omitempty"`
+}

app/wasm/query/handle_leverage.go

@@ -0,0 +1,91 @@
+package query
+
+import (
+	"context"
+
+	"github.com/gogo/protobuf/proto"
+
+	lvtypes "github.com/umee-network/umee/v4/x/leverage/types"
+)
+
+// HandleLeverageParams handles the get the x/leverage module's parameters.
+func (q UmeeQuery) HandleLeverageParams(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	return qs.Params(ctx, &lvtypes.QueryParams{})
+}
+
+// HandleRegisteredTokens handles the get all registered tokens query and response.
+func (q UmeeQuery) HandleRegisteredTokens(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	if len(q.RegisteredTokens.BaseDenom) != 0 {
+		return qs.RegisteredTokens(ctx, &lvtypes.QueryRegisteredTokens{
+			BaseDenom: q.RegisteredTokens.BaseDenom,
+		})
+	}
+	return qs.RegisteredTokens(ctx, &lvtypes.QueryRegisteredTokens{})
+}
+
+// HandleMarketSummary queries a base asset's current borrowing and supplying conditions.
+func (q UmeeQuery) HandleMarketSummary(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	return qs.MarketSummary(ctx, &lvtypes.QueryMarketSummary{Denom: q.MarketSummary.Denom})
+}
+
+// HandleAccountBalances queries an account's current supply, collateral, and borrow positions.
+func (q UmeeQuery) HandleAccountBalances(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	req := &lvtypes.QueryAccountBalances{Address: q.AccountBalances.Address}
+	return qs.AccountBalances(ctx, req)
+}
+
+// HandleAccountSummary queries USD values representing an account's total
+// positions and borrowing limits. It requires oracle prices to return successfully.
+func (q UmeeQuery) HandleAccountSummary(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	req := &lvtypes.QueryAccountSummary{Address: q.AccountSummary.Address}
+	return qs.AccountSummary(ctx, req)
+}
+
+// HandleLiquidationTargets queries a list of all borrower account addresses eligible for liquidation.
+func (q UmeeQuery) HandleLiquidationTargets(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	return qs.LiquidationTargets(ctx, &lvtypes.QueryLiquidationTargets{})
+}
+
+// HandleBadDebts queries bad debts.
+func (q UmeeQuery) HandleBadDebts(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	return qs.BadDebts(ctx, &lvtypes.QueryBadDebts{})
+}
+
+// HandleBadDebts queries bad debts.
+func (q UmeeQuery) HandleMaxWithdraw(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	req := &lvtypes.QueryMaxWithdraw{Address: q.MaxWithdraw.Address, Denom: q.MaxWithdraw.Denom}
+	return qs.MaxWithdraw(ctx, req)
+}
+
+// HandleMaxBorrow queries max borrow.
+func (q UmeeQuery) HandleMaxBorrow(
+	ctx context.Context,
+	qs lvtypes.QueryServer,
+) (proto.Message, error) {
+	req := &lvtypes.QueryMaxBorrow{Address: q.MaxBorrow.Address, Denom: q.MaxBorrow.Address}
+	return qs.MaxBorrow(ctx, req)
+}