minor changes

BakaOtaku · Oct 24, 2023 · 2895f48 · 2895f48
1 parent a1057e2
commit 2895f48
Show file tree

Hide file tree

Showing 3 changed files with 13 additions and 132 deletions.
diff --git a/.gitignore b/.gitignore
@@ -17,4 +17,5 @@ script.sh
 # IDEs
 *.iml
 .idea
-node_modules
+node_modules
+deploy.sh
diff --git a/contracts/limit/src/contract.rs b/contracts/limit/src/contract.rs
@@ -7,9 +7,9 @@ use cosmwasm_std::{
 use cw2::set_contract_version;
 use cw20::Cw20ExecuteMsg::Transfer;
 
-use self::execute::{execute_order, execute_internal_swap};
+use self::execute::execute_order;
 use crate::error::ContractError;
-use crate::msg::{ExecuteMsg, InstantiateMsg, NibiruQuerier, QueryMsg, QueryperpMsg};
+use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
 use crate::state::ORDER_ID_COUNTER;
 use anybuf::Anybuf;
 use base64::decode;
@@ -35,7 +35,7 @@ pub fn instantiate(
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn execute(
-    deps: DepsMut<QueryperpMsg>,
+    deps: DepsMut,
     _env: Env,
     info: MessageInfo,
     msg: ExecuteMsg,
@@ -70,7 +70,6 @@ pub fn execute(
         ),
 
         ExecuteMsg::ExecuteSwapOrder { order_id } => execute_order(deps, order_id.u64()),
-        ExecuteMsg::ExecuteSwapOrderIntenal { order_id } => execute_internal_swap(deps, order_id.u64()),
     }
 }
 
@@ -82,13 +81,11 @@ pub mod execute {
     use serde::de;
 
     use super::*;
-    use crate::{
-        msg::{OraclePricesResponse, QueryperpMsg, ContractExecMsg, NibiruRoute},
-        state::{SwapOrder, ORDER_ID_COUNTER, SWAP_ORDER_STORE},
-    };
+    use crate::state::{SwapOrder, ORDER_ID_COUNTER, SWAP_ORDER_STORE};
+
 
     pub fn store_swap_order(
-        deps: DepsMut<QueryperpMsg>,
+        deps: DepsMut,
         info: MessageInfo,
         to: String,
         order_requester: String,
@@ -125,74 +122,34 @@ pub mod execute {
     }
 
     pub fn execute_order(
-        deps: DepsMut<QueryperpMsg>,
+        deps: DepsMut,
         order_id: u64,
     ) -> Result<Response, ContractError> {
         let mut swap_order = SWAP_ORDER_STORE.load(deps.storage, order_id)?;
         let mut pair = swap_order.token_sell.clone();
-        pair.push_str(":");
-        pair.push_str(&swap_order.token_bought.clone());
-        let querier = NibiruQuerier::new(&deps.querier);
-        let price_map: OraclePricesResponse = querier.oracle_prices(Some(vec![pair.clone()]))?;
-        let decimaldefault = Decimal::zero();
-        let price = price_map.get(&pair).unwrap_or(&decimaldefault);
-        let swap_lower = Decimal::new(swap_order.swap_lower_usd.into());
-        let swap_upper = Decimal::new(swap_order.swap_upper_usd.into());
-        let mut msg: CosmosMsg;
-        if price.le(&swap_lower) {
-            let sell = Coin::new(swap_order.quantity_order.into(), swap_order.token_sell.clone());
-            let msg = CosmosMsg::Bank(
-                cosmwasm_std::BankMsg::Send { to_address: swap_order.to, amount: vec![sell] },
-            );
-        } else {
-            let sell = Coin::new(swap_order.quantity_order.into(), swap_order.token_bought.clone());
-            msg = CosmosMsg::Bank(
-                cosmwasm_std::BankMsg::Send { to_address: swap_order.to, amount: vec![sell] },
-            )
-        }
+
 
-        Ok(Response::new().add_message(msg))
-    }
-
-
-    pub fn execute_internal_swap(deps:DepsMut<QueryperpMsg>, order_id:u64) -> Result<Response,ContractError> {
-        let mut swap_order = SWAP_ORDER_STORE.load(deps.storage, order_id)?;
-        let mut pair_id= swap_order.pair_id.unwrap();
-
-        let msg= ContractExecMsg{
-            route:NibiruRoute::Perp,
-            msg:ExecuteMsg::SwapAssets { pool_id: pair_id , token_in: swap_order.token_bought, token_out_denom: swap_order.token_sell}.into(),
-        };
+        Ok(Response::default())
     }
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
-pub fn query(deps: Deps<QueryperpMsg>, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
+pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
     match msg {
         QueryMsg::GetOrder { orderId } => to_binary(&query::get_order(deps, orderId)?),
-        QueryMsg::GetExchangeRate { pair } => to_binary(&query::get_exchange_rate(deps, pair)?),
     }
 }
 
 pub mod query {
     use super::*;
     use crate::msg::GetOrderResponse;
-    use crate::msg::OraclePricesResponse;
     use crate::state::{SwapOrder, SWAP_ORDER_STORE};
 
-    pub fn get_order(deps: Deps<QueryperpMsg>, orderId: u64) -> StdResult<GetOrderResponse> {
+    pub fn get_order(deps: Deps, orderId: u64) -> StdResult<GetOrderResponse> {
         let state = SWAP_ORDER_STORE.load(deps.storage, orderId)?;
 
         Ok(GetOrderResponse { order: state })
     }
-
-
-    pub fn get_exchange_rate(deps: Deps<QueryperpMsg>, pair: String) -> StdResult<OraclePricesResponse> {
-        let querier = NibiruQuerier::new(&deps.querier);
-        let price_map: OraclePricesResponse = querier.oracle_prices(Some(vec![pair.clone()]))?;
-
-        Ok(price_map)
-    }
 }
 
 #[cfg(test)]

diff --git a/contracts/limit/src/msg.rs b/contracts/limit/src/msg.rs
@@ -7,32 +7,6 @@ use std::collections::HashMap;
 pub struct InstantiateMsg {}
 
 
-#[cw_serde]
-pub enum NibiruRoute {
-    /// "perp" is the route corresponding to bindings for the x/perp module.
-    Perp,
-    Oracle,
-    Spot,
-
-    /// "no_op" is a valid route that doesn't do anything. It's necessary for
-    /// formatting in the custom Wasm execute handler.
-    NoOp,
-}
-
-#[cw_serde]
-pub struct ContractExecMsg {
-    pub route: NibiruRoute,
-    pub msg: Option<ExecuteMsg>,
-}
-
-impl CustomMsg for ContractExecMsg{}
-
-impl  From<ContractExecMsg> for CustomMsg<ContractExecMsg>{
-    fn from(msg: ContractExecMsg) -> Self {
-        CosmosMsg::Custom(msg)
-    }
-}
-
 #[cw_serde]
 pub enum ExecuteMsg {
     StoreSwapOrder {
@@ -52,16 +26,6 @@ pub enum ExecuteMsg {
     ExecuteSwapOrder {
         order_id: Uint64,
     },
-
-    ExecuteSwapOrderIntenal{
-        order_id:Uint64
-    },
-
-    SwapAssets {
-        pool_id: Uint64,
-        token_in: Coin,  
-        token_out_denom:String
-    },
 }
 
 
@@ -74,49 +38,8 @@ pub enum QueryMsg {
     #[returns(GetOrderResponse)]
     GetOrder { orderId: u64 },
 
-    #[returns(OraclePricesResponse)]
-    GetExchangeRate{pair:String}
-}
-
-#[cw_serde]
-pub enum QueryperpMsg {
-    OraclePrices {},
-}
-
-impl CustomQuery for QueryperpMsg {}
-pub struct NibiruQuerier<'a> {
-    querier: &'a QuerierWrapper<'a, QueryperpMsg>,
 }
 
-impl<'a> NibiruQuerier<'a> {
-    pub fn new(querier: &'a QuerierWrapper<QueryperpMsg>) -> Self {
-        NibiruQuerier { querier }
-    }
-
-    pub fn oracle_prices(&self, pairs: Option<Vec<String>>) -> StdResult<OraclePricesResponse> {
-        let request = QueryperpMsg::OraclePrices {};
-        let price_map: OraclePricesResponse = self.querier.query(&request.into())?;
-
-        let mut out_price_map: OraclePricesResponse;
-        if pairs.is_none() || pairs.as_ref().unwrap().is_empty() {
-            out_price_map = price_map;
-        } else {
-            let pair_vec: Vec<String> = pairs.unwrap();
-            out_price_map = HashMap::new();
-            for p in &pair_vec {
-                match price_map.get(p) {
-                    Some(rate) => out_price_map.insert(p.clone(), *rate),
-                    None => continue,
-                };
-            }
-        }
-
-        Ok(out_price_map)
-    }
-}
-
-pub type OraclePricesResponse = HashMap<String, Decimal>;
-
 // We define a custom struct for each query response
 #[cw_serde]
 pub struct GetOrderResponse {