Add FlowYieldVaults structure

Author: holyfuchs

cadence/contracts/actions/FlowActions.cdc

@@ -1,4 +1,44 @@
+import "FungibleToken"
 
 access(all) contract FlowActions {
 
-}
+    // Interfaces are not fixed and still under development.
+    // This is the typical EVM interface translated to cadence.
+    // Necessary to setup FlowYieldVaults structure.
+    access(all) struct interface Swapper {
+        access(all) token0: Type
+        access(all) token1: Type
+        access(all) fee: UInt32
+
+        /// Exact Input: "I have this many tokens, give me whatever they are worth"
+        access(all) fun quoteExactInput(
+            zeroForOne: Bool,
+            amountIn: UFix64
+        ): UFix64
+
+        /// Exact Output: "I want exactly this many tokens, how much do I need to pay?"
+        access(all) fun quoteExactOutput(
+            zeroForOne: Bool,
+            amountOut: UFix64
+        ): UFix64
+
+        access(all) fun swap(
+            zeroForOne: Bool,
+            inVault: @{FungibleToken.Vault}
+        ): @{FungibleToken.Vault}
+    }
+
+    /// FYV needs this functionality but it doesn't have to be implemented like this!
+    /// this is dangerous!! if a 3rd party provides a type and we are executing
+    /// createEmptyVault any code can be run. (reentrancy, etc)
+    access(all) fun getEmptyVault(_ vaultType: Type): @{FungibleToken.Vault} {
+        post {
+            result.getType() == vaultType:
+            "Invalid Vault returned - expected \(vaultType.identifier) but returned \(result.getType().identifier)"
+        }
+        return <- getAccount(vaultType.address!)
+            .contracts
+            .borrow<&{FungibleToken}>(name: vaultType.contractName!)!
+            .createEmptyVault(vaultType: vaultType)
+    }
+}

cadence/contracts/yield_vaults/FlowYieldVaults.cdc

@@ -1,4 +1,107 @@
+import "FlowYieldVaultsInterfaces"
 
-access(all) contract FlowYieldVaults {
+/// Registry of yield vault strategies on this account, keyed by name.
+/// An `Admin` resource (saved at `adminStoragePath` on the contract account)
+/// registers and removes strategies conforming to
+/// `FlowYieldVaultsInterfaces.Strategy`. Yield vaults are minted from a
+/// registered strategy by `name` through `createYieldVault`.
+///
+/// This contract is strategy-agnostic: it does not depend on any specific
+/// strategy family. Concrete strategies live in their own contracts and are
+/// plugged in through `Admin.registerStrategy`.
+access(all) contract FlowYieldVaults: FlowYieldVaultsInterfaces {
 
+    /// Emitted when a strategy is registered under `name`.
+    access(all) event StrategyCreated(name: String)
+    /// Emitted when a strategy is removed from the registry.
+    access(all) event StrategyRemoved(name: String)
+    /// Emitted when a yield vault is minted from the named strategy.
+    access(all) event StrategyVaultCreated(name: String)
+
+    /// Storage path where the `Admin` resource is saved on this account.
+    access(all) let adminStoragePath: StoragePath
+
+    /// Registered strategies, keyed by name. Names are unique; registering
+    /// an already-used name panics.
+    access(self) let strategies: {String: {FlowYieldVaultsInterfaces.Strategy}}
+
+    /// Admin resource; holder may register / remove strategies and mint
+    /// yield vaults directly (bypassing any external access gate).
+    access(all) resource Admin {
+        /// Registers `strategy` under `name`.
+        /// Panics if a strategy is already registered under that name.
+        ///
+        /// **Parameters**
+        /// - `name`: Unique identifier for the strategy in this registry.
+        /// - `strategy`: Any value conforming to
+        ///   `FlowYieldVaultsInterfaces.Strategy`.
+        access(all) fun registerStrategy(
+            name: String,
+            strategy: {FlowYieldVaultsInterfaces.Strategy}
+        ) {
+            assert(
+                FlowYieldVaults.strategies[name] == nil,
+                message: "Strategy already registered: \(name)"
+            )
+            FlowYieldVaults.strategies[name] = strategy
+            emit StrategyCreated(name: name)
+        }
+
+        /// Removes the strategy registered under `name`.
+        /// Panics if no strategy is registered under that name. Does not
+        /// affect already-minted yield vaults — those captured the strategy
+        /// parameters at creation time.
+        ///
+        /// **Parameters**
+        /// - `name`: Name of the strategy to remove.
+        access(all) fun removeStrategy(name: String) {
+            let strategy = FlowYieldVaults.strategies.remove(key: name)
+            if strategy == nil {
+                panic("Strategy not found")
+            }
+            emit StrategyRemoved(name: name)
+        }
+
+        /// Mints a yield vault from a registered strategy.
+        /// Wrapper around the contract-level `createYieldVault`
+        /// for callers that hold the admin resource.
+        ///
+        /// **Parameters**
+        /// - `name`: Name of the registered strategy.
+        ///
+        /// **Returns** A new `YieldVault` for the caller to save in storage.
+        access(all) fun createYieldVault(name: String): @{FlowYieldVaultsInterfaces.YieldVault} {
+            return <- FlowYieldVaults.createYieldVault(name: name)
+        }
+    }
+
+    /// Mints a yield vault from a registered strategy.
+    /// Panics if no strategy is registered under `name`.
+    /// `access(account)` so that only contracts on this account (e.g.
+    /// `FlowYieldVaultsEarlyAccess`) can gate or invoke vault creation.
+    ///
+    /// **Parameters**
+    /// - `name`: Name of the registered strategy.
+    ///
+    /// **Returns** A new `YieldVault` for the caller to save in storage.
+    access(account) fun createYieldVault(name: String): @{FlowYieldVaultsInterfaces.YieldVault} {
+        let strategy = self.strategies[name] ?? panic("Strategy not found")
+        let vault <- strategy.createYieldVault(name: name)
+        emit StrategyVaultCreated(name: name)
+        return <- vault
+    }
+
+    view access(all) fun strategyCount(): UInt64 {
+        return UInt64(self.strategies.length)
+    }
+
+    view access(all) fun strategyNames(): [String] {
+        return self.strategies.keys
+    }
+
+    init() {
+        self.strategies = {}
+        self.adminStoragePath = StoragePath(identifier: "FlowYieldVaultsAdmin")!
+        self.account.storage.save(<- create Admin(), to: self.adminStoragePath)
+    }
 }

cadence/contracts/yield_vaults/FlowYieldVaultsEarlyAccess.cdc

@@ -32,14 +32,14 @@ access(all) contract FlowYieldVaultsEarlyAccess {
         /// Panics if allowance is exhausted.
         ///
         /// **Parameters**
-        /// - `strategyID`: Identifies the vault strategy to create.
+        /// - `name`: Name of the registered strategy to create a vault for.
         ///
         /// **Returns** A new `YieldVault` to be saved in the caller's storage.
-        access(all) fun createYieldVault(strategyID: UInt64): @{FlowYieldVaultsInterfaces.YieldVault} {
+        access(all) fun createYieldVault(name: String): @{FlowYieldVaultsInterfaces.YieldVault} {
             pre { self.remainingAllowance > 0: "No remaining allowance" }
             self.remainingAllowance = self.remainingAllowance - 1
             let fyv = FlowYieldVaultsEarlyAccess.getFlowYieldVaultsContract()
-            let vault <- fyv.createYieldVault(strategyID: strategyID)
+            let vault <- fyv.createYieldVault(name: name)
             emit PassUsed(passUUID: self.uuid, remainingAllowance: self.remainingAllowance)
             return <- vault
         }

cadence/contracts/yield_vaults/FlowYieldVaultsInterfaces.cdc

@@ -3,10 +3,10 @@ import "FungibleToken"
 access(all) contract interface FlowYieldVaultsInterfaces {
 
     access(all) struct interface Strategy {
-        access(all) fun createYieldVault(strategyID: UInt64): @{YieldVault}
+        access(all) fun createYieldVault(name: String): @{YieldVault}
     }
 
     access(all) resource interface YieldVault: FungibleToken.Provider, FungibleToken.Receiver {}
 
-    access(account) fun createYieldVault(strategyID: UInt64): @{YieldVault}
+    access(account) fun createYieldVault(name: String): @{YieldVault}
 }

cadence/scripts/yield_vaults/get_strategies.cdc

@@ -0,0 +1,5 @@
+import "FlowYieldVaults"
+
+access(all) fun main(): [String] {
+    return FlowYieldVaults.strategyNames()
+}

cadence/scripts/yield_vaults/get_strategy_count.cdc

@@ -0,0 +1,5 @@
+import "FlowYieldVaults"
+
+access(all) fun main(): UInt64 {
+    return FlowYieldVaults.strategyCount()
+}