Global supervisor rebalancing + auto-register + strict proofs + E2E tests

.cursor/rules/standards.mdc

@@ -3,4 +3,6 @@ description:
 globs: 
 alwaysApply: true
 ---
-Do not use emojis
+- Do not use emojis
+- All documentation markdown files (.md) should be placed in the `docs/` folder, not in the repository root
+- Keep README.md in the root as the only exception

.cursor/worktrees.json

@@ -0,0 +1,5 @@
+{
+  "setup-worktree": [
+    "npm install"
+  ]
+}

.cursorignore

@@ -0,0 +1,3 @@
+
+keshav-scheduled-testnet.pkey
+demo2.pkey

.github/workflows/cadence_tests.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Update PATH
         run: echo "/root/.local/bin" >> $GITHUB_PATH
       - name: Install dependencies
-        run: flow deps install --skip-alias --skip-deployments
+        run: flow deps install --skip-deployments
       - name: Run tests
         run: flow test --cover --covercode="contracts" --coverprofile="coverage.lcov" ./cadence/tests/*_test.cdc
       - name: Upload coverage reports to Codecov

.github/workflows/e2e_tests.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Update PATH
         run: echo "/root/.local/bin" >> $GITHUB_PATH
       - name: Install dependencies
-        run: flow deps install --skip-alias --skip-deployments
+        run: flow deps install --skip-deployments
       - name: Run Emulator
         run: ./local/run_emulator.sh
       - name: Setup Wallets

.github/workflows/incrementfi_tests.yml

@@ -26,7 +26,7 @@ jobs:
       - name: Run emulator
         run: ./local/run_emulator.sh 
       - name: Install flow dependencies
-        run: flow deps install --skip-alias --skip-deployments
+        run: flow deps install --skip-deployments
       - name: Create wallets
         run: ./local/setup_wallets.sh
       - name: Run EVM gateway

.github/workflows/punchswap.yml

@@ -32,7 +32,7 @@ jobs:
       - name: Run emulator
         run: ./local/run_emulator.sh
       - name: Install Flow deps
-        run: flow deps install --skip-alias --skip-deployments
+        run: flow deps install --skip-deployments
       - name: Create wallets
         run: ./local/setup_wallets.sh
       - name: Run EVM gateway

.github/workflows/scheduled_rebalance_tests.yml

@@ -0,0 +1,49 @@
+name: Scheduled Rebalance Tests
+
+on:
+  push:
+    branches:
+      - main
+      - scheduled-rebalancing
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  scheduled-rebalance-tests:
+    name: FlowVaults Scheduled Rebalancing Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GH_PAT }}
+          submodules: recursive
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: "1.23.x"
+      - uses: actions/cache@v4
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+      - name: Install Flow CLI
+        run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)"
+      - name: Flow CLI Version
+        run: flow version
+      - name: Update PATH
+        run: echo "/root/.local/bin" >> $GITHUB_PATH
+      - name: Install dependencies
+        run: flow deps install --skip-deployments
+      - name: Run scheduled rebalancing tests
+        run: |
+          flow test \
+            cadence/tests/scheduled_rebalance_integration_test.cdc \
+            cadence/tests/scheduled_rebalance_scenario_test.cdc \
+            cadence/tests/tide_lifecycle_test.cdc \
+            cadence/tests/atomic_registration_gc_test.cdc \
+            cadence/tests/scheduled_supervisor_test.cdc \
+            cadence/tests/scheduler_edge_cases_test.cdc
+
+

.gitignore

@@ -20,3 +20,6 @@ solidity/out/
 broadcast
 cache
 db
+
+# logs
+run_logs/*.log

cadence/contracts/FlowVaults.cdc

@@ -5,6 +5,7 @@ import "ViewResolver"
 // DeFiActions
 import "DeFiActions"
 import "FlowVaultsClosedBeta"
+// Note: FlowVaultsScheduler registration moved to FlowVaultsAutoBalancers
 
 /// THIS CONTRACT IS A MOCK AND IS NOT INTENDED FOR USE IN PRODUCTION
 /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -231,7 +232,8 @@ access(all) contract FlowVaults {
                 remainingBalance: self.getTideBalance()
             )
             let _strategy <- self.strategy <- nil
-            Burner.burn(<-_strategy)
+            // Force unwrap to ensure burnCallback is called on the Strategy
+            Burner.burn(<-_strategy!)
         }
         /// TODO: FlowVaults specific views
         access(all) view fun getViews(): [Type] {
@@ -318,18 +320,24 @@ access(all) contract FlowVaults {
         access(all) view fun getNumberOfTides(): Int {
             return self.tides.length
         }
-        /// Creates a new Tide executing the specified Strategy with the provided funds
-        access(all) fun createTide(betaRef: auth(FlowVaultsClosedBeta.Beta) &FlowVaultsClosedBeta.BetaBadge, strategyType: Type, withVault: @{FungibleToken.Vault}) {
+        /// Creates a new Tide executing the specified Strategy with the provided funds.
+        /// Returns the newly created Tide ID.
+        access(all) fun createTide(
+            betaRef: auth(FlowVaultsClosedBeta.Beta) &FlowVaultsClosedBeta.BetaBadge,
+            strategyType: Type,
+            withVault: @{FungibleToken.Vault}
+        ): UInt64 {
             pre {
                 FlowVaultsClosedBeta.validateBeta(self.owner?.address!, betaRef):
                 "Invalid Beta Ref"
             }
             let balance = withVault.balance
             let type = withVault.getType()
             let tide <-create Tide(strategyType: strategyType, withVault: <-withVault)
+            let newID = tide.uniqueID.id
 
             emit CreatedTide(
-                id: tide.uniqueID.id,
+                id: newID,
                 uuid: tide.uuid,
                 strategyType: strategyType.identifier,
                 tokenType: type.identifier,
@@ -338,6 +346,12 @@ access(all) contract FlowVaults {
             )
 
             self.addTide(betaRef: betaRef, <-tide)
+
+            // Note: Scheduler registration happens in FlowVaultsAutoBalancers._initNewAutoBalancer
+            // which is called during Strategy creation. This keeps registration atomic with
+            // AutoBalancer creation and decouples Tide lifecycle from scheduling.
+
+            return newID
         }
         /// Adds an open Tide to this TideManager resource. This effectively transfers ownership of the newly added
         /// Tide to the owner of this TideManager
@@ -400,6 +414,10 @@ access(all) contract FlowVaults {
                 self.tides[id] != nil:
                 "No Tide with ID \(id) found"
             }
+            // Note: Scheduler unregistration happens in FlowVaultsAutoBalancers._cleanupAutoBalancer
+            // which is called when the Strategy is burned. This keeps unregistration atomic with
+            // AutoBalancer cleanup and decouples Tide lifecycle from scheduling.
+
             let tide <- self._withdrawTide(id: id)
             let res <- tide.withdraw(amount: tide.getTideBalance())
             Burner.burn(<-tide)

cadence/contracts/FlowVaultsAutoBalancers.cdc

@@ -4,6 +4,8 @@ import "FungibleToken"
 // DeFiActions
 import "DeFiActions"
 import "FlowTransactionScheduler"
+// Scheduler
+import "FlowVaultsScheduler"
 
 /// FlowVaultsAutoBalancers
 ///
@@ -14,7 +16,12 @@ import "FlowTransactionScheduler"
 /// which identifies all DeFiActions components in the stack related to their composite Strategy.
 ///
 /// When a Tide and necessarily the related Strategy is closed & burned, the related AutoBalancer and its Capabilities
-/// are destroyed and deleted
+/// are destroyed and deleted.
+///
+/// Registration with FlowVaultsScheduler happens here (not in FlowVaults) because:
+/// - Only strategies with AutoBalancers need scheduled rebalancing
+/// - Registration is atomic with AutoBalancer creation
+/// - Unregistration happens at AutoBalancer cleanup
 ///
 access(all) contract FlowVaultsAutoBalancers {
 
@@ -40,13 +47,24 @@ access(all) contract FlowVaultsAutoBalancers {
 
     /// Configures a new AutoBalancer in storage, configures its public Capability, and sets its inner authorized
     /// Capability. If an AutoBalancer is stored with an associated UniqueID value, the operation reverts.
+    ///
+    /// @param oracle: The oracle used to query deposited & withdrawn value and to determine if a rebalance should execute
+    /// @param vaultType: The type of Vault wrapped by the AutoBalancer
+    /// @param lowerThreshold: The percentage below base value at which a rebalance pulls from rebalanceSource
+    /// @param upperThreshold: The percentage above base value at which a rebalance pushes to rebalanceSink
+    /// @param rebalanceSink: An optional DeFiActions Sink to which excess value is directed when rebalancing
+    /// @param rebalanceSource: An optional DeFiActions Source from which value is withdrawn when rebalancing
+    /// @param recurringConfig: Optional configuration for automatic recurring rebalancing via FlowTransactionScheduler
+    /// @param uniqueID: The DeFiActions UniqueIdentifier used for identifying this AutoBalancer
+    ///
     access(account) fun _initNewAutoBalancer(
         oracle: {DeFiActions.PriceOracle},
         vaultType: Type,
         lowerThreshold: UFix64,
         upperThreshold: UFix64,
         rebalanceSink: {DeFiActions.Sink}?,
         rebalanceSource: {DeFiActions.Source}?,
+        recurringConfig: DeFiActions.AutoBalancerRecurringConfig?,
         uniqueID: DeFiActions.UniqueIdentifier
     ): auth(DeFiActions.Auto, DeFiActions.Set, DeFiActions.Get, FungibleToken.Withdraw) &DeFiActions.AutoBalancer {
 
@@ -60,15 +78,15 @@ access(all) contract FlowVaultsAutoBalancers {
         assert(!publishedCap,
             message: "Published Capability collision found when publishing AutoBalancer for UniqueIdentifier.id \(uniqueID.id) at path \(publicPath)")
 
-        // create & save AutoBalancer
+        // create & save AutoBalancer with optional recurring config
         let autoBalancer <- DeFiActions.createAutoBalancer(
                 oracle: oracle,
                 vaultType: vaultType,
                 lowerThreshold: lowerThreshold,
                 upperThreshold: upperThreshold,
                 rebalanceSink: rebalanceSink,
                 rebalanceSource: rebalanceSource,
-                recurringConfig: nil,
+                recurringConfig: recurringConfig,
                 uniqueID: uniqueID
             )
         self.account.storage.save(<-autoBalancer, to: storagePath)
@@ -89,6 +107,11 @@ access(all) contract FlowVaultsAutoBalancers {
             message: "Error when configuring AutoBalancer for UniqueIdentifier.id \(uniqueID.id) at path \(storagePath)")
         assert(publishedCap,
             message: "Error when publishing AutoBalancer Capability for UniqueIdentifier.id \(uniqueID.id) at path \(publicPath)")
+
+        // Register with scheduler and schedule first execution atomically
+        // This panics if scheduling fails, reverting AutoBalancer creation
+        FlowVaultsScheduler.registerTide(tideID: uniqueID.id)
+
         return autoBalancerRef
     }
 
@@ -105,15 +128,25 @@ access(all) contract FlowVaultsAutoBalancers {
     /// Called by strategies defined in the FlowVaults account which leverage account-hosted AutoBalancers when a
     /// Strategy is burned
     access(account) fun _cleanupAutoBalancer(id: UInt64) {
+        // Unregister from scheduler first (cancels pending schedules, returns fees)
+        FlowVaultsScheduler.unregisterTide(tideID: id)
+
         let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
         let publicPath = self.deriveAutoBalancerPath(id: id, storage: false) as! PublicPath
         // unpublish the public AutoBalancer Capability
-        self.account.capabilities.unpublish(publicPath)
-        // delete any CapabilityControllers targetting the AutoBalancer
+        let _ = self.account.capabilities.unpublish(publicPath)
+
+        // Collect controller IDs first (can't modify during iteration)
+        var controllersToDelete: [UInt64] = []
         self.account.capabilities.storage.forEachController(forPath: storagePath, fun(_ controller: &StorageCapabilityController): Bool {
-            controller.delete()
+            controllersToDelete.append(controller.capabilityID)
             return true
         })
+        // Delete controllers after iteration
+        for controllerID in controllersToDelete {
+            self.account.capabilities.storage.getController(byCapabilityID: controllerID)?.delete()
+        }
+
         // load & burn the AutoBalancer
         let autoBalancer <-self.account.storage.load<@DeFiActions.AutoBalancer>(from: storagePath)
         Burner.burn(<-autoBalancer)