IConfigurator

IConfigurator.sol

// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.16;

import { DataTypes } from "../protocol/libraries/types/DataTypes.sol";
import { ConfigTypes } from "../protocol/libraries/types/ConfigTypes.sol";

interface IConfigurator {
    /**
     * @dev Emitted when borrowing is enabled on a reserve
     * @param reserveId The id of the reserve
     **/
    event BorrowingEnabledOnReserve(uint256 indexed reserveId);

    /**
     * @dev Emitted when borrowing is disabled on a reserve
     * @param reserveId The id of the reserve
     **/
    event BorrowingDisabledOnReserve(uint256 indexed reserveId);

    /**
     * @dev Emitted when variable rate borrowing is enabled on a reserve
     * @param reserveId The id of the reserve
     **/
    event VariableRateBorrowingEnabledOnReserve(uint256 indexed reserveId);

    /**
     * @dev Emitted when variable rate borrowing is disabled on a reserve
     * @param reserveId The id of the reserve
     **/
    event VariableRateBorrowingDisabledOnReserve(uint256 indexed reserveId);


    /**
     * @dev Emitted when a reserve is activated
     * @param reserveId The id of the reserve
     **/
    event ReserveActivated(uint256 indexed reserveId);

    /**
     * @dev Emitted when a reserve is deactivated
     * @param reserveId The id of the reserve
     **/
    event ReserveDeactivated(uint256 indexed reserveId);

    /**
     * @dev Emitted when a reserve is frozen
     * @param reserveId The id of the reserve
     **/
    event ReserveFrozen(uint256 indexed reserveId);

    /**
     * @dev Emitted when a reserve is unfrozen
     * @param reserveId The id of the reserve
     **/
    event ReserveUnfrozen(uint256 indexed reserveId);

    /**
     * @dev Emitted when a reserve factor is updated
     * @param reserveId The id of the reserve
     * @param factor The new reserve factor
     **/
    event ReserveFactorChanged(uint256 indexed reserveId, uint256 factor);

    /**
     * @dev Emitted when a reserve interest strategy contract is updated
     * @param reserveId The id of the reserve
     * @param strategy The new address of the interest strategy contract
     **/
    event ReserveInterestRateChanged(uint256 indexed reserveId, address strategy);

    /**
     * @dev Emitted when a reserve collateral configuration is updated
     * @param reserveId The id of the reserve
     * @param ltv The loan to value of the asset when used as NFT
     * @param liquidationThreshold The threshold at which loans using this asset as NFT will be considered undercollateralized
     * @param liquidationBonus The bonus liquidators receive to liquidate this asset
     **/
    event ReserveCollateralConfigurationChanged(
        uint256 indexed reserveId, 
        uint256 ltv,
        uint256 liquidationThreshold,
        uint256 liquidationBonus
    );

    /**
     * @dev Emitted when a reserve auction is updated
     * @param reserveId The id of the reserve
     * @param liquidationBonus The new liquidation bonus
     * @param auctionDuration The new auction duration
     * @param auctionPriceMultiple The dutch auction start price multiple
     **/
    event ReserveAuctionChanged(uint256 indexed reserveId, uint256 liquidationBonus, uint256 auctionDuration, uint256 auctionPriceMultiple);

    /**
     * @dev Emitted when a redeem threshold is updated
     * @param reserveId The id of the reserve
     * @param redeemThreshold The new redeem threshold
     **/
    event ReserveRedeemThresholdChanged(uint256 indexed reserveId, uint256 redeemThreshold);

    /**
     * @dev Emitted when a reserve max supply is updated
     * @param reserveId The id of the reserve
     * @param maxSupply The new maximum supply
     **/
    event ReserveMaxSupplyChanged(uint256 indexed reserveId, uint256 maxSupply);

    /**
     * @dev Emitted when max number of reserves is updated
     * @param maxNumberOfReserves The new maximum number of reserves
     **/
    event MaxNumberOfReservesChanged(uint256 maxNumberOfReserves);

    /**
     * @dev Emitted when the price consumer asset price method is updated
     * @param method The new price consumer method
     **/
    event PriceConsumerAssetPriceMethodChanged(string method);

    /**
     * @dev Emitted when the price consumer NFT price method is updated
     * @param method The new price consumer method
     **/
    event PriceConsumerNftPriceMethodChanged(string method);

    /**
     * @dev Emitted when a reserve is initialized.
     * @param reserveId The id of the reserve
     * @param collateral The address of the underlying collateral of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @param fToken The address of the associated fToken contract
     * @param stableDebtToken The address of the associated stableDebtToken contract
     * @param variableDebtToken The address of the associated variableDebtToken contract
     * @param interestRateStrategyAddress The address of the interest rate strategy for the reserve
     **/
    event ReserveInitialized(
        uint256 indexed reserveId,
        address indexed collateral,
        address indexed asset,
        address fToken,
        address stableDebtToken,
        address variableDebtToken,
        address interestRateStrategyAddress
    );

    /**
     * @dev Emitted when an fToken implementation is upgraded
     * @param reserveId The id of the reserve
     * @param collateral The address of the underlying collateral of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @param proxy The fToken proxy address
     * @param implementation The new fToken implementation
     **/
    event FTokenUpgraded(
        uint256 indexed reserveId,
        address collateral, 
        address asset, 
        address indexed proxy, 
        address indexed implementation
    );

    /**
     * @dev Emitted when the implementation of a debtToken is upgraded
     * @param reserveId The id of the reserve
     * @param collateral The address of the underlying collateral of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @param proxy The debt token proxy address
     * @param implementation The new debtToken implementation
     **/
    event DebtTokenUpgraded(
        uint256 indexed reserveId,
        address collateral, 
        address asset, 
        address indexed proxy, 
        address indexed implementation
    );

    function batchInitLendingPoolReserve(
        ConfigTypes.InitReserveInput[] calldata input
    ) 
        external
        returns (
            address[] memory, 
            address[] memory, 
            address[] memory
        );

    function setActiveFlagOnReserve(
        uint256[] calldata reserveIds, 
        bool flag
    ) external;

    function setBorrowingFlagOnReserve(
        uint256[] calldata reserveIds, 
        bool flag
    ) external;

    function setVariableRateBorrowingFlagOnReserve(
        uint256[] calldata reserveIds, 
        bool flag
    ) external;

    function setFreezeFlagOnReserve(
        uint256[] calldata reserveIds, 
        bool flag
    ) external;

    function setPoolPause(bool val) external;

    function setPoolPausedTime(uint256 startTime, uint256 durationTime) external;

    function setMaxNumberOfReserves(uint256 newVal) external;

    function setReserveFactor(
        uint256[] calldata reserveIds, 
        uint256 reserveFactor
    ) external;

    function setReserveInterestRateAddress(
        uint256[] calldata reserveIds, 
        address rateAddress) external;

    function setReserveCreatorAddress(uint256 reserveId, address creator) external;

    function setReserveCreatorPercentage(uint256 reserveId, uint256 percentage) external;

    function setReserveMaxSupply(
        uint256[] calldata reserveIds, 
        uint256 maxSupply
    ) external;

    function configureReserveAuction(
        uint256[] calldata reserveIds, 
        uint256 liquidationBonus,
        uint256 auctionDuration,
        uint256 auctionPriceMultiple
    ) external;

    function batchConfigReserve(ConfigTypes.ConfigReserveInput[] calldata input) external;
    
    function updateFToken(ConfigTypes.UpdateFTokenInput[] calldata inputs) external;

    function updateStableDebtToken(ConfigTypes.UpdateDebtTokenInput[] calldata inputs) external;

    function updateVariableDebtToken(ConfigTypes.UpdateDebtTokenInput[] calldata inputs) external;

    function approveExecutionDelegateContracts(address[] calldata inputs) external;
}

DataTypes.sol

// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.16;

library DataTypes {

    /// -----------------------------------------------------------------------
    /// Exec
    /// -----------------------------------------------------------------------
    
    struct ExecItemParams {
        address target;
        bytes payload;
    }

    struct ExecBatchItemParams {
        address[] targets;
        bytes[] payloads;
        bool[] allowErrors;
    }

    /// -----------------------------------------------------------------------
    /// P2Pool
    /// -----------------------------------------------------------------------

    enum BorrowStatus { 
        None, // Default zero
        Active, // Open
        Repaid, // Closed, paid by borrower
        Auction, // In Auction
        Liquidated // Closed, paid by liquidator
    }

    enum PriceGroupStatus {
        None, // Default zero
        Active, // Able to set / get prices
        Paused, // Not able to perform any operation
        Protected // Only able to get prices
    }
    
    struct Reserve {
        ReserveConfigurationMap configuration;
        address collateral;
        address asset;
        address fTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        address interestRateAddress;
        string assetPriceFeed;
        uint256 id;
        uint256 maxTokenSupply;
        uint256 maxTokenId;
        uint256 minTokenId;
        uint128 liquidityIndex;
        uint128 variableBorrowIndex;
        uint128 currentLiquidityRate;
        uint128 currentVariableBorrowRate;
        uint40 lastUpdateTimestamp;
    }

    struct ReserveData {
        address collateral;
        address asset;
        uint256 maxTokenId;
        uint256 minTokenId;
    }

    struct InitReserveData {
        uint256 reserveId;
        address collateral;
        address asset;
        uint256 maxTokenId;
        uint256 minTokenId;
        address fTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        address interestRateAddress;
        string assetPriceFeed;
    }

    struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: Reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: variable rate borrowing enabled
        //bit 60-63: reserved
        //bit 64-79: reserve factor
        //bit 80-95: grace period
        //bit 96-111: auction duration
        //bit 112-127: auction start price multiple
        uint256 data;
    }

    struct NFTPriceGroup {
        NFTPriceGroupConfigurationMap configuration;
        PriceGroupStatus status;
        address[15] nfts;
        uint256[15] reserveIds; 
        uint256[15] traitIds; 
        uint256[15] basePrices;
        uint256 id;
    } 

    struct NFTPriceGroupConfigurationMap {
        //bit 0-15: DELTA_01
        //bit 16-31: DELTA_02
        //bit 32-47: DELTA_03
        //bit 48-63: DELTA_04
        //bit 64-79: DELTA_05
        //bit 80-95: DELTA_06
        //bit 96-111: DELTA_07
        //bit 112-127: DELTA_08
        //bit 128-143: DELTA_09
        //bit 144-159: DELTA_10
        //bit 160-175: DELTA_11
        //bit 176-191: DELTA_12
        //bit 192-207: DELTA_13
        //bit 208-223: DELTA_14
        //bit 224-239: DELTA_15
        //bit 240: SIGN_01
        //bit 241: SIGN_02
        //bit 242: SIGN_03
        //bit 243: SIGN_04
        //bit 244: SIGN_05
        //bit 245: SIGN_06
        //bit 246: SIGN_07
        //bit 247: SIGN_08
        //bit 248: SIGN_09
        //bit 249: SIGN_10
        //bit 250: SIGN_11
        //bit 251: SIGN_12
        //bit 252: SIGN_13
        //bit 253: SIGN_14
        //bit 254: SIGN_15
        uint256 data;
    }

    struct Auction {
        address caller;
        uint256 startPrice;
        uint256 endPrice;
        uint256 timestamp;
    }

    struct Borrow {
        BorrowStatus status;
        Collateral collateral;
        Auction auction;
        address borrower;
        address erc20Token;
        uint256 borrowAmount; 
        uint256 scaledAmount;
        uint256 timestamp;
        uint256 duration;
        uint256 reserveId;
        uint256 tokenizedId;
    }

    struct ExecuteDepositParams {
        address initiator;
        uint256 amount;
        uint256 reserveId;
        address onBehalfOf;
        uint16 referralCode;
    }

    struct ExecuteBatchDepositParams {
        address initiator;
        uint256[] amounts;
        uint256[] reserveIds;
        address[] onBehalfOfs;
        uint16[] referralCodes;
    }

    struct ExecuteWithdrawParams {
        address initiator;
        uint256 amount;
        uint256 reserveId;
        address to;
    }

    struct ExecuteBatchWithdrawParams {
        address initiator;
        uint256[] amounts;
        uint256[] reserveIds;
        address[] tos;
    }

    struct ExecuteBorrowParams {
        address initiator;
        uint256 amount;
        uint256 tokenId;
        uint256 tokenValue;
        uint256 reserveId;
        uint256 duration;
        address onBehalfOf;
        uint16 referralCode;
    }

    struct ExecuteBatchBorrowParams {
        address initiator;
        uint256[] amounts;
        uint256[] tokenIds;
        uint256[] tokenValues;
        uint256[] reserveIds;
        uint256 duration;
        address onBehalfOf;
        uint16 referralCode;
    }

    struct ExecuteRepayParams {
        address initiator;
        uint256 borrowId;
        uint256 amount;
    }

    struct ExecuteBatchRepayParams {
        address initiator;
        uint256[] borrowIds;
        uint256[] amounts;
    }

    struct ExecuteRefinanceParams {
        address initiator;
        uint256 borrowId;
        uint256 amount;
        uint256 duration;
    }

    struct ExecuteBatchRefinanceParams {
        address initiator;
        uint256[] borrowIds;
        uint256[] amounts;
        uint256[] durations;
    }

    struct ExecuteAuctionParams {
        address initiator;
        uint256 borrowId;
        address onBehalfOf;
    }

    struct ExecuteBatchAuctionParams {
        address initiator;
        uint256[] borrowIds;
        address[] onBehalfOfs;
    }

    struct ExecuteBidParams {
        address initiator;
        address asset;
        uint256 amount;
        uint256 borrowId;
        address onBehalfOf;
    }

    struct ExecuteBatchBidParams {
        address initiator;
        address[] assets;
        uint256[] amounts;
        uint256[] borrowIds;
        address[] onBehalfOfs;
    }

    /// -----------------------------------------------------------------------
    /// Tokenized 
    /// -----------------------------------------------------------------------

    struct TokenizedLoan {
        address collateral;
        uint256 tokenId;
        uint256 id;
    }

    /// -----------------------------------------------------------------------
    /// P2Peer
    /// -----------------------------------------------------------------------

    enum LoanStatus {
        None, // Default zero
        Escrow, // Open
        Repaid, // Closed, lender received repayment 
        Refinanced, // Closed, lender received repayment 
        Foreclosed // Closed, lender received collateral
    }

    enum Side { Offer,  Listing }

    enum SignatureVersion { Single, Bulk }

    enum CollateralType { ERC721, ERC1155 } //TODO

    enum LoanType {
        Loan,
        Trait,
        Collection,
        Bundle,
        Renegotiation,
        Refinancing
    }

    struct Terms {
        LoanType loanType;
        /* Order collaterlTypes - empty item if not isBundle. */
        CollateralType[] collateralTypes;
        CollateralType collateralType;
        /* Order collaterals & tokenIds - empty if not isBundle. */
        address[] collaterals;
        uint256[] tokenIds;
        /* Order values - empty item if not ERC1155. */
        uint256[] values;
        /* Order collateral & tokenId - address(0) if isBundle. */
        address collateral;
        uint256 tokenId;
        /* Order value - empty item if not ERC1155. */
        uint256 value;
        address asset;
        uint256 amount;
        /* Order maximumRepayment - used for both fixed price and pro-rata loans. */
        uint256 maximumRepayment;
        /* Order minimumRepayment - used for pro-rata loans, 0 if none */
        uint256 minimumRepayment;
        /* Order interestRateInBasisPoints - used for pro-rata loans. */
        uint256 interestRateInBasisPoints; 
        uint256 duration;
        /* Loan isProRata - used enable pro-rata loan repayments. */
        bool isProRata;
        bool isBundle;
        /* Order loanId - 0 if creating a new loan. */
        uint256 loanId;
        /* Order fee - paid on renegotiation. */
        uint256 fee;
    }

    struct Order {
        address user;
        /* Referrer - for new loans & refinancing (borrower-side). */
        address referrer;
        Side side;
        Terms terms;
        /* Order counterparty - address(0) for open order. */
        address counterparty;
        bool isInstantExecution; 
        /* Order loanRepayment - for refinancing. */
        uint256 loanRepayment;
        uint256 listingTime;
        uint256 expirationTime;
        uint256 salt;
        /* Order message - for renegotiations. */
        string message;
        bytes extraParams;
        /* Borrow Id - for p2pool orders. */
        uint256 borrowId;
        /* Reserve Id - for fToken orders. */
        uint256 reserveId;
    }

    struct Input {
        Order order;
        uint8 v;
        bytes32 r;
        bytes32 s;
        bytes extraSignature;
        SignatureVersion signatureVersion;
        uint256 blockNumber;
    }

    struct Execution {
        Input offer;
        Input listing;
    }

    struct Collateral {
        /* Loan collateralType - ERC721 or ERC1155. */
        CollateralType collateralType;
        address collateral;
        uint256 tokenId;
        /* Loan value - collateral token amount (ERC1155, only). */
        uint256 value;
    }

    struct Collaterals {
        /* Loan collateralType - ERC721 or ERC1155. */
        CollateralType[] collateralTypes;
        address[] collaterals;
        uint256[] tokenIds;
        /* Loan value - collateral token amount (ERC1155, only). */
        uint256[] values;
    }

    struct Principal {
        address asset;
        uint256 amount;
    }

    struct Interest {
        /* Loan:Interest rate - in basis points (1/100th of a percent), used in pro-rata loans. */
        uint256 rate;
        /* Loan.Interest isProRata - to enable pro-rata loan repayments. */
        bool isProRata;
    }

    struct Repayment {
        /* Loan Repayment.maximum - used in both fixed price & pro-rata loans. */
        uint256 maximum;
        /* Loan Repayment.minimum - (optional) used in pro-rata loans. */
        uint256 minimum;
    }

    struct Loan {
        LoanStatus status;
        Collateral collateral;
        Principal principal;
        Interest interest;
        Repayment repayment;
        address borrower;
        address lender;
        address referrer;
        uint256 timestamp;
        uint256 duration;
        /* Loan tokenizedId - tokenId of promissoryNote and obligationReceipt. */
        uint256 tokenizedId;
    }

    struct LoanBundle {
        LoanStatus status;
        Collaterals collaterals;
        Principal principal;
        Interest interest;
        Repayment repayment;
        address borrower;
        address lender;
        address referrer;
        uint256 timestamp;
        uint256 duration;
        /* Loan tokenizedId - tokenId of promissoryNote and obligationReceipt. */
        uint256 tokenizedId;
    } 

    struct ExecuteNewLoanParams {
        DataTypes.Terms terms;
        address borrower;
        address lender;
        address referrer;
        /* Borrow Id - for p2pool Orders */
        uint256 borrowId;
        /* Reserve Id - for fToken Orders */
        uint256 reserveId;
    }

    struct ExecuteRepayLoanParams {
        uint256 loanId;
        uint256 lendingFactor;
        /* Reserve Id - for fToken repayment */
        uint256 reserveId;
    }

    struct ExecuteForecloseLoanParams {
        uint256 loanId;
    }

    struct ExecuteRenegotiateLoanParams {
        DataTypes.Terms terms;
        address borrower;
        address lender;
        /* Reserve Ids - for fToken Orders */
        uint256 borrowerReserveId;
        uint256 lenderReserveId;
    }

    struct ExecuteRefinanceLoanParams {
        DataTypes.Terms terms;
        address borrower;
        address lender;
        address referrer;
        uint256 loanRepayment;
        uint256 lendingFactor;
        /* Reserve Ids - for fToken Orders */
        uint256 borrowerReserveId;
        uint256 lenderReserveId;
    }
}

ConfigTypes.sol

// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.16;

library ConfigTypes {
    struct InitReserveInput {
        //collateral params
        address underlyingCollateral;
        string underlyingCollateralName;
        string underlyingCollateralSymbol;
        uint256 underlyingMaxTokenId;
        uint256 underlyingMinTokenId;
        //asset params
        address underlyingAsset;
        string underlyingAssetName;
        string underlyingAssetSymbol;
        uint8 underlyingAssetDecimals;
        //fToken params
        address fTokenImpl;
        string fTokenName;
        string fTokenSymbol;
        //stable debtToken params
        address stableDebtTokenImpl;
        string stableDebtTokenName;
        string stableDebtTokenSymbol;
        //variable debtToken params
        address variableDebtTokenImpl;
        string variableDebtTokenName;
        string variableDebtTokenSymbol;
        //risk params
        address interestRateStrategy;
        uint256 baseLTV;
        //account params
        address treasury;
        address creator;
        //fee params
        uint256 creatorPercentage;
        //auction params
        uint256 auctionCallerPercentage;
        uint256 auctionCreatorPercentage;
        //oracle params
        string assetPriceFeed;
    }

    struct ConfigReserveInput {
        //reserve params
        uint256 reserveId;
        uint256 reserveFactor;
        //collateral params
        uint256 ltv;
        //asset params
        uint256 decimals;
        //default params
        uint256 gracePeriod;
        uint256 liquidationBonus;
        uint256 liquidationThreshold;
        //auction params
        uint256 auctionDuration;
        uint256 auctionPriceMultiple;
        //conditional params
        bool borrowingEnabled;
    }

    struct InitNFTPriceGroupDataInput {
        address[15] nfts;
        uint256[15] reserveIds; 
        uint256[15] traitIds; 
        uint256[15] basePrices;
    }

    struct BasePriceInput {
        uint256 groupId;
        address[15] nfts;
        uint256[15] traitIds;
        uint256[15] basePrices;
    }

    struct DeltaInput {
        uint256 groupId;
        uint256[15] nfts;
        uint256[15] currentPrices;
    }

    struct UpdateFTokenInput {
        address collateral;
        address asset;
        address implementation;
        uint256 reserveId;
        bytes encodedCallData;
    }

    struct UpdateDebtTokenInput {
        address collateral;
        address asset;
        address implementation;
        uint256 reserveId;
        bytes encodedCallData;
    }
}