Merge branch 'djeck1432:main' into zklend-liquidation-research

emarc99 · web-flow · commit 436714613680 · 2025-01-02T19:46:28.000+01:00
diff --git a/src/deposit.cairo b/src/deposit.cairo
@@ -1,6 +1,8 @@
 #[starknet::contract]
 mod Deposit {
-    use alexandria_math::fast_power::fast_power;
+    use openzeppelin::access::ownable::interface::OwnableTwoStepABI;
+use super::super::interfaces::IVaultDispatcherTrait;
+use alexandria_math::fast_power::fast_power;
     use core::num::traits::Zero;
 
     use ekubo::{
@@ -17,11 +19,11 @@ mod Deposit {
         constants::{ZK_SCALE_DECIMALS, STRK_ADDRESS},
         interfaces::{
             IMarketDispatcher, IMarketDispatcherTrait, IAirdropDispatcher, IAirdropDispatcherTrait,
-            IDeposit
+            IDeposit, IVaultDispatcher
         },
         types::{
             SwapData, SwapResult, DepositData, Claim, EkuboSlippageLimits, TokenAmount, TokenPrice,
-            DecimalScale
+            DecimalScale, VaultRepayData
         }
     };
 
@@ -172,6 +174,31 @@ mod Deposit {
                 self.ekubo_core.read(), @swap_data
             )
         }
+        fn repay_vaults(ref self: ContractState, supply_token: ContractAddress, vaults: Span<VaultRepayData>){
+            let zk_market = self.zk_market.read();
+            let contract_address = get_contract_address();
+            let owner = self.owner();
+
+            for vault in vaults {
+                let vault_disp = IVaultDispatcher{contract_address: (*vault).vault};
+                let vault_token = vault_disp.get_vault_token();
+                if vault_token == supply_token {
+                    continue;
+                }
+                let mut amount = (*vault).amount;
+                let token_disp = ERC20ABIDispatcher { contract_address: vault_token };
+
+                if amount == 0 {
+                    zk_market.withdraw_all(vault_token);
+                    amount = token_disp.balanceOf(contract_address);
+                } else {
+                    zk_market.withdraw(vault_token, amount.try_into().unwrap());
+                }
+
+                token_disp.approve((*vault).vault, amount);
+                vault_disp.return_liquidity(owner, amount);
+            }
+        }
     }
 
     #[abi(embed_v0)]
@@ -316,6 +343,7 @@ mod Deposit {
         /// * `repay_const`: u8 - Sets how much to borrow from free amount.
         /// * `supply_price`: TokenPrice - Price of `supply` token in terms of `debt` token.
         /// * `debt_price`: TokenPrice - Price of `debt` token in terms of `supply` token.
+        /// * `repay_vaults`: Span<VaultRepayData> - Vaults that need to be repaid.
         fn close_position(
             ref self: ContractState,
             supply_token: ContractAddress,
@@ -324,7 +352,8 @@ mod Deposit {
             ekubo_limits: EkuboSlippageLimits,
             borrow_portion_percent: u8,
             supply_price: TokenPrice,
-            debt_price: TokenPrice
+            debt_price: TokenPrice,
+            repay_vaults: Span<VaultRepayData>
         ) {
             assert(
                 get_tx_info().unbox().account_contract_address == self.ownable.owner(),
@@ -418,6 +447,7 @@ mod Deposit {
             };
             zk_market.withdraw_all(supply_token);
             zk_market.disable_collateral(supply_token);
+            self.repay_vaults(supply_token, repay_vaults);
             self.is_position_open.write(false);
             let withdrawn_amount = token_disp.balanceOf(contract_address);
             token_disp.transfer(self.ownable.owner(), withdrawn_amount);
diff --git a/src/interfaces.cairo b/src/interfaces.cairo
@@ -1,6 +1,6 @@
 use ekubo::types::keys::PoolKey;
 use spotnet::types::{
-    MarketReserveData, DepositData, Claim, EkuboSlippageLimits, TokenPrice, TokenAmount
+    MarketReserveData, DepositData, Claim, EkuboSlippageLimits, TokenPrice, TokenAmount, VaultRepayData
 };
 use starknet::ContractAddress;
 
@@ -22,7 +22,8 @@ pub trait IDeposit<TContractState> {
         ekubo_limits: EkuboSlippageLimits,
         borrow_portion_percent: u8,
         supply_price: TokenPrice,
-        debt_price: TokenPrice
+        debt_price: TokenPrice,
+        repay_vaults: Span<VaultRepayData>
     );
 
     fn claim_reward(
@@ -72,5 +73,7 @@ pub trait IVault<TContractState> {
         user: ContractAddress,
         amount: TokenAmount
     );
+    fn return_liquidity(ref self: TContractState, user: ContractAddress, amount: TokenAmount);
+    fn get_vault_token(self: @TContractState) -> ContractAddress;
 }
 
diff --git a/src/mocks/erc20_mock.cairo b/src/mocks/erc20_mock.cairo
@@ -1,6 +1,6 @@
 #[starknet::contract]
 pub mod SnakeERC20Mock {
-    use openzeppelin_token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use openzeppelin::token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
     use starknet::ContractAddress;
 
     component!(path: ERC20Component, storage: erc20, event: ERC20Event);
diff --git a/src/types.cairo b/src/types.cairo
@@ -38,6 +38,12 @@ pub struct Claim {
     pub amount: u128
 }
 
+#[derive(Copy, Drop, Serde)]
+pub struct VaultRepayData {
+    pub vault: ContractAddress,
+    pub amount: TokenAmount
+}
+
 #[derive(Drop, Serde, starknet::Store)]
 pub struct MarketReserveData {
     pub enabled: bool,
diff --git a/src/vault.cairo b/src/vault.cairo
@@ -47,7 +47,8 @@ mod Vault {
         LiquidityAdded: LiquidityAdded,
         LiquidityWithdrawn: LiquidityWithdrawn,
         ContractAdded: ContractAdded,
-        PositionProtected: PositionProtected
+        PositionProtected: PositionProtected,
+        LiquidityReturned: LiquidityReturned
     }
 
     #[derive(Drop, starknet::Event)]
@@ -89,6 +90,15 @@ mod Vault {
         amount: TokenAmount,
     }
 
+    #[derive(Drop, starknet::Event)]
+    struct LiquidityReturned {
+        #[key]
+        user: ContractAddress,
+        #[key]
+        token: ContractAddress,
+        amount: TokenAmount,
+    }
+
 
     #[constructor]
     fn constructor(ref self: ContractState, owner: ContractAddress, token: ContractAddress) {
@@ -251,5 +261,36 @@ mod Vault {
 
             self.emit(PositionProtected { token, deposit_contract, contract_owner: user, amount });
         }
+
+        /// Return liquidity from the vault by transferring tokens to the user.
+        ///
+        /// # Arguments
+        ///
+        /// * `user` - The address of the recipient
+        /// * `amount` - The amount of tokens to send from the vault
+        ///
+        /// # Events
+        ///
+        /// Emits a `LiquidityReturned` event with:
+        /// * `user` - The address of the recipient
+        /// * `token` - The address of the token
+        /// * `amount` - The amount of tokens that send from the vault
+        fn return_liquidity(ref self: ContractState, user: ContractAddress, amount: TokenAmount){
+            let token = self.token.read();
+            let current_amount = self.amounts.entry(user).read();
+
+            // update new amount
+            self.amounts.entry(user).write(current_amount + amount);
+
+            // transfer token to user
+            IERC20Dispatcher { contract_address: token }.transfer_from(get_caller_address(), user, amount);
+
+            self.emit(LiquidityReturned { user, token, amount });
+        }
+
+        /// Returns the token address stored in the vault
+        fn get_vault_token(self: @ContractState) -> ContractAddress {
+            return self.token.read();
+        }
     }
 }
diff --git a/tests/test_defispring.cairo b/tests/test_defispring.cairo
@@ -1,4 +1,4 @@
-use openzeppelin_token::erc20::interface::{ERC20ABIDispatcher, ERC20ABIDispatcherTrait};
+use openzeppelin::token::erc20::interface::{ERC20ABIDispatcher, ERC20ABIDispatcherTrait};
 use snforge_std::{
     declare, DeclareResultTrait, replace_bytecode, store, cheat_account_contract_address, CheatSpan
 };
diff --git a/tests/test_loop.cairo b/tests/test_loop.cairo
@@ -15,17 +15,23 @@ use snforge_std::cheatcodes::execution_info::block_timestamp::{
 use snforge_std::cheatcodes::execution_info::caller_address::{
     start_cheat_caller_address, stop_cheat_caller_address
 };
-use spotnet::constants::ZK_SCALE_DECIMALS;
+use spotnet::constants::{ZK_SCALE_DECIMALS, STRK_ADDRESS};
 use spotnet::interfaces::{
     IDepositDispatcher, IDepositSafeDispatcher, IDepositSafeDispatcherTrait, IDepositDispatcherTrait
 };
-use spotnet::types::DepositData;
+use spotnet::types::{DepositData, VaultRepayData};
 
 use starknet::{ContractAddress, get_block_timestamp};
 use super::constants::{contracts, tokens, HYPOTHETICAL_OWNER_ADDR, pool_key};
 
 use super::interfaces::{IMarketTestingDispatcher, IMarketTestingDispatcherTrait};
-use super::utils::{deploy_deposit_contract, get_asset_price_pragma, get_slippage_limits};
+use super::utils::{
+    deploy_deposit_contract, 
+    get_asset_price_pragma, 
+    get_slippage_limits, 
+    setup_test_suite,
+    assert_vault_amount_bigger_than_zero
+};
 
 fn get_deposit_dispatcher(user: ContractAddress) -> IDepositDispatcher {
     IDepositDispatcher { contract_address: deploy_deposit_contract(user) }
@@ -375,7 +381,8 @@ fn test_close_position_usdc_valid_time_passed() {
             get_slippage_limits(pool_key),
             95,
             pool_price,
-            quote_token_price
+            quote_token_price,
+            [].span()
         );
 
     stop_cheat_block_timestamp(contracts::ZKLEND_MARKET.try_into().unwrap());
@@ -432,7 +439,8 @@ fn test_close_position_amounts_cleared() {
             get_slippage_limits(pool_key),
             95,
             pool_price.try_into().unwrap(),
-            quote_token_price
+            quote_token_price,
+            [].span()
         );
     stop_cheat_account_contract_address(deposit_disp.contract_address);
     let zk_market = IMarketTestingDispatcher {
@@ -506,7 +514,8 @@ fn test_close_position_partial_debt_utilization() {
             get_slippage_limits(pool_key),
             95,
             pool_price,
-            quote_token_price
+            quote_token_price,
+            [].span()
         );
     stop_cheat_account_contract_address(deposit_disp.contract_address);
     let zk_market = IMarketTestingDispatcher {
@@ -662,7 +671,8 @@ fn test_extra_deposit_supply_token_close_position_fuzz(extra_amount: u32) {
             get_slippage_limits(pool_key),
             95,
             pool_price,
-            quote_token_price.try_into().unwrap()
+            quote_token_price.try_into().unwrap(),
+            [].span()
         );
     stop_cheat_account_contract_address(deposit_disp.contract_address);
 
@@ -742,7 +752,8 @@ fn test_withdraw_valid_fuzz(amount: u32) {
             get_slippage_limits(pool_key),
             95,
             pool_price,
-            quote_token_price
+            quote_token_price,
+            [].span()
         );
     stop_cheat_account_contract_address(deposit_disp.contract_address);
 
@@ -920,3 +931,96 @@ fn test_transfer_renounced_ownership() {
 
     assert(ownable_disp.owner() == new_owner, 'Owner did not change');
 }
+
+#[test]
+#[fork("MAINNET")]
+fn test_repay_vaults_in_close_position(){
+    let usdc_addr: ContractAddress = tokens::USDC.try_into().unwrap();
+    let eth_addr: ContractAddress = tokens::ETH.try_into().unwrap();
+    let strk_addr: ContractAddress = STRK_ADDRESS.try_into().unwrap();
+    let user: ContractAddress = HYPOTHETICAL_OWNER_ADDR.try_into().unwrap();
+    let amount = 1000000;
+
+    let repay_vaults = array![
+        // First will be skip in repay_vaults, because usdc_addr == supply_token
+        VaultRepayData{vault: setup_test_suite(user, usdc_addr).vault.contract_address, amount},
+        VaultRepayData{vault: setup_test_suite(user, eth_addr).vault.contract_address, amount},
+        VaultRepayData{vault: setup_test_suite(user, strk_addr).vault.contract_address, amount}
+    ];
+    
+    let pool_key = PoolKey {
+        token0: eth_addr,
+        token1: usdc_addr,
+        fee: pool_key::FEE,
+        tick_spacing: pool_key::TICK_SPACING,
+        extension: pool_key::EXTENSION.try_into().unwrap()
+    };
+    let quote_token_price = get_asset_price_pragma('ETH/USD').into();
+
+    let usdc_token_disp = ERC20ABIDispatcher { contract_address: usdc_addr };
+    let eth_token_disp = ERC20ABIDispatcher { contract_address: eth_addr };
+    let strk_token_disp = ERC20ABIDispatcher { contract_address: strk_addr };
+
+    let decimals_sum_power: u128 = fast_power(
+        10,
+        (eth_token_disp.decimals() + usdc_token_disp.decimals())
+            .into()
+    );
+    let pool_price = ((1
+        * ZK_SCALE_DECIMALS
+        * decimals_sum_power.into()
+        / get_asset_price_pragma('ETH/USD').into())
+        / ZK_SCALE_DECIMALS)
+        .try_into()
+        .unwrap();
+
+    let deposit_disp = get_deposit_dispatcher(user);
+    let borrow_portion_percent = 90;
+    let multiplier = 35;
+    let limits = get_slippage_limits(pool_key);
+
+    start_cheat_caller_address(usdc_addr, user);
+    usdc_token_disp.approve(deposit_disp.contract_address, amount);
+    stop_cheat_caller_address(usdc_addr);
+
+    start_cheat_caller_address(strk_addr, user);
+    strk_token_disp.approve(deposit_disp.contract_address, amount);
+    stop_cheat_caller_address(strk_addr);
+
+    start_cheat_caller_address(eth_addr, user);
+    eth_token_disp.approve(deposit_disp.contract_address, amount);
+    stop_cheat_caller_address(eth_addr);
+
+    start_cheat_account_contract_address(deposit_disp.contract_address, user);
+    deposit_disp
+        .loop_liquidity(
+            DepositData {
+                token: usdc_addr, amount, 
+                multiplier, borrow_portion_percent
+            },
+            pool_key, limits, pool_price
+        );
+    stop_cheat_account_contract_address(deposit_disp.contract_address);
+
+    start_cheat_caller_address(deposit_disp.contract_address, user);
+    deposit_disp.extra_deposit(strk_addr, amount);
+    deposit_disp.extra_deposit(eth_addr, amount);
+    stop_cheat_caller_address(deposit_disp.contract_address);
+
+    start_cheat_account_contract_address(deposit_disp.contract_address, user);
+    start_cheat_block_timestamp(
+        contracts::ZKLEND_MARKET.try_into().unwrap(), get_block_timestamp() + 40000000
+    );
+    deposit_disp
+        .close_position(
+            usdc_addr, eth_addr, pool_key, limits,
+            borrow_portion_percent, pool_price, quote_token_price,
+            repay_vaults.span()
+        );
+    stop_cheat_block_timestamp(contracts::ZKLEND_MARKET.try_into().unwrap());
+    stop_cheat_account_contract_address(deposit_disp.contract_address);
+
+    for vault in repay_vaults {
+        assert_vault_amount_bigger_than_zero(vault.vault, user);
+    }
+}
diff --git a/tests/test_vault.cairo b/tests/test_vault.cairo
diff --git a/tests/utils.cairo b/tests/utils.cairo

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use openzeppelin_token::erc20::interface::{ERC20ABIDispatcher, ERC20ABIDispatcherTrait};`
	`1`	`+use openzeppelin::token::erc20::interface::{ERC20ABIDispatcher, ERC20ABIDispatcherTrait};`
`2`	`2`	`use snforge_std::{`
`3`	`3`	`declare, DeclareResultTrait, replace_bytecode, store, cheat_account_contract_address, CheatSpan`
`4`	`4`	`};`