IConfigurator
// 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;
}// 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;
}
}// 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;
}
}Last updated