Merge pull request #39 from onflow/gio/dfa-rename-followup

Rename DeFiBlocks (DFB) references to DeFiActions (DFA)

Author: nialexsan

.gitmodules

@@ -1,8 +1,7 @@
-[submodule "lib/DeFiBlocks"]
-	path = lib/DeFiBlocks
-	url = git@github.com:onflow/DeFiBlocks.git
-	branch = main
 [submodule "lib/TidalProtocol"]
 	path = lib/TidalProtocol
 	url = git@github.com:onflow/TidalProtocol.git
-	branch = tracer-bullet
+	branch = main
+[submodule "lib/DeFiActions"]
+	path = lib/DeFiActions
+	url = git@github.com:onflow/DeFiActions.git

README.md

@@ -1,6 +1,6 @@
 # Tidal Smart Contracts
 
-Tidal is a yield farming platform built on the Flow blockchain using Cadence 1.0. The platform enables users to deposit tokens to supported DeFi strategies such as collateralized borrowing via TidalProtocol's Active Lending Platform. Tidal aims to support yield-generating strategies, automatically optimizing returns through DeFiBlocks components and auto-balancing mechanisms.
+Tidal is a yield farming platform built on the Flow blockchain using Cadence 1.0. The platform enables users to deposit tokens to supported DeFi strategies such as collateralized borrowing via TidalProtocol's Active Lending Platform. Tidal aims to support yield-generating strategies, automatically optimizing returns through DeFiActions components and auto-balancing mechanisms.
 
 ## System Architecture
 
@@ -21,7 +21,7 @@ The main contract that orchestrates the entire yield farming system:
 Implements specific yield strategies:
 
 - **TracerStrategy**: A strategy that uses TidalProtocol lending positions with auto-balancing
-- **TracerStrategyComposer**: Creates TracerStrategy instances with complex DeFiBlocks stacking
+- **TracerStrategyComposer**: Creates TracerStrategy instances with complex DeFiActions stacking
 - **StrategyComposerIssuer**: Controls access to strategy composer creation
 
 #### 3. TidalYieldAutoBalancers.cdc - Auto-Balancing System
@@ -43,7 +43,7 @@ Mock FungibleToken implementations representing:
 #### MockOracle.cdc
 - Provides price feeds for testing and demonstrations
 - Supports price manipulation for testing scenarios
-- Implements DFB.PriceOracle interface
+- Implements DeFiActions.PriceOracle interface
 
 #### MockSwapper.cdc  
 - Simulates token swapping functionality
@@ -55,7 +55,7 @@ Mock FungibleToken implementations representing:
 Below is an overview of the initial prototype Tracer Strategy in the broader context of TidalProtocol and the Tidal platform.
 
 ### 1. Strategy Architecture
-The TracerStrategy demonstrates the power of DeFiBlocks composition:
+The TracerStrategy demonstrates the power of DeFiActions composition:
 
 ```
 User Deposit (FLOW) → TidalProtocol Position → MOET Issuance → Swap to YieldToken → AutoBalancer
@@ -69,8 +69,8 @@ User Deposit (FLOW) → TidalProtocol Position → MOET Issuance → Swap to Yie
 - Excess value flows into position recollateralization
 - Insufficient value triggers position adjustments
 
-### 3. DeFiBlocks Integration
-The system heavily uses DeFiBlocks components:
+### 3. DeFiActions Integration
+The system heavily uses DeFiActions components:
 - **Sinks**: Accept token deposits
 - **Sources**: Provide token withdrawals  
 - **Swappers**: Handle token conversions
@@ -248,9 +248,9 @@ Users can track their position status by comparing:
 3. **Yield Optimization**: Continuously adjusts to market conditions
 4. **User Experience**: No manual intervention required for position maintenance
 
-### Integration with DeFiBlocks
+### Integration with DeFiActions
 
-The rebalancing system leverages DeFiBlocks components:
+The rebalancing system leverages DeFiActions components:
 
 - **Sinks**: Route tokens into rebalancing flows
 - **Sources**: Extract tokens for rebalancing operations
@@ -704,7 +704,7 @@ The TracerStrategy leverages this health system:
 #### Top-Up Source Integration
 ```cadence
 // Position structure includes automatic top-up capability
-access(EImplementation) var topUpSource: {DFB.Source}?
+access(EImplementation) var topUpSource: {DeFiActions.Source}?
 ```
 
 ### Oracle Price Integration
@@ -1441,7 +1441,7 @@ This testing framework allows you to validate that the rebalancing system correc
 ## Key Features
 
 ### 1. Composable Strategies
-- Strategies are built by composing DeFiBlocks components
+- Strategies are built by composing DeFiActions components
 - Each strategy can have different risk/reward profiles
 - New strategies can be added by implementing the Strategy interface
 

cadence/contracts/TidalYield.cdc

@@ -2,8 +2,8 @@
 import "FungibleToken"
 import "Burner"
 import "ViewResolver"
-// DeFiBlocks
-import "DFB"
+// DeFiActions
+import "DeFiActions"
 
 /// THIS CONTRACT IS A MOCK AND IS NOT INTENDED FOR USE IN PRODUCTION
 /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -34,28 +34,28 @@ access(all) contract TidalYield {
     /// Strategy
     ///
     /// A Strategy is meant to encapsulate the Sink/Source entrypoints allowing for flows into and out of stacked
-    /// DeFiBlocks components. These compositions are intended to capitalize on some yield-bearing opportunity so that
+    /// DeFiActions components. These compositions are intended to capitalize on some yield-bearing opportunity so that
     /// a Strategy bears yield on that which is deposited into it, albeit not without some risk. A Strategy then can be
-    /// thought of as the top-level of a nesting of DeFiBlocks connectors & adapters where one can deposit & withdraw
+    /// thought of as the top-level of a nesting of DeFiActions connectors & adapters where one can deposit & withdraw
     /// funds into the composed DeFi workflows.
     ///
-    /// While two types of strategies may not highly differ with respect to their fields, the stacking of DeFiBlocks
+    /// While two types of strategies may not highly differ with respect to their fields, the stacking of DeFiActions
     /// components & connections they provide access to likely do. This difference in wiring is why the Strategy is a
     /// resource - because the Type and uniqueness of composition of a given Strategy must be preserved as that is its
     /// distinguishing factor. These qualities are preserved by restricting the party who can construct it, which for
     /// resources is within the contract that defines it.
     ///
     /// TODO: Consider making Sink/Source multi-asset - we could then make Strategy a composite Sink, Source & do away
     ///     with the added layer of abstraction introduced by a StrategyComposer.
-    access(all) resource interface Strategy : DFB.IdentifiableResource, Burner.Burnable {
+    access(all) resource interface Strategy : DeFiActions.IdentifiableResource, Burner.Burnable {
         /// Returns the type of Vaults that this Strategy instance can handle
         access(all) view fun getSupportedCollateralTypes(): {Type: Bool}
         /// Returns whether the provided Vault type is supported by this Strategy instance
         access(all) view fun isSupportedCollateralType(_ type: Type): Bool {
             return self.getSupportedCollateralTypes()[type] ?? false
         }
         /// Returns the balance of the given token available for withdrawal. Note that this may be an estimate due to
-        /// the lack of guarantees inherent to DeFiBlocks Sources
+        /// the lack of guarantees inherent to DeFiActions Sources
         access(all) fun availableBalance(ofToken: Type): UFix64
         /// Deposits up to the balance of the referenced Vault into this Strategy
         access(all) fun deposit(from: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}) {
@@ -75,10 +75,10 @@ access(all) contract TidalYield {
 
     /// StrategyComposer
     ///
-    /// A StrategyComposer is responsible for stacking DeFiBlocks connectors in a manner that composes a final Strategy.
-    /// Since DeFiBlock Sink/Source only support single assets and some Strategies may be multi-asset, we deal with
-    /// building a Strategy distinctly from encapsulating the top-level DFB connectors acting as entrypoints in to the
-    /// DeFiBlocks stack.
+    /// A StrategyComposer is responsible for stacking DeFiActions connectors in a manner that composes a final Strategy.
+    /// Since DeFiActions Sink/Source only support single assets and some Strategies may be multi-asset, we deal with
+    /// building a Strategy distinctly from encapsulating the top-level DFA connectors acting as entrypoints in to the
+    /// DeFiActions stack.
     ///
     /// TODO: Consider making Sink/Source multi-asset - we could then make Strategy a composite Sink, Source & do away
     ///     with the added layer of abstraction introduced by a StrategyComposer.
@@ -93,7 +93,7 @@ access(all) contract TidalYield {
         /// Composes a Strategy of the given type with the provided funds
         access(all) fun createStrategy(
             _ type: Type,
-            uniqueID: DFB.UniqueIdentifier,
+            uniqueID: DeFiActions.UniqueIdentifier,
             withFunds: @{FungibleToken.Vault}
         ): @{Strategy} {
             pre {
@@ -131,10 +131,10 @@ access(all) contract TidalYield {
                 ?.getSupportedInstanceVaults(forStrategy: forStrategy, initializedWith: initializedWith)
                 ?? {}
         }
-        /// Initializes a new Strategy of the given type with the provided Vault, identifying all associated DeFiBlocks
+        /// Initializes a new Strategy of the given type with the provided Vault, identifying all associated DeFiActions
         /// components by the provided UniqueIdentifier
         access(all)
-        fun createStrategy(_ type: Type, uniqueID: DFB.UniqueIdentifier, withFunds: @{FungibleToken.Vault}): @{Strategy} {
+        fun createStrategy(_ type: Type, uniqueID: DeFiActions.UniqueIdentifier, withFunds: @{FungibleToken.Vault}): @{Strategy} {
             pre {
                 self.composers[type] != nil: "Strategy \(type.identifier) is unsupported"
             }
@@ -193,15 +193,15 @@ access(all) contract TidalYield {
     /// A Tide is a resource enabling the management of a composed Strategy
     ///
     access(all) resource Tide : Burner.Burnable, FungibleToken.Receiver, ViewResolver.Resolver {
-        /// The UniqueIdentifier that identifies all related DeFiBlocks connectors used in the encapsulated Strategy
-        access(contract) let uniqueID: DFB.UniqueIdentifier
+        /// The UniqueIdentifier that identifies all related DeFiActions connectors used in the encapsulated Strategy
+        access(contract) let uniqueID: DeFiActions.UniqueIdentifier
         /// The type of Vault this Tide can receive as a deposit and provides as a withdrawal
         access(self) let vaultType: Type
-        /// The Strategy granting top-level access to the yield-bearing DeFiBlocks stack
+        /// The Strategy granting top-level access to the yield-bearing DeFiActions stack
         access(self) var strategy: @{Strategy}?
 
         init(strategyType: Type, withVault: @{FungibleToken.Vault}) {
-            self.uniqueID = DFB.UniqueIdentifier()
+            self.uniqueID = DeFiActions.UniqueIdentifier()
             self.vaultType = withVault.getType()
             let _strategy <- TidalYield.createStrategy(
                     type: strategyType,
@@ -213,7 +213,7 @@ access(all) contract TidalYield {
             self.strategy <-_strategy
         }
 
-        /// Returns the Tide's ID as defined by it's DFB.UniqueIdentifier.id
+        /// Returns the Tide's ID as defined by it's DeFiActions.UniqueIdentifier.id
         access(all) view fun id(): UInt64 {
             return self.uniqueID.id
         }
@@ -402,7 +402,7 @@ access(all) contract TidalYield {
         return self._borrowFactory().getSupportedInstanceVaults(forStrategy: forStrategy, initializedWith: initializedWith)
     }
     /// Creates a Strategy of the requested Type using the provided Vault as an initial deposit
-    access(all) fun createStrategy(type: Type, uniqueID: DFB.UniqueIdentifier, withFunds: @{FungibleToken.Vault}): @{Strategy} {
+    access(all) fun createStrategy(type: Type, uniqueID: DeFiActions.UniqueIdentifier, withFunds: @{FungibleToken.Vault}): @{Strategy} {
         return <- self._borrowFactory().createStrategy(type, uniqueID: uniqueID, withFunds: <-withFunds)
     }
     /// Creates a TideManager used to create and manage Tides

cadence/contracts/TidalYieldAutoBalancers.cdc

@@ -1,16 +1,16 @@
 // standards
 import "Burner"
 import "FungibleToken"
-// DeFiBlocks
-import "DFB"
+// DeFiActions
+import "DeFiActions"
 
 /// TidalYieldAutoBalancers
 ///
-/// This contract deals with the storage, retrieval and cleanup of DeFiBlocks AutoBalancers as they are used in
+/// This contract deals with the storage, retrieval and cleanup of DeFiActions AutoBalancers as they are used in
 /// TidalYield defined Strategies.
 ///
-/// AutoBalancers are stored in contract account storage at paths derived by their related DFB.UniqueIdentifier.id
-/// which identifies all DeFiBlocks components in the stack related to their composite Strategy.
+/// 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 Tide and necessarily the related Strategy is closed & burned, the related AutoBalancer and its Capabilities
 /// are destroyed and deleted
@@ -30,24 +30,24 @@ access(all) contract TidalYieldAutoBalancers {
 
     /// 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): &DFB.AutoBalancer? {
+    access(all) fun borrowAutoBalancer(id: UInt64): &DeFiActions.AutoBalancer? {
         let publicPath = self.deriveAutoBalancerPath(id: id, storage: false) as! PublicPath
-        return self.account.capabilities.borrow<&DFB.AutoBalancer>(publicPath)
+        return self.account.capabilities.borrow<&DeFiActions.AutoBalancer>(publicPath)
     }
 
     /* --- 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.
     access(account) fun _initNewAutoBalancer(
-        oracle: {DFB.PriceOracle},
+        oracle: {DeFiActions.PriceOracle},
         vaultType: Type,
         lowerThreshold: UFix64,
         upperThreshold: UFix64,
-        rebalanceSink: {DFB.Sink}?,
-        rebalanceSource: {DFB.Source}?,
-        uniqueID: DFB.UniqueIdentifier
-    ): auth(DFB.Auto, DFB.Set, DFB.Get, FungibleToken.Withdraw) &DFB.AutoBalancer {
+        rebalanceSink: {DeFiActions.Sink}?,
+        rebalanceSource: {DeFiActions.Source}?,
+        uniqueID: DeFiActions.UniqueIdentifier
+    ): auth(DeFiActions.Auto, DeFiActions.Set, DeFiActions.Get, FungibleToken.Withdraw) &DeFiActions.AutoBalancer {
 
         // derive paths & prevent collision
         let storagePath = self.deriveAutoBalancerPath(id: uniqueID.id, storage: true) as! StoragePath
@@ -60,7 +60,7 @@ access(all) contract TidalYieldAutoBalancers {
             message: "Published Capability collision found when publishing AutoBalancer for UniqueIdentifier.id \(uniqueID.id) at path \(publicPath)")
 
         // create & save AutoBalancer
-        let autoBalancer <- DFB.createAutoBalancer(
+        let autoBalancer <- DeFiActions.createAutoBalancer(
                 oracle: oracle,
                 vaultType: vaultType,
                 lowerThreshold: lowerThreshold,
@@ -73,17 +73,17 @@ access(all) contract TidalYieldAutoBalancers {
         let autoBalancerRef = self._borrowAutoBalancer(uniqueID.id)
 
         // issue & publish public capability
-        let publicCap = self.account.capabilities.storage.issue<&DFB.AutoBalancer>(storagePath)
+        let publicCap = self.account.capabilities.storage.issue<&DeFiActions.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) &DFB.AutoBalancer>(storagePath)
+        let authorizedCap = self.account.capabilities.storage.issue<auth(FungibleToken.Withdraw) &DeFiActions.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<@DFB.AutoBalancer>(),
+        assert(storedType == Type<@DeFiActions.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)")
@@ -93,9 +93,9 @@ access(all) contract TidalYieldAutoBalancers {
     /// 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(DFB.Auto, DFB.Set, DFB.Get, FungibleToken.Withdraw) &DFB.AutoBalancer {
+    fun _borrowAutoBalancer(_ id: UInt64): auth(DeFiActions.Auto, DeFiActions.Set, DeFiActions.Get, FungibleToken.Withdraw) &DeFiActions.AutoBalancer {
         let storagePath = self.deriveAutoBalancerPath(id: id, storage: true) as! StoragePath
-        return self.account.storage.borrow<auth(DFB.Auto, DFB.Set, DFB.Get, FungibleToken.Withdraw) &DFB.AutoBalancer>(
+        return self.account.storage.borrow<auth(DeFiActions.Auto, DeFiActions.Set, DeFiActions.Get, FungibleToken.Withdraw) &DeFiActions.AutoBalancer>(
                 from: storagePath
             ) ?? panic("Could not borrow reference to AutoBalancer with UniqueIdentifier.id \(id) from StoragePath \(storagePath)")
     }
@@ -113,7 +113,7 @@ access(all) contract TidalYieldAutoBalancers {
             return true
         })
         // load & burn the AutoBalancer
-        let autoBalancer <-self.account.storage.load<@DFB.AutoBalancer>(from: storagePath)
+        let autoBalancer <-self.account.storage.load<@DeFiActions.AutoBalancer>(from: storagePath)
         Burner.burn(<-autoBalancer)
     }