Merge branch 'main' into holyfuchs/scheduled-rebalance

Author: holyfuchs

cadence/contracts/FlowCreditMarket.cdc

@@ -179,7 +179,6 @@ access(all) contract FlowCreditMarket {
     /// Note that this entitlement provides access to all positions in the pool,
     /// not just individual position owners' positions.
     access(all) entitlement EPosition
-    access(all) entitlement ERebalance
 
     /// EGovernance
     ///
@@ -3422,6 +3421,22 @@ access(all) contract FlowCreditMarket {
             self._unlockPosition(pid)
         }
 
+        /// Attempts to rebalance a position toward its configured `targetHealth` without acquiring
+        /// or releasing the position lock. This function performs *best-effort* rebalancing and may
+        /// partially rebalance or no-op depending on available sinks/sources and their capacity.
+        ///
+        /// This helper is intentionally "no-lock" and "effects-only" with respect to orchestration.
+        /// Callers are responsible for acquiring and releasing the position lock and for enforcing
+        /// any higher-level invariants.
+        access(self) fun _rebalancePositionNoLock(pid: UInt64, force: Bool) {
+            post {
+                self.positionLock[pid] == nil: "Position is not unlocked"
+            }
+            self._lockPosition(pid)
+            self._rebalancePositionNoLock(pid: pid, force: force)
+            self._unlockPosition(pid)
+        }
+
         /// Attempts to rebalance a position toward its configured `targetHealth` without acquiring
         /// or releasing the position lock. This function performs *best-effort* rebalancing and may
         /// partially rebalance or no-op depending on available sinks/sources and their capacity.
@@ -3853,7 +3868,7 @@ access(all) contract FlowCreditMarket {
         /// The unique ID of the Position used to track deposits and withdrawals to the Pool
         access(all) let id: UInt64
 
-        /// An authorized Capability to which the Position was opened
+        /// An authorized Capability to the Pool for which this Position was opened.
         access(self) let pool: Capability<auth(EPosition) &Pool>
 
         init(
@@ -4132,7 +4147,62 @@ access(all) contract FlowCreditMarket {
         access(all) fun getPositionIDs(): [UInt64] {
             return self.positions.keys
         }
+    }
+
+    /// Creates and returns a new PositionManager resource
+    access(all) fun createPositionManager(): @PositionManager {
+        return <- create PositionManager()
+    }
+
+    /// PositionManager
+    ///
+    /// A collection resource that manages multiple Position resources for an account.
+    /// This allows users to have multiple positions while using a single, constant storage path.
+    ///
+    access(all) resource PositionManager {
+
+        /// Dictionary storing all positions owned by this manager, keyed by position ID
+        access(self) let positions: @{UInt64: Position}
+
+        init() {
+            self.positions <- {}
+        }
 
+        /// Adds a new position to the manager.
+        access(EPositionAdmin) fun addPosition(position: @Position) {
+            let pid = position.id
+            let old <- self.positions[pid] <- position
+            if old != nil {
+                panic("Cannot add position with same pid (\(pid)) as existing position: must explicitly remove existing position first")
+            }
+            destroy old
+        }
+
+        /// Removes and returns a position from the manager.
+        access(EPositionAdmin) fun removePosition(pid: UInt64): @Position {
+            if let position <- self.positions.remove(key: pid) {
+                return <-position
+            }
+            panic("Position with pid=\(pid) not found in PositionManager")
+        }
+
+        /// Internal method that returns a reference to a position authorized with all entitlements.
+        /// Callers who wish to provide a partially authorized reference can downcast the result as needed.
+        access(EPositionAdmin) fun borrowAuthorizedPosition(pid: UInt64): auth(FungibleToken.Withdraw, EPositionAdmin) &Position {
+            return (&self.positions[pid] as auth(FungibleToken.Withdraw, EPositionAdmin) &Position?)
+                ?? panic("Position with pid=\(pid) not found in PositionManager")
+        }
+
+        /// Returns a public reference to a position with no entitlements.
+        access(all) fun borrowPosition(pid: UInt64): &Position {
+            return (&self.positions[pid] as &Position?)
+                ?? panic("Position with pid=\(pid) not found in PositionManager")
+        }
+
+        /// Returns the IDs of all positions in this manager
+        access(all) fun getPositionIDs(): [UInt64] {
+            return self.positions.keys
+        }
     }
 
     /// Creates and returns a new PositionManager resource

cadence/tests/test_helpers.cdc

@@ -468,19 +468,6 @@ fun createPosition(signer: Test.TestAccount, amount: UFix64, vaultStoragePath: S
     Test.expect(openRes, Test.beSucceeded())
 }
 
-access(all)
-fun createPositionNotManaged(signer: Test.TestAccount, amount: UFix64, vaultStoragePath: StoragePath, pushToDrawDownSink: Bool, positionStoragePath: StoragePath) {
-    // Grant beta access to the signer if they don't have it yet
-    grantBetaPoolParticipantAccess(PROTOCOL_ACCOUNT, signer)
-
-    let openRes = _executeTransaction(
-        "../transactions/flow-credit-market/position/create_position_not_managed.cdc",
-        [amount, vaultStoragePath, pushToDrawDownSink, positionStoragePath],
-        signer
-    )
-    Test.expect(openRes, Test.beSucceeded())
-}
-
 access(all)
 fun depositToPosition(signer: Test.TestAccount, positionID: UInt64, amount: UFix64, vaultStoragePath: StoragePath, pushToDrawDownSink: Bool) {
     let depositRes = _executeTransaction(
@@ -491,16 +478,6 @@ fun depositToPosition(signer: Test.TestAccount, positionID: UInt64, amount: UFix
     Test.expect(depositRes, Test.beSucceeded())
 }
 
-access(all)
-fun depositToPositionNotManaged(signer: Test.TestAccount, positionStoragePath: StoragePath, amount: UFix64, vaultStoragePath: StoragePath, pushToDrawDownSink: Bool) {
-    let depositRes = _executeTransaction(
-        "./transactions/position/deposit_to_position.cdc",
-        [positionStoragePath, amount, vaultStoragePath, pushToDrawDownSink],
-        signer
-    )
-    Test.expect(depositRes, Test.beSucceeded())
-}
-
 access(all)
 fun borrowFromPosition(signer: Test.TestAccount, positionId: UInt64, tokenTypeIdentifier: String, amount: UFix64, beFailed: Bool) {
     let borrowRes = _executeTransaction(