close position from strategies

cadence/contracts/FlowYieldVaults.cdc

@@ -105,6 +105,10 @@ access(all) contract FlowYieldVaults {
                 "Invalid Vault returns - requests \(ofToken.identifier) but returned \(result.getType().identifier)"
             }
         }
+        /// Closes the underlying position by repaying all debt and returning all collateral.
+        /// This method uses the AutoBalancer as a repayment source to swap yield tokens to debt tokens as needed.
+        /// Returns a Vault containing all collateral including any dust residuals.
+        access(FungibleToken.Withdraw) fun closePosition(collateralType: Type): @{FungibleToken.Vault}
     }
 
     /// StrategyComposer
@@ -340,6 +344,23 @@ access(all) contract FlowYieldVaults {
 
             return <- res
         }
+        /// Closes the YieldVault by repaying all debt on the underlying position and returning all collateral.
+        /// This method properly closes the FlowALP position by using the AutoBalancer to swap yield tokens
+        /// to MOET for debt repayment, then returns all collateral including any dust residuals.
+        access(FungibleToken.Withdraw) fun close(): @{FungibleToken.Vault} {
+            let collateral <- self._borrowStrategy().closePosition(collateralType: self.vaultType)
+
+            emit WithdrawnFromYieldVault(
+                id: self.uniqueID.id,
+                strategyType: self.getStrategyType(),
+                tokenType: collateral.getType().identifier,
+                amount: collateral.balance,
+                owner: self.owner?.address,
+                toUUID: collateral.uuid
+            )
+
+            return <- collateral
+        }
         /// Returns an authorized reference to the encapsulated Strategy
         access(self) view fun _borrowStrategy(): auth(FungibleToken.Withdraw) &{Strategy} {
             return &self.strategy as auth(FungibleToken.Withdraw) &{Strategy}?
@@ -465,16 +486,17 @@ access(all) contract FlowYieldVaults {
             let yieldVault = (&self.yieldVaults[id] as auth(FungibleToken.Withdraw) &YieldVault?)!
             return <- yieldVault.withdraw(amount: amount)
         }
-        /// Withdraws and returns all available funds from the specified YieldVault, destroying the YieldVault and access to any
-        /// Strategy-related wiring with it
+        /// Closes the YieldVault by repaying all debt and returning all collateral, then destroys the YieldVault.
+        /// This properly closes the underlying FlowALP position by using the AutoBalancer to swap yield tokens
+        /// to MOET for debt repayment, ensuring all collateral (including dust) is returned to the caller.
         access(FungibleToken.Withdraw) fun closeYieldVault(_ id: UInt64): @{FungibleToken.Vault} {
             pre {
                 self.yieldVaults[id] != nil:
                 "No YieldVault with ID \(id) found"
             }
 
             let yieldVault <- self._withdrawYieldVault(id: id)
-            let res <- yieldVault.withdraw(amount: yieldVault.getYieldVaultBalance())
+            let res <- yieldVault.close()
             Burner.burn(<-yieldVault)
             return <-res
         }

cadence/contracts/FlowYieldVaultsAutoBalancers.cdc

@@ -44,6 +44,20 @@ access(all) contract FlowYieldVaultsAutoBalancers {
         return self.account.capabilities.borrow<&DeFiActions.AutoBalancer>(publicPath)
     }
 
+    /// Creates a source from an AutoBalancer for external use (e.g., position close operations).
+    /// This allows bypassing position topUpSource to avoid circular dependency issues.
+    ///
+    /// @param id: The yield vault/AutoBalancer ID
+    /// @return Source that can withdraw from the AutoBalancer, or nil if not found
+    ///
+    access(account) fun createExternalSource(id: UInt64): {DeFiActions.Source}? {
+        let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
+        if let autoBalancer = self.account.storage.borrow<auth(DeFiActions.Get) &DeFiActions.AutoBalancer>(from: storagePath) {
+            return autoBalancer.createBalancerSource()
+        }
+        return nil
+    }
+
     /// Checks if an AutoBalancer has at least one active (Scheduled) transaction.
     /// Used by Supervisor to detect stuck yield vaults that need recovery.
     ///

cadence/contracts/FlowYieldVaultsStrategiesV2.cdc

@@ -42,7 +42,7 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
     access(all) let univ3RouterEVMAddress: EVM.EVMAddress
     access(all) let univ3QuoterEVMAddress: EVM.EVMAddress
 
-    access(all) let config: {String: AnyStruct} 
+    access(all) let config: {String: AnyStruct}
 
     /// Canonical StoragePath where the StrategyComposerIssuer should be stored
     access(all) let IssuerStoragePath: StoragePath
@@ -80,11 +80,24 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
         access(self) let position: @FlowALPv0.Position
         access(self) var sink: {DeFiActions.Sink}
         access(self) var source: {DeFiActions.Source}
+        /// Tracks whether the underlying FlowALP position has been closed. Once true,
+        /// availableBalance() returns 0.0 to avoid panicking when the pool no longer
+        /// holds the position (e.g. during YieldVault burnCallback after close).
+        access(self) var positionClosed: Bool
 
-        init(id: DeFiActions.UniqueIdentifier, collateralType: Type, position: @FlowALPv0.Position) {
+        /// @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,
+            position: @FlowALPv0.Position
+        ) {
             self.uniqueID = id
             self.sink = position.createSink(type: collateralType)
             self.source = position.createSourceWithOptions(type: collateralType, pullFromTopUpSource: true)
+            self.positionClosed = false
             self.position <-position
         }
 
@@ -96,6 +109,7 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
         }
         /// Returns the amount available for withdrawal via the inner Source
         access(all) fun availableBalance(ofToken: Type): UFix64 {
+            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
@@ -110,6 +124,104 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
             }
             return <- self.source.withdrawAvailable(maxAmount: maxAmount)
         }
+        /// Closes the underlying FlowALP position by preparing repayment funds and closing with them.
+        ///
+        /// This method:
+        /// 1. Calculates debt amount from position
+        /// 2. Creates external yield token source from AutoBalancer
+        /// 3. Swaps yield tokens → MOET via stored swapper
+        /// 4. Closes position with prepared MOET vault
+        ///
+        /// This approach eliminates circular dependencies by preparing all funds externally
+        /// before calling the position's close method.
+        ///
+        access(FungibleToken.Withdraw) fun closePosition(collateralType: Type): @{FungibleToken.Vault} {
+            pre {
+                self.isSupportedCollateralType(collateralType):
+                "Unsupported collateral type \(collateralType.identifier)"
+            }
+            post {
+                result.getType() == collateralType: "Withdraw Vault (\(result.getType().identifier)) is not of a requested collateral type (\(collateralType.identifier))"
+            }
+
+            // Step 1: Get debt amounts - returns {Type: UFix64} dictionary
+            let debtsByType = self.position.getTotalDebt()
+
+            // Step 2: Calculate total debt amount across all debt types
+            var totalDebtAmount: UFix64 = 0.0
+            for debtAmount in debtsByType.values {
+                totalDebtAmount = totalDebtAmount + debtAmount
+            }
+
+            // Step 3: If no debt, close with empty sources array
+            if totalDebtAmount == 0.0 {
+                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()
+                destroy resultVaults
+                self.positionClosed = true
+                return <- collateralVault
+            }
+
+            // Step 4: Create external yield token source from AutoBalancer
+            let yieldTokenSource = FlowYieldVaultsAutoBalancers.createExternalSource(id: self.id()!)
+                ?? panic("Could not create external source from AutoBalancer")
+
+            // Step 5: Retrieve yield→MOET swapper from contract config
+            let swapperKey = FlowYieldVaultsStrategiesV2.getYieldToMoetSwapperConfigKey(self.uniqueID)!
+            let yieldToMoetSwapper = FlowYieldVaultsStrategiesV2.config[swapperKey] as! {DeFiActions.Swapper}?
+                ?? panic("No yield→MOET swapper found for strategy \(self.id()!)")
+
+            // Step 6: Create a SwapSource that converts yield tokens to MOET when pulled by closePosition.
+            // The pool will call source.withdrawAvailable(maxAmount: debtAmount) which internally uses
+            // quoteIn(forDesired: debtAmount) to compute the exact yield token input needed.
+            let moetSource = SwapConnectors.SwapSource(
+                swapper: yieldToMoetSwapper,
+                source: yieldTokenSource,
+                uniqueID: self.copyID()
+            )
+
+            // 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")
+
+            // First vault should be collateral
+            var collateralVault <- resultVaults.removeFirst()
+
+            // Handle any overpayment dust (MOET) by swapping back to collateral
+            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 {
+                    destroy dustVault
+                }
+            }
+
+            destroy resultVaults
+            self.positionClosed = true
+            return <- collateralVault
+        }
         /// Executed when a Strategy is burned, cleaning up the Strategy's stored AutoBalancer
         access(contract) fun burnCallback() {
             FlowYieldVaultsAutoBalancers._cleanupAutoBalancer(id: self.id()!)
@@ -301,9 +413,48 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
                 uniqueID: uniqueID
             )
 
+            // Create Position source with CONSERVATIVE settings
+            // pullFromTopUpSource: false ensures Position maintains health buffer
+            // This prevents Position from being pushed to minHealth (1.1) limit
+            let positionSource = position.createSourceWithOptions(
+                type: collateralType,
+                pullFromTopUpSource: false  // ← CONSERVATIVE: maintain safety buffer
+            )
+
+            // Create Collateral -> Yield swapper (reverse of yieldToCollateralSwapper)
+            // Allows AutoBalancer to pull collateral, swap to yield token
+            let collateralToYieldSwapper = self._createCollateralToYieldSwapper(
+                collateralConfig: collateralConfig,
+                yieldTokenEVMAddress: tokens.yieldTokenEVMAddress,
+                yieldTokenType: tokens.yieldTokenType,
+                collateralType: collateralType,
+                uniqueID: uniqueID
+            )
+
+            // Create Position swap source for AutoBalancer deficit recovery
+            // When AutoBalancer value drops below deposits, pulls collateral from Position
+            let positionSwapSource = SwapConnectors.SwapSource(
+                swapper: collateralToYieldSwapper,
+                source: positionSource,
+                uniqueID: uniqueID
+            )
+
             // Set AutoBalancer sink for overflow -> recollateralize
             balancerIO.autoBalancer.setSink(positionSwapSink, updateSinkID: true)
 
+            // Set AutoBalancer source for deficit recovery -> pull from Position
+            // CONSERVATIVE: pullFromTopUpSource=false means Position maintains health buffer
+            balancerIO.autoBalancer.setSource(positionSwapSource, updateSourceID: true)
+
+            // Store yield→MOET swapper in contract config for later access during closePosition
+            let yieldToMoetSwapperKey = FlowYieldVaultsStrategiesV2.getYieldToMoetSwapperConfigKey(uniqueID)!
+            FlowYieldVaultsStrategiesV2.config[yieldToMoetSwapperKey] = yieldToMoetSwapper
+
+            // @TODO implement moet to collateral swapper
+            // let moetToCollateralSwapperKey = FlowYieldVaultsStrategiesV2.getMoetToCollateralSwapperConfigKey(uniqueID)
+            //
+            // FlowYieldVaultsStrategiesV2.config[moetToCollateralSwapperKey] = moetToCollateralSwapper
+            //
             switch type {
             case Type<@FUSDEVStrategy>():
                 return <-create FUSDEVStrategy(
@@ -514,6 +665,16 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
             }
         }
 
+        /// @TODO
+        /// implement moet to collateral swapper
+        // access(self) fun _createMoetToCollateralSwapper(
+        //     strategyType: Type,
+        //     tokens: FlowYieldVaultsStrategiesV2.TokenBundle,
+        //     uniqueID: DeFiActions.UniqueIdentifier
+        // ): SwapConnectors.MultiSwapper {
+        //     // Direct MOET -> underlying via AMM
+        // }
+
         access(self) fun _initAutoBalancerAndIO(
             oracle: {DeFiActions.PriceOracle},
             yieldTokenType: Type,
@@ -595,6 +756,50 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
                 uniqueID: uniqueID
             )
         }
+
+        /// Creates a Collateral -> Yield token swapper using UniswapV3
+        /// This is the REVERSE of _createYieldToCollateralSwapper
+        /// Used by AutoBalancer to pull collateral from Position and swap to yield tokens
+        ///
+        access(self) fun _createCollateralToYieldSwapper(
+            collateralConfig: FlowYieldVaultsStrategiesV2.CollateralConfig,
+            yieldTokenEVMAddress: EVM.EVMAddress,
+            yieldTokenType: Type,
+            collateralType: Type,
+            uniqueID: DeFiActions.UniqueIdentifier
+        ): UniswapV3SwapConnectors.Swapper {
+            // Reverse the swap path: collateral -> yield (opposite of yield -> collateral)
+            let forwardPath = collateralConfig.yieldToCollateralUniV3AddressPath
+            let reversedTokenPath: [EVM.EVMAddress] = []
+            var i = forwardPath.length
+            while i > 0 {
+                i = i - 1
+                reversedTokenPath.append(forwardPath[i])
+            }
+
+            // Reverse the fee path as well
+            let forwardFees = collateralConfig.yieldToCollateralUniV3FeePath
+            let reversedFeePath: [UInt32] = []
+            var j = forwardFees.length
+            while j > 0 {
+                j = j - 1
+                reversedFeePath.append(forwardFees[j])
+            }
+
+            // Verify the reversed path starts with collateral (ends with yield)
+            assert(
+                reversedTokenPath[reversedTokenPath.length - 1].equals(yieldTokenEVMAddress),
+                message: "Reversed path must end with yield token \(yieldTokenEVMAddress.toString())"
+            )
+
+            return self._createUniV3Swapper(
+                tokenPath: reversedTokenPath,
+                feePath: reversedFeePath,
+                inVault: collateralType,     // ← Input is collateral
+                outVault: yieldTokenType,    // ← Output is yield token
+                uniqueID: uniqueID
+            )
+        }
     }
 
     access(all) entitlement Configure
@@ -810,6 +1015,20 @@ access(all) contract FlowYieldVaultsStrategiesV2 {
         )
     }
 
+    access(self) fun getYieldToMoetSwapperConfigKey(_ uniqueID: DeFiActions.UniqueIdentifier?): String {
+        pre {
+            uniqueID != nil: "Missing UniqueIdentifier for swapper config key"
+        }
+        return "yieldToMoetSwapper_\(uniqueID!.id.toString())"
+    }
+
+    access(self) fun getMoetToCollateralSwapperConfigKey(_ uniqueID: DeFiActions.UniqueIdentifier?): String {
+        pre {
+            uniqueID != nil: "Missing UniqueIdentifier for swapper config key"
+        }
+        return "moetToCollateralSwapper_\(uniqueID!.id.toString())"
+    }
+
     init(
         univ3FactoryEVMAddress: String,
         univ3RouterEVMAddress: String,