Swap non vault funds

smart-contracts/osmosis/contracts/cl-vault/src/contract.rs

@@ -77,10 +77,9 @@ pub fn execute(
 ) -> Result<Response, ContractError> {
     match msg {
         cw_vault_multi_standard::VaultStandardExecuteMsg::AnyDeposit {
-            amount: _,
-            asset: _,
             recipient,
             max_slippage,
+            .. // asset and amount fields are not used in this implementation, they are for CW20 tokens
         } => execute_any_deposit(deps, env, info, recipient, max_slippage),
         cw_vault_multi_standard::VaultStandardExecuteMsg::ExactDeposit { recipient } => {
             execute_exact_deposit(deps, env, info, recipient)
@@ -137,9 +136,10 @@ pub fn execute(
                         claim_after,
                     )?,
                 ),
-                crate::msg::ExtensionExecuteMsg::SwapNonVaultFunds { swap_operations } => {
-                    execute_swap_non_vault_funds(deps, env, info, swap_operations)
-                }
+                crate::msg::ExtensionExecuteMsg::SwapNonVaultFunds {
+                    swap_operations,
+                    twap_window_seconds,
+                } => execute_swap_non_vault_funds(deps, env, swap_operations, twap_window_seconds),
                 crate::msg::ExtensionExecuteMsg::CollectRewards {} => {
                     execute_collect_rewards(deps, env)
                 }

smart-contracts/osmosis/contracts/cl-vault/src/error.rs

@@ -33,6 +33,9 @@ pub enum ContractError {
     #[error("ratio_of_swappable_funds_to_use should be >0 and <=1")]
     InvalidRatioOfSwappableFundsToUse,
 
+    #[error("Invalid swap direction")]
+    InvalidSwapDirection,
+
     #[error("Cannot do two swaps at the same time")]
     SwapInProgress,
 
@@ -48,6 +51,9 @@ pub enum ContractError {
     #[error("This message does no accept funds")]
     NonPayable {},
 
+    #[error("Modify range state already exists")]
+    ModifyRangeStateAlreadyExists {},
+
     // Add any other custom errors you like here.
     // Look at https://docs.rs/thiserror/1.0.21/thiserror/ for details.
 

smart-contracts/osmosis/contracts/cl-vault/src/helpers/getters.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 use cosmwasm_std::{
     Addr, Coin, Decimal, Decimal256, Deps, DepsMut, Env, Fraction, QuerierWrapper, Storage,
-    Uint128, Uint256,
+    Timestamp, Uint128, Uint256,
 };
 
 use super::coinlist::CoinList;
@@ -27,8 +27,7 @@ pub fn get_range_admin(deps: Deps) -> Result<Addr, ContractError> {
 pub fn get_asset0_value(
     storage: &dyn Storage,
     querier: &QuerierWrapper,
-    token0: Uint128,
-    token1: Uint128,
+    tokens_provided: (Uint128, Uint128),
 ) -> Result<Uint128, ContractError> {
     let pool_config = POOL_CONFIG.load(storage)?;
 
@@ -38,26 +37,56 @@ pub fn get_asset0_value(
         .spot_price
         .parse()?;
 
-    let total = token0
-        .checked_add(token1.multiply_ratio(spot_price.denominator(), spot_price.numerator()))?;
+    let total = tokens_provided.0.checked_add(
+        tokens_provided
+            .1
+            .multiply_ratio(spot_price.denominator(), spot_price.numerator()),
+    )?;
 
     Ok(total)
 }
 
-pub fn get_twap_price(
+pub fn get_position_balance(
     storage: &dyn Storage,
     querier: &QuerierWrapper,
-    env: &Env,
+) -> Result<(f64, f64), ContractError> {
+    let position = get_position(storage, querier)?;
+    let asset0_amount = Uint128::from_str(&position.clone().asset0.unwrap_or_default().amount)?;
+    let asset1_amount = Uint128::from_str(&position.clone().asset1.unwrap_or_default().amount)?;
+
+    // Handle cases where either asset amount is zero
+    if asset0_amount.is_zero() && asset1_amount.is_zero() {
+        return Ok((0.0, 0.0));
+    } else if asset0_amount.is_zero() {
+        return Ok((0.0, 1.0));
+    } else if asset1_amount.is_zero() {
+        return Ok((1.0, 0.0));
+    }
+
+    // Get the total amount of the vault's position in asset0 denom
+    let asset_0_value = get_asset0_value(storage, querier, (asset0_amount, asset1_amount))?;
+
+    // Calculate the ratio of the vault's position in asset0 and asset1
+    let asset_0_ratio = asset0_amount.u128() as f64 / asset_0_value.u128() as f64;
+    let asset_1_ratio = asset1_amount.u128() as f64 / asset_0_value.u128() as f64;
+
+    Ok((asset_0_ratio, asset_1_ratio))
+}
+
+pub fn get_twap_price(
+    querier: &QuerierWrapper,
+    block_time: Timestamp,
     twap_window_seconds: u64,
+    pool_id: u64,
+    token0_denom: String,
+    token1_denom: String,
 ) -> Result<Decimal, ContractError> {
-    let pool_config = POOL_CONFIG.load(storage)?;
-
     let twap_querier = TwapQuerier::new(querier);
-    let start_of_window = env.block.time.minus_seconds(twap_window_seconds);
+    let start_of_window = block_time.minus_seconds(twap_window_seconds);
     let twap_price = twap_querier.arithmetic_twap_to_now(
-        pool_config.pool_id,
-        pool_config.token0,
-        pool_config.token1,
+        pool_id,
+        token0_denom,
+        token1_denom,
         Some(OsmoTimestamp {
             seconds: start_of_window.seconds().try_into()?,
             nanos: 0,
@@ -101,16 +130,15 @@ pub fn get_depositable_tokens(
         position.asset0.unwrap_or_default().try_into()?,
         position.asset1.unwrap_or_default().try_into()?,
     );
-    compute_deposit_and_refund_tokens(&assets, token0, token1)
+    compute_deposit_and_refund_tokens(&assets, (token0.amount, token1.amount))
 }
 
 fn compute_deposit_and_refund_tokens(
     assets: &PoolAssets,
-    provided_base: Coin,
-    provided_quote: Coin,
+    tokens_provided: (Uint128, Uint128),
 ) -> Result<DepositInfo, ContractError> {
-    let provided_base_amount: Uint256 = provided_base.amount.into();
-    let provided_quote_amount: Uint256 = provided_quote.amount.into();
+    let provided_base_amount: Uint256 = tokens_provided.0.into();
+    let provided_quote_amount: Uint256 = tokens_provided.1.into();
 
     let base_deposit = if assets.quote.amount.is_zero() {
         provided_base_amount
@@ -393,7 +421,8 @@ mod tests {
             base: token0.clone(),
             quote: token1.clone(),
         };
-        let result = compute_deposit_and_refund_tokens(&assets, token0, token1).unwrap();
+        let result =
+            compute_deposit_and_refund_tokens(&assets, (token0.amount, token1.amount)).unwrap();
         assert_eq!(
             result,
             DepositInfo {
@@ -423,7 +452,8 @@ mod tests {
             },
             quote: token1.clone(),
         };
-        let result = compute_deposit_and_refund_tokens(&assets, token0, token1).unwrap();
+        let result =
+            compute_deposit_and_refund_tokens(&assets, (token0.amount, token1.amount)).unwrap();
         assert_eq!(
             result,
             DepositInfo {
@@ -453,7 +483,8 @@ mod tests {
             },
             base: token0.clone(),
         };
-        let result = compute_deposit_and_refund_tokens(&assets, token0, token1).unwrap();
+        let result =
+            compute_deposit_and_refund_tokens(&assets, (token0.amount, token1.amount)).unwrap();
         assert_eq!(
             result,
             DepositInfo {
@@ -480,9 +511,11 @@ mod tests {
             base: token0.clone(),
             quote: token1.clone(),
         };
-        let result =
-            compute_deposit_and_refund_tokens(&assets, coin(2000, "token0"), coin(5000, "token1"))
-                .unwrap();
+        let result = compute_deposit_and_refund_tokens(
+            &assets,
+            (coin(2000, "token0").amount, coin(5000, "token1").amount),
+        )
+        .unwrap();
         assert_eq!(
             result,
             DepositInfo {
@@ -509,9 +542,11 @@ mod tests {
             base: token0.clone(),
             quote: token1.clone(),
         };
-        let result =
-            compute_deposit_and_refund_tokens(&assets, coin(2000, "token0"), coin(3000, "token1"))
-                .unwrap();
+        let result = compute_deposit_and_refund_tokens(
+            &assets,
+            (coin(2000, "token0").amount, coin(3000, "token1").amount),
+        )
+        .unwrap();
         assert_eq!(
             result,
             DepositInfo {

smart-contracts/osmosis/contracts/cl-vault/src/helpers/msgs.rs

@@ -3,9 +3,9 @@ use cosmwasm_std::{
     WasmMsg,
 };
 use dex_router_osmosis::msg::ExecuteMsg as DexRouterExecuteMsg;
-use osmosis_std::types::{
-    cosmos::base::v1beta1::Coin as OsmoCoin,
-    osmosis::{
+use osmosis_std::{
+    cosmwasm_to_proto_coins,
+    types::osmosis::{
         concentratedliquidity::v1beta1::{MsgCollectIncentives, MsgCollectSpreadRewards},
         poolmanager::v1beta1::SwapAmountInRoute,
     },
@@ -58,52 +58,49 @@ pub fn refund_bank_msg(
 
 /// swap will always swap over the CL pool. In the future we may expand the
 /// feature such that it chooses best swaps over all routes
-pub fn swap_msg(deps: &DepsMut, env: &Env, params: SwapParams) -> Result<CosmosMsg, ContractError> {
+pub fn swap_msg(
+    deps: &DepsMut,
+    contract_address: Addr,
+    params: SwapParams,
+) -> Result<CosmosMsg, ContractError> {
     // let pool_config = POOL_CONFIG.load(deps.storage)?;
     let dex_router = DEX_ROUTER.may_load(deps.storage)?;
 
     // we will only ever have a route length of one, this will likely change once we start selecting different routes
     let pool_route = SwapAmountInRoute {
         pool_id: params.pool_id,
-        token_out_denom: params.token_out_denom.to_string(),
+        token_out_denom: params.min_token_out.denom.to_string(),
     };
 
     // if we don't have a dex_router, we will always swap over the osmosis pool
     if dex_router.is_none() {
         return Ok(osmosis_swap_exact_amount_in_msg(
-            env,
+            contract_address,
             pool_route,
-            params.token_in_amount,
-            &params.token_in_denom.to_string(),
-            params.token_out_min_amount,
+            params.token_in,
+            params.min_token_out.amount,
         ));
     }
 
     // we know we have a dex_router, so we can unwrap it and execute the swap
     cw_dex_execute_swap_operations_msg(
         dex_router.clone().unwrap(),
         params.forced_swap_route,
-        params.token_in_denom.to_string(),
-        params.token_in_amount,
-        params.token_out_denom.to_string(),
-        params.token_out_min_amount,
+        params.token_in,
+        params.min_token_out,
     )
 }
 
 fn osmosis_swap_exact_amount_in_msg(
-    env: &Env,
+    contract_address: Addr,
     pool_route: SwapAmountInRoute,
-    token_in_amount: Uint128,
-    token_in_denom: &String,
+    token_in: Coin,
     token_out_min_amount: Uint128,
 ) -> CosmosMsg {
     osmosis_std::types::osmosis::poolmanager::v1beta1::MsgSwapExactAmountIn {
-        sender: env.contract.address.to_string(),
+        sender: contract_address.to_string(),
         routes: vec![pool_route],
-        token_in: Some(OsmoCoin {
-            denom: token_in_denom.to_string(),
-            amount: token_in_amount.to_string(),
-        }),
+        token_in: cosmwasm_to_proto_coins([token_in]).first().cloned(),
         token_out_min_amount: token_out_min_amount.to_string(),
     }
     .into()
@@ -112,22 +109,17 @@ fn osmosis_swap_exact_amount_in_msg(
 fn cw_dex_execute_swap_operations_msg(
     dex_router_address: Addr,
     path: Option<Vec<SwapAmountInRoute>>,
-    token_in_denom: String,
-    token_in_amount: Uint128,
-    token_out_denom: String,
-    token_out_min_amount: Uint128,
+    token_in: Coin,
+    min_token_out: Coin,
 ) -> Result<CosmosMsg, ContractError> {
     let swap_msg: CosmosMsg = WasmMsg::Execute {
         contract_addr: dex_router_address.to_string(),
         msg: to_json_binary(&DexRouterExecuteMsg::Swap {
             path,
-            out_denom: token_out_denom,
-            minimum_receive: Some(token_out_min_amount),
+            out_denom: min_token_out.denom,
+            minimum_receive: Some(min_token_out.amount),
         })?,
-        funds: vec![Coin {
-            denom: token_in_denom,
-            amount: token_in_amount,
-        }],
+        funds: vec![token_in],
     }
     .into();
 

smart-contracts/osmosis/contracts/cl-vault/src/instantiate.rs

@@ -153,8 +153,10 @@ pub fn handle_instantiate_create_position_reply(
     let asset_value = get_asset0_value(
         deps.storage,
         &deps.querier,
-        assets[0].amount + free_asset0.amount,
-        assets[1].amount + free_asset1.amount,
+        (
+            assets[0].amount + free_asset0.amount,
+            assets[1].amount + free_asset1.amount,
+        ),
     )?;
 
     let vault_denom = VAULT_DENOM.load(deps.storage)?;

smart-contracts/osmosis/contracts/cl-vault/src/lib.rs

@@ -7,7 +7,7 @@ pub mod msg;
 pub mod query;
 mod reply;
 pub mod state;
-mod vault;
+pub mod vault;
 
 pub use crate::error::ContractError;
 

smart-contracts/osmosis/contracts/cl-vault/src/msg.rs

@@ -8,7 +8,10 @@ use crate::query::{
     AssetsBalanceResponse, PoolResponse, PositionResponse, RangeAdminResponse,
     UserSharesBalanceResponse, VerifyTickCacheResponse,
 };
-use crate::state::{Metadata, VaultConfig};
+use crate::{
+    state::{Metadata, VaultConfig},
+    vault::swap::SwapOperation,
+};
 
 /// Extension execute messages for an apollo autocompounding vault
 #[cw_serde]
@@ -29,7 +32,10 @@ pub enum ExtensionExecuteMsg {
     /// MigrationStep
     MigrationStep { amount_of_users: Uint128 },
     /// SwapNonVaultFunds
-    SwapNonVaultFunds { swap_operations: Vec<SwapOperation> },
+    SwapNonVaultFunds {
+        swap_operations: Vec<SwapOperation>,
+        twap_window_seconds: Option<u64>,
+    },
 }
 
 /// Extension messages for Authz. This interface basically reexports certain vault functionality
@@ -96,16 +102,6 @@ pub struct MergePositionMsg {
     pub position_ids: Vec<u64>,
 }
 
-// struct used by swap.rs on swap non vault funds
-#[cw_serde]
-pub struct SwapOperation {
-    pub token_in_denom: String,
-    pub pool_id_0: u64, // the osmosis pool_id as mandatory to have at least the chance to swap on CL pools
-    pub pool_id_1: u64, // the osmosis pool_id as mandatory to have at least the chance to swap on CL pools
-    pub forced_swap_route_token_0: Option<Vec<SwapAmountInRoute>>,
-    pub forced_swap_route_token_1: Option<Vec<SwapAmountInRoute>>,
-}
-
 /// Extension query messages for an apollo autocompounding vault
 #[cw_serde]
 pub enum ExtensionQueryMsg {