move per-user deposit limit to depositLimit()

Author: tim-barry

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 user deposit limit cap and available deposit 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,13 +1376,15 @@ access(all) contract FlowALPModels {
             )
         }
 
-        /// Returns the per-deposit limit based on user deposit limit cap and available deposit capacity.
-        access(EImplementation) view fun depositLimit(): UFix64 {
-            let cap = self.getUserDepositLimitCap()
-            if self.depositCapacity < cap {
-                return self.depositCapacity
+        /// 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 cap
+            return available
         }
 
         /// Updates interest indices and regenerates deposit capacity for elapsed time.

cadence/contracts/FlowALPv0.cdc

@@ -1113,18 +1113,10 @@ access(all) contract FlowALPv0 {
 
             // Time-based state is handled by the tokenState() helper function
 
-            // Deposit rate limiting: prevent a single large deposit from monopolizing capacity.
+            // Deposit rate limiting: prevent a single user or single large deposit from monopolizing capacity.
             // Excess is queued to be processed asynchronously (see asyncUpdatePosition).
             let depositAmount = from.balance
-            var depositLimit = tokenState.depositLimit()
-
-            // Per-user deposit limit: check if user has exceeded their per-user limit
-            let userDepositLimitCap = tokenState.getUserDepositLimitCap()
-            let currentUsage = tokenState.getDepositUsageForPosition(pid)
-            let remainingUserLimit = userDepositLimitCap - currentUsage
-            if remainingUserLimit < depositLimit {
-                depositLimit = remainingUserLimit
-            }
+            let depositLimit = tokenState.depositLimit(pid: pid)
 
             // depositAmount is bounded by the smaller of:
             // User deposit limit, per-deposit limit, and global deposit capacity
@@ -1858,7 +1850,7 @@ access(all) contract FlowALPv0 {
                 let queuedVault <- position.removeQueuedDeposit(depositType)!
                 let queuedAmount = queuedVault.balance
                 let depositTokenState = self._borrowUpdatedTokenState(type: depositType)
-                let maxDeposit = depositTokenState.depositLimit()
+                let maxDeposit = depositTokenState.depositLimit(pid: pid)
 
                 if maxDeposit >= queuedAmount {
                     // We can deposit all of the queued deposit, so just do it and remove it from the queue