Implement manual liquidation path

cadence/contracts/mocks/MockDexSwapper.cdc

@@ -87,5 +87,3 @@ access(all) contract MockDexSwapper {
         access(contract) fun setID(_ id: DeFiActions.UniqueIdentifier?) { self.uniqueID = id }
     }
 }
-
-

cadence/tests/test_helpers.cdc

@@ -182,6 +182,17 @@ fun getPositionDetails(pid: UInt64, beFailed: Bool): FlowCreditMarket.PositionDe
     return res.returnValue as! FlowCreditMarket.PositionDetails
 }
 
+access(all)
+fun getPositionBalance(pid: UInt64, vaultID: String): FlowCreditMarket.PositionBalance {
+    let positionDetails = getPositionDetails(pid: pid, beFailed: false)
+    for bal in positionDetails.balances {
+        if bal.vaultType == CompositeType(vaultID) {
+            return bal
+        }
+    }
+    panic("expected to find balance for \(vaultID) in position\(pid)")
+}
+
 access(all)
 fun poolExists(address: Address): Bool {
     let res = _executeScript("../scripts/flow-credit-market/pool_exists.cdc", [address])
@@ -429,6 +440,18 @@ fun mintMoet(signer: Test.TestAccount, to: Address, amount: UFix64, beFailed: Bo
     Test.expect(mintRes, beFailed ? Test.beFailed() : Test.beSucceeded())
 }
 
+access(all)
+fun setupMockYieldTokenVault(_ signer: Test.TestAccount, beFailed: Bool) {
+    let setupRes = _executeTransaction("../transactions/mocks/yieldtoken/setup_vault.cdc", [], signer)
+    Test.expect(setupRes, beFailed ? Test.beFailed() : Test.beSucceeded())
+}
+
+access(all)
+fun mintMockYieldToken(signer: Test.TestAccount, to: Address, amount: UFix64, beFailed: Bool) {
+    let mintRes = _executeTransaction("../transactions/mocks/yieldtoken/mint.cdc", [to, amount], signer)
+    Test.expect(mintRes, beFailed ? Test.beFailed() : Test.beSucceeded())
+}
+
 
 // Transfer Flow tokens from service account to recipient
 access(all)

cadence/tests/transactions/flow-credit-market/pool-management/manual_liquidation_chosen_vault.cdc

@@ -0,0 +1,65 @@
+import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "MetadataViews"
+
+import "FlowCreditMarket"
+
+/// Attempt to liquidation a position by repaying `repayAmount`.
+/// This TESTING-ONLY transaction allows specifying a different repayment vault type.
+///
+/// debtVaultIdentifier: e.g., Type<@MOET.Vault>().identifier
+/// seizeVaultIdentifier: e.g., Type<@FlowToken.Vault>().identifier
+transaction(pid: UInt64, purportedDebtVaultIdentifier: String, actualDebtVaultIdentifier: String, seizeVaultIdentifier: String, seizeAmount: UFix64, repayAmount: UFix64) {
+    let pool: &FlowCreditMarket.Pool
+    let receiver: &{FungibleToken.Receiver}
+    let actualDebtType: Type
+    let purportedDebtType: Type
+    let seizeType: Type
+    let repay: @{FungibleToken.Vault}
+
+    prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, PublishCapability, UnpublishCapability) &Account) {
+        let protocolAddress = Type<@FlowCreditMarket.Pool>().address!
+        self.pool = getAccount(protocolAddress).capabilities.borrow<&FlowCreditMarket.Pool>(FlowCreditMarket.PoolPublicPath)
+            ?? panic("Could not borrow Pool at \(FlowCreditMarket.PoolPublicPath)")
+
+        // Resolve types
+        self.actualDebtType = CompositeType(actualDebtVaultIdentifier) ?? panic("Invalid actualDebtVaultIdentifier: \(actualDebtVaultIdentifier)")
+        self.purportedDebtType = CompositeType(purportedDebtVaultIdentifier) ?? panic("Invalid purportedDebtVaultIdentifier: \(purportedDebtVaultIdentifier)")
+        self.seizeType = CompositeType(seizeVaultIdentifier) ?? panic("Invalid seizeVaultIdentifier: \(seizeVaultIdentifier)")
+
+        // Get the path and type data for the provided token type identifier
+        let debtVaultData = MetadataViews.resolveContractViewFromTypeIdentifier(
+            resourceTypeIdentifier: actualDebtVaultIdentifier,
+            viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+        ) as? FungibleTokenMetadataViews.FTVaultData
+            ?? panic("Could not construct valid FT type and view from identifier \(actualDebtVaultIdentifier)")
+
+        let seizeVaultData = MetadataViews.resolveContractViewFromTypeIdentifier(
+            resourceTypeIdentifier: seizeVaultIdentifier,
+            viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+        ) as? FungibleTokenMetadataViews.FTVaultData
+            ?? panic("Could not construct valid FT type and view from identifier \(seizeVaultIdentifier)")
+
+        // Check if the service account has a vault for this token type at the correct storage path
+        let debtVaultRef = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(from: debtVaultData.storagePath)
+            ?? panic("no debt vault in storage at path \(debtVaultData.storagePath)")
+        assert(debtVaultRef.balance >= repayAmount, message: "Insufficient debt token \(debtVaultRef.getType().identifier) balance \(debtVaultRef.balance)<\(repayAmount)")
+        self.repay <- debtVaultRef.withdraw(amount: repayAmount)
+
+        let seizeVaultRef = signer.capabilities.borrow<&{FungibleToken.Receiver}>(seizeVaultData.receiverPath)
+            ?? panic("no seize receiver in storage at path \(seizeVaultData.receiverPath)")
+        self.receiver = seizeVaultRef
+    }
+
+    execute {
+        let seizedVault <- self.pool.manualLiquidation(
+            pid: pid,
+            debtType: self.purportedDebtType,
+            seizeType: self.seizeType,
+            seizeAmount: seizeAmount,
+            repayment: <-self.repay
+        )
+
+        self.receiver.deposit(from: <-seizedVault)
+    }
+}

cadence/transactions/flow-credit-market/pool-management/manual_liquidation.cdc

@@ -0,0 +1,62 @@
+import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "MetadataViews"
+
+import "FlowCreditMarket"
+
+/// Attempt to liquidation a position by repaying `repayAmount`.
+///
+/// debtVaultIdentifier: e.g., Type<@MOET.Vault>().identifier
+/// seizeVaultIdentifier: e.g., Type<@FlowToken.Vault>().identifier
+transaction(pid: UInt64, debtVaultIdentifier: String, seizeVaultIdentifier: String, seizeAmount: UFix64, repayAmount: UFix64) {
+    let pool: &FlowCreditMarket.Pool
+    let receiver: &{FungibleToken.Receiver}
+    let debtType: Type
+    let seizeType: Type
+    let repay: @{FungibleToken.Vault}
+
+    prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, PublishCapability, UnpublishCapability) &Account) {
+        let protocolAddress = Type<@FlowCreditMarket.Pool>().address!
+        self.pool = getAccount(protocolAddress).capabilities.borrow<&FlowCreditMarket.Pool>(FlowCreditMarket.PoolPublicPath)
+            ?? panic("Could not borrow Pool at \(FlowCreditMarket.PoolPublicPath)")
+
+        // Resolve types
+        self.debtType = CompositeType(debtVaultIdentifier) ?? panic("Invalid debtVaultIdentifier: \(debtVaultIdentifier)")
+        self.seizeType = CompositeType(seizeVaultIdentifier) ?? panic("Invalid seizeVaultIdentifier: \(seizeVaultIdentifier)")
+
+        // Get the path and type data for the provided token type identifier
+        let debtVaultData = MetadataViews.resolveContractViewFromTypeIdentifier(
+            resourceTypeIdentifier: debtVaultIdentifier,
+            viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+        ) as? FungibleTokenMetadataViews.FTVaultData
+            ?? panic("Could not construct valid FT type and view from identifier \(debtVaultIdentifier)")
+
+        let seizeVaultData = MetadataViews.resolveContractViewFromTypeIdentifier(
+            resourceTypeIdentifier: seizeVaultIdentifier,
+            viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+        ) as? FungibleTokenMetadataViews.FTVaultData
+            ?? panic("Could not construct valid FT type and view from identifier \(seizeVaultIdentifier)")
+
+        // Check if the service account has a vault for this token type at the correct storage path
+        let debtVaultRef = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(from: debtVaultData.storagePath)
+            ?? panic("no debt vault in storage at path \(debtVaultData.storagePath)")
+        assert(debtVaultRef.balance >= repayAmount, message: "Insufficient debt token \(debtVaultRef.getType().identifier) balance \(debtVaultRef.balance)<\(repayAmount)")
+        self.repay <- debtVaultRef.withdraw(amount: repayAmount)
+
+        let seizeVaultRef = signer.capabilities.borrow<&{FungibleToken.Receiver}>(seizeVaultData.receiverPath)
+            ?? panic("no seize receiver in storage at path \(seizeVaultData.receiverPath)")
+        self.receiver = seizeVaultRef
+    }
+
+    execute {
+        let seizedVault <- self.pool.manualLiquidation(
+            pid: pid,
+            debtType: self.debtType,
+            seizeType: self.seizeType,
+            seizeAmount: seizeAmount,
+            repayment: <-self.repay
+        )
+
+        self.receiver.deposit(from: <-seizedVault)
+    }
+}

cadence/transactions/mocks/yieldtoken/mint.cdc

@@ -0,0 +1,29 @@
+import "FungibleToken"
+
+import "MockYieldToken"
+
+/// Mints MockYieldToken using the Minter stored in the signer's account and deposits to the recipients MockYieldToken Vault. If the
+/// recipient's MockYieldToken Vault is not configured with a public Capability or the signer does not have a MOET Minter
+/// stored, the transaction will revert.
+///
+/// @param to: The recipient's Flow address
+/// @param amount: How many MockYieldToken tokens to mint to the recipient's account
+///
+transaction(to: Address, amount: UFix64) {
+
+    let receiver: &{FungibleToken.Vault}
+    let minter: &MockYieldToken.Minter
+
+    prepare(signer: auth(BorrowValue) &Account) {
+        self.minter = signer.storage.borrow<&MockYieldToken.Minter>(from: MockYieldToken.AdminStoragePath)
+            ?? panic("Could not borrow reference to MOET Minter from signer's account at path \(MockYieldToken.AdminStoragePath)")
+        self.receiver = getAccount(to).capabilities.borrow<&{FungibleToken.Vault}>(MockYieldToken.VaultPublicPath)
+            ?? panic("Could not borrow reference to MOET Vault from recipient's account at path \(MockYieldToken.VaultPublicPath)")
+    }
+
+    execute {
+        self.receiver.deposit(
+            from: <-self.minter.mintTokens(amount: amount)
+        )
+    }
+}