Merge pull request #72 from onflow/fix/rebalance-tests-flowalp-submodule

Fix: Rebalance tests - Initialize FlowALP submodule and revert incomplete UniswapV3 integration

Author: Kay-Zee

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
+.pr-drafts/
 # flow
 *.pkey
 !local/mock-incrementfi.pkey

cadence/contracts/FlowVaultsAutoBalancers.cdc

@@ -79,8 +79,7 @@ access(all) contract FlowVaultsAutoBalancers {
         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
-) &DeFiActions.AutoBalancer>(storagePath)
+        let authorizedCap = self.account.capabilities.storage.issue<auth(FungibleToken.Withdraw, FlowTransactionScheduler.Execute) &DeFiActions.AutoBalancer>(storagePath)
         autoBalancerRef.setSelfCapability(authorizedCap)
 
         // ensure proper configuration before closing

cadence/contracts/FlowVaultsStrategies.cdc

@@ -128,6 +128,176 @@ access(all) contract FlowVaultsStrategies {
             return { Type<@FlowToken.Vault>(): true }
         }
 
+        /// Composes a Strategy of the given type with the provided funds
+        access(all) fun createStrategy(
+            _ type: Type,
+            uniqueID: DeFiActions.UniqueIdentifier,
+            withFunds: @{FungibleToken.Vault}
+        ): @{FlowVaults.Strategy} {
+            // this PriceOracle is mocked and will be shared by all components used in the TracerStrategy
+            // TODO: add ERC4626 price oracle
+            let oracle = MockOracle.PriceOracle()
+
+            // assign token types
+
+            let moetTokenType: Type = Type<@MOET.Vault>()
+            let yieldTokenType = Type<@YieldToken.Vault>()
+            // assign collateral & flow token types
+            let collateralType = withFunds.getType()
+
+            // configure and AutoBalancer for this stack
+            let autoBalancer = FlowVaultsAutoBalancers._initNewAutoBalancer(
+                oracle: oracle,             // used to determine value of deposits & when to rebalance
+                vaultType: yieldTokenType,  // the type of Vault held by the AutoBalancer
+                lowerThreshold: 0.95,       // set AutoBalancer to pull from rebalanceSource when balance is 5% below value of deposits
+                upperThreshold: 1.05,       // set AutoBalancer to push to rebalanceSink when balance is 5% below value of deposits
+                rebalanceSink: nil,         // nil on init - will be set once a PositionSink is available
+                rebalanceSource: nil,       // nil on init - not set for TracerStrategy
+                uniqueID: uniqueID          // identifies AutoBalancer as part of this Strategy
+            )
+            // enables deposits of YieldToken to the AutoBalancer
+            let abaSink = autoBalancer.createBalancerSink() ?? panic("Could not retrieve Sink from AutoBalancer with id \(uniqueID.id)")
+            // enables withdrawals of YieldToken from the AutoBalancer
+            let abaSource = autoBalancer.createBalancerSource() ?? panic("Could not retrieve Sink from AutoBalancer with id \(uniqueID.id)")
+
+            // init Stable <> YIELD swappers
+            //
+            // Stable -> YieldToken
+            let stableToYieldSwapper = MockSwapper.Swapper(
+                    inVault: moetTokenType,
+                    outVault: yieldTokenType,
+                    uniqueID: uniqueID
+                )
+            // YieldToken -> Stable
+            let yieldToStableSwapper = MockSwapper.Swapper(
+                    inVault: yieldTokenType,
+                    outVault: moetTokenType,
+                    uniqueID: uniqueID
+                )
+
+            // init SwapSink directing swapped funds to AutoBalancer
+            //
+            // Swaps provided Stable to YieldToken & deposits to the AutoBalancer
+            let abaSwapSink = SwapConnectors.SwapSink(swapper: stableToYieldSwapper, sink: abaSink, uniqueID: uniqueID)
+            // Swaps YieldToken & provides swapped Stable, sourcing YieldToken from the AutoBalancer
+            let abaSwapSource = SwapConnectors.SwapSource(swapper: yieldToStableSwapper, source: abaSource, uniqueID: uniqueID)
+
+            // open a FlowALP position
+            let poolCap = FlowVaultsStrategies.account.storage.load<Capability<auth(FlowALP.EParticipant, FlowALP.EPosition) &FlowALP.Pool>>(
+                from: FlowALP.PoolCapStoragePath
+            ) ?? panic("Missing pool capability")
+
+            let poolRef = poolCap.borrow() ?? panic("Invalid Pool Cap")
+
+            let pid = poolRef.createPosition(
+                funds: <-withFunds,
+                issuanceSink: abaSwapSink,
+                repaymentSource: abaSwapSource,
+                pushToDrawDownSink: true
+            )
+            let position = FlowALP.Position(id: pid, pool: poolCap)
+            FlowVaultsStrategies.account.storage.save(poolCap, to: FlowALP.PoolCapStoragePath)
+
+            // get Sink & Source connectors relating to the new Position
+            let positionSink = position.createSinkWithOptions(type: collateralType, pushToDrawDownSink: true)
+            let positionSource = position.createSourceWithOptions(type: collateralType, pullFromTopUpSource: true) // TODO: may need to be false
+
+            // init YieldToken -> FLOW Swapper
+            let yieldToFlowSwapper = MockSwapper.Swapper(
+                inVault: yieldTokenType,
+                outVault: collateralType, 
+                uniqueID: uniqueID
+            )
+            // allows for YieldToken to be deposited to the Position
+            let positionSwapSink = SwapConnectors.SwapSink(swapper: yieldToFlowSwapper, sink: positionSink, uniqueID: uniqueID)
+
+            // set the AutoBalancer's rebalance Sink which it will use to deposit overflown value,
+            // recollateralizing the position
+            autoBalancer.setSink(positionSwapSink, updateSinkID: true)
+
+            return <-create TracerStrategy(
+                id: DeFiActions.createUniqueIdentifier(),
+                collateralType: collateralType,
+                position: position
+            )
+        }
+    }
+
+    /// This strategy uses mUSDC vaults
+    access(all) resource mUSDCStrategy : FlowVaults.Strategy, DeFiActions.IdentifiableResource {
+        /// An optional identifier allowing protocols to identify stacked connector operations by defining a protocol-
+        /// specific Identifier to associated connectors on construction
+        access(contract) var uniqueID: DeFiActions.UniqueIdentifier?
+        access(self) let position: FlowALP.Position
+        access(self) var sink: {DeFiActions.Sink}
+        access(self) var source: {DeFiActions.Source}
+
+        init(id: DeFiActions.UniqueIdentifier, collateralType: Type, position: FlowALP.Position) {
+            self.uniqueID = id
+            self.position = position
+            self.sink = position.createSink(type: collateralType)
+            self.source = position.createSourceWithOptions(type: collateralType, pullFromTopUpSource: true)
+        }
+
+        // Inherited from FlowVaults.Strategy default implementation
+        // access(all) view fun isSupportedCollateralType(_ type: Type): Bool
+
+        access(all) view fun getSupportedCollateralTypes(): {Type: Bool} {
+            return { self.sink.getSinkType(): true }
+        }
+        /// Returns the amount available for withdrawal via the inner Source
+        access(all) fun availableBalance(ofToken: Type): UFix64 {
+            return ofToken == self.source.getSourceType() ? self.source.minimumAvailable() : 0.0
+        }
+        /// Deposits up to the inner Sink's capacity from the provided authorized Vault reference
+        access(all) fun deposit(from: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}) {
+            self.sink.depositCapacity(from: from)
+        }
+        /// Withdraws up to the max amount, returning the withdrawn Vault. If the requested token type is unsupported,
+        /// an empty Vault is returned.
+        access(FungibleToken.Withdraw) fun withdraw(maxAmount: UFix64, ofToken: Type): @{FungibleToken.Vault} {
+            if ofToken != self.source.getSourceType() {
+                return <- DeFiActionsUtils.getEmptyVault(ofToken)
+            }
+            return <- self.source.withdrawAvailable(maxAmount: maxAmount)
+        }
+        /// Executed when a Strategy is burned, cleaning up the Strategy's stored AutoBalancer
+        access(contract) fun burnCallback() {
+            FlowVaultsAutoBalancers._cleanupAutoBalancer(id: self.id()!)
+        }
+        access(all) fun getComponentInfo(): DeFiActions.ComponentInfo {
+            return DeFiActions.ComponentInfo(
+                type: self.getType(),
+                id: self.id(),
+                innerComponents: []
+            )
+        }
+        access(contract) view fun copyID(): DeFiActions.UniqueIdentifier? {
+            return self.uniqueID
+        }
+        access(contract) fun setID(_ id: DeFiActions.UniqueIdentifier?) {
+            self.uniqueID = id
+        }
+    }
+
+    /// This StrategyComposer builds a mUSDCStrategy
+    access(all) resource mUSDCStrategyComposer : FlowVaults.StrategyComposer {
+        /// Returns the Types of Strategies composed by this StrategyComposer
+        access(all) view fun getComposedStrategyTypes(): {Type: Bool} {
+            return { Type<@mUSDCStrategy>(): true }
+        }
+
+        /// Returns the Vault types which can be used to initialize a given Strategy
+        access(all) view fun getSupportedInitializationVaults(forStrategy: Type): {Type: Bool} {
+            return { Type<@FlowToken.Vault>(): true }
+        }
+
+        /// Returns the Vault types which can be deposited to a given Strategy instance if it was initialized with the
+        /// provided Vault type
+        access(all) view fun getSupportedInstanceVaults(forStrategy: Type, initializedWith: Type): {Type: Bool} {
+            return { Type<@FlowToken.Vault>(): true }
+        }
+
         /// Composes a Strategy of the given type with the provided funds
         access(all) fun createStrategy(
             _ type: Type,

flow.json

@@ -60,20 +60,6 @@
 				"testnet": "c16c0b1229843606"
 			}
 		},
-		"FlowTransactionScheduler": {
-			"source": "mainnet://e467b9dd11fa00df.FlowTransactionScheduler",
-			"aliases": {
-				"emulator": "f8d6e0586b0a20c7",
-				"mainnet": "e467b9dd11fa00df",
-				"testnet": "8c5303eaa26202d6"
-			}
-		},
-		"FlowTransactionSchedulerUtils": {
-			"source": "mainnet://e467b9dd11fa00df.FlowTransactionSchedulerUtils",
-			"aliases": {
-				"mainnet": "e467b9dd11fa00df"
-			}
-		},
 		"FlowVaults": {
 			"source": "cadence/contracts/FlowVaults.cdc",
 			"aliases": {
@@ -358,6 +344,15 @@
 				"testnet": "dfc20aee650fcbdf"
 			}
 		},
+		"FlowFees": {
+			"source": "mainnet://f919ee77447b7497.FlowFees",
+			"hash": "d02bc8295c0434cf2b0a96a77d992f49f52e7865debda84e7a21e176e163a680",
+			"aliases": {
+				"emulator": "e5a8b7f23e8b548f",
+				"mainnet": "f919ee77447b7497",
+				"testnet": "912d5440f7e3769e"
+			}
+		},
 		"FlowStorageFees": {
 			"source": "mainnet://e467b9dd11fa00df.FlowStorageFees",
 			"hash": "e38d8a95f6518b8ff46ce57dfa37b4b850b3638f33d16333096bc625b6d9b51a",
@@ -376,6 +371,24 @@
 				"testnet": "7e60df042a9c0868"
 			}
 		},
+		"FlowTransactionScheduler": {
+			"source": "mainnet://e467b9dd11fa00df.FlowTransactionScheduler",
+			"hash": "312885f5fa3bc70327dfb59edc5da6d30b826002c322db8c566ddf17099310ac",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"mainnet": "e467b9dd11fa00df",
+				"testnet": "8c5303eaa26202d6"
+			}
+		},
+		"FlowTransactionSchedulerUtils": {
+			"source": "mainnet://e467b9dd11fa00df.FlowTransactionSchedulerUtils",
+			"hash": "2e26d0bf8e6278b79880a47cb3cd55c499777fb96d76bde3f647b546805bc470",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"mainnet": "e467b9dd11fa00df",
+				"testnet": "8c5303eaa26202d6"
+			}
+		},
 		"FungibleToken": {
 			"source": "mainnet://f233dcee88fe0abe.FungibleToken",
 			"hash": "23c1159cf99b2b039b6b868d782d57ae39b8d784045d81597f100a4782f0285b",