add stargate bindings for sims

Author: jcompagni10

packages/neutron-sdk/src/proto_types/neutron.dex.rs

@@ -175,6 +175,10 @@ pub struct MsgPlaceLimitOrder {
     pub expiration_time: ::core::option::Option<::prost_types::Timestamp>,
     #[prost(string, tag = "10")]
     pub max_amount_out: ::prost::alloc::string::String,
+    #[prost(string, optional, tag = "11")]
+    pub limit_sell_price: ::core::option::Option<::prost::alloc::string::String>,
+    #[prost(string, optional, tag = "12")]
+    pub min_average_sell_price: ::core::option::Option<::prost::alloc::string::String>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MsgPlaceLimitOrderResponse {
@@ -189,6 +193,9 @@ pub struct MsgPlaceLimitOrderResponse {
     /// maker portion which will have withdrawn in the future
     #[prost(message, optional, tag = "3")]
     pub taker_coin_out: ::core::option::Option<cosmos_sdk_proto::cosmos::base::v1beta1::Coin>,
+    /// Total amount of the token in that was immediately swapped for takerOutCoin
+    #[prost(message, optional, tag = "4")]
+    pub taker_coin_in: ::core::option::Option<cosmos_sdk_proto::cosmos::base::v1beta1::Coin>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MsgWithdrawFilledLimitOrder {
@@ -234,6 +241,10 @@ pub struct MsgMultiHopSwap {
 pub struct MsgMultiHopSwapResponse {
     #[prost(message, optional, tag = "1")]
     pub coin_out: ::core::option::Option<cosmos_sdk_proto::cosmos::base::v1beta1::Coin>,
+    #[prost(message, optional, tag = "2")]
+    pub route: ::core::option::Option<MultiHopRoute>,
+    #[prost(message, repeated, tag = "3")]
+    pub dust: ::prost::alloc::vec::Vec<cosmos_sdk_proto::cosmos::base::v1beta1::Coin>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MsgUpdateParams {
@@ -634,4 +645,26 @@ pub struct QueryAllPoolMetadataResponse {
     pub pagination:
         ::core::option::Option<cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>,
 }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySimulatePlaceLimitOrderRequest {
+    #[prost(message, optional, tag = "1")]
+    pub msg: ::core::option::Option<MsgPlaceLimitOrder>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySimulatePlaceLimitOrderResponse {
+    #[prost(message, optional, tag = "1")]
+    pub resp: ::core::option::Option<MsgPlaceLimitOrderResponse>,
+}
+
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySimulateMultiHopSwapRequest {
+    #[prost(message, optional, tag = "1")]
+    pub msg: ::core::option::Option<MsgMultiHopSwap>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QuerySimulateMultiHopSwapResponse {
+    #[prost(message, optional, tag = "1")]
+    pub resp: ::core::option::Option<MsgPlaceLimitOrderResponse>,
+}
+
 // @@protoc_insertion_point(module)

packages/neutron-sdk/src/stargate/dex/query.rs

@@ -6,6 +6,7 @@ use crate::proto_types::neutron::dex::{
     QueryGetInactiveLimitOrderTrancheRequest, QueryGetLimitOrderTrancheRequest,
     QueryGetLimitOrderTrancheUserRequest, QueryGetPoolMetadataRequest, QueryGetPoolReservesRequest,
     QueryParamsRequest, QueryPoolByIdRequest, QueryPoolRequest,
+    QuerySimulatePlaceLimitOrderRequest, QuerySimulateMultiHopSwapRequest,
 };
 use crate::stargate::aux::make_stargate_query;
 use crate::stargate::dex::types::{
@@ -17,10 +18,12 @@ use crate::stargate::dex::types::{
     EstimateMultiHopSwapRequest, EstimateMultiHopSwapResponse, EstimatePlaceLimitOrderRequest,
     EstimatePlaceLimitOrderResponse, GetInactiveLimitOrderTrancheRequest,
     GetInactiveLimitOrderTrancheResponse, GetLimitOrderTrancheRequest,
+    SimulatePlaceLimitOrderResponse, SimulateMultiHopSwapResponse,
     GetLimitOrderTrancheResponse, GetPoolMetadataRequest, GetPoolMetadataResponse,
     GetPoolReservesRequest, GetPoolReservesResponse, LimitOrderTrancheUserAllRequest,
     LimitOrderTrancheUserAllResponse, LimitOrderTrancheUserRequest, LimitOrderTrancheUserResponse,
     ParamsRequest, ParamsResponse, PoolByIdRequest, PoolRequest, PoolResponse,
+    SimulatePlaceLimitOrderRequest, SimulateMultiHopSwapRequest
 };
 use cosmwasm_std::{Deps, StdResult};
 
@@ -45,6 +48,8 @@ const POOL_QUERY_PATH: &str = "/neutron.dex.Query/Pool";
 const POOL_BY_ID_QUERY_PATH: &str = "/neutron.dex.Query/PoolByID";
 const POOL_METADATA_QUERY_PATH: &str = "/neutron.dex.Query/PoolMetadata";
 const POOL_METADATA_ALL_QUERY_PATH: &str = "/neutron.dex.Query/PoolMetadataAll";
+const SIMULATE_PLACE_LIMIT_ORDER__QUERY_PATH: &str = "/neutron.dex.Query/SimulatePlaceLimitOrder";
+const SIMULATE_MULTI_HOP_SWAP_QUERY_PATH: &str = "/neutron.dex.Query/SimulateMultiHopSwap";
 
 /// Queries the parameters of the module.
 pub fn get_params(deps: Deps, req: ParamsRequest) -> StdResult<ParamsResponse> {
@@ -240,3 +245,28 @@ pub fn get_pool_metadata_all(
         QueryAllPoolMetadataRequest::from(req),
     )
 }
+
+
+/// Simulate Place Limit Order
+pub fn simulate_place_place_order(
+    deps: Deps,
+    req: SimulatePlaceLimitOrderRequest,
+) -> StdResult<SimulatePlaceLimitOrderResponse> {
+    make_stargate_query(
+        deps,
+        SIMULATE_PLACE_LIMIT_ORDER__QUERY_PATH,
+        QuerySimulatePlaceLimitOrderRequest::from(req),
+    )
+}
+
+/// Simulate MultiHopSwap
+pub fn simulate_multi_hop_swap(
+    deps: Deps,
+    req: SimulateMultiHopSwapRequest,
+) -> StdResult<SimulateMultiHopSwapResponse> {
+    make_stargate_query(
+        deps,
+        SIMULATE_MULTI_HOP_SWAP_QUERY_PATH,
+        QuerySimulateMultiHopSwapRequest::from(req),
+    )
+}

packages/neutron-sdk/src/stargate/dex/types.rs

@@ -8,7 +8,7 @@ use crate::proto_types::neutron::dex::{
     QueryEstimateMultiHopSwapRequest, QueryEstimatePlaceLimitOrderRequest,
     QueryGetInactiveLimitOrderTrancheRequest, QueryGetLimitOrderTrancheRequest,
     QueryGetLimitOrderTrancheUserRequest, QueryGetPoolMetadataRequest, QueryGetPoolReservesRequest,
-    QueryParamsRequest, QueryPoolByIdRequest, QueryPoolRequest,
+    QueryParamsRequest, QueryPoolByIdRequest, QueryPoolRequest, QuerySimulatePlaceLimitOrderRequest, QuerySimulateMultiHopSwapRequest,
 };
 use crate::stargate::aux::proto_timestamp_from_i64;
 use cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest as PageRequestGen;
@@ -121,6 +121,8 @@ pub struct PlaceLimitOrderRequest {
     /// Expiration time for order. Only valid for GoodTilTime limit orders.
     pub expiration_time: Option<i64>,
     pub max_amount_out: Option<String>,
+    pub limit_sell_price: Option<String>,
+    pub min_avg_sell_price: Option<String>,
 }
 
 impl From<PlaceLimitOrderRequest> for MsgPlaceLimitOrder {
@@ -135,6 +137,8 @@ impl From<PlaceLimitOrderRequest> for MsgPlaceLimitOrder {
             order_type: v.order_type as i32,
             expiration_time: v.expiration_time.map(proto_timestamp_from_i64),
             max_amount_out: v.max_amount_out.unwrap_or_default(),
+            limit_sell_price: v.limit_sell_price,
+            min_average_sell_price: v.min_avg_sell_price,
         }
     }
 }
@@ -665,6 +669,97 @@ impl From<AllPoolMetadataRequest> for QueryAllPoolMetadataRequest {
     }
 }
 
+//SimulatePlaceLimitOrder
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+pub struct SimulatePlaceLimitOrderRequest {
+    /// Account from which token_in is debited.
+    pub sender: String,
+    /// Account to which token_out is credited or that will be allowed to withdraw or cancel a
+    /// maker order.
+    pub receiver: String,
+    /// Token being “sold”.
+    pub token_in: String,
+    /// Token being “bought”.
+    pub token_out: String,
+    /// Limit tick for a limit order, specified in terms of token_in to token_out.
+    pub tick_index_in_to_out: i64,
+    /// Amount of TokenIn to be traded.
+    pub amount_in: String,
+    /// Type of limit order to be used.
+    pub order_type: LimitOrderType,
+    /// Expiration time for order. Only valid for GoodTilTime limit orders.
+    pub expiration_time: Option<i64>,
+    pub max_amount_out: Option<String>,
+    pub limit_sell_price: Option<String>,
+    pub min_avg_sell_price: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+pub struct SimulatePlaceLimitOrderResponse{
+    resp: PlaceLimitOrderResponse
+}
+
+impl From<SimulatePlaceLimitOrderRequest> for QuerySimulatePlaceLimitOrderRequest {
+    fn from(v: SimulatePlaceLimitOrderRequest) -> QuerySimulatePlaceLimitOrderRequest {
+        QuerySimulatePlaceLimitOrderRequest {
+            msg: Some(MsgPlaceLimitOrder{
+                creator: v.sender,
+                receiver: v.receiver,
+                token_in: v.token_in,
+                token_out: v.token_out,
+                tick_index_in_to_out: v.tick_index_in_to_out,
+                amount_in: v.amount_in,
+                order_type: v.order_type as i32,
+                expiration_time: v.expiration_time.map(proto_timestamp_from_i64),
+                max_amount_out: v.max_amount_out.unwrap_or_default(),
+                limit_sell_price: v.limit_sell_price,
+                min_average_sell_price: v.min_avg_sell_price,
+            })
+        }
+    }
+}
+
+// SimulateMultiHopSwap
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+pub struct SimulateMultiHopSwapRequest{
+    pub sender: String,
+    /// Account to which TokenOut is credited
+    receiver: String,
+    /// Array of possible routes
+    routes: Vec<Vec<String>>,
+    /// Amount of TokenIn to swap
+    amount_in: String,
+    /// Minimum price that that must be satisfied for a route to succeed
+    exit_limit_price: String,
+    /// If true all routes are run and the route with the best price is used
+    pick_best_route: bool,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+pub struct SimulateMultiHopSwapResponse{
+    resp: MultiHopSwapResponse
+}
+
+impl From<SimulateMultiHopSwapRequest> for QuerySimulateMultiHopSwapRequest {
+    fn from(v: SimulateMultiHopSwapRequest) -> QuerySimulateMultiHopSwapRequest {
+        QuerySimulateMultiHopSwapRequest {
+            msg: Some(MsgMultiHopSwap{
+                creator: v.sender,
+                receiver: v.receiver,
+                routes: v
+                    .routes
+                    .into_iter()
+                    .map(|r| MultiHopRoute { hops: r })
+                    .collect(),
+                amount_in: v.amount_in,
+                exit_limit_price: v.exit_limit_price,
+                pick_best_route: v.pick_best_route,
+            })
+        }
+    }
+}
+
 // Common
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]