Update Pool & Position creation (replaces #6)

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "DeFiBlocks"]
 	path = DeFiBlocks
-	url = https://github.com/onflow/DeFiBlocks
+	url = git@github.com:onflow/DeFiBlocks.git

cadence/contracts/MOET.cdc

@@ -149,8 +149,11 @@ access(all) contract MOET : FungibleToken {
 
         access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let vault <- from as! @MOET.Vault
-            self.balance = self.balance + vault.balance
+            let amount = vault.balance
+            vault.balance = 0.0
             destroy vault
+
+            self.balance = self.balance + amount
         }
 
         access(all) fun createEmptyVault(): @MOET.Vault {

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/tidal-protocol/get_available_balance.cdc

@@ -0,0 +1,13 @@
+import "TidalProtocol"
+
+access(all)
+fun main(pid: UInt64, vaultIdentifier: String, pullFromTopUpSource: Bool): UFix64 {
+    let vaultType = CompositeType(vaultIdentifier) ?? panic("Invalid vaultIdentifier \(vaultIdentifier)")
+
+    let protocolAddress= Type<@TidalProtocol.Pool>().address!
+
+    let pool = getAccount(protocolAddress).capabilities.borrow<&TidalProtocol.Pool>(TidalProtocol.PoolPublicPath)
+        ?? panic("Could not find a configured TidalProtocol Pool in account \(protocolAddress) at path \(TidalProtocol.PoolPublicPath)")
+
+    return pool.availableBalance(pid: pid, type: vaultType, pullFromTopUpSource: pullFromTopUpSource)
+}

cadence/scripts/tidal-protocol/get_reserve_balance_for_type.cdc

@@ -0,0 +1,17 @@
+import "TidalProtocol"
+
+/// Returns the Pool's reserve balance for a given Vault type
+///
+/// @param vaultIdentifier: The Type identifier (e.g. vault.getType().identifier) of the related token vault
+///
+access(all)
+fun main(vaultIdentifier: String): UFix64 {
+    let vaultType = CompositeType(vaultIdentifier) ?? panic("Invalid vaultIdentifier \(vaultIdentifier)")
+
+    let protocolAddress= Type<@TidalProtocol.Pool>().address!
+
+    let pool = getAccount(protocolAddress).capabilities.borrow<&TidalProtocol.Pool>(TidalProtocol.PoolPublicPath)
+        ?? panic("Could not find a configured TidalProtocol Pool in account \(protocolAddress) at path \(TidalProtocol.PoolPublicPath)")
+
+    return pool.reserveBalance(type: vaultType)
+}

cadence/scripts/tidal-protocol/pool_exists.cdc

@@ -0,0 +1,9 @@
+import "TidalProtocol"
+
+/// Returns whether there is a Pool stored in the provided account's address. This address would normally be the
+/// TidalProtocol contract address
+///
+access(all)
+fun main(address: Address): Bool {
+    return getAccount(address).storage.type(at: TidalProtocol.PoolStoragePath) == Type<@TidalProtocol.Pool>()
+}

cadence/scripts/tidal-protocol/position_health.cdc

@@ -0,0 +1,13 @@
+import "TidalProtocol"
+
+/// Returns the position health for a given position id, reverting if the position does not exist
+///
+/// @param pid: The Position ID
+///
+access(all)
+fun main(pid: UInt64): UFix64 {
+    let protocolAddress= Type<@TidalProtocol.Pool>().address!
+    return getAccount(protocolAddress).capabilities.borrow<&TidalProtocol.Pool>(TidalProtocol.PoolPublicPath)
+        ?.positionHealth(pid: pid)
+        ?? panic("Could not find a configured TidalProtocol Pool in account \(protocolAddress) at path \(TidalProtocol.PoolPublicPath)")
+}

cadence/scripts/tokens/get_balance.cdc

@@ -0,0 +1,8 @@
+import "FungibleToken"
+
+/// Returns a account's balance of a FungibleToken Vault with public Capability published at the provided path
+///
+access(all)
+fun main(address: Address, vaultPublicPath: PublicPath): UFix64? {
+    return getAccount(address).capabilities.borrow<&{FungibleToken.Vault}>(vaultPublicPath)?.balance ?? nil
+}