wasmx query test

contracts/injective-cosmwasm-mock/src/contract.rs

@@ -3,18 +3,18 @@ use crate::{
     handle::{handle_test_transient_derivative_order, handle_test_transient_spot_order},
     msg::{ExecuteMsg, InstantiateMsg, QueryMsg},
     query::{
-        handle_aggregate_account_volume_query, handle_aggregate_market_volume_query, handle_derivative_market_mid_price_and_tob_query,
-        handle_derivative_market_orderbook_query, handle_derivative_market_query, handle_derivative_orders_to_cancel_up_to_amount_query,
-        handle_effective_subaccount_position_query, handle_exchange_params_query, handle_market_atomic_execution_fee_multiplier_query,
-        handle_market_volatility_query, handle_oracle_price_query, handle_oracle_volatility_query, handle_perpetual_market_funding_query,
-        handle_perpetual_market_info_query, handle_pyth_price_query, handle_spot_market_mid_price_and_tob_query, handle_spot_market_orderbook_query,
-        handle_spot_market_query, handle_spot_orders_to_cancel_up_to_amount_query, handle_subaccount_deposit_query,
-        handle_trader_derivative_orders_query, handle_trader_spot_orders_query, handle_vanilla_subaccount_position_query,
+        handle_aggregate_account_volume_query, handle_aggregate_market_volume_query, handle_contract_registration_info_query,
+        handle_derivative_market_mid_price_and_tob_query, handle_derivative_market_orderbook_query, handle_derivative_market_query,
+        handle_derivative_orders_to_cancel_up_to_amount_query, handle_effective_subaccount_position_query, handle_exchange_params_query,
+        handle_market_atomic_execution_fee_multiplier_query, handle_market_volatility_query, handle_oracle_price_query,
+        handle_oracle_volatility_query, handle_perpetual_market_funding_query, handle_perpetual_market_info_query, handle_pyth_price_query,
+        handle_spot_market_mid_price_and_tob_query, handle_spot_market_orderbook_query, handle_spot_market_query,
+        handle_spot_orders_to_cancel_up_to_amount_query, handle_staked_amount_query, handle_subaccount_deposit_query,
+        handle_token_factory_creation_fee, handle_token_factory_denom_total_supply, handle_trader_derivative_orders_query,
+        handle_trader_spot_orders_query, handle_vanilla_subaccount_position_query,
     },
     reply::{handle_create_derivative_order_reply, handle_create_order_reply},
 };
-
-use crate::query::{handle_staked_amount_query, handle_token_factory_creation_fee, handle_token_factory_denom_total_supply};
 use cosmwasm_std::{entry_point, Binary, Deps, DepsMut, Env, MessageInfo, Reply, Response, StdResult};
 use cw2::set_contract_version;
 use injective_cosmwasm::{create_deposit_msg, InjectiveMsgWrapper, InjectiveQuerier, InjectiveQueryWrapper};
@@ -138,7 +138,7 @@ pub fn query(deps: Deps<InjectiveQueryWrapper>, _env: Env, msg: QueryMsg) -> Std
         } => handle_staked_amount_query(&querier, deps.api.addr_validate(delegator_address.as_str())?, max_delegations),
         QueryMsg::TestQueryTokenFactoryDenomTotalSupply { denom } => handle_token_factory_denom_total_supply(&querier, denom),
         QueryMsg::TestQueryTokenFactoryCreationFee {} => handle_token_factory_creation_fee(&querier),
-        QueryMsg::TestQueryContractRegistrationInfo { .. } => Ok(Default::default()),
+        QueryMsg::TestQueryContractRegistrationInfo { contract_address } => handle_contract_registration_info_query(&querier, contract_address),
     }
 }
 

contracts/injective-cosmwasm-mock/src/query.rs

@@ -155,3 +155,7 @@ pub fn handle_token_factory_creation_fee(querier: &InjectiveQuerier) -> StdResul
 pub fn handle_staked_amount_query(querier: &InjectiveQuerier, delegator_address: Addr, max_delegations: u16) -> StdResult<Binary> {
     to_json_binary(&querier.query_staked_amount(delegator_address, max_delegations)?)
 }
+
+pub fn handle_contract_registration_info_query(querier: &InjectiveQuerier, contract_address: String) -> StdResult<Binary> {
+    to_json_binary(&querier.query_contract_registration_info(&contract_address)?)
+}

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

@@ -3,3 +3,4 @@ mod test_exchange_derivative;
 mod test_oracle;
 mod test_staking;
 mod test_token_factory;
+mod test_wasmx;

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

@@ -6,20 +6,18 @@ use crate::{
         scale_price_quantity_for_spot_market_dec, str_coin, ExchangeType, HumanOrder, Setup, BASE_DECIMALS, BASE_DENOM, QUOTE_DECIMALS, QUOTE_DENOM,
     },
 };
-
 use cosmwasm_std::{Addr, Coin};
 use injective_cosmwasm::{
     checked_address_to_subaccount_id,
     exchange::{response::QueryOrderbookResponse, types::VolumeByType},
-    ExchangeParamsResponse, MarketId, MarketMidPriceAndTOBResponse, MarketVolatilityResponse, OrderSide, PriceLevel, QueryAggregateVolumeResponse,
-    QueryMarketAtomicExecutionFeeMultiplierResponse, SpotMarketResponse, SubaccountDepositResponse, SubaccountId, TraderSpotOrdersResponse,
-    TrimmedSpotLimitOrder,
+    CancellationStrategy, ExchangeParamsResponse, MarketId, MarketMidPriceAndTOBResponse, MarketVolatilityResponse, OrderSide, PriceLevel,
+    QueryAggregateVolumeResponse, QueryMarketAtomicExecutionFeeMultiplierResponse, SpotMarketResponse, SubaccountDepositResponse, SubaccountId,
+    TraderSpotOrdersResponse, TrimmedSpotLimitOrder,
 };
 use injective_math::FPDecimal;
 use injective_std::types::injective::exchange::v1beta1::{
     Deposit, MsgDeposit, MsgInstantSpotMarketLaunch, OrderType, QueryAggregateMarketVolumeResponse, QuerySubaccountDepositsRequest,
 };
-
 use injective_test_tube::{injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Exchange, Module, RunnerResult, Wasm};
 
 #[test]
@@ -436,11 +434,54 @@ fn test_query_market_atomic_execution_fee_multiplier() {
 
 #[test]
 #[cfg_attr(not(feature = "integration"), ignore)]
-fn test_query_spot_orders_to_cancel_up_to_amount() {}
+fn test_query_spot_orders_to_cancel_up_to_amount() {
+    let env = Setup::new(ExchangeType::Spot);
+    let wasm = Wasm::new(&env.app);
+    let market_id = env.market_id.unwrap();
 
-#[test]
-#[cfg_attr(not(feature = "integration"), ignore)]
-fn test_query_derivative_orders_to_cancel_up_to_amount() {}
+    let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(env.users[0].account.address()))
+        .as_str()
+        .to_string();
+
+    let query_spot_msg = QueryMsg::TestTraderSpotOrders {
+        market_id: MarketId::new(market_id.clone()).unwrap(),
+        subaccount_id: SubaccountId::new(subaccount_id.to_owned()).unwrap(),
+    };
+
+    {
+        let (price, quantity) = scale_price_quantity_for_spot_market("9.90", "1", &BASE_DECIMALS, &QUOTE_DECIMALS);
+        add_spot_order_as(&env.app, market_id.to_owned(), &env.users[0], price, quantity, OrderType::Buy);
+
+        let res: TraderSpotOrdersResponse = wasm.query(&env.contract_address, &query_spot_msg).unwrap();
+        let orders = res.orders.clone().unwrap();
+
+        let expected_order = TrimmedSpotLimitOrder {
+            price: human_to_dec("9.90", QUOTE_DECIMALS - BASE_DECIMALS),
+            quantity: human_to_dec("1", BASE_DECIMALS),
+            fillable: human_to_dec("1", BASE_DECIMALS),
+            isBuy: true,
+            order_hash: "".to_string(),
+        };
+        assert_eq!(orders[0].price, expected_order.price);
+        assert_eq!(orders[0].quantity, expected_order.quantity);
+        assert_eq!(orders[0].fillable, expected_order.fillable);
+        assert_eq!(orders[0].isBuy, expected_order.isBuy);
+    }
+
+    {
+        let query_spot_cancel_msg = QueryMsg::TestSpotOrdersToCancelUpToAmount {
+            market_id: MarketId::new(market_id.clone()).unwrap(),
+            subaccount_id: SubaccountId::new(subaccount_id).unwrap(),
+            base_amount: human_to_dec("0", BASE_DECIMALS),
+            quote_amount: human_to_dec("0.2", QUOTE_DECIMALS),
+            strategy: CancellationStrategy::UnspecifiedOrder,
+            reference_price: None,
+        };
+        let res: TraderSpotOrdersResponse = wasm.query(&env.contract_address, &query_spot_cancel_msg).unwrap();
+        let orders = res.orders.clone().unwrap();
+        assert_eq!(orders.len(), 1);
+    }
+}
 
 #[test]
 #[cfg_attr(not(feature = "integration"), ignore)]

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

@@ -1,24 +1,21 @@
 use crate::{
     msg::{ExecuteMsg, QueryMsg},
     utils::{
-        add_derivative_order_as, add_derivative_orders, add_perp_initial_liquidity, dec_to_proto, get_initial_perp_liquidity_orders_vector,
-        get_perpetual_market_id, human_to_dec, scale_price_quantity_perp_market, ExchangeType, HumanOrder, Setup, BASE_DENOM, QUOTE_DECIMALS,
-        QUOTE_DENOM,
+        add_derivative_order_as, add_derivative_orders, add_perp_initial_liquidity, dec_to_proto, execute_all_authorizations,
+        get_initial_perp_liquidity_orders_vector, get_perpetual_market_id, human_to_dec, scale_price_quantity_perp_market,
+        scale_price_quantity_perp_market_dec, ExchangeType, HumanOrder, Setup, BASE_DENOM, QUOTE_DECIMALS, QUOTE_DENOM,
     },
 };
-
-use crate::utils::{execute_all_authorizations, scale_price_quantity_perp_market_dec};
 use cosmwasm_std::Addr;
-use injective_cosmwasm::exchange::response::QueryOrderbookResponse;
 use injective_cosmwasm::{
-    checked_address_to_subaccount_id, DerivativeMarketResponse, MarketId, MarketMidPriceAndTOBResponse, PerpetualMarketFundingResponse,
-    PerpetualMarketInfoResponse, PriceLevel, SubaccountEffectivePositionInMarketResponse, SubaccountId, SubaccountPositionInMarketResponse,
-    TraderDerivativeOrdersResponse, TrimmedDerivativeLimitOrder,
+    checked_address_to_subaccount_id, exchange::response::QueryOrderbookResponse, CancellationStrategy, DerivativeMarketResponse, MarketId,
+    MarketMidPriceAndTOBResponse, PerpetualMarketFundingResponse, PerpetualMarketInfoResponse, PriceLevel,
+    SubaccountEffectivePositionInMarketResponse, SubaccountId, SubaccountPositionInMarketResponse, TraderDerivativeOrdersResponse,
+    TrimmedDerivativeLimitOrder,
 };
 use injective_math::FPDecimal;
 use injective_std::types::injective::exchange::v1beta1::{MsgInstantPerpetualMarketLaunch, OrderType};
-use injective_test_tube::injective_cosmwasm::get_default_subaccount_id_for_checked_address;
-use injective_test_tube::{Account, Exchange, Module, Wasm};
+use injective_test_tube::{injective_cosmwasm::get_default_subaccount_id_for_checked_address, Account, Exchange, Module, Wasm};
 
 #[test]
 #[cfg_attr(not(feature = "integration"), ignore)]
@@ -47,7 +44,6 @@ fn test_query_derivative_market() {
     let env = Setup::new(ExchangeType::None);
     let wasm = Wasm::new(&env.app);
     let exchange = Exchange::new(&env.app);
-
     let ticker = "INJ/USDT".to_string();
     let initial_margin_ratio = FPDecimal::must_from_str("0.195");
     let maintenance_margin_ratio = FPDecimal::must_from_str("0.05");
@@ -138,7 +134,6 @@ fn test_query_vanilla_subaccount_position() {
     add_perp_initial_liquidity(&env.app, market_id.clone());
 
     let (price, quantity, margin) = scale_price_quantity_perp_market("9.7", "1", "2", &QUOTE_DECIMALS);
-
     let trader = &env.users[1];
     let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(trader.account.address()))
         .as_str()
@@ -179,7 +174,6 @@ fn test_query_trader_derivative_orders() {
     let market_id = env.market_id.unwrap();
 
     let (price, quantity, margin) = scale_price_quantity_perp_market("10.1", "1", "2", &QUOTE_DECIMALS);
-
     let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(env.users[1].account.address()))
         .as_str()
         .to_string();
@@ -200,7 +194,6 @@ fn test_query_trader_derivative_orders() {
     };
     let res: TraderDerivativeOrdersResponse = wasm.query(&env.contract_address, &query_msg).unwrap();
     assert!(res.orders.is_some());
-
     let orders = res.orders.clone().unwrap();
     assert_eq!(orders.len(), 1);
     let expected_order = TrimmedDerivativeLimitOrder {
@@ -218,13 +211,63 @@ fn test_query_trader_derivative_orders() {
     assert_eq!(orders[0].margin, expected_order.margin);
 }
 
+#[test]
+#[cfg_attr(not(feature = "integration"), ignore)]
+fn test_query_derivative_orders_to_cancel_up_to_amount() {
+    let env = Setup::new(ExchangeType::Derivative);
+    let wasm = Wasm::new(&env.app);
+    let market_id = env.market_id.unwrap();
+    let subaccount_id = get_default_subaccount_id_for_checked_address(&Addr::unchecked(env.users[1].account.address()))
+        .as_str()
+        .to_string();
+
+    let (price, quantity, margin) = scale_price_quantity_perp_market("10.1", "1", "2", &QUOTE_DECIMALS);
+    add_derivative_order_as(
+        &env.app,
+        market_id.to_owned(),
+        &env.users[1].account,
+        price,
+        quantity,
+        OrderType::Sell,
+        margin,
+    );
+    let (price, quantity, margin) = scale_price_quantity_perp_market("12", "1", "2", &QUOTE_DECIMALS);
+    add_derivative_order_as(
+        &env.app,
+        market_id.to_owned(),
+        &env.users[1].account,
+        price,
+        quantity,
+        OrderType::Sell,
+        margin,
+    );
+    let query_msg_derivative = QueryMsg::TestTraderDerivativeOrders {
+        market_id: MarketId::new(market_id.clone()).unwrap(),
+        subaccount_id: SubaccountId::new(subaccount_id.to_owned()).unwrap(),
+    };
+    let res: TraderDerivativeOrdersResponse = wasm.query(&env.contract_address, &query_msg_derivative).unwrap();
+    assert!(res.orders.is_some());
+    let orders = res.orders.clone().unwrap();
+    assert_eq!(orders.len(), 2);
+    let query_derivative_order_cancel_msg = QueryMsg::TestDerivativeOrdersToCancelUpToAmount {
+        market_id: MarketId::new(market_id.clone()).unwrap(),
+        subaccount_id: SubaccountId::new(subaccount_id).unwrap(),
+        quote_amount: human_to_dec("0.2", QUOTE_DECIMALS),
+        strategy: CancellationStrategy::UnspecifiedOrder,
+        reference_price: None,
+    };
+    let res: TraderDerivativeOrdersResponse = wasm.query(&env.contract_address, &query_derivative_order_cancel_msg).unwrap();
+    assert!(res.orders.is_some());
+    let orders = res.orders.clone().unwrap();
+    assert_eq!(orders.len(), 1);
+}
+
 #[test]
 #[cfg_attr(not(feature = "integration"), ignore)]
 fn test_query_perpetual_market_funding() {
     let env = Setup::new(ExchangeType::Derivative);
     let wasm = Wasm::new(&env.app);
     let exchange = Exchange::new(&env.app);
-
     let ticker = "INJ/USDT".to_string();
     let derivative_market_id = get_perpetual_market_id(&exchange, ticker.to_owned());
     let market_id = MarketId::new(derivative_market_id.clone()).unwrap();
@@ -271,7 +314,6 @@ fn test_query_derivative_market_orderbook() {
         market_id: MarketId::new(market_id.clone()).unwrap(),
         limit_cumulative_notional: FPDecimal::MAX,
     };
-
     let res: QueryOrderbookResponse = wasm.query(&env.contract_address, &query_msg).unwrap();
     let buys_price_level = res.buys_price_level;
     let sells_price_level = res.sells_price_level;
@@ -291,7 +333,6 @@ fn test_query_derivative_market_orderbook() {
             q: FPDecimal::must_from_str(liquidity_orders[3].quantity.as_str()),
         }
     );
-
     assert_eq!(
         sells_price_level[0],
         PriceLevel {
@@ -314,14 +355,10 @@ fn test_query_trader_transient_derivative_orders() {
     let env = Setup::new(ExchangeType::Derivative);
     let wasm = Wasm::new(&env.app);
     let market_id = env.market_id.unwrap();
-
     let subaccount_id = checked_address_to_subaccount_id(&Addr::unchecked(env.users[0].account.address()), 0u32);
-
     execute_all_authorizations(&env.app, &env.users[0].account, env.contract_address.clone());
     add_perp_initial_liquidity(&env.app, market_id.clone());
-
     let (price, quantity, margin) = scale_price_quantity_perp_market("9.7", "0.5", "2", &QUOTE_DECIMALS);
-
     add_derivative_order_as(
         &env.app,
         market_id.to_owned(),
@@ -331,9 +368,7 @@ fn test_query_trader_transient_derivative_orders() {
         OrderType::Sell,
         margin,
     );
-
     let (scale_price, scale_quantity, scaled_margin) = scale_price_quantity_perp_market_dec("9.7", "0.1", "2", &QUOTE_DECIMALS);
-
     let res = wasm
         .execute(
             &env.contract_address,

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

@@ -12,14 +12,13 @@ fn test_query_staked_amount() {
     let env = Setup::new(ExchangeType::None);
     let wasm = Wasm::new(&env.app);
     let staking = Staking::new(&env.app);
-
     let validator_address = env.app.get_first_validator_address().unwrap();
 
     staking
         .delegate(
             MsgDelegate {
                 delegator_address: env.owner.address(),
-                validator_address: validator_address,
+                validator_address,
                 amount: Some(Coin {
                     amount: "10".to_string(),
                     denom: BASE_DENOM.to_string(),

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

@@ -0,0 +1,18 @@
+use crate::msg::QueryMsg;
+use crate::utils::{ExchangeType, Setup};
+use injective_cosmwasm::wasmx::response::QueryContractRegistrationInfoResponse;
+use injective_test_tube::{Module, Wasm};
+
+#[test]
+#[cfg_attr(not(feature = "integration"), ignore)]
+fn test_query_contract_registration_info() {
+    let env = Setup::new(ExchangeType::None);
+    let wasm = Wasm::new(&env.app);
+
+    let query_msg = QueryMsg::TestQueryContractRegistrationInfo {
+        contract_address: env.contract_address.to_owned(),
+    };
+
+    let response: QueryContractRegistrationInfoResponse = wasm.query(&env.contract_address, &query_msg).unwrap();
+    assert!(response.contract.is_none())
+}