Nialexsan/close position main

.github/workflows/cadence_tests.yml

@@ -5,9 +5,11 @@ on:
   push:
     branches:
       - main
+      - v0
   pull_request:
     branches:
       - main
+      - v0
 
 jobs:
   tests:

cadence/contracts/FlowALPEvents.cdc

@@ -44,6 +44,18 @@ access(all) contract FlowALPEvents {
         withdrawnUUID: UInt64
     )
 
+    /// Emitted when a position is closed via the closePosition() method.
+    /// This indicates a full position closure with debt repayment and collateral extraction.
+    ///
+    /// Uses dictionaries instead of parallel arrays for deterministic, unambiguous data.
+    /// Keys are token type identifiers (e.g., "A.xxx.FlowToken.Vault").
+    access(all) event PositionClosed(
+        pid: UInt64,
+        poolUUID: UInt64,
+        repaymentsByType: {String: UFix64},    // Map of debt token type → amount repaid
+        withdrawalsByType: {String: UFix64}    // Map of token type → amount withdrawn (collateral + overpayment dust)
+    )
+
     /// Emitted when a position is automatically rebalanced toward its target health factor.
     /// Rebalancing occurs when a position drifts above or below its configured health thresholds.
     ///
@@ -317,4 +329,31 @@ access(all) contract FlowALPEvents {
     access(account) fun emitDepositCapacityConsumed(tokenType: Type, pid: UInt64, amount: UFix64, remainingCapacity: UFix64) {
         emit DepositCapacityConsumed(tokenType: tokenType, pid: pid, amount: amount, remainingCapacity: remainingCapacity)
     }
+
+    /// Emits the PositionClosed event
+    access(account) fun emitPositionClosed(
+        pid: UInt64,
+        poolUUID: UInt64,
+        debtsByType: {Type: UFix64},
+        withdrawalsByType: {Type: UFix64}
+    ) {
+        // Emit event for position closure
+        // Note: repayments = debts owed (sources may have provided more, but that became credit)
+        let repaymentsEvent: {String: UFix64} = {}
+        for debtType in debtsByType.keys {
+            repaymentsEvent[debtType.identifier] = debtsByType[debtType]!
+        }
+
+        let withdrawalsEvent: {String: UFix64} = {}
+        for withdrawalType in withdrawalsByType.keys {
+            withdrawalsEvent[withdrawalType.identifier] = withdrawalsByType[withdrawalType]!
+        }
+
+        emit PositionClosed(
+            pid: pid,
+            poolUUID: poolUUID,
+            repaymentsByType: repaymentsEvent,
+            withdrawalsByType: withdrawalsEvent
+        )
+    }
 }

cadence/contracts/FlowALPModels.cdc

@@ -140,16 +140,24 @@ access(all) contract FlowALPModels {
                         interestIndex: tokenState.getDebitInterestIndex()
                     )
 
-                    // Harmonize comparison with withdrawal: treat an exact match as "does not flip to credit"
+                    // Use >= comparison to match withdrawal pattern (both use >= for consistency).
+                    // When deposit exactly equals debt, we enter this branch and check if balance reaches zero.
                     if trueBalance >= amount {
                         // The deposit isn't big enough to clear the debt,
                         // so we just decrement the debt.
                         let updatedBalance = trueBalance - amount
 
-                        self.scaledBalance = FlowALPMath.trueBalanceToScaledBalance(
-                            updatedBalance,
-                            interestIndex: tokenState.getDebitInterestIndex()
-                        )
+                        // Special case: If debt is fully repaid (exact match), flip to Credit with zero balance.
+                        // This ensures a position with zero debt is always represented as Credit, not Debit.
+                        if updatedBalance == 0.0 {
+                            self.direction = BalanceDirection.Credit
+                            self.scaledBalance = 0.0
+                        } else {
+                            self.scaledBalance = FlowALPMath.trueBalanceToScaledBalance(
+                                updatedBalance,
+                                interestIndex: tokenState.getDebitInterestIndex()
+                            )
+                        }
 
                         // Decrease the total debit balance for the token
                         tokenState.decreaseDebitBalance(by: amount)
@@ -1599,6 +1607,9 @@ access(all) contract FlowALPModels {
         /// Removes and returns the first position ID from the update queue
         access(EImplementation) fun removeFirstPositionNeedingUpdate(): UInt64
 
+        /// Removes and returns a speicific position ID by index from the update queue.
+        access(EImplementation) fun removeAtPositionNeedingUpdate(_ i: Int): UInt64
+
         /// Returns whether the given position ID is in the update queue
         access(all) view fun positionsNeedingUpdatesContains(_ pid: UInt64): Bool
 
@@ -1781,6 +1792,11 @@ access(all) contract FlowALPModels {
             return self.positionsNeedingUpdates.removeFirst()
         }
 
+        /// Removes and returns a speicific position ID by index from the update queue.
+        access(EImplementation) fun removeAtPositionNeedingUpdate(_ i: Int): UInt64 {
+            return self.positionsNeedingUpdates.remove(at: i)
+        }
+
         /// Returns whether the given position ID is in the update queue.
         access(all) view fun positionsNeedingUpdatesContains(_ pid: UInt64): Bool {
             return self.positionsNeedingUpdates.contains(pid)