文件 1 的 35：Address.sol
pragma solidity ^0.7.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 35：AddressUpgradeable.sol
pragma solidity ^0.7.0;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 3 的 35：Clones.sol
pragma solidity >=0.6.0 <0.8.0;
library Clones {
function clone(address master) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, master))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address master, bytes32 salt) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, master))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(address master, bytes32 salt, address deployer) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, master))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
mstore(add(ptr, 0x38), shl(0x60, deployer))
mstore(add(ptr, 0x4c), salt)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
function predictDeterministicAddress(address master, bytes32 salt) internal view returns (address predicted) {
return predictDeterministicAddress(master, salt, address(this));
}
}
文件 4 的 35：CollateralManager.sol
pragma solidity 0.7.6;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {Ownable} from "../roles/Ownable.sol";
import {IOracle} from "../Oracle.sol";
import {ITokenManager} from "./TokenManager.sol";
import {IDiscountManager} from "./DiscountManager.sol";
import {VersionManager} from "../registries/VersionManager.sol";
interface ICollateralManager
{
function isSufficientInitialCollateral(address lendingToken, uint256 principal, address collateralToken, uint256 collateralAmount) external view returns (bool);
function isSufficientCollateral(address borrower, address lendingToken, uint256 principal, address collateralToken, uint256 collateralAmount) external view returns (bool, uint256);
}
contract CollateralManager is ICollateralManager, Ownable, VersionManager
{
using SafeMath for uint256;
uint256 private constant _BASIS_POINT = 10000;
mapping(address => uint256) private _initThreshold;
mapping(address => uint256) private _liquidationThreshold;
function _calcPercentOf(uint256 amount, uint256 percent) private pure returns (uint256)
{
return amount.mul(percent).div(_BASIS_POINT);
}
function getThresholds(address token) external view returns (uint256, uint256)
{
return (_initThreshold[token], _liquidationThreshold[token]);
}
function setInitThresholds(address[] calldata tokens, uint256[] calldata thresholds) external onlyOwner
{
require(tokens.length == thresholds.length, "!=");
for (uint256 i = 0; i < tokens.length; i++)
{
address token = tokens[i];
uint256 threshold = thresholds[i];
require(token != address(0), "0 addy");
require(threshold > 10000, "Invalid val");
_initThreshold[token] = threshold;
}
}
function setLiquidationThresholds(address[] calldata tokens, uint256[] calldata thresholds) external onlyOwner
{
require(tokens.length == thresholds.length, "!=");
for (uint256 i = 0; i < tokens.length; i++)
{
address token = tokens[i];
uint256 threshold = thresholds[i];
require(token != address(0), "0 addy");
require(threshold > 10000 && threshold <= 17500, "Invalid val");
_liquidationThreshold[token] = threshold;
}
}
function _convert(address from, address to, uint256 amount) private view returns (uint256)
{
return IOracle(VersionManager._oracle()).convert(from, to, amount);
}
function _isValidPairing(address lendingToken, address collateralToken) private view returns (bool)
{
return (lendingToken != collateralToken) && ITokenManager(VersionManager._tokenMgr()).isBothWhitelisted(lendingToken, collateralToken) && !ITokenManager(VersionManager._tokenMgr()).isBothStable(lendingToken, collateralToken);
}
function isSufficientInitialCollateral(address lendingToken, uint256 principal, address collateralToken, uint256 collateralAmount) external view override returns (bool)
{
require(_isValidPairing(lendingToken, collateralToken), "Bad pair");
uint256 convertedPrincipal = _convert(lendingToken, collateralToken, _calcPercentOf(principal, _initThreshold[collateralToken]));
return collateralAmount >= convertedPrincipal;
}
function isSufficientCollateral(address borrower, address lendingToken, uint256 principal, address collateralToken, uint256 collateralAmount) external view override returns (bool, uint256)
{
uint256 collateralThreshold = _liquidationThreshold[collateralToken];
if (IDiscountManager(VersionManager._discountMgr()).isDiscounted(borrower))
{
collateralThreshold = ITokenManager(VersionManager._tokenMgr()).isStableToken(collateralToken) ? collateralThreshold.sub(250) : collateralThreshold.sub(500);
}
uint256 convertedPrincipal = _convert(lendingToken, collateralToken, _calcPercentOf(principal, collateralThreshold));
return (collateralAmount > convertedPrincipal, collateralAmount.div(convertedPrincipal.div(collateralThreshold)));
}
}
文件 5 的 35：Context.sol
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
文件 6 的 35：DiscountManager.sol
pragma solidity 0.7.6;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {DiscounterRole} from "../roles/DiscounterRole.sol";
import {IYLD} from "../interfaces/IYLD.sol";
interface IDiscountManager
{
event Enroll(address indexed account, uint256 amount);
event Exit(address indexed account);
function isDiscounted(address account) external view returns (bool);
function updateUnlockTime(address lender, address borrower, uint256 duration) external;
}
contract DiscountManager is IDiscountManager, DiscounterRole, ReentrancyGuard
{
using SafeMath for uint256;
address private immutable _YLD;
uint256 private _requiredAmount = 50 * 1e18;
bool private _discountsActivated = true;
mapping(address => uint256) private _balanceOf;
mapping(address => uint256) private _unlockTimeOf;
constructor()
{
_YLD = address(0xDcB01cc464238396E213a6fDd933E36796eAfF9f);
}
function requiredAmount () public view returns (uint256)
{
return _requiredAmount;
}
function discountsActivated () public view returns (bool)
{
return _discountsActivated;
}
function balanceOf (address account) public view returns (uint256)
{
return _balanceOf[account];
}
function unlockTimeOf (address account) public view returns (uint256)
{
return _unlockTimeOf[account];
}
function isDiscounted(address account) public view override returns (bool)
{
return _discountsActivated ? _balanceOf[account] >= _requiredAmount : false;
}
function enroll() external nonReentrant
{
require(_discountsActivated, "Discounts off");
require(!isDiscounted(msg.sender), "In");
require(IERC20(_YLD).transferFrom(msg.sender, address(this), _requiredAmount));
_balanceOf[msg.sender] = _requiredAmount;
_unlockTimeOf[msg.sender] = block.timestamp.add(4 weeks);
emit Enroll(msg.sender, _requiredAmount);
}
function exit() external nonReentrant
{
require(_balanceOf[msg.sender] >= _requiredAmount, "!in");
require(block.timestamp > _unlockTimeOf[msg.sender], "Discounting");
require(IERC20(_YLD).transfer(msg.sender, _balanceOf[msg.sender]));
_balanceOf[msg.sender] = 0;
_unlockTimeOf[msg.sender] = 0;
emit Exit(msg.sender);
}
function updateUnlockTime(address lender, address borrower, uint256 duration) external override onlyDiscounter
{
uint256 lenderUnlockTime = _unlockTimeOf[lender];
uint256 borrowerUnlockTime = _unlockTimeOf[borrower];
if (isDiscounted(lender))
{
_unlockTimeOf[lender] = (block.timestamp >= lenderUnlockTime || lenderUnlockTime.sub(block.timestamp) < duration) ? lenderUnlockTime.add(duration.add(4 weeks)) : lenderUnlockTime;
}
else if (isDiscounted(borrower))
{
_unlockTimeOf[borrower] = (block.timestamp >= borrowerUnlockTime || borrowerUnlockTime.sub(block.timestamp) < duration) ? borrowerUnlockTime.add(duration.add(4 weeks)) : borrowerUnlockTime;
}
}
function activateDiscounts() external onlyDiscounter
{
require(!_discountsActivated, "Activated");
_discountsActivated = true;
}
function deactivateDiscounts() external onlyDiscounter
{
require(_discountsActivated, "Deactivated");
_discountsActivated = false;
}
function setRequiredAmount(uint256 newAmount) external onlyDiscounter
{
require(newAmount > (0.75 * 1e18) && newAmount < type(uint256).max, "Invalid val");
_requiredAmount = newAmount;
}
}
文件 7 的 35：DiscounterRole.sol
pragma solidity 0.7.6;
import {Roles} from "./Roles.sol";
contract DiscounterRole
{
using Roles for Roles.Role;
Roles.Role private _discounters;
event DiscounterAdded(address indexed account);
event DiscounterRemoved(address indexed account);
modifier onlyDiscounter()
{
require(isDiscounter(msg.sender), "!discounter");
_;
}
constructor()
{
_discounters.add(msg.sender);
emit DiscounterAdded(msg.sender);
}
function isDiscounter(address account) public view returns (bool)
{
return _discounters.has(account);
}
function addDiscounter(address account) public onlyDiscounter
{
_discounters.add(account);
emit DiscounterAdded(account);
}
function renounceDiscounter() public
{
_discounters.remove(msg.sender);
emit DiscounterRemoved(msg.sender);
}
}
文件 8 的 35：ERC20.sol
pragma solidity ^0.7.0;
import "../../utils/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
文件 9 的 35：EnumerableSet.sol
pragma solidity ^0.7.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
文件 10 的 35：Escrow.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {IFeeBurnManager} from "./managers/FeeBurnManager.sol";
import {ILoanFactory} from "./factories/LoanFactory.sol";
import {ILoan} from "./Loan.sol";
import {VersionManager} from "./registries/VersionManager.sol";
interface IEscrow
{
enum Status {Pending, Accepted, Canceled}
event Accept(address lender, address borrower, address loan);
event Cancel(address caller);
function getLoanDetails() external view returns (ILoan.LoanDetails memory details);
}
contract Escrow is IEscrow, ReentrancyGuardUpgradeable, VersionManager
{
using SafeERC20 for IERC20;
Status internal _status;
ILoan.LoanDetails internal _loanDetails;
function _initialize() internal initializer
{
ReentrancyGuardUpgradeable.__ReentrancyGuard_init();
}
function _isPending() internal view
{
require(_status == Status.Pending, "!pending");
}
function _getBurner() internal view returns (address)
{
return IFeeBurnManager(VersionManager._feeBurnMgr()).burner();
}
function _getPrincipalBalance() internal view returns (uint256)
{
return IERC20(_loanDetails.lendingToken).balanceOf(address(this));
}
function _getCollateralBalance() internal view returns (uint256)
{
return IERC20(_loanDetails.collateralToken).balanceOf(address(this));
}
function getStatus () external view returns (Status)
{
return _status;
}
function getLoanDetails() external view override returns (ILoan.LoanDetails memory details)
{
return _loanDetails;
}
function _accept(uint256 feeOnInterest, uint256 feeOnPrincipal, bool isOffer) internal returns (address loan)
{
_isPending();
_status = Status.Accepted;
IERC20(_loanDetails.lendingToken).safeTransfer(Escrow._getBurner(), feeOnInterest);
IERC20(_loanDetails.collateralToken).safeTransfer(Escrow._getBurner(), feeOnPrincipal);
if (isOffer)
{
_loanDetails.principal = _getPrincipalBalance();
}
else
{
_loanDetails.collateral = _getCollateralBalance();
}
loan = ILoanFactory(VersionManager._loanFactory()).createLoan(_loanDetails);
IERC20(_loanDetails.collateralToken).safeTransfer(loan, _loanDetails.collateral);
IERC20(_loanDetails.lendingToken).safeTransfer(_loanDetails.borrower, _loanDetails.principal);
emit Accept(_loanDetails.lender, _loanDetails.borrower, loan);
return loan;
}
}
文件 11 的 35：FeeBurnManager.sol
pragma solidity 0.7.6;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {Ownable} from "../roles/Ownable.sol";
import {IOracle} from "../Oracle.sol";
import {IDiscountManager} from "./DiscountManager.sol";
import {VersionManager} from "../registries/VersionManager.sol";
interface IFeeBurnManager
{
function burner() external view returns (address);
function getDefaultingFee(uint256 collateral) external view returns (uint256);
function getFeeOnInterest(address lender, address lendingToken, uint256 principal, uint256 interest) external view returns (uint256);
function getFeeOnPrincipal(address borrower, address lendingToken, uint256 principal, address collateralToken) external view returns (uint256);
}
contract FeeBurnManager is IFeeBurnManager, Ownable, VersionManager
{
using SafeMath for uint256;
uint256 private constant _BASIS_POINT = 10000;
address private _burner;
uint256 private _defaultingFeePct = 700;
uint256 private _lenderInterestFeePct = 750;
uint256 private _borrowerPrincipalFeePct = 100;
constructor()
{
_burner = msg.sender;
}
function _calcPercentOf(uint256 amount, uint256 percent) private pure returns (uint256)
{
return amount.mul(percent).div(_BASIS_POINT);
}
function burner() external view override returns (address burnerAddress)
{
return _burner;
}
function getFeePcts () public view returns (uint256, uint256, uint256)
{
return (_lenderInterestFeePct, _borrowerPrincipalFeePct, _defaultingFeePct);
}
function getFeeOnInterest(address lender, address lendingToken, uint256 principal, uint256 interest) external view override returns (uint256)
{
uint256 interestAmount = _calcPercentOf(principal, interest);
uint256 oneUSDOfToken = IOracle(VersionManager._oracle()).convertFromUSD(lendingToken, 1e18);
uint256 discountedFeePct = _calcPercentOf(_lenderInterestFeePct, 7500);
uint256 fee = _calcPercentOf(interestAmount, IDiscountManager(VersionManager._discountMgr()).isDiscounted(lender) ? discountedFeePct : _lenderInterestFeePct);
return fee < oneUSDOfToken ? oneUSDOfToken : fee;
}
function getFeeOnPrincipal(address borrower, address lendingToken, uint256 principal, address collateralToken) external view override returns (uint256)
{
return _calcPercentOf(IOracle(VersionManager._oracle()).convert(lendingToken, collateralToken, principal), IDiscountManager(VersionManager._discountMgr()).isDiscounted(borrower) ? _borrowerPrincipalFeePct.sub(25) : _borrowerPrincipalFeePct);
}
function getDefaultingFee(uint256 collateral) external view override returns (uint256)
{
return _calcPercentOf(collateral, _defaultingFeePct);
}
function setBurner(address newBurner) external onlyOwner
{
require(newBurner != address(0), "0 addy");
_burner = newBurner;
}
function setDefaultingFeePct(uint256 newPct) external onlyOwner
{
require(newPct > 0 && newPct <= 750, "Invalid val");
_defaultingFeePct = newPct;
}
function setPeerFeePcts(uint256 newLenderFeePct, uint256 newBorrowerFeePct) external onlyOwner
{
require(newLenderFeePct > 0 && newBorrowerFeePct > 0, "0% fee");
require(newLenderFeePct <= 1000 && newBorrowerFeePct <= 150, "Too high");
_lenderInterestFeePct = newLenderFeePct;
_borrowerPrincipalFeePct = newBorrowerFeePct;
}
}
文件 12 的 35：IERC20.sol
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
文件 13 的 35：IYLD.sol
pragma solidity 0.7.6;
interface IYLD
{
function renounceMinter() external;
function mint(address account, uint256 amount) external returns (bool);
}
文件 14 的 35：Initializable.sol
pragma solidity >=0.4.24 <0.8.0;
import "../utils/AddressUpgradeable.sol";
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
文件 15 的 35：Loan.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {ICollateralManager} from "./managers/CollateralManager.sol";
import {IFeeBurnManager} from "./managers/FeeBurnManager.sol";
import {ITokenManager} from "./managers/TokenManager.sol";
import {IOracle} from "./Oracle.sol";
import {VersionManager} from "./registries/VersionManager.sol";
interface ILoan
{
enum Status {Active, Repaid, Defaulted}
struct LoanDetails
{
address lender;
address borrower;
address lendingToken;
address collateralToken;
uint256 principal;
uint256 interest;
uint256 duration;
uint256 collateral;
}
struct LoanMetadata
{
ILoan.Status status;
uint256 timestampStart;
uint256 timestampRepaid;
uint256 liquidatableTimeAllowance;
}
event Repay(address indexed lender, address indexed borrower, address loan);
event Default(address indexed lender, address indexed borrower, address loan);
event Liquidate(address indexed loan, address liquidator, uint256 amountRepaid);
function __Loan_init(LoanDetails memory loanDetails) external;
function isDefaulted() external view returns (bool);
function getLoanDetails() external view returns (LoanDetails memory details);
function getLoanMetadata() external view returns (LoanMetadata memory metadata);
}
contract Loan is ILoan, ReentrancyGuardUpgradeable, VersionManager
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private constant _COMPENSATION_THRESHOLD = 10650;
uint256 private constant _BASIS_POINT = 10000;
LoanDetails private _loanDetails;
LoanMetadata private _loanMetadata;
modifier onlyLender
{
require(msg.sender == _loanDetails.lender, "!lender");
_;
}
modifier onlyBorrower
{
require(msg.sender == _loanDetails.borrower, "!borrower");
_;
}
function __Loan_init(LoanDetails memory loanDetails) external override initializer
{
ReentrancyGuardUpgradeable.__ReentrancyGuard_init();
_loanDetails = loanDetails;
_loanMetadata.timestampStart = block.timestamp;
}
function _calcPercentOf(uint256 amount, uint256 percent) private pure returns (uint256)
{
return amount.mul(percent).div(_BASIS_POINT);
}
function _isActive() private view
{
require(_loanMetadata.status == ILoan.Status.Active, "!active");
}
function isDefaulted() public view override returns (bool)
{
(bool sufficient,) = ICollateralManager(VersionManager._collateralMgr()).isSufficientCollateral(_loanDetails.borrower, _loanDetails.lendingToken, _loanDetails.principal, _loanDetails.collateralToken, _getCollateralBalance());
return !sufficient || block.timestamp > getTimestampDue();
}
function _hasDefaulted() private view
{
require(isDefaulted(), "!defaulted");
}
function _hasNotDefaulted() private view
{
require(!isDefaulted(), "Defaulted");
}
function getTimestampDue() public view returns (uint256)
{
return _loanMetadata.timestampStart.add(_loanDetails.duration);
}
function getCollateralBalance() public view returns (uint256)
{
return _getCollateralBalance();
}
function _getFullCollateralBalance() private view returns (uint256)
{
return IERC20(_loanDetails.collateralToken).balanceOf(address(this));
}
function _getCollateralBalance() private view returns (uint256)
{
if (ITokenManager(VersionManager._tokenMgr()).isDynamicToken(_loanDetails.collateralToken))
{
return _getFullCollateralBalance();
}
return _loanDetails.collateral;
}
function _repaymentAmount() private view returns (uint256 amount)
{
return _loanDetails.principal.add(_calcPercentOf(_loanDetails.principal, _loanDetails.interest));
}
function getLoanDetails() public view override returns (LoanDetails memory details)
{
return _loanDetails;
}
function getLoanMetadata() public view override returns (LoanMetadata memory metadata)
{
return _loanMetadata;
}
function _increaseCollateralBalance (uint amount) private
{
if (!ITokenManager(VersionManager._tokenMgr()).isDynamicToken(_loanDetails.collateralToken))
{
_loanDetails.collateral = _loanDetails.collateral.add(amount);
}
}
function topUpCollateral(uint256 amount) external nonReentrant onlyBorrower
{
_isActive();
_hasNotDefaulted();
require(amount > 0 && amount < type(uint256).max, "Invalid val");
_increaseCollateralBalance(amount);
IERC20(_loanDetails.collateralToken).safeTransferFrom(_loanDetails.borrower, address(this), amount);
}
function _handleRepayment() private
{
LoanDetails memory loanDetails = getLoanDetails();
_loanMetadata.status = ILoan.Status.Repaid;
IERC20(loanDetails.lendingToken).safeTransferFrom(loanDetails.borrower, loanDetails.lender, _repaymentAmount());
IERC20(loanDetails.collateralToken).safeTransfer(loanDetails.borrower, _getFullCollateralBalance());
_loanMetadata.timestampRepaid = block.timestamp;
emit Repay(loanDetails.lender, loanDetails.borrower, address(this));
}
function repay() external nonReentrant onlyBorrower
{
require(block.timestamp > _loanMetadata.timestampStart.add(5 minutes), "fresh");
_isActive();
_hasNotDefaulted();
_handleRepayment();
}
function _txDefaultingFee() internal
{
IERC20(_loanDetails.collateralToken).safeTransfer(IFeeBurnManager(VersionManager._feeBurnMgr()).burner(), IFeeBurnManager(VersionManager._feeBurnMgr()).getDefaultingFee(_getFullCollateralBalance()));
}
function _handleDefault() private
{
_loanMetadata.status = ILoan.Status.Defaulted;
_txDefaultingFee();
IERC20(_loanDetails.collateralToken).safeTransfer(_loanDetails.lender, _getFullCollateralBalance());
emit Default(_loanDetails.lender, _loanDetails.borrower, address(this));
}
function setLiquidatableTimeAllowance() public nonReentrant
{
_isActive();
_hasDefaulted();
require(_loanMetadata.liquidatableTimeAllowance == 0, "Set");
_loanMetadata.liquidatableTimeAllowance = block.timestamp.add(10 minutes);
}
function seizeCollateral() external nonReentrant onlyLender
{
_isActive();
_hasDefaulted();
_handleDefault();
}
function seizeForLender() public nonReentrant
{
_isActive();
_hasDefaulted();
require(_loanMetadata.liquidatableTimeAllowance != 0 && block.timestamp >= _loanMetadata.liquidatableTimeAllowance, "Liquidatable");
uint256 compensation = IOracle(VersionManager._oracle()).convertFromUSD(_loanDetails.collateralToken, 5 * 1e18);
IERC20(_loanDetails.collateralToken).safeTransfer(msg.sender, compensation);
_handleDefault();
}
function liquidate() external nonReentrant
{
_isActive();
_hasDefaulted();
LoanDetails memory loanDetails = getLoanDetails();
_loanMetadata.status = ILoan.Status.Defaulted;
_txDefaultingFee();
uint256 collateralBalance = _getFullCollateralBalance();
uint256 amountToRepay = loanDetails.principal.add(_repaymentAmount().sub(loanDetails.principal).div(2));
uint256 maxCompensation = IOracle(VersionManager._oracle()).convert(loanDetails.lendingToken, loanDetails.collateralToken, _calcPercentOf(amountToRepay, _COMPENSATION_THRESHOLD));
uint256 compensation = collateralBalance > maxCompensation ? maxCompensation : collateralBalance;
IERC20(loanDetails.lendingToken).safeTransferFrom(msg.sender, loanDetails.lender, amountToRepay);
IERC20(loanDetails.collateralToken).safeTransfer(msg.sender, compensation);
if (collateralBalance > maxCompensation)
{
IERC20(loanDetails.collateralToken).safeTransfer(loanDetails.lender, _getFullCollateralBalance());
}
emit Default(loanDetails.lender, loanDetails.borrower, address(this));
emit Liquidate(address(this), msg.sender, amountToRepay);
}
}
文件 16 的 35：LoanFactory.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {ILoan} from "../Loan.sol";
import {IDiscountManager} from "../managers/DiscountManager.sol";
import {IRewardManager} from "../managers/RewardManager.sol";
import {ProxyFactory} from "./ProxyFactory.sol";
import {Pausable} from "../roles/Pausable.sol";
import {LoanerRole} from "../roles/LoanerRole.sol";
import {VersionManager} from "../registries/VersionManager.sol";
interface ILoanFactory
{
event NewLoan(address indexed lender, address indexed borrower, address loan);
function addLoaner(address account) external;
function createLoan(ILoan.LoanDetails memory loanDetails) external returns (address);
}
contract LoanFactory is ILoanFactory, Pausable, LoanerRole, VersionManager
{
using SafeMath for uint256;
address[] private _loans;
mapping(address => address[]) private _loansOf;
function getLoans() external view returns (address[] memory)
{
return _loans;
}
function getLoansOf(address account) external view returns (address[] memory)
{
return _loansOf[account];
}
function addLoaner(address account) public override(ILoanFactory, LoanerRole)
{
LoanerRole.addLoaner(account);
}
function createLoan(ILoan.LoanDetails memory loanDetails) external override onlyLoaner returns (address)
{
Pausable._isNotPaused();
bytes memory initData = abi.encodeWithSelector(ILoan.__Loan_init.selector, loanDetails);
address loan = ProxyFactory._deployMinimal(VersionManager._loanImplementation(), initData);
require(IRewardManager(VersionManager._rewardMgr()).trackLoan(loan, loanDetails.borrower, loanDetails.lendingToken, loanDetails.principal, loanDetails.interest, loanDetails.duration), "Track err");
_loans.push(loan);
_loansOf[loanDetails.lender].push(loan);
_loansOf[loanDetails.borrower].push(loan);
IDiscountManager(VersionManager._discountMgr()).updateUnlockTime(loanDetails.lender, loanDetails.borrower, loanDetails.duration);
emit NewLoan(loanDetails.lender, loanDetails.borrower, loan);
return loan;
}
}
文件 17 的 35：LoanerRole.sol
pragma solidity 0.7.6;
import {Roles} from "./Roles.sol";
contract LoanerRole
{
using Roles for Roles.Role;
Roles.Role private _loaners;
event LoanerAdded(address indexed account);
event LoanerRemoved(address indexed account);
modifier onlyLoaner()
{
require(isLoaner(msg.sender), "!loaner");
_;
}
constructor()
{
_loaners.add(msg.sender);
emit LoanerAdded(msg.sender);
}
function isLoaner(address account) public view returns (bool)
{
return _loaners.has(account);
}
function addLoaner(address account) public virtual onlyLoaner
{
_loaners.add(account);
emit LoanerAdded(account);
}
function renounceLoaner() public
{
_loaners.remove(msg.sender);
emit LoanerRemoved(msg.sender);
}
}
文件 18 的 35：MainFactory.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {Pausable} from "../roles/Pausable.sol";
import {ProxyFactory} from "./ProxyFactory.sol";
import {VersionManager} from "../registries/VersionManager.sol";
import {ILoan} from "../Loan.sol";
import {IOffer} from "../Offer.sol";
import {IRequest} from "../Request.sol";
import {ILoanFactory} from "./LoanFactory.sol";
import {ITokenManager} from "../managers/TokenManager.sol";
import {IFeeBurnManager} from "../managers/FeeBurnManager.sol";
import {IOracle} from "../Oracle.sol";
interface IMainFactory
{
event NewOffer(address indexed lender, address offer);
event NewRequest(address indexed borrower, address request);
}
contract MainFactory is IMainFactory, Pausable, ReentrancyGuard, VersionManager
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private constant _DECIMALS = 1e18;
uint256 private constant _MIN_INTEREST = 200;
uint256 private constant _MAX_INTEREST = 1250;
uint256 private constant _MAX_DURATION = 60 days;
uint256 private constant _MIN_DURATION = 10 days;
address[] private _offers;
address[] private _requests;
mapping(address => address[]) private _offersOf;
mapping(address => address[]) private _requestsOf;
function getOffers() external view returns (address[] memory)
{
return _offers;
}
function getRequests() external view returns (address[] memory)
{
return _requests;
}
function getOffersOf(address account) external view returns (address[] memory)
{
return _offersOf[account];
}
function getRequestsOf(address account) external view returns (address[] memory)
{
return _requestsOf[account];
}
function createOffer(address lendingToken, uint256 principal, uint256 interest, uint256 duration) external nonReentrant
{
Pausable._isNotPaused();
require(ITokenManager(VersionManager._tokenMgr()).isWhitelisted(lendingToken), "Bad token");
_isValid(lendingToken, principal, interest, duration);
uint256 feeOnInterest = IFeeBurnManager(VersionManager._feeBurnMgr()).getFeeOnInterest(msg.sender, lendingToken, principal, interest);
bytes memory initData = abi.encodeWithSelector(IOffer.__Offer_init.selector, msg.sender, lendingToken, principal, interest, duration, feeOnInterest);
address offer = ProxyFactory._deployMinimal(VersionManager._offerImplementation(), initData);
IERC20(lendingToken).safeTransferFrom(msg.sender, offer, principal.add(feeOnInterest));
_offers.push(offer);
ILoanFactory(VersionManager._loanFactory()).addLoaner(offer);
_offersOf[msg.sender].push(offer);
emit NewOffer(msg.sender, offer);
}
function createRequest(address lendingToken, uint256 principal, uint256 interest, uint256 duration, address collateralToken, uint256 collateral) external nonReentrant
{
Pausable._isNotPaused();
_isValid(lendingToken, principal, interest, duration);
uint256 feeOnPrincipal = IFeeBurnManager(VersionManager._feeBurnMgr()).getFeeOnPrincipal(msg.sender, lendingToken, principal, collateralToken);
bytes memory initData = abi.encodeWithSelector(IRequest.__Request_init.selector, msg.sender, lendingToken, principal, interest, duration, collateralToken, collateral, feeOnPrincipal);
address request = ProxyFactory._deployMinimal(VersionManager._requestImplementation(), initData);
IERC20(collateralToken).safeTransferFrom(msg.sender, request, collateral.add(feeOnPrincipal));
_requests.push(request);
ILoanFactory(VersionManager._loanFactory()).addLoaner(request);
_requestsOf[msg.sender].push(request);
emit NewRequest(msg.sender, request);
}
function _isValid(address lendingToken, uint256 principal, uint256 interest, uint256 duration) private view
{
require(_hasValidTerms(lendingToken, principal, interest, duration), "Bad terms");
}
function _hasValidTerms(address lendingToken, uint256 principal, uint256 interest, uint256 duration) private view returns (bool)
{
uint256 principalInUSD = IOracle(VersionManager._oracle()).convertToUSD(lendingToken, principal);
return principalInUSD >= (1000 * _DECIMALS) && principalInUSD <= (50000 * _DECIMALS) && interest >= _MIN_INTEREST && interest <= _MAX_INTEREST && duration >= _MIN_DURATION && duration <= _MAX_DURATION;
}
}
文件 19 的 35：Offer.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {ICollateralManager} from "./managers/CollateralManager.sol";
import {IFeeBurnManager} from "./managers/FeeBurnManager.sol";
import {ILoan} from "./Loan.sol";
import {Escrow} from "./Escrow.sol";
interface IOffer
{
function __Offer_init(address lender, address lendingToken, uint256 principal, uint256 interest, uint256 duration, uint256 feeOnInterest) external;
function claim(address collateralToken, uint256 collateral) external returns (address loan);
function cancel() external;
}
contract Offer is IOffer, Escrow
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _feeOnInterest;
function __Offer_init(address lender, address lendingToken, uint256 principal, uint256 interest, uint256 duration, uint256 feeOnInterest) external override initializer
{
Escrow._initialize();
_loanDetails.lender = lender;
_loanDetails.duration = duration;
_loanDetails.lendingToken = lendingToken;
_loanDetails.principal = principal;
_loanDetails.interest = interest;
_feeOnInterest = feeOnInterest;
}
function claim(address collateralToken, uint256 collateral) external override nonReentrant returns (address loan)
{
require(msg.sender != _loanDetails.lender, "Own Offer");
require(ICollateralManager(_collateralMgr()).isSufficientInitialCollateral(_loanDetails.lendingToken, _loanDetails.principal, collateralToken, collateral), "Inadequate collateral");
uint256 feeOnPrincipal = IFeeBurnManager(_feeBurnMgr()).getFeeOnPrincipal(msg.sender, _loanDetails.lendingToken, _loanDetails.principal, collateralToken);
IERC20(collateralToken).safeTransferFrom(msg.sender, address(this), collateral.add(feeOnPrincipal));
_loanDetails.borrower = msg.sender;
_loanDetails.collateralToken = collateralToken;
_loanDetails.collateral = collateral;
return Escrow._accept(_feeOnInterest, feeOnPrincipal, true);
}
function cancel() external override nonReentrant
{
Escrow._isPending();
require(msg.sender == _loanDetails.lender, "!lender");
_status = Status.Canceled;
IERC20(_loanDetails.lendingToken).safeTransfer(msg.sender, _getPrincipalBalance());
emit Cancel(msg.sender);
}
}
文件 20 的 35：Oracle.sol
pragma solidity 0.7.6;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "./roles/Ownable.sol";
interface IFeed
{
function latestAnswer() external view returns (int256);
}
interface IOracle
{
function getRate(address from, address to) external view returns (uint256);
function convertFromUSD(address to, uint256 amount) external view returns (uint256);
function convertToUSD(address from, uint256 amount) external view returns (uint256);
function convert(address from, address to, uint256 amount) external view returns (uint256);
}
contract Oracle is IOracle, Ownable
{
using SafeMath for uint256;
address private constant _DAI = address(0x6B175474E89094C44Da98b954EedeAC495271d0F);
address private constant _WETH = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
uint256 private constant _DECIMALS = 1e18;
mapping(address => address) private _ETHFeeds;
mapping(address => address) private _USDFeeds;
constructor()
{
_ETHFeeds[_DAI] = address(0x773616E4d11A78F511299002da57A0a94577F1f4);
_ETHFeeds[0x111111111117dC0aa78b770fA6A738034120C302] = address(0x72AFAECF99C9d9C8215fF44C77B94B99C28741e8);
_ETHFeeds[0xD46bA6D942050d489DBd938a2C909A5d5039A161] = address(0x492575FDD11a0fCf2C6C719867890a7648d526eB);
_ETHFeeds[0x1F573D6Fb3F13d689FF844B4cE37794d79a7FF1C] = address(0xCf61d1841B178fe82C8895fe60c2EDDa08314416);
_ETHFeeds[0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9] = address(0x6Df09E975c830ECae5bd4eD9d90f3A95a4f88012);
_ETHFeeds[0xa117000000f279D81A1D3cc75430fAA017FA5A2e] = address(0x8f83670260F8f7708143b836a2a6F11eF0aBac01);
_ETHFeeds[0xba100000625a3754423978a60c9317c58a424e3D] = address(0xC1438AA3823A6Ba0C159CfA8D98dF5A994bA120b);
_ETHFeeds[0xBA11D00c5f74255f56a5E366F4F77f5A186d7f55] = address(0x0BDb051e10c9718d1C29efbad442E88D38958274);
_ETHFeeds[0x0D8775F648430679A709E98d2b0Cb6250d2887EF] = address(0x0d16d4528239e9ee52fa531af613AcdB23D88c94);
_ETHFeeds[0xc00e94Cb662C3520282E6f5717214004A7f26888] = address(0x1B39Ee86Ec5979ba5C322b826B3ECb8C79991699);
_ETHFeeds[0x2ba592F78dB6436527729929AAf6c908497cB200] = address(0x82597CFE6af8baad7c0d441AA82cbC3b51759607);
_ETHFeeds[0xA0b73E1Ff0B80914AB6fe0444E65848C4C34450b] = address(0xcA696a9Eb93b81ADFE6435759A29aB4cf2991A96);
_ETHFeeds[0xD533a949740bb3306d119CC777fa900bA034cd52] = address(0x8a12Be339B0cD1829b91Adc01977caa5E9ac121e);
_ETHFeeds[0xF629cBd94d3791C9250152BD8dfBDF380E2a3B9c] = address(0x24D9aB51950F3d62E9144fdC2f3135DAA6Ce8D1B);
_ETHFeeds[0xc944E90C64B2c07662A292be6244BDf05Cda44a7] = address(0x17D054eCac33D91F7340645341eFB5DE9009F1C1);
_ETHFeeds[0xdd974D5C2e2928deA5F71b9825b8b646686BD200] = address(0x656c0544eF4C98A6a98491833A89204Abb045d6b);
_ETHFeeds[0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44] = address(0xe7015CCb7E5F788B8c1010FC22343473EaaC3741);
_ETHFeeds[0x514910771AF9Ca656af840dff83E8264EcF986CA] = address(0xDC530D9457755926550b59e8ECcdaE7624181557);
_ETHFeeds[0xBBbbCA6A901c926F240b89EacB641d8Aec7AEafD] = address(0x160AC928A16C93eD4895C2De6f81ECcE9a7eB7b4);
_ETHFeeds[0x0F5D2fB29fb7d3CFeE444a200298f468908cC942] = address(0x82A44D92D6c329826dc557c5E1Be6ebeC5D5FeB9);
_ETHFeeds[0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2] = address(0x24551a8Fb2A7211A25a17B1481f043A8a8adC7f2);
_ETHFeeds[0x408e41876cCCDC0F92210600ef50372656052a38] = address(0x3147D7203354Dc06D9fd350c7a2437bcA92387a4);
_ETHFeeds[0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F] = address(0x79291A9d692Df95334B1a0B3B4AE6bC606782f8c);
_ETHFeeds[0x57Ab1ec28D129707052df4dF418D58a2D46d5f51] = address(0x8e0b7e6062272B5eF4524250bFFF8e5Bd3497757);
_ETHFeeds[0x6B3595068778DD592e39A122f4f5a5cF09C90fE2] = address(0xe572CeF69f43c2E488b33924AF04BDacE19079cf);
_ETHFeeds[0x0000000000085d4780B73119b644AE5ecd22b376] = address(0x3886BA987236181D98F2401c507Fb8BeA7871dF2);
_ETHFeeds[0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984] = address(0xD6aA3D25116d8dA79Ea0246c4826EB951872e02e);
_ETHFeeds[0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48] = address(0x986b5E1e1755e3C2440e960477f25201B0a8bbD4);
_ETHFeeds[0xdAC17F958D2ee523a2206206994597C13D831ec7] = address(0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46);
_ETHFeeds[0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599] = address(0xdeb288F737066589598e9214E782fa5A8eD689e8);
_ETHFeeds[0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e] = address(0x7c5d4F8345e66f68099581Db340cd65B078C41f4);
_ETHFeeds[0xE41d2489571d322189246DaFA5ebDe1F4699F498] = address(0x2Da4983a622a8498bb1a21FaE9D8F6C664939962);
_USDFeeds[_WETH] = address(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
}
function getFeeds(address token) external view returns (address, address)
{
return (_ETHFeeds[token], _USDFeeds[token]);
}
function setFeeds(address[] calldata tokens, address[] calldata feeds, bool is_USDFeeds) external onlyOwner
{
require(tokens.length == feeds.length, "!=");
if (is_USDFeeds)
{
for (uint256 i = 0; i < tokens.length; i++)
{
address token = tokens[i];
_USDFeeds[token] = feeds[i];
}
}
else
{
for (uint256 i = 0; i < tokens.length; i++)
{
address token = tokens[i];
_ETHFeeds[token] = feeds[i];
}
}
}
function uintify(int256 val) private pure returns (uint256)
{
require(val > 0, "Feed err");
return uint256(val);
}
function getTokenETHRate(address token) private view returns (uint256)
{
if (_ETHFeeds[token] != address(0))
{
return uintify(IFeed(_ETHFeeds[token]).latestAnswer());
}
else if (_USDFeeds[token] != address(0))
{
return uintify(IFeed(_USDFeeds[token]).latestAnswer()).mul(_DECIMALS).div(uintify(IFeed(_USDFeeds[_WETH]).latestAnswer()));
}
else
{
return 0;
}
}
function getRate(address from, address to) public view override returns (uint256)
{
if (from == to && to == _DAI)
{
return _DECIMALS;
}
uint256 srcRate = from == _WETH ? _DECIMALS : getTokenETHRate(from);
uint256 destRate = to == _WETH ? _DECIMALS : getTokenETHRate(to);
require(srcRate > 0 && destRate > 0 && srcRate < type(uint256).max && destRate < type(uint256).max, "No oracle");
return srcRate.mul(_DECIMALS).div(destRate);
}
function calcDestQty(uint256 srcQty, address from, address to, uint256 rate) private view returns (uint256)
{
uint256 srcDecimals = ERC20(from).decimals();
uint256 destDecimals = ERC20(to).decimals();
uint256 difference;
if (destDecimals >= srcDecimals)
{
difference = 10 ** destDecimals.sub(srcDecimals);
return srcQty.mul(rate).mul(difference).div(_DECIMALS);
}
else
{
difference = 10 ** srcDecimals.sub(destDecimals);
return srcQty.mul(rate).div(_DECIMALS.mul(difference));
}
}
function convertFromUSD(address to, uint256 amount) external view override returns (uint256)
{
return calcDestQty(amount, _DAI, to, getRate(_DAI, to));
}
function convertToUSD(address from, uint256 amount) external view override returns (uint256)
{
return calcDestQty(amount, from, _DAI, getRate(from, _DAI));
}
function convert(address from, address to, uint256 amount) external view override returns (uint256)
{
return calcDestQty(amount, from, to, getRate(from, to));
}
}
文件 21 的 35：Ownable.sol
pragma solidity ^0.7.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
文件 22 的 35：Pausable.sol
pragma solidity 0.7.6;
import {PauserRole} from "./PauserRole.sol";
contract Pausable is PauserRole
{
bool private _paused;
event Paused(address account);
event Unpaused(address account);
constructor()
{
_paused = false;
}
function _isPaused() internal view
{
require(_paused, "!paused");
}
function _isNotPaused() internal view
{
require(!_paused, "Paused");
}
function paused() public view returns (bool)
{
return _paused;
}
function pause() public onlyPauser
{
_isNotPaused();
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser
{
_isPaused();
_paused = false;
emit Unpaused(msg.sender);
}
}
文件 23 的 35：PauserRole.sol
pragma solidity 0.7.6;
import {Roles} from "./Roles.sol";
contract PauserRole
{
using Roles for Roles.Role;
Roles.Role private _pausers;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
modifier onlyPauser()
{
require(isPauser(msg.sender), "!pauser");
_;
}
constructor()
{
_pausers.add(msg.sender);
emit PauserAdded(msg.sender);
}
function isPauser(address account) public view returns (bool)
{
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser
{
_pausers.add(account);
emit PauserAdded(account);
}
function renouncePauser() public
{
_pausers.remove(msg.sender);
emit PauserRemoved(msg.sender);
}
}
文件 24 的 35：ProxyFactory.sol
pragma solidity 0.7.6;
import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
library ProxyFactory
{
event ProxyCreated(address proxy);
function _deployMinimal(address logic, bytes memory data) internal returns (address proxy)
{
proxy = Clones.clone(logic);
if (data.length > 0)
{
(bool success,) = proxy.call(data);
require(success, "ProxyFactory: init err");
}
emit ProxyCreated(proxy);
return proxy;
}
}
文件 25 的 35：ReentrancyGuard.sol
pragma solidity ^0.7.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
文件 26 的 35：ReentrancyGuardUpgradeable.sol
pragma solidity ^0.7.0;
import "../proxy/Initializable.sol";
abstract contract ReentrancyGuardUpgradeable is Initializable {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal initializer {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal initializer {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
uint256[49] private __gap;
}
文件 27 的 35：Request.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {ICollateralManager} from "./managers/CollateralManager.sol";
import {IFeeBurnManager} from "./managers/FeeBurnManager.sol";
import {ILoan} from "./Loan.sol";
import {Escrow} from "./Escrow.sol";
interface IRequest
{
function __Request_init(address borrower, address lendingToken, uint256 principal, uint256 interest, uint256 duration, address collateralToken, uint256 collateral, uint256 feeOnPrincipal) external;
function fund() external returns (address loan);
function cancel() external;
}
contract Request is IRequest, Escrow
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _feeOnPrincipal;
function __Request_init(address borrower, address lendingToken, uint256 principal, uint256 interest, uint256 duration, address collateralToken, uint256 collateral, uint256 feeOnPrincipal) external override initializer
{
Escrow._initialize();
require(ICollateralManager(_collateralMgr()).isSufficientInitialCollateral(lendingToken, principal, collateralToken, collateral), "Inadequate collateral");
_loanDetails.borrower = borrower;
_loanDetails.duration = duration;
_loanDetails.lendingToken = lendingToken;
_loanDetails.principal = principal;
_loanDetails.interest = interest;
_loanDetails.collateralToken = collateralToken;
_loanDetails.collateral = collateral;
_feeOnPrincipal = feeOnPrincipal;
}
function fund() external override nonReentrant returns (address loan)
{
require(msg.sender != _loanDetails.borrower, "Own Request");
_loanDetails.lender = msg.sender;
uint256 feeOnInterest = IFeeBurnManager(_feeBurnMgr()).getFeeOnInterest(msg.sender, _loanDetails.lendingToken, _loanDetails.principal, _loanDetails.interest);
IERC20(_loanDetails.lendingToken).safeTransferFrom(msg.sender, address(this), _loanDetails.principal.add(feeOnInterest));
return Escrow._accept(feeOnInterest, _feeOnPrincipal, false);
}
function cancel() external override nonReentrant
{
Escrow._isPending();
require(msg.sender == _loanDetails.borrower, "!borrower");
_status = Status.Canceled;
IERC20(_loanDetails.collateralToken).safeTransfer(msg.sender, _getCollateralBalance());
emit Cancel(msg.sender);
}
}
文件 28 的 35：RewardManager.sol
pragma solidity 0.7.6;
pragma abicoder v2;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {RewarderRole} from "../roles/RewarderRole.sol";
import {ILoan} from "../Loan.sol";
import {IOracle} from "../Oracle.sol";
import {IYLD} from "../interfaces/IYLD.sol";
import {IDiscountManager} from "./DiscountManager.sol";
import {VersionManager} from "../registries/VersionManager.sol";
interface IRewardManager
{
event Claim(address indexed borrower, address indexed loan, uint256 amount);
function trackLoan(address loan, address borrower, address lendingToken, uint256 principal, uint256 interest, uint256 duration) external returns (bool);
}
contract RewardManager is IRewardManager, RewarderRole, ReentrancyGuard, VersionManager
{
using SafeMath for uint256;
address private immutable _YLD;
uint256 private constant _basePrice = 1e18;
uint256 private constant _baseRewardCap = 350 * 1e18;
uint256 private _lastPrice = 100 * 1e18;
uint256 private _rewardCostPct = 1 * 1e18;
uint256 private _shortDurationPct = 100 * 1e18;
uint256 private _rebasingFactor;
uint256 private _currentRewardCap;
mapping(address => bool) private _claimed;
mapping(address => bool) private _trackedLoan;
mapping(address => uint256) private _fullRewardOf;
constructor()
{
_YLD = address(0xDcB01cc464238396E213a6fDd933E36796eAfF9f);
_rebasingFactor = _basePrice.mul(100 * 1e18).div(_lastPrice);
_currentRewardCap = _calcPercentOf(_baseRewardCap, _rebasingFactor);
}
function _calcPercentOf(uint256 amount, uint256 percent) private pure returns (uint256)
{
return amount.mul(percent).div(100 * 1e18);
}
function getRewardOf(address loan) external view returns (uint256)
{
return _fullRewardOf[loan];
}
function getDetails() external view returns (uint256, uint256, uint256, uint256, uint256)
{
return (_rewardCostPct, _shortDurationPct, _rebasingFactor, _lastPrice, _currentRewardCap);
}
function hasClaimed(address loan) public view returns (bool)
{
return _claimed[loan];
}
function calcUnlockDuration(uint256 duration, uint256 timestampStart, uint256 timestampRepaid) public pure returns (uint256 unlockDuration)
{
if (duration <= 12 days)
{
unlockDuration = timestampRepaid.add(2 days) >= timestampStart.add(duration) ? 10 days : 90 days;
}
else
{
unlockDuration = (timestampRepaid > timestampStart.add(12 days) && timestampRepaid >= timestampStart.add(10 days).add(_calcPercentOf(duration, 2500))) ? 10 days : 90 days;
}
}
function _getMintableReward(address loan, uint256 timestampRepaid, uint256 timestampFullUnlock) private view returns (uint256)
{
uint256 fullReward = _fullRewardOf[loan];
uint256 mintRate = fullReward.div(timestampFullUnlock.sub(timestampRepaid));
uint256 secondsSinceRepaid = block.timestamp.sub(timestampRepaid);
uint256 mintableReward = block.timestamp >= timestampFullUnlock ? fullReward : secondsSinceRepaid.mul(mintRate);
return mintableReward > _currentRewardCap ? _currentRewardCap : mintableReward;
}
function _isEligibleLoan(address loan, ILoan.Status loanStatus) private view returns (bool)
{
return _trackedLoan[loan] && loanStatus == ILoan.Status.Repaid;
}
function claimReward(address loan) external nonReentrant
{
ILoan.LoanMetadata memory loanMetadata = ILoan(loan).getLoanMetadata();
ILoan.LoanDetails memory loanDetails = ILoan(loan).getLoanDetails();
require(msg.sender == loanDetails.borrower, "Go borrow");
require(!hasClaimed(loan), "Claimed");
require(_isEligibleLoan(loan, loanMetadata.status), "!eligible");
uint256 unlockDuration = calcUnlockDuration(loanDetails.duration, loanMetadata.timestampStart, loanMetadata.timestampRepaid);
uint256 reward = _getMintableReward(loan, loanMetadata.timestampRepaid, loanMetadata.timestampRepaid.add(unlockDuration));
require(IYLD(_YLD).mint(msg.sender, reward));
_claimed[loan] = true;
emit Claim(msg.sender, loan, reward);
}
function _calcFullReward(address borrower, address lendingToken, uint256 principal, uint256 interest, uint256 duration) private view returns (uint256)
{
uint256 maxReward = _currentRewardCap;
uint256 interestPct = interest.mul(1e18).div(100);
uint256 multiplier = interestPct.sub(_rewardCostPct);
uint256 principalInUSD = IOracle(VersionManager._oracle()).convertToUSD(lendingToken, principal);
if (IDiscountManager(VersionManager._discountMgr()).isDiscounted(borrower))
{
multiplier = multiplier.add(0.25 * 1e18);
}
multiplier = _calcPercentOf(multiplier, _rebasingFactor);
if (duration <= 12 days)
{
maxReward = _calcPercentOf(maxReward, _shortDurationPct);
}
uint256 reward = _calcPercentOf(principalInUSD, multiplier);
return reward > maxReward ? maxReward : reward;
}
function trackLoan(address loan, address borrower, address lendingToken, uint256 principal, uint256 interest, uint256 duration) external override onlyRewarder returns (bool)
{
require(!_trackedLoan[loan], "Tracked");
_fullRewardOf[loan] = _calcFullReward(borrower, lendingToken, principal, interest, duration);
require(_fullRewardOf[loan] > 0 && _fullRewardOf[loan] < type(uint256).max, "Err setting reward");
_trackedLoan[loan] = true;
return true;
}
function setRewardCostPct(uint256 newPct) external onlyRewarder
{
require(newPct > 0 && newPct < type(uint256).max, "Invalid x%");
_rewardCostPct = newPct;
}
function setShortDurationPct(uint256 newPct) external onlyRewarder
{
require(newPct > 0 && newPct < type(uint256).max, "Invalid x%");
_shortDurationPct = newPct;
}
function setLastPrice(uint256 lastPrice) external onlyRewarder
{
require(lastPrice > 0 && lastPrice < type(uint256).max, "Invalid $x");
_lastPrice = lastPrice;
_rebasingFactor = _basePrice.mul(100 * 1e18).div(lastPrice);
_currentRewardCap = _calcPercentOf(_baseRewardCap, _rebasingFactor);
}
function renounceMinter() external onlyRewarder
{
IYLD(_YLD).renounceMinter();
}
}
文件 29 的 35：RewarderRole.sol
pragma solidity 0.7.6;
import {Roles} from "./Roles.sol";
contract RewarderRole
{
using Roles for Roles.Role;
Roles.Role private _rewarders;
event RewarderAdded(address indexed account);
event RewarderRemoved(address indexed account);
modifier onlyRewarder()
{
require(isRewarder(msg.sender), "!rewarder");
_;
}
constructor()
{
_rewarders.add(msg.sender);
emit RewarderAdded(msg.sender);
}
function isRewarder(address account) public view returns (bool)
{
return _rewarders.has(account);
}
function addRewarder(address account) public onlyRewarder
{
_rewarders.add(account);
emit RewarderAdded(account);
}
function renounceRewarder() public
{
_rewarders.remove(msg.sender);
emit RewarderRemoved(msg.sender);
}
}
文件 30 的 35：Roles.sol
pragma solidity 0.7.6;
library Roles
{
struct Role
{
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal
{
require(!has(role, account), "has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal
{
require(has(role, account), "!has role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool)
{
require(account != address(0), "Roles: 0 addy");
return role.bearer[account];
}
}
文件 31 的 35：SafeERC20.sol
pragma solidity ^0.7.0;
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
文件 32 的 35：SafeMath.sol
pragma solidity ^0.7.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
文件 33 的 35：TokenManager.sol
pragma solidity 0.7.6;
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {Ownable} from "../roles/Ownable.sol";
interface ITokenManager
{
function isWhitelisted(address token) external view returns (bool);
function isStableToken(address token) external view returns (bool);
function isDynamicToken(address token) external view returns (bool);
function isBothStable(address tokenA, address tokenB) external view returns (bool);
function isBothWhitelisted(address tokenA, address tokenB) external view returns (bool);
}
contract TokenManager is ITokenManager, Ownable
{
using SafeMath for uint256;
address[] private _stableTokens;
address[] private _dynamicTokens;
address[] private _whitelistedTokens;
uint256 private _tokenID;
uint256 private _stableTokenID;
uint256 private _dynamicTokenID;
mapping(address => uint256) private _tokenIDOf;
mapping(address => bool) private _whitelistedToken;
mapping(address => bool) private _stableToken;
mapping(address => uint256) private _stableTokenIDOf;
mapping(address => bool) private _dynamicToken;
mapping(address => uint256) private _dynamicTokenIDOf;
constructor ()
{
_handleAddition(0x6B175474E89094C44Da98b954EedeAC495271d0F, false);
_handleAddition(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, false);
_handleAddition(0x111111111117dC0aa78b770fA6A738034120C302, false);
_handleAddition(0xD46bA6D942050d489DBd938a2C909A5d5039A161, false);
_handleAddition(0x1F573D6Fb3F13d689FF844B4cE37794d79a7FF1C, false);
_handleAddition(0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9, false);
_handleAddition(0xa117000000f279D81A1D3cc75430fAA017FA5A2e, false);
_handleAddition(0xba100000625a3754423978a60c9317c58a424e3D, false);
_handleAddition(0xBA11D00c5f74255f56a5E366F4F77f5A186d7f55, false);
_handleAddition(0x0D8775F648430679A709E98d2b0Cb6250d2887EF, false);
_handleAddition(0xc00e94Cb662C3520282E6f5717214004A7f26888, false);
_handleAddition(0x2ba592F78dB6436527729929AAf6c908497cB200, false);
_handleAddition(0xA0b73E1Ff0B80914AB6fe0444E65848C4C34450b, false);
_handleAddition(0xD533a949740bb3306d119CC777fa900bA034cd52, false);
_handleAddition(0xF629cBd94d3791C9250152BD8dfBDF380E2a3B9c, false);
_handleAddition(0xc944E90C64B2c07662A292be6244BDf05Cda44a7, false);
_handleAddition(0xdd974D5C2e2928deA5F71b9825b8b646686BD200, false);
_handleAddition(0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44, false);
_handleAddition(0x514910771AF9Ca656af840dff83E8264EcF986CA, false);
_handleAddition(0xBBbbCA6A901c926F240b89EacB641d8Aec7AEafD, false);
_handleAddition(0x0F5D2fB29fb7d3CFeE444a200298f468908cC942, false);
_handleAddition(0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2, false);
_handleAddition(0x408e41876cCCDC0F92210600ef50372656052a38, false);
_handleAddition(0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F, false);
_handleAddition(0x57Ab1ec28D129707052df4dF418D58a2D46d5f51, false);
_handleAddition(0x57Ab1ec28D129707052df4dF418D58a2D46d5f51, true);
_handleAddition(0x6B3595068778DD592e39A122f4f5a5cF09C90fE2, false);
_handleAddition(0x0000000000085d4780B73119b644AE5ecd22b376, false);
_handleAddition(0x0000000000085d4780B73119b644AE5ecd22b376, true);
_handleAddition(0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984, false);
_handleAddition(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, false);
_handleAddition(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, true);
_handleAddition(0xdAC17F958D2ee523a2206206994597C13D831ec7, false);
_handleAddition(0xdAC17F958D2ee523a2206206994597C13D831ec7, true);
_handleAddition(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599, false);
_handleAddition(0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e, false);
_handleAddition(0xE41d2489571d322189246DaFA5ebDe1F4699F498, false);
}
function isWhitelisted(address token) public view override returns (bool)
{
return token != address(0) && _whitelistedToken[token];
}
function isStableToken(address token) public view override returns (bool)
{
return token != address(0) && _stableToken[token];
}
function isDynamicToken(address token) public view override returns (bool)
{
return token != address(0) && _dynamicToken[token];
}
function isBothStable(address tokenA, address tokenB) external view override returns (bool)
{
return _stableToken[tokenA] && _stableToken[tokenB];
}
function isBothWhitelisted(address tokenA, address tokenB) external view override returns (bool)
{
return _whitelistedToken[tokenA] && _whitelistedToken[tokenB];
}
function getDynamicTokens() external view returns (address[] memory)
{
return _dynamicTokens;
}
function getStableTokens() external view returns (address[] memory)
{
return _stableTokens;
}
function getWhitelistedTokens() external view returns (address[] memory)
{
return _whitelistedTokens;
}
function whitelistToken(address token) external onlyOwner
{
require(!isWhitelisted(token), "Whitelisted");
_handleAddition(token, false);
}
function whitelistTokens(address[] calldata tokens) external onlyOwner
{
for (uint256 i = 0; i < tokens.length; i++)
{
if (!isWhitelisted(tokens[i]))
{
_handleAddition(tokens[i], false);
}
}
}
function unwhitelistToken(address token) external onlyOwner
{
require(isWhitelisted(token), "!whitelisted");
_handleRemoval(token, false);
if (isStableToken(token))
{
_handleRemoval(token, true);
}
if (isDynamicToken(token))
{
_handleDynamicRemoval(token);
}
}
function setAsStableToken(address token) external onlyOwner
{
require(!isStableToken(token), "Set");
require(isWhitelisted(token), "!whitelisted");
_handleAddition(token, true);
}
function unsetAsStableToken(address token) external onlyOwner
{
require(isStableToken(token), "!stabletoken");
_handleRemoval(token, true);
}
function setAsDynamicToken(address token) external onlyOwner
{
require(!isDynamicToken(token), "Set");
require(isWhitelisted(token), "!whitelisted");
_dynamicTokenID = _dynamicTokenID.add(1);
_dynamicTokenIDOf[token] = _dynamicTokenID;
_dynamicToken[token] = true;
_dynamicTokens.push(token);
}
function unsetAsDynamicToken(address token) external onlyOwner
{
require(isDynamicToken(token), "!dynamic");
_handleDynamicRemoval(token);
}
function _handleAddition(address token, bool forStableToken) private
{
if (!forStableToken)
{
_tokenID = _tokenID.add(1);
_tokenIDOf[token] = _tokenID;
_whitelistedToken[token] = true;
_whitelistedTokens.push(token);
}
else
{
_stableTokenID = _stableTokenID.add(1);
_stableTokenIDOf[token] = _stableTokenID;
_stableToken[token] = true;
_stableTokens.push(token);
}
}
function _handleRemoval(address token, bool forStableToken) private
{
if (!forStableToken)
{
uint256 tokenIndex = _tokenIDOf[token].sub(1);
_tokenIDOf[token] = 0;
_whitelistedToken[token] = false;
delete _whitelistedTokens[tokenIndex];
}
else
{
uint256 stableTokenIndex = _stableTokenIDOf[token].sub(1);
_stableTokenIDOf[token] = 0;
_stableToken[token] = false;
delete _stableTokens[stableTokenIndex];
}
}
function _handleDynamicRemoval(address token) private
{
uint256 dynamicTokenIndex = _dynamicTokenIDOf[token].sub(1);
_dynamicTokenIDOf[token] = 0;
_dynamicToken[token] = false;
delete _dynamicTokens[dynamicTokenIndex];
}
}
文件 34 的 35：VersionBeacon.sol
pragma solidity 0.7.6;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/EnumerableSet.sol";
interface IVersionBeacon
{
event Registered(bytes32 entity, uint256 version, address implementation);
function exists(bytes32 entity) external view returns (bool status);
function getLatestVersion(bytes32 entity) external view returns (uint256 version);
function getLatestImplementation(bytes32 entity) external view returns (address implementation);
function getImplementationAt(bytes32 entity, uint256 version) external view returns (address implementation);
function register(bytes32 entity, address implementation) external returns (uint256 version);
}
contract VersionBeacon is IVersionBeacon, Ownable
{
using EnumerableSet for EnumerableSet.Bytes32Set;
EnumerableSet.Bytes32Set private _entitySet;
mapping(bytes32 => address[]) private _versions;
function getKey (string calldata name) external pure returns (bytes32)
{
return keccak256(bytes(name));
}
function exists(bytes32 entity) public view override returns (bool status)
{
return _entitySet.contains(entity);
}
function getImplementationAt(bytes32 entity, uint256 version) public view override returns (address implementation)
{
require(exists(entity) && version < _versions[entity].length, "no ver reg'd");
return _versions[entity][version];
}
function getLatestVersion(bytes32 entity) public view override returns (uint256 version)
{
require(exists(entity), "no ver reg'd");
return _versions[entity].length - 1;
}
function getLatestImplementation(bytes32 entity) public view override returns (address implementation)
{
uint256 latestVersion = getLatestVersion(entity);
return getImplementationAt(entity, latestVersion);
}
function register(bytes32 entity, address implementation) external override onlyOwner returns (uint256 version)
{
version = _versions[entity].length;
_entitySet.add(entity);
_versions[entity].push(implementation);
emit Registered(entity, version, implementation);
return version;
}
}
文件 35 的 35：VersionManager.sol
pragma solidity 0.7.6;
import {IVersionBeacon} from "./VersionBeacon.sol";
contract VersionManager
{
address private constant _versionBeacon = address(0xfc90c4ae4343f958215b82ff4575b714294Cdd75);
function getVersionBeacon() public pure returns (address versionBeacon)
{
return _versionBeacon;
}
function _oracle() internal view returns (address oracle)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("Oracle"));
}
function _tokenMgr() internal view returns (address tokenMgr)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("TokenManager"));
}
function _discountMgr() internal view returns (address discountMgr)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("DiscountManager"));
}
function _feeBurnMgr() internal view returns (address feeBurnMgr)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("FeeBurnManager"));
}
function _rewardMgr() internal view returns (address rewardMgr)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("RewardManager"));
}
function _collateralMgr() internal view returns (address collateralMgr)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("CollateralManager"));
}
function _loanFactory() internal view returns (address loanFactory)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("LoanFactory"));
}
function _offerImplementation() internal view returns (address offerImplementation)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("Offer"));
}
function _requestImplementation() internal view returns (address requestImplementation)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("Request"));
}
function _loanImplementation() internal view returns (address loanImplementation)
{
return IVersionBeacon(_versionBeacon).getLatestImplementation(keccak256("Loan"));
}
}
{
"compilationTarget": {
"contracts/factories/MainFactory.sol": "MainFactory"
},
"evmVersion": "istanbul",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": false,
"runs": 200
},
"remappings": []
}[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"lender","type":"address"},{"indexed":false,"internalType":"address","name":"offer","type":"address"}],"name":"NewOffer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"address","name":"request","type":"address"}],"name":"NewRequest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"PauserAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"PauserRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addPauser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lendingToken","type":"address"},{"internalType":"uint256","name":"principal","type":"uint256"},{"internalType":"uint256","name":"interest","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"createOffer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lendingToken","type":"address"},{"internalType":"uint256","name":"principal","type":"uint256"},{"internalType":"uint256","name":"interest","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"address","name":"collateralToken","type":"address"},{"internalType":"uint256","name":"collateral","type":"uint256"}],"name":"createRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOffers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getOffersOf","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRequests","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getRequestsOf","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVersionBeacon","outputs":[{"internalType":"address","name":"versionBeacon","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPauser","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renouncePauser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]
