zkCRA PR into merge-create-loan

contracts/escrow/dapps/DappMods.sol

@@ -19,7 +19,7 @@ abstract contract DappMods {
         );
         _;
     }
-    
+
     /**
      * @notice checks if the respective loan escrow is secure
      * @param loanID uint256 of the respective loan escrow

contracts/lending/ttoken/TToken_V1.sol

@@ -425,7 +425,9 @@ contract TToken_V1 is ITToken {
 
     /**
      * @notice it retrives the value in the underlying tokens
-     * 
+     * @param amount the amount of underlying
+     * @param rate the rate the underlying is exchanging at
+     * @return value_ the value of the underlying
      */
     function _valueInUnderlying(uint256 amount, uint256 rate)
         internal

contracts/market/CreateLoanFacet.sol

@@ -7,14 +7,14 @@ import {
     ReentryMods
 } from "../contexts2/access-control/reentry/ReentryMods.sol";
 import { RolesMods } from "../contexts2/access-control/roles/RolesMods.sol";
-import { AUTHORIZED } from "../shared/roles.sol";
+import { AUTHORIZED, ADMIN } from "../shared/roles.sol";
 import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 // Libraries
 import { LibLoans } from "./libraries/LibLoans.sol";
 import { LibEscrow } from "../escrow/libraries/LibEscrow.sol";
 import { LibCollateral } from "./libraries/LibCollateral.sol";
-import { LibConsensus } from "./libraries/LibConsensus.sol";
+import { MarketLib } from "./cra/MarketLib.sol";
 import { LendingLib } from "../lending/libraries/LendingLib.sol";
 import {
     PlatformSettingsLib
@@ -31,6 +31,9 @@ import {
 } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import { NumbersLib } from "../shared/libraries/NumbersLib.sol";
 import { NFTLib } from "../nft/libraries/NFTLib.sol";
+import { Verifier } from "./cra/verifier.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { MarketLib } from "./cra/MarketLib.sol";
 
 // Interfaces
 import { ILoansEscrow } from "../escrow/escrow/ILoansEscrow.sol";
@@ -48,10 +51,15 @@ import {
     LoanStatus,
     LoanTerms,
     Loan,
-    MarketStorageLib
+    MarketStorageLib,
+    Signature,
+    SignatureData
 } from "../storage/market.sol";
 import { AppStorageLib } from "../storage/app.sol";
 
+// hardhat helpers
+import "hardhat/console.sol";
+
 contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {
     /**
      * @notice This event is emitted when a loan has been successfully taken out
@@ -72,6 +80,7 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {
      * @param request Struct of the protocol loan request
      */
     modifier __createLoan(LoanRequest calldata request, bool withNFT) {
+        console.log("creating loan");
         Loan storage loan = CreateLoanLib.createLoan(request, withNFT);
 
         _;
@@ -81,6 +90,28 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {
         loan.duration = request.request.duration;
     }
 
+    // used for testing our zkcra function
+    function initializeMarketAdmins() external authorized(ADMIN, msg.sender) {
+        // setting market admin
+        MarketLib.m(bytes32(0)).admin[msg.sender] = true;
+        // setting providers admin
+        MarketLib.p(bytes32(0)).admin[msg.sender] = true;
+        MarketLib.p(bytes32(uint256(1))).admin[msg.sender] = true;
+        MarketLib.p(bytes32(uint256(2))).admin[msg.sender] = true;
+    }
+
+    function setProviderInformation(
+        bytes32 providerId,
+        uint32 maxAge,
+        address signer,
+        bool signerValue
+    ) external {
+        console.log("solidity: about to set provider signer");
+        MarketLib.setProviderSigner(providerId, signer, signerValue);
+        console.log("solidity: about to set provider max age");
+        MarketLib.setProviderMaxAge(providerId, maxAge);
+    }
+
     /**
      * @notice Creates a loan with the loan request and NFTs without any collateral
      * @param request Struct of the protocol loan request
@@ -145,6 +176,7 @@ contract CreateLoanFacet is RolesMods, ReentryMods, PausableMods {
         authorized(AUTHORIZED, msg.sender)
         __createLoan(request, false)
     {
+        console.log("taking out loan");
         // Check if collateral token is zero
         require(
             collateralToken != address(0x0),
@@ -211,7 +243,7 @@ library CreateLoanLib {
 
         // Get consensus values from request
         (uint16 interestRate, uint16 collateralRatio, uint256 maxLoanAmount) =
-            LibConsensus.processLoanTerms(request);
+            processMarketRequest(request);
 
         // Perform loan value checks
         require(
@@ -254,6 +286,133 @@ library CreateLoanLib {
         );
     }
 
+    /**
+     * @notice it uses our request to verify the returned proof and witness with each other,
+     * verifies our signature data with our respective data providers, then retrieves our interest rate,
+     * collateral ratio and max loan amount
+     * @param request contains all the needed data to do the above
+     * @return interestRate the rate of the loan
+     * @return collateralRatio the collateral ratio required for the loan, if any
+     * @return maxLoanAmount the max loan amount the user is entitled to
+     */
+    function processMarketRequest(LoanRequest memory request)
+        internal
+        returns (
+            uint16 interestRate,
+            uint16 collateralRatio,
+            uint256 maxLoanAmount
+        )
+    {
+        console.log("processing market request");
+        // Overwrite the first snark witness item with the on-chain identifier
+        // for the loan (msg.sender ^ nonce). This forces the CRA to have been
+        // run with the proper identifier.
+        request.witness[0] =
+            uint256(uint160(msg.sender)) ^
+            LibLoans.s().borrowerLoans[msg.sender].length;
+
+        // Verify the snark proof.
+        // call from deployed contract
+        // SnarkVerifier sv = new SnarkVerifier(contract address)
+
+        // deploy verifier library and integrate into create loan facet
+        console.log("about to verify tx");
+        require(
+            Verifier.verifyTx(request.proof, request.witness),
+            "Proof not verified"
+        );
+
+        bytes32[3] memory commitments = [bytes32(0), bytes32(0), bytes32(0)];
+
+        // constructing our commitments to verify with our signature data
+        for (uint8 i = 0; i < commitments.length; i++) {
+            for (uint8 j = 0; j < 8; j++) {
+                commitments[i] =
+                    (commitments[i] << 32) ^
+                    bytes32(request.witness[2 + i * 8 + j]);
+            }
+            commitments[i] ^= bytes32(request.signatureData[i].signedAt);
+        }
+
+        require(request.signatureData.length == 3, "Must have 3 providers!");
+
+        // Verify that the commitment signatures are valid and that the data
+        // is not too old for the market's liking.
+        _verifySignatures(commitments, request.signatureData);
+
+        // The second witness item (after identifier) is the market
+        // score
+        uint256 marketScore = uint256(request.witness[1]);
+
+        // Let the market handle the loan request and disperse the loan.
+
+        // create default teller market handler
+        // pass it the marketId and return max loan amount, collateral ratio, interest rate
+        // upper and lower bound for loan amount, interest rate and collateral ratio depending on
+        // market id
+        (interestRate, collateralRatio, maxLoanAmount) = MarketLib.handler(
+            marketScore,
+            request
+        );
+        return (interestRate, collateralRatio, maxLoanAmount);
+    }
+
+    function _verifySignatures(
+        bytes32[3] memory commitments,
+        SignatureData[] memory signatureData
+    ) private {
+        for (uint256 i = 0; i < signatureData.length; i++) {
+            bytes32 providerId = bytes32(i);
+            require(
+                signatureData[i].signedAt >
+                    // solhint-disable-next-line
+                    block.timestamp - MarketLib.p(providerId).maxAge,
+                "Signed at less than max age"
+            );
+            require(
+                MarketLib.s().usedCommitments[commitments[i]] == false,
+                "Teller: commitment already used"
+            );
+
+            MarketLib.s().usedCommitments[commitments[i]] = true;
+
+            _validateSignature(
+                signatureData[i].signature,
+                commitments[i],
+                providerId
+            );
+        }
+    }
+
+    /**
+     * @notice It validates whether a signature is valid or not.
+     * @param signature signature to validate.
+     * @param commitment used to recover the signer.
+     * @param providerId the expected signer address.
+     */
+    function _validateSignature(
+        Signature memory signature,
+        bytes32 commitment,
+        bytes32 providerId
+    ) private view {
+        address recoveredSigner =
+            ECDSA.recover(
+                keccak256(
+                    abi.encodePacked(
+                        "\x19Ethereum Signed Message:\n32",
+                        uint256(commitment)
+                    )
+                ),
+                signature.v,
+                signature.r,
+                signature.s
+            );
+        require(
+            MarketLib.p(providerId).signer[recoveredSigner],
+            "Teller: not valid signature"
+        );
+    }
+
     /**
      * @notice increments the loanIDCounter
      * @return id_ the new ID requested, which stores it in the loan data

contracts/market/LendingPool.sol

@@ -0,0 +1,3 @@
+contract LendingPool {
+    function deposit(uint256 loanAsset, uint256 depositAmount) external {}
+}

contracts/market/LoanDataFacet.sol

@@ -133,7 +133,7 @@ contract LoanDataFacet {
     /**
      * @notice it returns the total escrow tokens held by an escrow
      * @param loanID the identifier of the respective escrow's loan
-     * @return tokens_ the tokens held at the escrow loan 
+     * @return tokens_ the tokens held at the escrow loan
      */
     function getEscrowTokens(uint256 loanID)
         external

contracts/market/cra/AMarket.sol

@@ -0,0 +1,98 @@
+// // SPDX-License-Identifier: MIT
+
+// pragma solidity ^0.8.0;
+
+// // import { TellerAssets } from "./utils.sol";
+// import { LoanRequest } from "./Borrow.sol";
+
+// interface IMarket {
+//     // Called by teller.
+//     function handler(bytes memory input) external;
+// }
+
+// contract BasicMarket is IMarket {
+//     struct Storage {
+//         mapping(uint256 => bool) supportedCollateralAssets;
+//         mapping(uint256 => bool) supportedLoanAssets;
+//     }
+
+//     bytes32 internal constant POS = keccak256("teller.finance.market.storage");
+
+//     function handler(bytes memory input) external override {
+//         (address borrower, uint256 marketScore, LoanRequest memory request) =
+//             abi.decode(input, (address, uint256, LoanRequest));
+
+//         uint256 maxDebtRatio = 6666;
+//         uint256 minLoanValue = 1000 * 10**18;
+//         uint256 maxLoanValue = 5000 * 10**18;
+//         uint256 minCollateralRatio = 2000;
+//         uint256 maxCollateralRatio = 13500;
+//         uint256 minDuration = 1 days;
+//         uint256 maxDuration = 180 days;
+
+//         require(s().supportedLoanAssets[request.loanToken], "ME00");
+//         require(
+//             getDebtRatioFor(request.loanToken, request.loanAmount) <=
+//                 maxDebtRatio,
+//             "ME06"
+//         );
+//         require(
+//             request.duration >= minDuration && request.duration <= maxDuration,
+//             "ME01"
+//         );
+
+//         uint256 collateralValue;
+
+//         for (uint8 i = 0; i < request.collateralAssets.length; i++) {
+//             require(
+//                 s().supportedCollateralAssets[request.collateralAssets[i]],
+//                 "ME03"
+//             );
+//             collateralValue += 100;
+//             // collateralValue += priceFor(
+//             // collateralAssets[i],
+//             // collateralAmounts[i]
+//             // );
+//         }
+
+//         uint256 loanValue = 100;
+//         // uint256 loanValue = priceFor(loanAsset, loanAmount);
+//         require(loanValue >= minLoanValue && loanValue <= maxLoanValue, "ME04");
+
+//         uint256 collateralRatio = (collateralValue * 10000) / loanValue;
+//         require(
+//             collateralRatio >= minCollateralRatio &&
+//                 collateralRatio <= maxCollateralRatio,
+//             "ME05"
+//         );
+
+//         uint256 interestRate =
+//             (((maxCollateralRatio - collateralRatio) / 10)) +
+//                 ((30 - marketScore) * 20);
+
+//         // teller.lend(
+//         //     borrower,
+//         //     loanAsset,
+//         //     loanAmount,
+//         //     collateralRatio,
+//         //     interestRate,
+//         //     duration
+//         // );
+//     }
+
+//     function getDebtRatioFor(uint256 loanAsset, uint256 loanAmount)
+//         internal
+//         view
+//         returns (uint256 debtRatio)
+//     {
+//         // TellerAssets.AssetType assetType = _assetType(loanAsset);
+//         return 10000;
+//     }
+
+//     function s() internal pure returns (Storage storage s_) {
+//         bytes32 pos = POS;
+//         assembly {
+//             s_.slot := pos
+//         }
+//     }
+// }