Feat/stargate tester contract

Cargo.toml

@@ -8,7 +8,7 @@ incremental   = false
 
 [workspace.dependencies]
 anyhow               = { version = "1.0.66" }
-base64               = { version = "0.13.1" }
+base64               = { version = "0.21.5" }
 chrono               = { version = "0.4.27", default-features = false }
 cosmos-sdk-proto     = { version = "0.20.0", default-features = false }
 cosmwasm-schema      = { version = "1.5.0" }
@@ -38,6 +38,7 @@ secp256k1            = { version = "0.6.2" }
 serde                = { version = "1.0.196", default-features = false, features = [ "derive" ] }
 serde-cw-value       = { version = "0.7.0" }
 serde-json-wasm      = { version = "1.0.0" }
+serde_json           = { version = "1.0.111" }
 serde_repr           = { version = "0.1.17" }
 serde_test           = { version = "1.0.176" }
 subtle-encoding      = { version = "0.5.1", features = [ "bech32-preview" ] }

contracts/atomic-order-example/src/tests.rs

@@ -144,6 +144,7 @@ fn create_spot_market_handler() -> impl HandlesMarketIdQuery {
                     status: MarketStatus::Active,
                     min_price_tick_size: FPDecimal::from_str("0.000000000000001").unwrap(),
                     min_quantity_tick_size: FPDecimal::from_str("1000000000000000").unwrap(),
+                    min_notional: FPDecimal::ONE,
                 }),
             };
             SystemResult::Ok(ContractResult::from(to_json_binary(&response)))

contracts/injective-cosmwasm-mock/src/testing/test_exchange.rs

@@ -154,6 +154,7 @@ fn test_query_spot_market() {
     let ticker = "INJ/USDT".to_string();
     let min_price_tick_size = FPDecimal::must_from_str("0.000000000000001");
     let min_quantity_tick_size = FPDecimal::must_from_str("1000000000000000");
+    let min_notional = FPDecimal::must_from_str("1");
 
     exchange
         .instant_spot_market_launch(
@@ -164,7 +165,7 @@ fn test_query_spot_market() {
                 quote_denom: QUOTE_DENOM.to_string(),
                 min_price_tick_size: dec_to_proto(min_price_tick_size),
                 min_quantity_tick_size: dec_to_proto(min_quantity_tick_size),
-                min_notional: "1".to_string(),
+                min_notional: dec_to_proto(min_notional),
             },
             &env.signer,
         )

contracts/injective-cosmwasm-mock/src/testing/test_exchange_derivative.rs

@@ -52,6 +52,7 @@ fn test_query_derivative_market() {
     let maintenance_margin_ratio = FPDecimal::must_from_str("0.05");
     let min_price_tick_size = FPDecimal::must_from_str("1000.0");
     let min_quantity_tick_size = FPDecimal::must_from_str("1000000000000000");
+    let min_notional = FPDecimal::must_from_str("1");
     let quote_denom = QUOTE_DENOM.to_string();
     let maker_fee_rate = FPDecimal::ZERO;
     let taker_fee_rate = FPDecimal::ZERO;
@@ -72,7 +73,7 @@ fn test_query_derivative_market() {
                 maintenance_margin_ratio: dec_to_proto(maintenance_margin_ratio),
                 min_price_tick_size: dec_to_proto(min_price_tick_size),
                 min_quantity_tick_size: dec_to_proto(min_quantity_tick_size),
-                min_notional: "1".to_string(),
+                min_notional: dec_to_proto(min_notional),
             },
             &env.signer,
         )

contracts/injective-cosmwasm-stargate-example/Cargo.toml

@@ -0,0 +1,42 @@
+[package]
+authors = [ "Jose Luis Bernal Castillo <[email protected]>" ]
+edition = "2018"
+name    = "injective-cosmwasm-stargate-example"
+version = "0.0.1"
+
+exclude = [
+ # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
+ "contract.wasm",
+ "hash.txt",
+]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = [ "cdylib", "rlib" ]
+
+[features]
+# use library feature to disable all instantiate/execute/query exports
+integration = [  ]
+library     = [  ]
+
+[dependencies]
+base64             = { workspace = true }
+cosmos-sdk-proto   = { workspace = true }
+cosmwasm-schema    = { workspace = true }
+cosmwasm-std       = { workspace = true }
+cw-storage-plus    = { workspace = true }
+cw2                = { workspace = true }
+injective-cosmwasm = { workspace = true }
+injective-math     = { workspace = true }
+injective-std      = { workspace = true }
+prost              = { workspace = true }
+schemars           = { workspace = true }
+serde              = { workspace = true }
+serde_json         = { workspace = true }
+thiserror          = { workspace = true }
+
+[dev-dependencies]
+injective-std       = { workspace = true }
+injective-test-tube = { workspace = true }
+injective-testing   = { workspace = true }

contracts/injective-cosmwasm-stargate-example/src/contract.rs

@@ -0,0 +1,70 @@
+use crate::{
+    error::ContractError,
+    handle::{handle_test_market_spot_order, handle_test_transient_derivative_order, handle_test_transient_spot_order},
+    msg::{ExecuteMsg, InstantiateMsg, QueryMsg},
+    query::{handle_query_bank_params, handle_query_spot_market, handle_query_stargate_raw},
+    reply::{handle_create_derivative_order_reply_stargate, handle_create_order_reply_stargate},
+};
+
+use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult};
+use cw2::set_contract_version;
+use injective_cosmwasm::{InjectiveMsgWrapper, InjectiveQueryWrapper};
+
+const CONTRACT_NAME: &str = "crates.io:injective:dummy-stargate-contract";
+const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const CREATE_SPOT_ORDER_REPLY_ID: u64 = 0u64;
+pub const CREATE_DERIVATIVE_ORDER_REPLY_ID: u64 = 1u64;
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn instantiate(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: InstantiateMsg) -> Result<Response, ContractError> {
+    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+    Ok(Response::default())
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn execute(
+    deps: DepsMut<InjectiveQueryWrapper>,
+    env: Env,
+    info: MessageInfo,
+    msg: ExecuteMsg,
+) -> Result<Response<InjectiveMsgWrapper>, ContractError> {
+    match msg {
+        ExecuteMsg::TestTraderTransientSpotOrders {
+            market_id,
+            subaccount_id,
+            price,
+            quantity,
+        } => handle_test_transient_spot_order(deps, env, &info, market_id, subaccount_id, price, quantity),
+        ExecuteMsg::TestMarketOrderStargate {
+            market_id,
+            subaccount_id,
+            price,
+            quantity,
+        } => handle_test_market_spot_order(deps, env.contract.address.as_ref(), market_id, subaccount_id, price, quantity),
+        ExecuteMsg::TestTraderTransientDerivativeOrders {
+            market_id,
+            subaccount_id,
+            price,
+            quantity,
+            margin,
+        } => handle_test_transient_derivative_order(deps, env, &info, market_id, subaccount_id, price, quantity, margin),
+    }
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn query(deps: Deps<InjectiveQueryWrapper>, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
+    match msg {
+        QueryMsg::QueryStargateRaw { path, query_request } => handle_query_stargate_raw(&deps.querier, path, query_request),
+        QueryMsg::QueryBankParams {} => handle_query_bank_params(deps),
+        QueryMsg::QuerySpotMarket { market_id } => handle_query_spot_market(deps, &market_id),
+    }
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn reply(deps: DepsMut<InjectiveQueryWrapper>, _env: Env, msg: Reply) -> Result<Response, ContractError> {
+    match msg.id {
+        CREATE_SPOT_ORDER_REPLY_ID => handle_create_order_reply_stargate(deps, &msg),
+        CREATE_DERIVATIVE_ORDER_REPLY_ID => handle_create_derivative_order_reply_stargate(deps, &msg),
+        _ => Err(ContractError::UnrecognizedReply(msg.id)),
+    }
+}

contracts/injective-cosmwasm-stargate-example/src/encode_helper.rs

@@ -0,0 +1,9 @@
+use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
+use base64::Engine;
+use prost::Message;
+
+pub fn encode_proto_message<T: Message>(msg: T) -> String {
+    let mut buf = vec![];
+    T::encode(&msg, &mut buf).unwrap();
+    BASE64_STANDARD.encode(&buf)
+}

contracts/injective-cosmwasm-stargate-example/src/error.rs

@@ -0,0 +1,14 @@
+use cosmwasm_std::StdError;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ContractError {
+    #[error("{0}")]
+    Std(#[from] StdError),
+    #[error("Unrecognized reply id: {0}")]
+    UnrecognizedReply(u64),
+    #[error("Invalid reply from sub-message {id}, {err}")]
+    ReplyParseFailure { id: u64, err: String },
+    #[error("Failure response from submsg: {0}")]
+    SubMsgFailure(String),
+}

contracts/injective-cosmwasm-stargate-example/src/handle.rs

@@ -0,0 +1,139 @@
+use crate::{
+    contract::{CREATE_DERIVATIVE_ORDER_REPLY_ID, CREATE_SPOT_ORDER_REPLY_ID},
+    msg::{MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT, MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT},
+    order_management::{create_derivative_limit_order, create_spot_limit_order, create_stargate_msg, encode_bytes_message},
+    spot_market_order_msg::create_spot_market_order_message,
+    state::{CacheOrderInfo, ORDER_CALL_CACHE},
+    ContractError,
+};
+use cosmos_sdk_proto::{cosmos::authz::v1beta1::MsgExec, traits::Message, Any};
+use cosmwasm_std::{DepsMut, Env, MessageInfo, Response, SubMsg};
+use injective_cosmwasm::{InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper, MarketId, OrderType, SubaccountId};
+use injective_math::FPDecimal;
+
+pub const MSG_EXEC: &str = "/cosmos.authz.v1beta1.MsgExec";
+
+pub fn handle_test_market_spot_order(
+    deps: DepsMut<InjectiveQueryWrapper>,
+    sender: &str,
+    market_id: MarketId,
+    subaccount_id: SubaccountId,
+    price: String,
+    quantity: String,
+) -> Result<Response<InjectiveMsgWrapper>, ContractError> {
+    let querier = InjectiveQuerier::new(&deps.querier);
+    let spot_market = querier.query_spot_market(&market_id).unwrap().market.unwrap();
+
+    let order_msg = create_spot_market_order_message(
+        FPDecimal::must_from_str(price.as_str()),
+        FPDecimal::must_from_str(quantity.as_str()),
+        OrderType::Sell,
+        sender,
+        subaccount_id.as_str(),
+        "",
+        &spot_market,
+    )?;
+
+    Ok(Response::new().add_message(order_msg))
+}
+
+pub fn handle_test_transient_spot_order(
+    deps: DepsMut<InjectiveQueryWrapper>,
+    env: Env,
+    info: &MessageInfo,
+    market_id: MarketId,
+    subaccount_id: SubaccountId,
+    price: String,
+    quantity: String,
+) -> Result<Response<InjectiveMsgWrapper>, ContractError> {
+    let querier = InjectiveQuerier::new(&deps.querier);
+    let spot_market = querier.query_spot_market(&market_id).unwrap().market.unwrap();
+
+    let order_msg = create_spot_limit_order(
+        FPDecimal::must_from_str(price.as_str()),
+        FPDecimal::must_from_str(quantity.as_str()),
+        OrderType::Sell,
+        info.sender.as_str(),
+        subaccount_id.as_str(),
+        &spot_market,
+    );
+
+    let order_bytes = encode_bytes_message(&order_msg).unwrap();
+
+    let msg_exec = MsgExec {
+        grantee: env.contract.address.to_string(),
+        msgs: vec![Any {
+            type_url: MSG_CREATE_SPOT_LIMIT_ORDER_ENDPOINT.to_string(),
+            value: order_bytes,
+        }],
+    };
+
+    let order_submessage = SubMsg::reply_on_success(
+        create_stargate_msg(MSG_EXEC, msg_exec.encode_to_vec()).unwrap(),
+        CREATE_SPOT_ORDER_REPLY_ID,
+    );
+
+    save_cache_info(deps, market_id, subaccount_id)?;
+
+    Ok(Response::new().add_submessage(order_submessage))
+}
+
+pub fn handle_test_transient_derivative_order(
+    deps: DepsMut<InjectiveQueryWrapper>,
+    env: Env,
+    info: &MessageInfo,
+    market_id: MarketId,
+    subaccount_id: SubaccountId,
+    price: String,
+    quantity: String,
+    margin: String,
+) -> Result<Response<InjectiveMsgWrapper>, ContractError> {
+    let querier: InjectiveQuerier = InjectiveQuerier::new(&deps.querier);
+    let market = querier.query_derivative_market(&market_id).unwrap().market.unwrap();
+
+    let order_msg = create_derivative_limit_order(
+        FPDecimal::must_from_str(price.as_str()),
+        FPDecimal::must_from_str(quantity.as_str()),
+        FPDecimal::must_from_str(margin.as_str()),
+        OrderType::Buy,
+        info.sender.as_str(),
+        subaccount_id.as_str(),
+        &market,
+    );
+
+    let order_bytes = encode_bytes_message(&order_msg).unwrap();
+
+    let msg_exec = MsgExec {
+        grantee: env.contract.address.to_string(),
+        msgs: vec![Any {
+            type_url: MSG_CREATE_DERIVATIVE_LIMIT_ORDER_ENDPOINT.to_string(),
+            value: order_bytes,
+        }],
+    };
+
+    let order_submessage = SubMsg::reply_on_success(
+        create_stargate_msg(MSG_EXEC, msg_exec.encode_to_vec()).unwrap(),
+        CREATE_DERIVATIVE_ORDER_REPLY_ID,
+    );
+
+    save_cache_info(deps, market_id, subaccount_id)?;
+
+    Ok(Response::new().add_submessage(order_submessage))
+}
+
+fn save_cache_info(deps: DepsMut<InjectiveQueryWrapper>, market_id: MarketId, subaccount_id: SubaccountId) -> Result<(), ContractError> {
+    let cache_order_info = CacheOrderInfo {
+        subaccount: subaccount_id,
+        market_id,
+    };
+
+    let mut order_cache = match ORDER_CALL_CACHE.may_load(deps.storage)? {
+        Some(order_cache) => order_cache,
+        None => vec![],
+    };
+
+    order_cache.push(cache_order_info);
+
+    ORDER_CALL_CACHE.save(deps.storage, &order_cache)?;
+    Ok(())
+}

contracts/injective-cosmwasm-stargate-example/src/lib.rs

@@ -0,0 +1,16 @@
+pub mod contract;
+mod encode_helper;
+mod error;
+mod handle;
+pub mod msg;
+mod order_management;
+mod query;
+mod reply;
+mod spot_market_order_msg;
+mod state;
+#[cfg(test)]
+mod testing;
+#[cfg(test)]
+pub mod utils;
+
+pub use crate::error::ContractError;