address strategy comments

Author: nialexsan

cadence/contracts/FlowYieldVaultsStrategiesV2.cdc

@@ -72,7 +72,11 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
         }
     }
 
-    /// This strategy uses FUSDEV vault
+    /// This strategy uses FUSDEV vault (Morpho ERC4626).
+    /// Deposits collateral into a single FlowALP position, borrowing MOET as debt.
+    /// MOET is swapped to PYUSD0 and deposited into the Morpho FUSDEV ERC4626 vault.
+    /// Each strategy instance holds exactly one collateral type and one debt type (MOET).
+    /// PYUSD0 (the FUSDEV vault's underlying asset) cannot be used as collateral.
     access(all) resource FUSDEVStrategy : FlowYieldVaults.Strategy, DeFiActions.IdentifiableResource {
         /// An optional identifier allowing protocols to identify stacked connector operations by defining a protocol-
         /// specific Identifier to associated connectors on construction
@@ -85,10 +89,6 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
         /// holds the position (e.g. during YieldVault burnCallback after close).
         access(self) var positionClosed: Bool
 
-        /// @TODO on the next iteration store yieldToMoetSwapper in the resource
-        /// Swapper used to convert yield tokens back to MOET for debt repayment
-        //access(self) let yieldToMoetSwapper: {DeFiActions.Swapper}
-
         init(
             id: DeFiActions.UniqueIdentifier,
             collateralType: Type,
@@ -112,8 +112,13 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
             if self.positionClosed { return 0.0 }
             return ofToken == self.source.getSourceType() ? self.source.minimumAvailable() : 0.0
         }
-        /// Deposits up to the inner Sink's capacity from the provided authorized Vault reference
+        /// Deposits up to the inner Sink's capacity from the provided authorized Vault reference.
+        /// Only the single configured collateral type is accepted — one collateral type per position.
         access(all) fun deposit(from: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}) {
+            pre {
+                from.getType() == self.sink.getSinkType():
+                    "FUSDEVStrategy position only accepts \(self.sink.getSinkType().identifier) as collateral, got \(from.getType().identifier)"
+            }
             self.sink.depositCapacity(from: from)
         }
         /// Withdraws up to the max amount, returning the withdrawn Vault. If the requested token type is unsupported,
@@ -147,7 +152,13 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
             // Step 1: Get debt amounts - returns {Type: UFix64} dictionary
             let debtsByType = self.position.getTotalDebt()
 
-            // Step 2: Calculate total debt amount across all debt types
+            // Enforce: one debt type per position
+            assert(
+                debtsByType.length <= 1,
+                message: "FUSDEVStrategy position must have at most one debt type, found \(debtsByType.length)"
+            )
+
+            // Step 2: Calculate total debt amount
             var totalDebtAmount: UFix64 = 0.0
             for debtAmount in debtsByType.values {
                 totalDebtAmount = totalDebtAmount + debtAmount
@@ -158,9 +169,16 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
                 let resultVaults <- self.position.closePosition(
                     repaymentSources: []
                 )
-                // Extract the first vault (should be collateral)
-                assert(resultVaults.length > 0, message: "No vaults returned from closePosition")
-                let collateralVault <- resultVaults.removeFirst()
+                // With one collateral type and no debt the pool returns at most one vault.
+                // Zero vaults is possible when the collateral balance is dust that rounds down
+                // to zero (e.g. drawDownSink had no capacity, or token reserves were empty).
+                assert(
+                    resultVaults.length <= 1,
+                    message: "Expected 0 or 1 collateral vault from closePosition, got \(resultVaults.length)"
+                )
+                let collateralVault <- resultVaults.length == 1
+                    ? resultVaults.removeFirst()
+                    : <- DeFiActionsUtils.getEmptyVault(collateralType)
                 destroy resultVaults
                 self.positionClosed = true
                 return <- collateralVault
@@ -187,30 +205,27 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
             // Step 7: Close position - pool pulls exactly the debt amount from moetSource
             let resultVaults <- self.position.closePosition(repaymentSources: [moetSource])
 
-            // Extract all returned vaults
-            assert(resultVaults.length > 0, message: "No vaults returned from closePosition")
+            // With one collateral type and one debt type, the pool returns at most two vaults:
+            // the collateral vault and optionally a MOET overpayment dust vault.
+            assert(
+                resultVaults.length >= 1 && resultVaults.length <= 2,
+                message: "Expected 1 or 2 vaults from closePosition, got \(resultVaults.length)"
+            )
 
-            // First vault should be collateral
             var collateralVault <- resultVaults.removeFirst()
+            assert(
+                collateralVault.getType() == collateralType,
+                message: "First vault returned from closePosition must be collateral (\(collateralType.identifier)), got \(collateralVault.getType().identifier)"
+            )
 
-            // Handle any overpayment dust (MOET) by swapping back to collateral
+            // Handle any overpayment dust (MOET) returned as the second vault
             while resultVaults.length > 0 {
                 let dustVault <- resultVaults.removeFirst()
                 if dustVault.balance > 0.0 {
                     if dustVault.getType() == collateralType {
                         collateralVault.deposit(from: <-dustVault)
                     } else {
                         // @TODO implement swapping moet to collateral
-
-                        // // Swap overpayment back to collateral using configured swapper
-                        // let moetToCollateralSwapperKey = FlowYieldVaultsStrategiesV2.getMoetToCollateralSwapperConfigKey(self.id()!)
-                        // let dustToCollateralSwapper = FlowYieldVaultsStrategiesV2.config[moetToCollateralSwapperKey] as! {DeFiActions.Swapper}?
-                        //     ?? panic("No MOET→collateral swapper found for strategy \(self.id()!)")
-                        // let swappedCollateral <- dustToCollateralSwapper.swap(
-                        //     quote: nil,
-                        //     inVault: <-dustVault
-                        // )
-                        // collateralVault.deposit(from: <-swappedCollateral)
                         destroy dustVault
                     }
                 } else {

cadence/contracts/mocks/MockStrategies.cdc

@@ -130,88 +130,39 @@ access(all) contract MockStrategies {
             let ytSource = FlowYieldVaultsAutoBalancers.createExternalSource(id: self.id()!)
                 ?? panic("Could not create external source from AutoBalancer")
 
-            // Step 5: Withdraw ALL available YT from AutoBalancer to avoid losing funds when Strategy is destroyed
-            let availableYt = ytSource.minimumAvailable()
-            let totalYtVault <- ytSource.withdrawAvailable(maxAmount: availableYt)
-            let totalYtAmount = totalYtVault.balance
-
-            // Step 6: Create YT→MOET swapper
-            let ytToMoetSwapper = MockSwapper.Swapper(
-                inVault: Type<@YieldToken.Vault>(),
-                outVault: Type<@MOET.Vault>(),
-                uniqueID: self.copyID()!
-            )
-
-            // Step 7: Calculate how much MOET we can get from the available YT
-            // Use quoteOut to see how much MOET we'll get from all available YT
-            let ytQuote = ytToMoetSwapper.quoteOut(forProvided: totalYtAmount, reverse: false)
-            let estimatedMoetFromYt = ytQuote.outAmount
-
-            // Step 8: Swap ALL YT to MOET to see how much we can cover
-            var moetVault <- ytToMoetSwapper.swap(quote: ytQuote, inVault: <-totalYtVault)
-            let moetFromYt = moetVault.balance
-
-            // Step 8: If YT didn't cover full debt, withdraw collateral to make up shortfall
-            if moetFromYt < totalDebtAmount {
-                let shortfall = totalDebtAmount - moetFromYt
-
-                // Create collateral→MOET swapper to convert collateral for debt repayment
-                let collateralToMoetSwapper = MockSwapper.Swapper(
-                    inVault: collateralType,
-                    outVault: Type<@MOET.Vault>(),
+            // Step 5: Build one SwapSource per debt type, each drawing from the AutoBalancer's YT.
+            // ytSource is a struct (capability-backed), so each copy references the same underlying vault.
+            // The pool drains each source sequentially to repay each debt type.
+            var repaymentSources: [{DeFiActions.Source}] = []
+            for debtType in debtsByType.keys {
+                let ytToDebtSwapper = MockSwapper.Swapper(
+                    inVault: Type<@YieldToken.Vault>(),
+                    outVault: debtType,
                     uniqueID: self.copyID()!
                 )
-
-                // Calculate how much collateral we need to cover the shortfall
-                let collateralQuote = collateralToMoetSwapper.quoteIn(
-                    forDesired: shortfall,
-                    reverse: false
-                )
-
-                // Withdraw collateral from position to cover shortfall
-                let collateralForDebt <- self.source.withdrawAvailable(maxAmount: collateralQuote.inAmount)
-
-                // Swap collateral to MOET and add to repayment vault
-                let additionalMoet <- collateralToMoetSwapper.swap(
-                    quote: collateralQuote,
-                    inVault: <-collateralForDebt
-                )
-                moetVault.deposit(from: <-additionalMoet)
+                repaymentSources.append(SwapConnectors.SwapSource(swapper: ytToDebtSwapper, source: ytSource, uniqueID: nil))
             }
 
-            // Step 9: Store MOET vault temporarily and create a VaultSource for closePosition.
-            // closePosition now takes [{DeFiActions.Source}] instead of @[{FungibleToken.Vault}].
-            let tempPath = StoragePath(identifier: "mockClosePositionMoet_\(self.uuid)")!
-            MockStrategies.account.storage.save(<-(moetVault as! @MOET.Vault), to: tempPath)
-            let moetCap = MockStrategies.account.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(tempPath)
-            let moetSource = FungibleTokenConnectors.VaultSource(min: nil, withdrawVault: moetCap, uniqueID: nil)
-
-            // Step 10: Close position - pool pulls exactly the debt amount from moetSource
-            let resultVaults <- self.position.closePosition(repaymentSources: [moetSource])
+            // Step 6: Close position - pool pulls each debt type's amount from its corresponding SwapSource
+            let resultVaults <- self.position.closePosition(repaymentSources: repaymentSources)
 
-            // Step 11: Recover any MOET not consumed by repayment from temp storage
-            let remainingMoet <- MockStrategies.account.storage.load<@MOET.Vault>(from: tempPath)!
-
-            // Extract all returned vaults
+            // Step 7: Extract collateral vault (first returned vault)
             assert(resultVaults.length > 0, message: "No vaults returned from closePosition")
-
-            // First vault should be collateral
             var collateralVault <- resultVaults.removeFirst()
 
-            // Swap any remaining MOET (not consumed by repayment) back to collateral
-            if remainingMoet.balance > 0.0 {
-                let moetToCollateralSwapper = MockSwapper.Swapper(
-                    inVault: Type<@MOET.Vault>(),
+            // Step 8: Recover any remaining YT from the AutoBalancer and swap back to collateral
+            let remainingYtAmount = ytSource.minimumAvailable()
+            if remainingYtAmount > 0.0 {
+                let remainingYt <- ytSource.withdrawAvailable(maxAmount: remainingYtAmount)
+                let ytToCollateralSwapper = MockSwapper.Swapper(
+                    inVault: Type<@YieldToken.Vault>(),
                     outVault: collateralType,
                     uniqueID: self.copyID()!
                 )
-                let swappedCollateral <- moetToCollateralSwapper.swap(quote: nil, inVault: <-remainingMoet)
-                collateralVault.deposit(from: <-swappedCollateral)
-            } else {
-                destroy remainingMoet
+                collateralVault.deposit(from: <-ytToCollateralSwapper.swap(quote: nil, inVault: <-remainingYt))
             }
 
-            // Handle any additional vaults in resultVaults (e.g., overpayment credits) by swapping back to collateral
+            // Step 9: Handle any additional vaults returned by closePosition (overpayments) by swapping to collateral
             while resultVaults.length > 0 {
                 let dustVault <- resultVaults.removeFirst()
                 if dustVault.balance > 0.0 && dustVault.getType() != collateralType {
@@ -220,11 +171,7 @@ access(all) contract MockStrategies {
                         outVault: collateralType,
                         uniqueID: self.copyID()!
                     )
-                    let swappedCollateral <- dustToCollateralSwapper.swap(
-                        quote: nil,
-                        inVault: <-dustVault
-                    )
-                    collateralVault.deposit(from: <-swappedCollateral)
+                    collateralVault.deposit(from: <-dustToCollateralSwapper.swap(quote: nil, inVault: <-dustVault))
                 } else {
                     destroy dustVault
                 }