Merge remote-tracking branch 'origin/v0' into nialexsan/mainnet-fork-test

Author: nialexsan

.github/workflows/cadence_tests.yml

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

.github/workflows/e2e_tests.yml

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

.github/workflows/incrementfi_tests.yml

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

.github/workflows/punchswap.yml

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

.gitmodules

@@ -22,3 +22,4 @@
 [submodule "lib/FlowALP"]
 	path = lib/FlowALP
 	url = git@github.com:onflow/FlowALP.git
+	branch = v0

README.md

@@ -86,7 +86,7 @@ Mock FungibleToken implementations representing:
 | USDC | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_f1815bd50389c46847f0bda824ec8da914045d14 | 0xF1815bd50389c46847f0Bda824eC8da914045D14 |
 | USDF | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_2aabea2058b5ac2d339b163c6ab6f2b6d53aabed | 0x2aabea2058b5ac2d339b163c6ab6f2b6d53aabed |
 | PYUSD0 | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_99af3eea856556646c98c8b9b2548fe815240750 | 0x99aF3EeA856556646C98c8B9b2548Fe815240750 |
-| cbBTC | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_a0197b2044d28b08be34d98b23c9312158ea9a18 | 0xA0197b2044D28b08Be34d98b23c9312158Ea9A18 |
+| WBTC | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579 | 0x717DAE2BaF7656BE9a9B01deE31d571a9d4c9579 |
 | wETH | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_2f6f07cdcf3588944bf4c42ac74ff24bf56e7590 | 0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590 |
 | FUSDEV (ERC4626) | 0x1e4aa0b87d10b141 | EVMVMBridgedToken_d069d989e2f44b70c65347d1853c0c67e10a9f8d | 0xd069d989e2F44B70c65347d1853C0c67e10a9F8D |
 

cadence/contracts/AutoBalancers.cdc

@@ -0,0 +1,294 @@
+// standards
+import "Burner"
+import "FungibleToken"
+// DeFiActions
+import "DeFiActions"
+import "AutoBalancers"
+import "FlowTransactionScheduler"
+// Registry for global yield vault mapping
+import "FlowYieldVaultsSchedulerRegistryV1"
+
+/// FlowYieldVaultsAutoBalancersV1
+///
+/// This contract deals with the storage, retrieval and cleanup of DeFiActions AutoBalancers as they are used in
+/// FlowYieldVaults defined Strategies.
+///
+/// AutoBalancers are stored in contract account storage at paths derived by their related DeFiActions.UniqueIdentifier.id
+/// which identifies all DeFiActions components in the stack related to their composite Strategy.
+///
+/// When a YieldVault and necessarily the related Strategy is closed & burned, the related AutoBalancer and its Capabilities
+/// are destroyed and deleted.
+///
+/// Scheduling approach:
+/// - AutoBalancers are configured with a recurringConfig at creation
+/// - After creation, scheduleNextRebalance(nil) starts the self-scheduling chain
+/// - The registry tracks all live yield vault IDs for global mapping
+/// - Cleanup unregisters from the registry
+///
+access(all) contract FlowYieldVaultsAutoBalancersV1 {
+
+    /// The path prefix used for StoragePath & PublicPath derivations
+    access(all) let pathPrefix: String
+
+    /// Storage path for the shared execution callback resource that reports to the registry (one per account)
+    access(self) let registryReportCallbackStoragePath: StoragePath
+
+    /// Callback resource invoked by each AutoBalancer after execution; calls Registry.reportExecution with its id
+    access(all) resource RegistryReportCallback: AutoBalancers.AutoBalancerExecutionCallback {
+        access(all) fun onExecuted(balancerUUID: UInt64) {
+            FlowYieldVaultsSchedulerRegistryV1.reportExecution(yieldVaultID: balancerUUID)
+        }
+    }
+
+    /* --- PUBLIC METHODS --- */
+
+    /// Returns the path (StoragePath or PublicPath) at which an AutoBalancer is stored with the associated
+    /// UniqueIdentifier.id.
+    access(all) view fun deriveAutoBalancerPath(id: UInt64, storage: Bool): Path {
+        return storage ? StoragePath(identifier: "\(self.pathPrefix)\(id)")! : PublicPath(identifier: "\(self.pathPrefix)\(id)")!
+    }
+
+    /// Returns an unauthorized reference to an AutoBalancer with the given UniqueIdentifier.id value. If none is
+    /// configured, `nil` will be returned.
+    access(all) fun borrowAutoBalancer(id: UInt64): &AutoBalancers.AutoBalancer? {
+        let publicPath = self.deriveAutoBalancerPath(id: id, storage: false) as! PublicPath
+        return self.account.capabilities.borrow<&AutoBalancers.AutoBalancer>(publicPath)
+    }
+
+    /// Creates a source from an AutoBalancer for external use (e.g., position close operations).
+    /// This allows bypassing position topUpSource to avoid circular dependency issues.
+    ///
+    /// @param id: The yield vault/AutoBalancer ID
+    /// @return Source that can withdraw from the AutoBalancer, or nil if not found
+    ///
+    access(account) fun createExternalSource(id: UInt64): {DeFiActions.Source}? {
+        let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
+        if let autoBalancer = self.account.storage.borrow<auth(AutoBalancers.Get) &AutoBalancers.AutoBalancer>(from: storagePath) {
+            return autoBalancer.createBalancerSource()
+        }
+        return nil
+    }
+
+    /// Creates a sink to an AutoBalancer for external deposits (e.g., cancel deferred redemption).
+    ///
+    /// @param id: The yield vault/AutoBalancer ID
+    /// @return Sink that can deposit to the AutoBalancer, or nil if not found
+    ///
+    access(account) fun createExternalSink(id: UInt64): {DeFiActions.Sink}? {
+        let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
+        if let autoBalancer = self.account.storage.borrow<auth(AutoBalancers.Get) &AutoBalancers.AutoBalancer>(from: storagePath) {
+            return autoBalancer.createBalancerSink()
+        }
+        return nil
+    }
+
+    /// Checks if an AutoBalancer has at least one active (Scheduled) transaction.
+    /// Used by Supervisor to detect stuck yield vaults that need recovery.
+    ///
+    /// @param id: The yield vault/AutoBalancer ID
+    /// @return Bool: true if there's at least one Scheduled transaction, false otherwise
+    ///
+    access(all) fun hasActiveSchedule(id: UInt64): Bool {
+        let autoBalancer = self.borrowAutoBalancer(id: id)
+        if autoBalancer == nil {
+            return false
+        }
+
+        let txnIDs = autoBalancer!.getScheduledTransactionIDs()
+        for txnID in txnIDs {
+            if autoBalancer!.borrowScheduledTransaction(id: txnID)?.status() == FlowTransactionScheduler.Status.Scheduled {
+                return true
+            }
+        }
+        return false
+    }
+
+    /// Checks if an AutoBalancer is overdue for execution.
+    /// A yield vault is considered overdue if:
+    /// - It has a recurring config
+    /// - The next expected execution time has passed
+    /// - It has no active schedule
+    ///
+    /// @param id: The yield vault/AutoBalancer ID
+    /// @return Bool: true if yield vault is overdue and stuck, false otherwise
+    ///
+    access(all) fun isStuckYieldVault(id: UInt64): Bool {
+        let autoBalancer = self.borrowAutoBalancer(id: id)
+        if autoBalancer == nil {
+            return false
+        }
+
+        // Check if yield vault has recurring config (should be executing periodically)
+        let config = autoBalancer!.getRecurringConfig()
+        if config == nil {
+            return false // Not configured for recurring, can't be "stuck"
+        }
+
+        // Check if there's an active schedule
+        if self.hasActiveSchedule(id: id) {
+            return false // Has active schedule, not stuck
+        }
+
+        // Check if yield vault is overdue
+        let nextExpected = autoBalancer!.calculateNextExecutionTimestampAsConfigured()
+        if nextExpected == nil {
+            return true // Can't calculate next time, likely stuck
+        }
+
+        // If next expected time has passed and no active schedule, yield vault is stuck
+        return nextExpected! < getCurrentBlock().timestamp
+    }
+
+    /* --- INTERNAL METHODS --- */
+
+    /// 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: AutoBalancers.AutoBalancerRecurringConfig?,
+        uniqueID: DeFiActions.UniqueIdentifier
+    ): auth(AutoBalancers.Auto, AutoBalancers.Set, AutoBalancers.Get, AutoBalancers.Schedule, FungibleToken.Withdraw) &AutoBalancers.AutoBalancer {
+
+        // derive paths & prevent collision
+        let storagePath = self.deriveAutoBalancerPath(id: uniqueID.id, storage: true) as! StoragePath
+        let publicPath = self.deriveAutoBalancerPath(id: uniqueID.id, storage: false) as! PublicPath
+        var storedType = self.account.storage.type(at: storagePath)
+        var publishedCap = self.account.capabilities.exists(publicPath)
+        assert(storedType == nil,
+            message: "Storage collision when creating AutoBalancer for UniqueIdentifier.id \(uniqueID.id) at path \(storagePath)")
+        assert(!publishedCap,
+            message: "Published Capability collision found when publishing AutoBalancer for UniqueIdentifier.id \(uniqueID.id) at path \(publicPath)")
+
+        let registryReportCallbackCapabilityStoragePath =
+            StoragePath(identifier: "FlowYieldVaultsRegistryReportCallbackCapability")!
+        if self.account.storage.type(at: registryReportCallbackCapabilityStoragePath) == nil {
+            let sharedReportCap = self.account.capabilities.storage.issue<&{AutoBalancers.AutoBalancerExecutionCallback}>(
+                self.registryReportCallbackStoragePath
+            )
+            self.account.storage.save(sharedReportCap, to: registryReportCallbackCapabilityStoragePath)
+        }
+        let reportCap = self.account.storage.copy<Capability<&{AutoBalancers.AutoBalancerExecutionCallback}>>(
+            from: registryReportCallbackCapabilityStoragePath
+        ) ?? panic(
+            "Missing shared registry report callback capability at \(registryReportCallbackCapabilityStoragePath)"
+        )
+
+        // create & save AutoBalancer with optional recurring config
+        let autoBalancer <- AutoBalancers.createAutoBalancer(
+                oracle: oracle,
+                vaultType: vaultType,
+                lowerThreshold: lowerThreshold,
+                upperThreshold: upperThreshold,
+                rebalanceSink: rebalanceSink,
+                rebalanceSource: rebalanceSource,
+                recurringConfig: recurringConfig,
+                uniqueID: uniqueID
+            )
+        autoBalancer.setExecutionCallback(reportCap)
+        self.account.storage.save(<-autoBalancer, to: storagePath)
+        let autoBalancerRef = self._borrowAutoBalancer(uniqueID.id)
+
+        // issue & publish public capability
+        let publicCap = self.account.capabilities.storage.issue<&AutoBalancers.AutoBalancer>(storagePath)
+        self.account.capabilities.publish(publicCap, at: publicPath)
+
+        // issue private capability & set within AutoBalancer
+        let authorizedCap = self.account.capabilities.storage.issue<auth(FungibleToken.Withdraw, FlowTransactionScheduler.Execute) &AutoBalancers.AutoBalancer>(storagePath)
+        autoBalancerRef.setSelfCapability(authorizedCap)
+
+        // ensure proper configuration before closing
+        storedType = self.account.storage.type(at: storagePath)
+        publishedCap = self.account.capabilities.exists(publicPath)
+        assert(storedType == Type<@AutoBalancers.AutoBalancer>(),
+            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)")
+
+        // Issue handler capability for the AutoBalancer (for FlowTransactionScheduler execution)
+        let handlerCap = self.account.capabilities.storage
+            .issue<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}>(storagePath)
+
+        // Issue schedule capability for the AutoBalancer (for Supervisor to call scheduleNextRebalance directly)
+        let scheduleCap = self.account.capabilities.storage
+            .issue<auth(AutoBalancers.Schedule) &AutoBalancers.AutoBalancer>(storagePath)
+
+        // Register yield vault in registry for global mapping of live yield vault IDs
+        FlowYieldVaultsSchedulerRegistryV1.register(yieldVaultID: uniqueID.id, handlerCap: handlerCap, scheduleCap: scheduleCap)
+
+        // Start the native AutoBalancer self-scheduling chain if recurringConfig was provided
+        // This schedules the first rebalance; subsequent ones are scheduled automatically
+        // by the AutoBalancer after each execution (via recurringConfig)
+        if recurringConfig != nil {
+            let scheduleError = autoBalancerRef.scheduleNextRebalance(whileExecuting: nil)
+            if scheduleError != nil {
+                panic("Failed to schedule first rebalance for AutoBalancer \(uniqueID.id): ".concat(scheduleError!))
+            }
+        }
+
+        return autoBalancerRef
+    }
+
+    /// Returns an authorized reference on the AutoBalancer with the associated UniqueIdentifier.id. If none is found,
+    /// the operation reverts.
+    access(account)
+    fun _borrowAutoBalancer(_ id: UInt64): auth(AutoBalancers.Auto, AutoBalancers.Set, AutoBalancers.Get, AutoBalancers.Schedule, FungibleToken.Withdraw) &AutoBalancers.AutoBalancer {
+        let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
+        return self.account.storage.borrow<auth(AutoBalancers.Auto, AutoBalancers.Set, AutoBalancers.Get, AutoBalancers.Schedule, FungibleToken.Withdraw) &AutoBalancers.AutoBalancer>(
+                from: storagePath
+            ) ?? panic("Could not borrow reference to AutoBalancer with UniqueIdentifier.id \(id) from StoragePath \(storagePath)")
+    }
+
+    /// Called by strategies defined in the FlowYieldVaults account which leverage account-hosted AutoBalancers when a
+    /// Strategy is burned
+    access(account) fun _cleanupAutoBalancer(id: UInt64) {
+        // Unregister from registry (removes from global yield vault mapping)
+        FlowYieldVaultsSchedulerRegistryV1.unregister(yieldVaultID: 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
+        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 {
+            controllersToDelete.append(controller.capabilityID)
+            return true
+        })
+        // Delete controllers after iteration
+        for controllerID in controllersToDelete {
+            if let controller = self.account.capabilities.storage.getController(byCapabilityID: controllerID) {
+                controller.delete()
+            }
+        }
+
+        // load & burn the AutoBalancer (this also handles any pending scheduled transactions via burnCallback)
+        let autoBalancer <-self.account.storage.load<@AutoBalancers.AutoBalancer>(from: storagePath)
+        Burner.burn(<-autoBalancer)
+    }
+
+    init() {
+        self.pathPrefix = "FlowYieldVaultsAutoBalancer_"
+        self.registryReportCallbackStoragePath = StoragePath(identifier: "FlowYieldVaultsRegistryReportCallback")!
+
+        // Ensure shared execution callback exists (reports this account's executions to Registry)
+        if self.account.storage.type(at: self.registryReportCallbackStoragePath) == nil {
+            self.account.storage.save(<-create RegistryReportCallback(), to: self.registryReportCallbackStoragePath)
+        }
+    }
+}