Support multiple routes in astroport adapter

contracts/adapters/swap/astroport/src/contract.rs

@@ -1,6 +1,6 @@
 use crate::{
     error::{ContractError, ContractResult},
-    state::ENTRY_POINT_CONTRACT_ADDRESS,
+    state::{ENTRY_POINT_CONTRACT_ADDRESS, PRE_SWAP_OUT_ASSET_AMOUNT},
 };
 use astroport::pair::{
     Cw20HookMsg as PairCw20HookMsg, ExecuteMsg as PairExecuteMsg, QueryMsg as PairQueryMsg,
@@ -15,10 +15,9 @@ use cw20::{Cw20Coin, Cw20ReceiveMsg};
 use cw_utils::one_coin;
 use skip::{
     asset::{get_current_asset_available, Asset},
-    error::SkipError,
     swap::{
         execute_transfer_funds_back, Cw20HookMsg, ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg,
-        SimulateSwapExactAssetInResponse, SimulateSwapExactAssetOutResponse, SwapOperation,
+        Route, SimulateSwapExactAssetInResponse, SimulateSwapExactAssetOutResponse, SwapOperation,
     },
 };
 
@@ -102,15 +101,7 @@ pub fn receive_cw20(
     info.sender = deps.api.addr_validate(&cw20_msg.sender)?;
 
     match from_json(&cw20_msg.msg)? {
-        Cw20HookMsg::Swap { routes } => {
-            if routes.len() != 1 {
-                return Err(ContractError::Skip(SkipError::MustBeSingleRoute));
-            }
-
-            let operations = routes.first().unwrap().operations.clone();
-
-            execute_swap(deps, env, info, operations)
-        }
+        Cw20HookMsg::Swap { routes } => execute_swap(deps, env, info, routes),
     }
 }
 
@@ -130,13 +121,7 @@ pub fn execute(
         ExecuteMsg::Swap { routes } => {
             one_coin(&info)?;
 
-            if routes.len() != 1 {
-                return Err(ContractError::Skip(SkipError::MustBeSingleRoute));
-            }
-
-            let operations = routes.first().unwrap().operations.clone();
-
-            execute_swap(deps, env, info, operations)
+            execute_swap(deps, env, info, routes)
         }
         ExecuteMsg::TransferFundsBack {
             swapper,
@@ -148,9 +133,10 @@ pub fn execute(
             swapper,
             return_denom,
         )?),
-        ExecuteMsg::AstroportPoolSwap { operation } => {
-            execute_astroport_pool_swap(deps, env, info, operation)
-        }
+        ExecuteMsg::AstroportPoolSwap {
+            operation,
+            offer_asset,
+        } => execute_astroport_pool_swap(deps, env, info, operation, offer_asset),
         _ => {
             unimplemented!()
         }
@@ -161,7 +147,7 @@ fn execute_swap(
     deps: DepsMut,
     env: Env,
     info: MessageInfo,
-    operations: Vec<SwapOperation>,
+    routes: Vec<Route>,
 ) -> ContractResult<Response> {
     // Get entry point contract address from storage
     let entry_point_contract_address = ENTRY_POINT_CONTRACT_ADDRESS.load(deps.storage)?;
@@ -171,22 +157,40 @@ fn execute_swap(
         return Err(ContractError::Unauthorized);
     }
 
+    // reset the pre swap out asset amount
+    PRE_SWAP_OUT_ASSET_AMOUNT.save(deps.storage, &Uint128::new(0))?;
+
     // Create a response object to return
     let mut response: Response = Response::new().add_attribute("action", "execute_swap");
 
-    // Add an astroport pool swap message to the response for each swap operation
-    for operation in &operations {
-        let swap_msg = WasmMsg::Execute {
-            contract_addr: env.contract.address.to_string(),
-            msg: to_json_binary(&ExecuteMsg::AstroportPoolSwap {
-                operation: operation.clone(),
-            })?,
-            funds: vec![],
-        };
-        response = response.add_message(swap_msg);
+    // Add an astroport pool swap message to the response for each swap operation in each route
+    for route in &routes {
+        for (idx, operation) in route.operations.iter().enumerate() {
+            // if first operation in a route, set offer asset to the route's offer asset
+            // otherwise, the offer asset will be determined by the contracts balance
+            let offer_asset = if idx == 0 {
+                Some(route.offer_asset.clone())
+            } else {
+                None
+            };
+
+            let swap_msg = WasmMsg::Execute {
+                contract_addr: env.contract.address.to_string(),
+                msg: to_json_binary(&ExecuteMsg::AstroportPoolSwap {
+                    operation: operation.clone(),
+                    offer_asset,
+                })?,
+                funds: vec![],
+            };
+
+            response = response.add_message(swap_msg);
+        }
     }
 
-    let return_denom = match operations.last() {
+    let return_denom = match routes
+        .last()
+        .and_then(|last_route| last_route.operations.last())
+    {
         Some(last_op) => last_op.denom_out.clone(),
         None => return Err(ContractError::SwapOperationsEmpty),
     };
@@ -211,20 +215,39 @@ fn execute_astroport_pool_swap(
     env: Env,
     info: MessageInfo,
     operation: SwapOperation,
+    offer_asset: Option<Asset>,
 ) -> ContractResult<Response> {
     // Ensure the caller is the contract itself
     if info.sender != env.contract.address {
         return Err(ContractError::Unauthorized);
     }
 
     // Get the current asset available on contract to swap in
-    let offer_asset = get_current_asset_available(&deps, &env, &operation.denom_in)?;
+    let offer_asset = match offer_asset {
+        Some(offer_asset) => offer_asset,
+        None => {
+            let pre_swap_out_asset_amount = PRE_SWAP_OUT_ASSET_AMOUNT
+                .load(deps.storage)
+                .unwrap_or(Uint128::zero());
+
+            let mut current_balance =
+                get_current_asset_available(&deps, &env, &operation.denom_in)?;
+
+            current_balance.sub(pre_swap_out_asset_amount)?;
+
+            current_balance
+        }
+    };
 
     // Error if the offer asset amount is zero
     if offer_asset.amount().is_zero() {
         return Err(ContractError::NoOfferAssetAmount);
     }
 
+    let pre_swap_out_asset_amount =
+        get_current_asset_available(&deps, &env, operation.denom_out.as_str())?.amount();
+    PRE_SWAP_OUT_ASSET_AMOUNT.save(deps.storage, &pre_swap_out_asset_amount)?;
+
     // Create the astroport pool swap msg depending on the offer asset type
     let msg = match offer_asset {
         Asset::Native(_) => to_json_binary(&PairExecuteMsg::Swap {

contracts/adapters/swap/astroport/src/state.rs

@@ -1,4 +1,6 @@
-use cosmwasm_std::Addr;
+use cosmwasm_std::{Addr, Uint128};
 use cw_storage_plus::Item;
 
 pub const ENTRY_POINT_CONTRACT_ADDRESS: Item<Addr> = Item::new("entry_point_contract_address");
+
+pub const PRE_SWAP_OUT_ASSET_AMOUNT: Item<Uint128> = Item::new("pre_swap_out_asset_amount");

contracts/adapters/swap/astroport/tests/test_execute_astroport_pool_swap.rs

@@ -8,9 +8,15 @@ use cosmwasm_std::{
     ReplyOn::Never,
     SubMsg, SystemResult, Uint128, WasmMsg, WasmQuery,
 };
-use cw20::{BalanceResponse, Cw20ExecuteMsg};
-use skip::swap::{ExecuteMsg, SwapOperation};
-use skip_api_swap_adapter_astroport::error::{ContractError, ContractResult};
+use cw20::{BalanceResponse, Cw20Coin, Cw20ExecuteMsg};
+use skip::{
+    asset::Asset,
+    swap::{ExecuteMsg, SwapOperation},
+};
+use skip_api_swap_adapter_astroport::{
+    error::{ContractError, ContractResult},
+    state::PRE_SWAP_OUT_ASSET_AMOUNT,
+};
 use test_case::test_case;
 
 /*
@@ -31,6 +37,8 @@ Expect Error
 struct Params {
     caller: String,
     contract_balance: Vec<Coin>,
+    pre_swap_out_asset_amount: Uint128,
+    offer_asset: Option<Asset>,
     swap_operation: SwapOperation,
     expected_message: Option<SubMsg>,
     expected_error: Option<ContractError>,
@@ -41,6 +49,8 @@ struct Params {
     Params {
         caller: "swap_contract_address".to_string(),
         contract_balance: vec![Coin::new(100, "os")],
+        pre_swap_out_asset_amount: Uint128::new(0),
+        offer_asset: Some(Asset::Native(Coin::new(100, "os"))),
         swap_operation: SwapOperation {
                 pool: "pool_1".to_string(),
                 denom_in: "os".to_string(),
@@ -76,6 +86,11 @@ struct Params {
     Params {
         caller: "swap_contract_address".to_string(),
         contract_balance: vec![],
+        pre_swap_out_asset_amount: Uint128::new(0),
+        offer_asset: Some(Asset::Cw20(Cw20Coin {
+            address: "neutron123".to_string(),
+            amount: Uint128::from(100u128),
+        })),
         swap_operation: SwapOperation {
                 pool: "pool_1".to_string(),
                 denom_in: "neutron123".to_string(),
@@ -104,10 +119,50 @@ struct Params {
         expected_error: None,
     };
     "Cw20 Swap Operation")]
+#[test_case(
+    Params {
+        caller: "swap_contract_address".to_string(),
+        contract_balance: vec![Coin::new(100, "os")],
+        pre_swap_out_asset_amount: Uint128::new(50),
+        offer_asset: None,
+        swap_operation: SwapOperation {
+            pool: "pool_1".to_string(),
+            denom_in: "os".to_string(),
+            denom_out: "ua".to_string(),
+            interface: None,
+        },
+        expected_message: Some(SubMsg {
+            id: 0,
+            msg: WasmMsg::Execute {
+                contract_addr: "pool_1".to_string(),
+                msg: to_json_binary(&AstroportPairExecuteMsg::Swap {
+                    offer_asset: AstroportAsset {
+                        info: AssetInfo::NativeToken {
+                            denom: "os".to_string(),
+                        },
+                        amount: Uint128::new(50),
+                    },
+                    ask_asset_info: None,
+                    belief_price: None,
+                    max_spread: Some(Decimal::percent(50)),
+                    to: None,
+                })?,
+                funds: vec![Coin::new(50, "os")],
+            }
+            .into(),
+            gas_limit: None,
+            reply_on: Never
+        }),
+        expected_error: None,
+    };
+    "Deducts pre swap out asset amount from contract balance before swap"
+)]
 #[test_case(
     Params {
         caller: "swap_contract_address".to_string(),
         contract_balance: vec![],
+        pre_swap_out_asset_amount: Uint128::new(0),
+        offer_asset: None,
         swap_operation: SwapOperation {
                 pool: "pool_1".to_string(),
                 denom_in: "os".to_string(),
@@ -122,6 +177,8 @@ struct Params {
     Params {
         caller: "swap_contract_address".to_string(),
         contract_balance: vec![],
+        pre_swap_out_asset_amount: Uint128::new(0),
+        offer_asset: None,
         swap_operation: SwapOperation {
                 pool: "pool_1".to_string(),
                 denom_in: "randomcw20".to_string(),
@@ -138,6 +195,8 @@ struct Params {
         contract_balance: vec![
             Coin::new(100, "un"),
         ],
+        pre_swap_out_asset_amount: Uint128::new(0),
+        offer_asset: Some(Asset::Native(Coin::new(100, "un"))),
         swap_operation: SwapOperation{
             pool: "".to_string(),
             denom_in: "".to_string(),
@@ -188,6 +247,8 @@ fn test_execute_astroport_pool_swap(params: Params) -> ContractResult<()> {
     let mut env = mock_env();
     env.contract.address = Addr::unchecked("swap_contract_address");
 
+    PRE_SWAP_OUT_ASSET_AMOUNT.save(&mut deps.storage, &params.pre_swap_out_asset_amount)?;
+
     // Create mock info
     let info = mock_info(&params.caller, &[]);
 
@@ -197,6 +258,7 @@ fn test_execute_astroport_pool_swap(params: Params) -> ContractResult<()> {
         env,
         info,
         ExecuteMsg::AstroportPoolSwap {
+            offer_asset: params.offer_asset,
             operation: params.swap_operation,
         },
     );

contracts/adapters/swap/astroport/tests/test_execute_receive.rs

@@ -63,6 +63,10 @@ struct Params {
                 msg: WasmMsg::Execute {
                     contract_addr: "swap_contract_address".to_string(),
                     msg: to_json_binary(&ExecuteMsg::AstroportPoolSwap {
+                        offer_asset: Some(Asset::Cw20(Cw20Coin {
+                            address: "neutron123".to_string(),
+                            amount: Uint128::from(100u128),
+                        })),
                         operation: SwapOperation {
                             pool: "pool_1".to_string(),
                             denom_in: "neutron123".to_string(),
@@ -115,6 +119,10 @@ struct Params {
                 msg: WasmMsg::Execute {
                     contract_addr: "swap_contract_address".to_string(),
                     msg: to_json_binary(&ExecuteMsg::AstroportPoolSwap {
+                        offer_asset: Some(Asset::Cw20(Cw20Coin {
+                            address: "neutron123".to_string(),
+                            amount: Uint128::from(100u128),
+                        })),
                         operation: SwapOperation {
                             pool: "pool_1".to_string(),
                             denom_in: "neutron123".to_string(),