Custom CosmWasm Integration

app/app.go

@@ -138,7 +138,7 @@ func init() {
 	DefaultNodeHome = filepath.Join(userHomeDir, ".osmosisd")
 }
 
-// NewOsmosis returns a reference to an initialized Osmosis.
+// NewOsmosisApp returns a reference to an initialized Osmosis.
 func NewOsmosisApp(
 	logger log.Logger,
 	db dbm.DB,

app/keepers.go

@@ -123,6 +123,8 @@ import (
 	bech32ibckeeper "github.com/osmosis-labs/bech32-ibc/x/bech32ibc/keeper"
 	bech32ibctypes "github.com/osmosis-labs/bech32-ibc/x/bech32ibc/types"
 	bech32ics20keeper "github.com/osmosis-labs/bech32-ibc/x/bech32ics20/keeper"
+
+	owasm "github.com/osmosis-labs/osmosis/v7/app/wasm"
 )
 
 type appKeepers struct {
@@ -367,7 +369,10 @@ func (app *OsmosisApp) InitNormalKeepers(
 
 	// The last arguments can contain custom message handlers, and custom query handlers,
 	// if we want to allow any custom callbacks
-	supportedFeatures := "iterator,staking,stargate"
+	supportedFeatures := "iterator,staking,stargate,osmosis"
+
+	wasmOpts = append(owasm.RegisterCustomPlugins(app.GAMMKeeper, app.BankKeeper), wasmOpts...)
+
 	wasmKeeper := wasm.NewKeeper(
 		appCodec,
 		keys[wasm.StoreKey],

app/wasm/README.md

@@ -0,0 +1,34 @@
+# CosmWasm support
+
+This package contains CosmWasm integration points.
+
+This package provides first class support for:
+
+* Queries
+  * Denoms
+  * Pools
+  * Prices
+* Messages / Execution
+  * Mint
+  * Swap
+
+### Command line interface (CLI)
+
+* Commands
+
+```sh
+  osmosisd tx wasm -h
+```
+
+* Query
+
+```sh
+  osmosisd query wasm -h
+```
+
+### Tests
+
+This contains a few high level tests that `x/wasm` is properly integrated.
+
+Since the code tested is not in this repo, and we are just testing the application
+integration (app.go), I figured this is the most suitable location for it.

app/wasm/bindings/msg.go

@@ -0,0 +1,23 @@
+package wasmbindings
+
+type OsmosisMsg struct {
+	// /// Contracts can mint native tokens that have an auto-generated denom
+	// /// namespaced under the contract's address. A contract may create any number
+	// /// of independent sub-denoms.
+	// MintTokens *MintTokens `json:"mint_tokens,omitempty"`
+	/// Swap over one or more pools
+	Swap *SwapMsg `json:"swap,omitempty"`
+}
+
+// type MintTokens struct {
+// 	/// Must be 2-32 alphanumeric characters
+// 	SubDenom  string  `json:"sub_denom"`
+// 	Amount    sdk.Int `json:"amount"`
+// 	Recipient string  `json:"recipient"`
+// }
+
+type SwapMsg struct {
+	First  Swap                `json:"first"`
+	Route  []Step              `json:"route"`
+	Amount SwapAmountWithLimit `json:"amount"`
+}

app/wasm/bindings/pool.go

@@ -0,0 +1,8 @@
+package wasmbindings
+
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+type PoolAssets struct {
+	Assets []sdk.Coin
+	Shares sdk.Coin
+}

app/wasm/bindings/query.go

@@ -0,0 +1,73 @@
+package wasmbindings
+
+import (
+	wasmvmtypes "github.com/CosmWasm/wasmvm/types"
+)
+
+// OsmosisQuery contains osmosis custom queries.
+// See https://github.com/confio/osmosis-bindings/blob/main/packages/bindings/src/query.rs
+type OsmosisQuery struct {
+	// /// Given a subdenom minted by a contract via `OsmosisMsg::MintTokens`,
+	// /// returns the full denom as used by `BankMsg::Send`.
+	// FullDenom *FullDenom `json:"full_denom,omitempty"`
+	/// For a given pool ID, list all tokens traded on it with current liquidity (spot).
+	/// As well as the total number of LP shares and their denom.
+	PoolState *PoolState `json:"pool_state,omitempty"`
+	/// Return current spot price swapping In for Out on given pool ID.
+	/// Warning: this can easily be manipulated via sandwich attacks, do not use as price oracle.
+	/// We will add TWAP for more robust price feed.
+	SpotPrice *SpotPrice `json:"spot_price,omitempty"`
+	/// Return current spot price swapping In for Out on given pool ID.
+	EstimateSwap *EstimateSwap `json:"estimate_swap,omitempty"`
+}
+
+// type FullDenom struct {
+// 	Contract string `json:"contract"`
+// 	SubDenom string `json:"sub_denom"`
+// }
+
+type PoolState struct {
+	PoolId uint64 `json:"id"`
+}
+
+type SpotPrice struct {
+	Swap        Swap `json:"swap"`
+	WithSwapFee bool `json:"with_swap_fee"`
+}
+
+type EstimateSwap struct {
+	Sender string     `json:"sender"`
+	First  Swap       `json:"first"`
+	Route  []Step     `json:"route"`
+	Amount SwapAmount `json:"amount"`
+}
+
+func (e *EstimateSwap) ToSwapMsg() *SwapMsg {
+	return &SwapMsg{
+		First:  e.First,
+		Route:  e.Route,
+		Amount: e.Amount.Unlimited(),
+	}
+}
+
+// type FullDenomResponse struct {
+// 	Denom string `json:"denom"`
+// }
+
+type PoolStateResponse struct {
+	/// The various assets that be swapped. Including current liquidity.
+	Assets []wasmvmtypes.Coin `json:"assets"`
+	/// The number of LP shares and their amount
+	Shares wasmvmtypes.Coin `json:"shares"`
+}
+
+type SpotPriceResponse struct {
+	/// How many output we would get for 1 input
+	Price string `json:"price"`
+}
+
+type EstimatePriceResponse struct {
+	// If you query with SwapAmount::Input, this is SwapAmount::Output.
+	// If you query with SwapAmount::Output, this is SwapAmount::Input.
+	Amount SwapAmount `json:"swap_amount"`
+}

app/wasm/bindings/types.go

@@ -0,0 +1,74 @@
+package wasmbindings
+
+import (
+	"math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type Swap struct {
+	PoolId   uint64 `json:"pool_id"`
+	DenomIn  string `json:"denom_in"`
+	DenomOut string `json:"denom_out"`
+}
+
+type Step struct {
+	PoolId   uint64 `json:"pool_id"`
+	DenomOut string `json:"denom_out"`
+}
+
+type SwapAmount struct {
+	In  *sdk.Int `json:"in,omitempty"`
+	Out *sdk.Int `json:"out,omitempty"`
+}
+
+// This returns SwapAmountWithLimit with the largest possible limits (that will never be hit)
+func (s SwapAmount) Unlimited() SwapAmountWithLimit {
+	if s.In != nil {
+		return SwapAmountWithLimit{
+			ExactIn: &ExactIn{
+				Input:     *s.In,
+				MinOutput: sdk.NewInt(1),
+			},
+		}
+	}
+	if s.Out != nil {
+		return SwapAmountWithLimit{
+			ExactOut: &ExactOut{
+				Output:   *s.Out,
+				MaxInput: sdk.NewInt(math.MaxInt64),
+			},
+		}
+	}
+	panic("Must define In or Out")
+}
+
+type SwapAmountWithLimit struct {
+	ExactIn  *ExactIn  `json:"exact_in,omitempty"`
+	ExactOut *ExactOut `json:"exact_out,omitempty"`
+}
+
+// This returns the amount without min/max to use as simpler argument
+func (s SwapAmountWithLimit) RemoveLimit() SwapAmount {
+	if s.ExactIn != nil {
+		return SwapAmount{
+			In: &s.ExactIn.Input,
+		}
+	}
+	if s.ExactOut != nil {
+		return SwapAmount{
+			Out: &s.ExactOut.Output,
+		}
+	}
+	panic("Must define ExactIn or ExactOut")
+}
+
+type ExactIn struct {
+	Input     sdk.Int `json:"input"`
+	MinOutput sdk.Int `json:"min_output"`
+}
+
+type ExactOut struct {
+	MaxInput sdk.Int `json:"max_input"`
+	Output   sdk.Int `json:"output"`
+}