Merge pull request #45 from onflow/nialexsan/non-public-pool

Nialexsan/non public pool

Author: nialexsan

.gitignore

@@ -1,6 +1,6 @@
-
+.DS_Store
 # flow
 *.pkey
 imports
 coverage.lcov
-coverage.json
+coverage.json

DeFiActions

@@ -18,6 +18,8 @@ access(all) contract TidalProtocol {
     /// The canonical PublicPath where the primary TidalProtocol Pool can be accessed publicly
     access(all) let PoolPublicPath: PublicPath
 
+    access(all) let PoolCapStoragePath: StoragePath
+
     /* --- EVENTS ---- */
 
     access(all) event Opened(pid: UInt64, poolUUID: UInt64)
@@ -31,6 +33,9 @@ access(all) contract TidalProtocol {
     access(all) entitlement EGovernance
     access(all) entitlement EImplementation
 
+    access(all) entitlement EParticipant
+
+
     /// InternalBalance
     ///
     /// A structure used internally to track a position's balance for a particular token
@@ -55,7 +60,7 @@ access(all) contract TidalProtocol {
         /// provided TokenState. It's assumed the TokenState and InternalBalance relate to the same token Type, but
         /// since neither struct have values defining the associated token, callers should be sure to make the arguments
         /// do in fact relate to the same token Type.
-        access(all) fun recordDeposit(amount: UInt128, tokenState: auth(EImplementation) &TokenState) {
+        access(contract) fun recordDeposit(amount: UInt128, tokenState: auth(EImplementation) &TokenState) {
             if self.direction == BalanceDirection.Credit {
                 // Depositing into a credit position just increases the balance.
 
@@ -216,7 +221,7 @@ access(all) contract TidalProtocol {
         /// deposits or the operation will revert.
         access(EImplementation) fun setDrawDownSink(_ sink: {DeFiActions.Sink}?) {
             pre {
-                sink?.getSinkType() ?? Type<@MOET.Vault>() == Type<@MOET.Vault>():
+                (sink?.getSinkType() ?? Type<@MOET.Vault>()) == Type<@MOET.Vault>():
                 "Invalid Sink provided - Sink \(sink.getType().identifier) must accept MOET"
             }
             self.drawDownSink = sink
@@ -743,7 +748,7 @@ access(all) contract TidalProtocol {
         access(all) fun getPositionDetails(pid: UInt64): PositionDetails {
             log("    [CONTRACT] getPositionDetails(pid: \(pid))")
             let position = self._borrowPosition(pid: pid)
-            let balances: [PositionBalance] = []
+            var balances: [PositionBalance] = []
 
             for type in position.balances.keys {
                 let balance = position.balances[type]!
@@ -1298,7 +1303,7 @@ access(all) contract TidalProtocol {
         /// Creates a lending position against the provided collateral funds, depositing the loaned amount to the
         /// given Sink. If a Source is provided, the position will be configured to pull loan repayment when the loan
         /// becomes undercollateralized, preferring repayment to outright liquidation.
-        access(all) fun createPosition(
+        access(EParticipant) fun createPosition(
             funds: @{FungibleToken.Vault},
             issuanceSink: {DeFiActions.Sink},
             repaymentSource: {DeFiActions.Source}?,
@@ -1333,7 +1338,7 @@ access(all) contract TidalProtocol {
 
         /// Allows anyone to deposit funds into any position. If the provided Vault is not supported by the Pool, the
         /// operation reverts.
-        access(all) fun depositToPosition(pid: UInt64, from: @{FungibleToken.Vault}) {
+        access(EParticipant) fun depositToPosition(pid: UInt64, from: @{FungibleToken.Vault}) {
             self.depositAndPush(pid: pid, from: <-from, pushToDrawDownSink: false)
         }
 
@@ -1845,9 +1850,9 @@ access(all) contract TidalProtocol {
         /// The unique ID of the Position used to track deposits and withdrawals to the Pool
         access(self) let id: UInt64
         /// An authorized Capability to which the Position was opened
-        access(self) let pool: Capability<auth(EPosition) &Pool>
+        access(self) let pool: Capability<auth(EPosition, EParticipant) &Pool>
 
-        init(id: UInt64, pool: Capability<auth(EPosition) &Pool>) {
+        init(id: UInt64, pool: Capability<auth(EPosition, EParticipant) &Pool>) {
             pre {
                 pool.check(): "Invalid Pool Capability provided - cannot construct Position"
             }
@@ -1905,13 +1910,13 @@ access(all) contract TidalProtocol {
         }
         /// Deposits funds to the Position without pushing to the drawDownSink if the deposit puts the Position above
         /// its maximum health
-        access(all) fun deposit(from: @{FungibleToken.Vault}) {
+        access(EParticipant) fun deposit(from: @{FungibleToken.Vault}) {
             let pool = self.pool.borrow()!
             pool.depositAndPush(pid: self.id, from: <-from, pushToDrawDownSink: false)
         }
         /// Deposits funds to the Position enabling the caller to configure whether excess value should be pushed to the
         /// drawDownSink if the deposit puts the Position above its maximum health
-        access(all) fun depositAndPush(from: @{FungibleToken.Vault}, pushToDrawDownSink: Bool) {
+        access(EParticipant) fun depositAndPush(from: @{FungibleToken.Vault}, pushToDrawDownSink: Bool) {
             let pool = self.pool.borrow()!
             pool.depositAndPush(pid: self.id, from: <-from, pushToDrawDownSink: pushToDrawDownSink)
         }
@@ -1973,7 +1978,7 @@ access(all) contract TidalProtocol {
         /// Each position can have only one source, and the source must accept the default token type configured for the
         /// pool. Providing a new source will replace the existing source. Pass nil to configure the position to not
         /// pull tokens.
-        access(all) fun provideSource(source: {DeFiActions.Source}?) {
+        access(EParticipant) fun provideSource(source: {DeFiActions.Source}?) {
             let pool = self.pool.borrow()!
             pool.provideTopUpSource(pid: self.id, source: source)
         }
@@ -2157,38 +2162,6 @@ access(all) contract TidalProtocol {
     }
 
     /* --- PUBLIC METHODS ---- */
-
-    /// Takes out a TidalProtocol loan with the provided collateral, returning a Position that can be used to manage
-    /// collateral and borrowed fund flows
-    ///
-    /// @param collateral: The collateral used as the basis for a loan. Only certain collateral types are supported, so
-    ///     callers should be sure to check the provided Vault is supported to prevent reversion.
-    /// @param issuanceSink: The DeFiActions Sink connector where the protocol will deposit borrowed funds. If the
-    ///     position becomes overcollateralized, additional funds will be borrowed (to maintain target LTV) and
-    ///     deposited to the provided Sink.
-    /// @param repaymentSource: An optional DeFiActions Source connector from which the protocol will attempt to source
-    ///     borrowed funds in the event of undercollateralization prior to liquidating. If none is provided, the
-    ///     position health will not be actively managed on the down side, meaning liquidation is possible as soon as
-    ///     the loan becomes undercollateralized.
-    ///
-    /// @return the Position via which the caller can manage their position
-    ///
-    access(all) fun openPosition(
-        collateral: @{FungibleToken.Vault},
-        issuanceSink: {DeFiActions.Sink},
-        repaymentSource: {DeFiActions.Source}?,
-        pushToDrawDownSink: Bool
-    ): Position {
-        let pid = self._borrowPool().createPosition(
-                funds: <-collateral,
-                issuanceSink: issuanceSink,
-                repaymentSource: repaymentSource,
-                pushToDrawDownSink: pushToDrawDownSink
-            )
-        let cap = self.account.capabilities.storage.issue<auth(EPosition) &Pool>(self.PoolStoragePath)
-        return Position(id: pid, pool: cap)
-    }
-
     /// Returns a health value computed from the provided effective collateral and debt values where health is a ratio
     /// of effective collateral over effective debt
     access(all) view fun healthComputation(effectiveCollateral: UInt128, effectiveDebt: UInt128): UInt128 {
@@ -2214,7 +2187,7 @@ access(all) contract TidalProtocol {
 
     /// Returns the compounded interest index reflecting the passage of time
     /// The result is: newIndex = oldIndex * perSecondRate ^ seconds
-    access(all) fun compoundInterestIndex(oldIndex: UInt128, perSecondRate: UInt128, elapsedSeconds: UFix64): UInt128 {
+    access(all) view fun compoundInterestIndex(oldIndex: UInt128, perSecondRate: UInt128, elapsedSeconds: UFix64): UInt128 {
         var result = oldIndex
         var current = UInt128(perSecondRate)
         var secondsCounter = UInt128(elapsedSeconds)
@@ -2258,12 +2231,6 @@ access(all) contract TidalProtocol {
 
     /* --- INTERNAL METHODS --- */
 
-    /// Returns an authorized reference to the contract account's Pool resource
-    access(self) view fun _borrowPool(): auth(EPosition) &Pool {
-        return self.account.storage.borrow<auth(EPosition) &Pool>(from: self.PoolStoragePath)
-            ?? panic("Could not borrow reference to internal TidalProtocol Pool resource")
-    }
-
     /// Returns a reference to the contract account's MOET Minter resource
     access(self) view fun _borrowMOETMinter(): &MOET.Minter {
         return self.account.storage.borrow<&MOET.Minter>(from: MOET.AdminStoragePath)
@@ -2274,6 +2241,7 @@ access(all) contract TidalProtocol {
         self.PoolStoragePath = StoragePath(identifier: "tidalProtocolPool_\(self.account.address)")!
         self.PoolFactoryPath = StoragePath(identifier: "tidalProtocolPoolFactory_\(self.account.address)")!
         self.PoolPublicPath = PublicPath(identifier: "tidalProtocolPool_\(self.account.address)")!
+        self.PoolCapStoragePath = StoragePath(identifier: "tidalProtocolPoolCap_\(self.account.address)")!
 
         // save PoolFactory in storage
         self.account.storage.save(

cadence/contracts/TidalProtocol.cdc

@@ -0,0 +1,46 @@
+import "DeFiActions"
+import "FungibleToken"
+import "MOET"
+
+access(all) contract DummyConnectors {
+
+    // Minimal sink for tests that accepts MOET and does nothing.
+    access(all) struct DummySink: DeFiActions.Sink {
+        // Must match the interface’s access modifier
+        access(contract) var uniqueID: DeFiActions.UniqueIdentifier?
+
+        init() {
+            self.uniqueID = nil
+        }
+
+        // ---- DeFiActions.Sink API ----
+        access(all) view fun getSinkType(): Type {
+            return Type<@MOET.Vault>()
+        }
+
+        access(all) fun minimumCapacity(): UFix64 {
+            return UFix64.max
+        }
+
+        access(all) fun depositCapacity(from: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}) {
+            // no-op
+        }
+
+        access(all) fun getComponentInfo(): DeFiActions.ComponentInfo {
+            return DeFiActions.ComponentInfo(
+                type: self.getType(),
+                id: self.id(),
+                innerComponents: []
+            )
+        }
+
+        // ---- Identity helpers (must be access(contract) to match interface) ----
+        access(contract) view fun copyID(): DeFiActions.UniqueIdentifier? {
+            return self.uniqueID
+        }
+
+        access(contract) fun setID(_ id: DeFiActions.UniqueIdentifier?) {
+            self.uniqueID = id
+        }
+    }
+}

cadence/contracts/mocks/DummyConnectors.cdc

@@ -23,13 +23,22 @@ access(all) contract MockTidalProtocolConsumer {
         repaymentSource: {DeFiActions.Source}?,
         pushToDrawDownSink: Bool
     ): @PositionWrapper {
-        return <- create PositionWrapper(
-            position: TidalProtocol.openPosition(
-                collateral: <-collateral,
+        let poolCap = self.account.storage.load<Capability<auth(TidalProtocol.EParticipant, TidalProtocol.EPosition) &TidalProtocol.Pool>>(
+            from: TidalProtocol.PoolCapStoragePath
+        ) ?? panic("Missing pool capability")
+
+        let poolRef = poolCap.borrow() ?? panic("Invalid Pool Cap")
+
+        let pid = poolRef.createPosition(
+                funds: <-collateral,
                 issuanceSink: issuanceSink,
                 repaymentSource: repaymentSource,
                 pushToDrawDownSink: pushToDrawDownSink
             )
+        let position = TidalProtocol.Position(id: pid, pool: poolCap)
+        self.account.storage.save(poolCap, to: TidalProtocol.PoolCapStoragePath)
+        return <- create PositionWrapper(
+            position: position
         )
     }
 

cadence/contracts/mocks/MockTidalProtocolConsumer.cdc

@@ -6,13 +6,18 @@ import "TidalProtocol"
 import "test_helpers.cdc"
 
 access(all) let protocolAccount = Test.getAccount(0x0000000000000007)
+access(all) let protocolConsumerAccount = Test.getAccount(0x0000000000000008)
 access(all) let flowTokenIdentifier = "A.0000000000000003.FlowToken.Vault"
 access(all) let moetTokenIdentifier = "A.0000000000000007.MOET.Vault"
 access(all) let flowVaultStoragePath = /storage/flowTokenVault
 
 access(all)
 fun setup() {
     deployContracts()
+
+    let betaTxResult = grantBeta(protocolAccount, protocolConsumerAccount)
+
+    Test.expect(betaTxResult, Test.beSucceeded())
 }
 
 access(all)
@@ -134,4 +139,4 @@ fun testNoAutoBorrowWhenPushToDrawDownSinkFalse() {
     let moetVaultBalanceAfter = getBalance(address: user.address, vaultPublicPath: MOET.VaultPublicPath) ?? 0.0
     Test.assert(moetVaultBalanceAfter == moetVaultBalanceBefore,
         message: "User's MOET Vault balance should remain unchanged when no borrow occurs")
-} 
+} 

cadence/tests/auto_borrow_behavior_test.cdc

@@ -0,0 +1,83 @@
+import Test
+import BlockchainHelpers
+
+import "MOET"
+import "test_helpers.cdc"
+
+// -----------------------------------------------------------------------------
+// Pool Creation Workflow Test
+// -----------------------------------------------------------------------------
+// Validates that a pool can be created and that essential invariants hold.
+// -----------------------------------------------------------------------------
+
+access(all) let protocolAccount = Test.getAccount(0x0000000000000007)
+access(all) let testerAccount = Test.getAccount(0x0000000000000008)
+access(all) var snapshot: UInt64 = 0
+
+// -----------------------------------------------------------------------------
+// SETUP
+// -----------------------------------------------------------------------------
+access(all)
+fun setup() {
+    deployContracts()
+
+    createAndStorePool(signer: protocolAccount, defaultTokenIdentifier: defaultTokenIdentifier, beFailed: false)
+
+    let exists = poolExists(address: protocolAccount.address)
+    Test.assert(exists)
+
+    // Reserve balance should be zero for default token
+    let reserveBal = getReserveBalance(vaultIdentifier: defaultTokenIdentifier)
+    Test.assertEqual(0.0, reserveBal)
+
+    snapshot = getCurrentBlockHeight()
+}
+
+// -----------------------------------------------------------------------------
+// TEST CASES
+// -----------------------------------------------------------------------------
+
+access(all)
+fun testPositionCreationFail() {
+
+    let txResult = _executeTransaction(
+        "../tests/transactions/tidal-protocol/pool-management/01_negative_no_eparticipant_fail.cdc",
+        [],
+        protocolAccount
+    )
+    Test.expect(txResult, Test.beFailed())
+}
+
+access(all)
+fun testPositionCreationSuccess() {
+    Test.reset(to: snapshot)
+
+    let txResult = _executeTransaction(
+        "../tests/transactions/tidal-protocol/pool-management/02_positive_with_eparticipant_pass.cdc",
+        [],
+        protocolAccount
+    )
+
+    Test.expect(txResult, Test.beSucceeded())
+} 
+
+access(all)
+fun testNegativeCap() {
+    Test.reset(to: snapshot)
+
+    let negativeResult = _executeTransaction("../tests/transactions/tidal-protocol/pool-management/05_negative_cap.cdc", [], testerAccount)
+    Test.expect(negativeResult, Test.beFailed())
+}
+
+access(all)
+fun testPublishClaimCap() {
+    Test.reset(to: snapshot)
+    
+    let publishCapResult = _executeTransaction("../transactions/tidal-protocol/beta/publish_beta_cap.cdc", [protocolAccount.address], protocolAccount)
+    Test.expect(publishCapResult, Test.beSucceeded())
+
+    let claimCapResult = _executeTransaction("../transactions/tidal-protocol/beta/claim_and_save_beta_cap.cdc", [protocolAccount.address], protocolAccount)
+    Test.expect(claimCapResult, Test.beSucceeded())
+
+    let createPositionResult = _executeTransaction("../tests/transactions/tidal-protocol/pool-management/04_create_position.cdc", [], protocolAccount)
+}

cadence/tests/cap_test.cdc

@@ -7,6 +7,7 @@ import "MOET"
 import "TidalProtocol"
 
 access(all) let protocolAccount = Test.getAccount(0x0000000000000007)
+access(all) let protocolConsumerAccount = Test.getAccount(0x0000000000000008)
 access(all) let userAccount = Test.createAccount()
 
 access(all) let flowTokenIdentifier = "A.0000000000000003.FlowToken.Vault"
@@ -53,6 +54,10 @@ fun setup() {
 
     deployContracts()
 
+    let betaTxResult = grantBeta(protocolAccount, protocolConsumerAccount)
+
+    Test.expect(betaTxResult, Test.beSucceeded())
+
     // price setup
     setMockOraclePrice(signer: protocolAccount, forTokenIdentifier: flowTokenIdentifier, price: flowStartPrice)