Merge branch 'main' into holyfuchs/rebalancer-refactor

Author: holyfuchs

.gitignore

@@ -7,4 +7,3 @@ coverage.json
 /.pr-body.md
 /.github/pr_bodies/
 lcov.info
-.flow-fork-cache

cadence/contracts/FlowALPModels.cdc

@@ -1037,13 +1037,13 @@ access(all) contract FlowALPModels {
         /// (used when deposits are made)
         access(EImplementation) fun consumeDepositCapacity(_ amount: UFix64, pid: UInt64)
 
-        /// Returns the per-deposit limit based on depositCapacity * depositLimitFraction
-        /// Rationale: cap per-deposit size to a fraction of the time-based
-        /// depositCapacity so a single large deposit cannot monopolize capacity.
+        /// Returns the per-deposit limit based on user deposit limit and available deposit capacity.
+        /// Rationale: cap per-deposit size to a fraction of the total depositCapacityCap
+        /// so a single large deposit cannot monopolize capacity.
         /// Excess is queued and drained in chunks (see asyncUpdatePosition),
         /// enabling fair throughput across many deposits in a block. The 5%
         /// fraction is conservative and can be tuned by protocol parameters.
-        access(EImplementation) view fun depositLimit(): UFix64
+        access(EImplementation) view fun depositLimit(pid: UInt64): UFix64
 
         /// Updates interest indices and regenerates deposit capacity for elapsed time
         access(EImplementation) fun updateForTimeChange()
@@ -1376,9 +1376,15 @@ access(all) contract FlowALPModels {
             )
         }
 
-        /// Returns the per-deposit limit based on depositCapacity * depositLimitFraction.
-        access(EImplementation) view fun depositLimit(): UFix64 {
-            return self.depositCapacity * self.depositLimitFraction
+        /// Returns the maximum amount that can be deposited to the given position without being queued.
+        access(EImplementation) view fun depositLimit(pid: UInt64): UFix64 {
+            let userCap = self.getUserDepositLimitCap()
+            let userUsed = self.getDepositUsageForPosition(pid)
+            var available = userCap - userUsed
+            if self.depositCapacity < available {
+                available = self.depositCapacity
+            }
+            return available
         }
 
         /// Updates interest indices and regenerates deposit capacity for elapsed time.

cadence/contracts/FlowALPPositionResources.cdc

@@ -7,19 +7,6 @@ import "FlowALPModels"
 
 access(all) contract FlowALPPositionResources {
 
-    /// A single authorized Capability to the Pool, shared across all Position resources.
-    /// Issued once at pool creation time to avoid per-position capability controller bloat.
-    access(self) var poolCap: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>?
-
-    /// Sets the contract-level pool capability. Called once by FlowALPv0 when the Pool is created.
-    access(account) fun setPoolCap(cap: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>) {
-        FlowALPPositionResources.poolCap = cap
-    }
-
-    access(self) fun borrowPool(): auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool} {
-        return self.poolCap!.borrow()!
-    }
-
     /// Position
     ///
     /// A Position is a resource representing ownership of value deposited to the protocol.
@@ -36,13 +23,24 @@ access(all) contract FlowALPPositionResources {
         /// The unique ID of the Position used to track deposits and withdrawals to the Pool
         access(all) let id: UInt64
 
-        init(id: UInt64) {
+        /// An authorized Capability to the Pool for which this Position was opened.
+        access(self) let pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>
+
+        init(
+            id: UInt64,
+            pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>
+        ) {
+            pre {
+                pool.check():
+                    "Invalid Pool Capability provided - cannot construct Position"
+            }
             self.id = id
+            self.pool = pool
         }
 
         /// Returns the balances (both positive and negative) for all tokens in this position.
         access(all) fun getBalances(): [FlowALPModels.PositionBalance] {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             return pool.getPositionDetails(pid: self.id).balances
         }
 
@@ -51,55 +49,55 @@ access(all) contract FlowALPPositionResources {
         /// below its min health. If pullFromTopUpSource is false, the calculation will return the balance currently
         /// available without topping up the position.
         access(all) fun availableBalance(type: Type, pullFromTopUpSource: Bool): UFix64 {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             return pool.availableBalance(pid: self.id, type: type, pullFromTopUpSource: pullFromTopUpSource)
         }
 
         /// Returns the current health of the position
         access(all) fun getHealth(): UFix128 {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             return pool.positionHealth(pid: self.id)
         }
 
         /// Returns the Position's target health (unitless ratio ≥ 1.0)
         access(all) fun getTargetHealth(): UFix64 {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             return FlowALPMath.toUFix64Round(pos.getTargetHealth())
         }
 
         /// Sets the target health of the Position
         access(FlowALPModels.EPositionAdmin) fun setTargetHealth(targetHealth: UFix64) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             pos.setTargetHealth(UFix128(targetHealth))
         }
 
         /// Returns the minimum health of the Position
         access(all) fun getMinHealth(): UFix64 {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             return FlowALPMath.toUFix64Round(pos.getMinHealth())
         }
 
         /// Sets the minimum health of the Position
         access(FlowALPModels.EPositionAdmin) fun setMinHealth(minHealth: UFix64) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             pos.setMinHealth(UFix128(minHealth))
             pool.queuePositionForUpdateIfNecessary(pid: self.id)
         }
 
         /// Returns the maximum health of the Position
         access(all) fun getMaxHealth(): UFix64 {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             return FlowALPMath.toUFix64Round(pos.getMaxHealth())
         }
 
         /// Sets the maximum health of the position
         access(FlowALPModels.EPositionAdmin) fun setMaxHealth(maxHealth: UFix64) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let pos = pool.borrowPosition(pid: self.id)
             pos.setMaxHealth(UFix128(maxHealth))
             pool.queuePositionForUpdateIfNecessary(pid: self.id)
@@ -127,7 +125,7 @@ access(all) contract FlowALPPositionResources {
             from: @{FungibleToken.Vault},
             pushToDrawDownSink: Bool
         ) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             pool.depositAndPush(
                 pid: self.id,
                 from: <-from,
@@ -152,7 +150,7 @@ access(all) contract FlowALPPositionResources {
             amount: UFix64,
             pullFromTopUpSource: Bool
         ): @{FungibleToken.Vault} {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             return <- pool.withdrawAndPull(
                 pid: self.id,
                 type: type,
@@ -183,8 +181,10 @@ access(all) contract FlowALPPositionResources {
             type: Type,
             pushToDrawDownSink: Bool
         ): {DeFiActions.Sink} {
+            let pool = self.pool.borrow()!
             return PositionSink(
                 id: self.id,
+                pool: self.pool,
                 type: type,
                 pushToDrawDownSink: pushToDrawDownSink
             )
@@ -212,8 +212,10 @@ access(all) contract FlowALPPositionResources {
             type: Type,
             pullFromTopUpSource: Bool
         ): {DeFiActions.Source} {
+            let pool = self.pool.borrow()!
             return PositionSource(
                 id: self.id,
+                pool: self.pool,
                 type: type,
                 pullFromTopUpSource: pullFromTopUpSource
             )
@@ -230,7 +232,7 @@ access(all) contract FlowALPPositionResources {
         ///
         /// Pass nil to configure the position to not push tokens when the Position exceeds its maximum health.
         access(FlowALPModels.EPositionAdmin) fun provideSink(sink: {DeFiActions.Sink}?) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             pool.lockPosition(self.id)
             let pos = pool.borrowPosition(pid: self.id)
             pos.setDrawDownSink(sink)
@@ -246,7 +248,7 @@ access(all) contract FlowALPPositionResources {
         ///
         /// Pass nil to configure the position to not pull tokens.
         access(FlowALPModels.EPositionAdmin) fun provideSource(source: {DeFiActions.Source}?) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             pool.lockPosition(self.id)
             let pos = pool.borrowPosition(pid: self.id)
             pos.setTopUpSource(source)
@@ -262,7 +264,7 @@ access(all) contract FlowALPPositionResources {
         /// of either cannot accept/provide sufficient funds for rebalancing, the rebalance will still occur but will
         /// not cause the position to reach its target health.
         access(FlowALPModels.EPosition | FlowALPModels.ERebalance) fun rebalance(force: Bool) {
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             pool.rebalancePosition(pid: self.id, force: force)
         }
     }
@@ -320,8 +322,11 @@ access(all) contract FlowALPPositionResources {
 
     /// Creates and returns a new Position resource.
     /// This remains account-scoped so only the protocol account can mint canonical wrappers.
-    access(account) fun createPosition(id: UInt64): @Position {
-        return <- create Position(id: id)
+    access(account) fun createPosition(
+        id: UInt64,
+        pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>
+    ): @Position {
+        return <- create Position(id: id, pool: pool)
     }
 
     /// Creates and returns a new PositionManager resource
@@ -339,6 +344,9 @@ access(all) contract FlowALPPositionResources {
         /// An optional DeFiActions.UniqueIdentifier that identifies this Sink with the DeFiActions stack its a part of
         access(contract) var uniqueID: DeFiActions.UniqueIdentifier?
 
+        /// An authorized Capability on the Pool for which the related Position is in
+        access(self) let pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>
+
         /// The ID of the position in the Pool
         access(self) let positionID: UInt64
 
@@ -351,11 +359,13 @@ access(all) contract FlowALPPositionResources {
 
         init(
             id: UInt64,
+            pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>,
             type: Type,
             pushToDrawDownSink: Bool
         ) {
             self.uniqueID = nil
             self.positionID = id
+            self.pool = pool
             self.type = type
             self.pushToDrawDownSink = pushToDrawDownSink
         }
@@ -367,20 +377,18 @@ access(all) contract FlowALPPositionResources {
 
         /// Returns the minimum capacity this Sink can accept as deposits
         access(all) fun minimumCapacity(): UFix64 {
-            return FlowALPPositionResources.poolCap?.check() ?? false ? UFix64.max : 0.0
+            return self.pool.check() ? UFix64.max : 0.0
         }
 
         /// Deposits the funds from the provided Vault reference to the related Position
         access(all) fun depositCapacity(from: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}) {
-            if FlowALPPositionResources.poolCap?.check() != true {
-                return
+            if let pool = self.pool.borrow() {
+                pool.depositAndPush(
+                    pid: self.positionID,
+                    from: <-from.withdraw(amount: from.balance),
+                    pushToDrawDownSink: self.pushToDrawDownSink
+                )
             }
-            let pool = FlowALPPositionResources.borrowPool()
-            pool.depositAndPush(
-                pid: self.positionID,
-                from: <-from.withdraw(amount: from.balance),
-                pushToDrawDownSink: self.pushToDrawDownSink
-            )
         }
 
         access(all) fun getComponentInfo(): DeFiActions.ComponentInfo {
@@ -410,6 +418,9 @@ access(all) contract FlowALPPositionResources {
         /// An optional DeFiActions.UniqueIdentifier that identifies this Sink with the DeFiActions stack its a part of
         access(contract) var uniqueID: DeFiActions.UniqueIdentifier?
 
+        /// An authorized Capability on the Pool for which the related Position is in
+        access(self) let pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>
+
         /// The ID of the position in the Pool
         access(self) let positionID: UInt64
 
@@ -422,11 +433,13 @@ access(all) contract FlowALPPositionResources {
 
         init(
             id: UInt64,
+            pool: Capability<auth(FlowALPModels.EPosition) &{FlowALPModels.PositionPool}>,
             type: Type,
             pullFromTopUpSource: Bool
         ) {
             self.uniqueID = nil
             self.positionID = id
+            self.pool = pool
             self.type = type
             self.pullFromTopUpSource = pullFromTopUpSource
         }
@@ -438,11 +451,11 @@ access(all) contract FlowALPPositionResources {
 
         /// Returns the minimum available this Source can provide on withdrawal
         access(all) fun minimumAvailable(): UFix64 {
-            if FlowALPPositionResources.poolCap?.check() != true {
+            if !self.pool.check() {
                 return 0.0
             }
 
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             return pool.availableBalance(
                 pid: self.positionID,
                 type: self.type,
@@ -452,11 +465,11 @@ access(all) contract FlowALPPositionResources {
 
         /// Withdraws up to the max amount as the sourceType Vault
         access(FungibleToken.Withdraw) fun withdrawAvailable(maxAmount: UFix64): @{FungibleToken.Vault} {
-            if FlowALPPositionResources.poolCap?.check() != true {
+            if !self.pool.check() {
                 return <- DeFiActionsUtils.getEmptyVault(self.type)
             }
 
-            let pool = FlowALPPositionResources.borrowPool()
+            let pool = self.pool.borrow()!
             let available = pool.availableBalance(
                 pid: self.positionID,
                 type: self.type,
@@ -492,8 +505,4 @@ access(all) contract FlowALPPositionResources {
             self.uniqueID = id
         }
     }
-
-    init() {
-        self.poolCap = nil
-    }
 }