[WIP] Update Pool & Position creation interface & logic

.cursor/rules/tests-rules.mdc

@@ -0,0 +1,5 @@
+---
+description:
+globs:
+alwaysApply: false
+---

cadence/contracts/mocks/MockOracle.cdc

@@ -0,0 +1,69 @@
+import "FungibleToken"
+
+import "DFB"
+
+///
+/// THIS CONTRACT IS A MOCK AND IS NOT INTENDED FOR USE IN PRODUCTION
+/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+///
+access(all) contract MockOracle {
+
+    /// token price denominated in USD
+    access(self) let mockedPrices: {Type: UFix64}
+    /// the token type in which prices are denominated
+    access(self) let unitOfAccount: Type
+    /// bps up or down by which current price moves when bumpPrice is called
+    access(self) let bumpVariance: UInt16
+
+    access(all) struct PriceOracle : DFB.PriceOracle {
+
+        /// Returns the asset type serving as the price basis - e.g. USD in FLOW/USD
+        access(all) view fun unitOfAccount(): Type {
+            return MockOracle.unitOfAccount
+        }
+
+        /// Returns the latest price data for a given asset denominated in unitOfAccount()
+        access(all) fun price(ofToken: Type): UFix64? {
+            if ofToken == self.unitOfAccount() {
+                return 1.0
+            }
+            return MockOracle.mockedPrices[ofToken]
+        }
+    }
+
+    // resets the price of the token within 0-bumpVariance (bps) of the current price
+    // allows for mocked data to have variability
+    access(all) fun bumpPrice(forToken: Type) {
+        if forToken == self.unitOfAccount {
+            return
+        }
+        let current = self.mockedPrices[forToken]
+            ?? panic("MockOracle does not have a price set for token \(forToken.identifier)")
+        let sign = revertibleRandom<UInt8>(modulo: 2) // 0 - down | 1 - up
+        let variance = self.convertToBPS(revertibleRandom<UInt16>(modulo: self.bumpVariance)) // bps up or down
+        if sign == 0 {
+            self.mockedPrices[forToken] = current - (current * variance)
+        } else {
+            self.mockedPrices[forToken] = current + (current * variance)
+        }
+    }
+
+    access(all) fun setPrice(forToken: Type, price: UFix64) {
+        self.mockedPrices[forToken] = price
+    }
+
+    access(self) view fun convertToBPS(_ variance: UInt16): UFix64 {
+        var res = UFix64(variance)
+        for i in InclusiveRange(0, 3) {
+            res = res / 10.0
+        } 
+        return res
+    }
+
+    init(unitOfAccountIdentifier: String) {
+        self.mockedPrices = {}
+        // e.g. vault.getType().identifier == 'A.0ae53cb6e3f42a79.FlowToken.Vault'
+        self.unitOfAccount = CompositeType(unitOfAccountIdentifier) ?? panic("Invalid unitOfAccountIdentifier \(unitOfAccountIdentifier)")
+        self.bumpVariance = 100 // 0.1% variance
+    }
+}

cadence/contracts/mocks/MockTidalProtocolConsumer.cdc

@@ -0,0 +1,56 @@
+import "FungibleToken"
+
+import "DFB"
+import "TidalProtocol"
+
+/// THIS CONTRACT IS NOT SAFE FOR PRODUCTION - FOR TEST USE ONLY
+/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+///
+/// A simple contract enabling the persistent storage of a Position similar to a pattern expected for platforms
+/// building on top of TidalProtocol's lending protocol
+///
+access(all) contract MockTidalProtocolConsumer {
+
+    /// Canonical path for where the wrapper is to be stored
+    access(all) let WrapperStoragePath: StoragePath
+
+    /// Opens a TidalProtocol Position and returns a PositionWrapper containing that new position
+    ///
+    access(all)
+    fun createPositionWrapper(
+        collateral: @{FungibleToken.Vault},
+        issuanceSink: {DFB.Sink},
+        repaymentSource: {DFB.Source}?,
+        pushToDrawDownSink: Bool
+    ): @PositionWrapper {
+        return <- create PositionWrapper(
+            position: TidalProtocol.openPosition(
+                collateral: <-collateral,
+                issuanceSink: issuanceSink,
+                repaymentSource: repaymentSource,
+                pushToDrawDownSink: pushToDrawDownSink
+            )
+        )
+    }
+
+    /// A simple resource encapsulating a TidalProtocol Position
+    access(all) resource PositionWrapper {
+
+        access(self) let position: TidalProtocol.Position
+
+        init(position: TidalProtocol.Position) {
+            self.position = position
+        }
+
+        /// NOT SAFE FOR PRODUCTION
+        ///
+        /// Returns a reference to the wrapped Position
+        access(all) fun borrowPosition(): &TidalProtocol.Position {
+            return &self.position
+        }
+    }
+
+    init() {
+        self.WrapperStoragePath = /storage/tidalProtocolPositionWrapper
+    }
+}

cadence/scripts/funds_required_for_target_health.cdc

@@ -0,0 +1,14 @@
+import TidalProtocol from "TidalProtocol"
+
+access(all) fun main(poolAddress: Address, pid: UInt64, tokenType: Type, targetHealth: UFix64): UFix64 {
+    let poolCap = getAccount(poolAddress)
+        .capabilities.get<&TidalProtocol.Pool>(/public/tidalPool)
+        .borrow()
+        ?? panic("Could not borrow pool capability")
+
+    return poolCap.fundsRequiredForTargetHealth(
+        pid: pid,
+        type: tokenType,
+        targetHealth: targetHealth
+    )
+} 

cadence/scripts/get_available_balance.cdc

@@ -0,0 +1,19 @@
+import TidalProtocol from "../contracts/TidalProtocol.cdc"
+
+access(all) fun main(poolAddress: Address, positionId: UInt64, tokenType: String): UFix64 {
+    // Get the pool reference
+    let pool = getAccount(poolAddress).capabilities.borrow<&TidalProtocol.Pool>(
+        /public/tidalPool
+    ) ?? panic("Could not borrow pool reference")
+
+    // Parse the token type
+    let vaultType = CompositeType(tokenType) 
+        ?? panic("Invalid token type identifier")
+
+    // Get the position
+    let position = pool.borrowPosition(pid: positionId)
+        ?? panic("Position not found")
+
+    // Get available balance (includes source integration)
+    return position.getAvailableBalance(tokenType: vaultType)
+} 

cadence/scripts/get_flowtoken_balance.cdc

@@ -0,0 +1,10 @@
+import FlowToken from "FlowToken"
+import FungibleToken from "FungibleToken"
+
+access(all) fun main(address: Address): UFix64 {
+    let account = getAccount(address)
+    let vaultRef = account.capabilities.borrow<&{FungibleToken.Balance}>(/public/flowTokenBalance)
+        ?? panic("Could not borrow Balance reference to the Vault")
+
+    return vaultRef.balance
+} 

cadence/scripts/get_pool_reference.cdc

@@ -0,0 +1,13 @@
+import TidalProtocol from "TidalProtocol"
+
+// Script to check if an account has a pool capability published
+access(all) fun main(address: Address): Bool {
+    let account = getAccount(address)
+
+    // Check if the account has a pool capability published
+    let poolCap = account.capabilities.get<&TidalProtocol.Pool>(
+        /public/tidalProtocolPool
+    )
+
+    return poolCap.check()
+} 

cadence/scripts/get_position_balances.cdc

@@ -0,0 +1,41 @@
+import TidalProtocol from "../contracts/TidalProtocol.cdc"
+
+access(all) struct BalanceInfo {
+    access(all) let tokenType: Type
+    access(all) let balance: UFix64
+    access(all) let availableBalance: UFix64
+
+    init(tokenType: Type, balance: UFix64, availableBalance: UFix64) {
+        self.tokenType = tokenType
+        self.balance = balance
+        self.availableBalance = availableBalance
+    }
+}
+
+access(all) fun main(poolAddress: Address, positionId: UInt64): [BalanceInfo] {
+    // Get the pool reference
+    let pool = getAccount(poolAddress).capabilities.borrow<&TidalProtocol.Pool>(
+        /public/tidalPool
+    ) ?? panic("Could not borrow pool reference")
+
+    // Get the position
+    let position = pool.borrowPosition(pid: positionId)
+        ?? panic("Position not found")
+
+    // Get all balances
+    let balances = position.getBalances()
+
+    // Create result array
+    let result: [BalanceInfo] = []
+
+    for balance in balances {
+        let availableBalance = position.getAvailableBalance(tokenType: balance.tokenType)
+        result.append(BalanceInfo(
+            tokenType: balance.tokenType,
+            balance: balance.balance,
+            availableBalance: availableBalance
+        ))
+    }
+
+    return result
+} 

cadence/scripts/get_position_details.cdc

@@ -0,0 +1,14 @@
+import TidalProtocol from "TidalProtocol"
+
+access(all) fun main(accountAddress: Address, positionID: UInt64): TidalProtocol.PositionDetails? {
+    // Get the pool capability from the account
+    let capability = getAccount(accountAddress).capabilities
+        .get<&TidalProtocol.Pool>(/public/testPool)
+
+    if let pool = capability.borrow() {
+        // Get position details
+        return pool.getPositionDetails(pid: positionID)
+    }
+
+    return nil
+} 

cadence/scripts/get_position_health.cdc

@@ -0,0 +1,10 @@
+import TidalProtocol from "TidalProtocol"
+
+access(all) fun main(poolAddress: Address, pid: UInt64): UFix64 {
+    let poolCap = getAccount(poolAddress)
+        .capabilities.get<&TidalProtocol.Pool>(/public/tidalPool)
+        .borrow()
+        ?? panic("Could not borrow pool capability")
+
+    return poolCap.positionHealth(pid: pid)
+} 

cadence/scripts/get_target_health.cdc

@@ -0,0 +1,16 @@
+import TidalProtocol from "../contracts/TidalProtocol.cdc"
+
+access(all) fun main(poolAddress: Address, positionId: UInt64): UFix64 {
+    // Get the pool reference
+    let pool = getAccount(poolAddress).capabilities.borrow<&TidalProtocol.Pool>(
+        /public/tidalPool
+    ) ?? panic("Could not borrow pool reference")
+
+    // Get the position
+    let position = pool.borrowPosition(pid: positionId)
+        ?? panic("Position not found")
+
+    // Note: getTargetHealth() always returns 1.5 in the Position struct interface
+    // The actual target health is stored in InternalPosition and not accessible
+    return position.getTargetHealth()
+} 

cadence/scripts/health_computation.cdc

@@ -0,0 +1,8 @@
+import TidalProtocol from "TidalProtocol"
+
+access(all) fun main(effectiveCollateral: UFix64, effectiveDebt: UFix64): UFix64 {
+    return TidalProtocol.healthComputation(
+        effectiveCollateral: effectiveCollateral,
+        effectiveDebt: effectiveDebt
+    )
+} 

cadence/scripts/test_access_control.cdc

@@ -0,0 +1,57 @@
+import TidalProtocol from "TidalProtocol"
+
+// Test script for validating access control and entitlements
+access(all) fun main(): Bool {
+    // Test 1: Create pool and position (tests public access)
+    let oracle = TidalProtocol.DummyPriceOracle(defaultToken: Type<String>())
+    let pool <- TidalProtocol.createTestPoolWithOracle(defaultToken: Type<String>())
+    let positionId = pool.createPosition()
+
+    // Test 2: Verify public functions work without special entitlements
+    let health = pool.positionHealth(pid: positionId)
+    let supportedTokens = pool.getSupportedTokens()
+    let tokenSupported = pool.isTokenSupported(tokenType: Type<String>())
+    let reserveBalance = pool.reserveBalance(type: Type<String>())
+
+    // Test 3: Get position details instead of creating Position struct
+    let positionDetails = pool.getPositionDetails(pid: positionId)
+    let positionHealth = positionDetails.health
+    let positionBalances = positionDetails.balances
+    let availableBalance = positionDetails.defaultTokenAvailableBalance
+
+    // Test 4: Test that health functions return expected values for empty position
+    let healthIsOne = health == 1.0 && positionHealth == 1.0
+    let balancesEmpty = positionBalances.length == 0
+    let reserveIsZero = reserveBalance == 0.0
+    let availableIsZero = availableBalance == 0.0
+
+    // Test 5: Verify DummyPriceOracle works correctly
+    let oracleUnitOfAccount = oracle.unitOfAccount()
+    let defaultTokenPrice = oracle.price(token: Type<String>())
+    let priceIsOne = defaultTokenPrice == 1.0
+    let correctUnitOfAccount = oracleUnitOfAccount == Type<String>()
+
+    // Test 6: Verify helper functions work
+    let healthCalc = TidalProtocol.healthComputation(effectiveCollateral: 100.0, effectiveDebt: 50.0)
+    let healthIs2 = healthCalc == 2.0
+
+    // Test 7: Verify Balance Direction enum
+    let creditDirection = TidalProtocol.BalanceDirection.Credit
+    let debitDirection = TidalProtocol.BalanceDirection.Debit
+    let directionsWork = creditDirection != debitDirection
+
+    // Cleanup
+    destroy pool
+
+    // Comprehensive result
+    return healthIsOne && 
+           balancesEmpty && 
+           reserveIsZero && 
+           availableIsZero && 
+           priceIsOne && 
+           correctUnitOfAccount && 
+           healthIs2 && 
+           directionsWork && 
+           tokenSupported && 
+           supportedTokens.length >= 1
+} 

cadence/scripts/test_access_practical.cdc

@@ -0,0 +1,34 @@
+import TidalProtocol from "TidalProtocol"
+
+// Test practical access control scenarios
+access(all) fun main(): Bool {
+    // Test 1: Create pool and verify public access
+    let oracle = TidalProtocol.DummyPriceOracle(defaultToken: Type<String>())
+    let pool <- TidalProtocol.createTestPoolWithOracle(defaultToken: Type<String>())
+
+    // Test 2: Public functions should work
+    let positionId = pool.createPosition()
+    let health = pool.positionHealth(pid: positionId)
+    let supportedTokens = pool.getSupportedTokens()
+
+    // Test 3: Verify position details access
+    let details = pool.getPositionDetails(pid: positionId)
+
+    // Test 4: Check all public getters work
+    let isSupported = pool.isTokenSupported(tokenType: Type<String>())
+    let reserveBalance = pool.reserveBalance(type: Type<String>())
+
+    // Get default token from position details
+    let defaultToken = details.poolDefaultToken
+
+    // Cleanup
+    destroy pool
+
+    // All tests passed if we got here
+    return health == 1.0 && 
+           details.health == 1.0 && 
+           supportedTokens.length >= 1 &&
+           defaultToken == Type<String>() &&
+           isSupported &&
+           reserveBalance == 0.0
+}