编译器
0.8.17+commit.8df45f5f
文件 1 的 20：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 20：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 3 的 20：ContextUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
文件 4 的 20：DepositSwapArbitrum.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./interfaces/facets/IYieldYakRouter.sol";
import "./Pool.sol";
contract DepositSwapArbitrum {
using SafeERC20 for IERC20;
address private constant PARA_TRANSFER_PROXY =
0x216B4B4Ba9F3e719726886d34a177484278Bfcae;
address private constant PARA_ROUTER =
0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57;
address public constant WETH_POOL_TUP = 0x0BeBEB5679115f143772CfD97359BBcc393d46b3;
address public constant USDC_POOL_TUP = 0x8FE3842e0B7472a57f2A2D56cF6bCe08517A1De0;
address public constant ARB_POOL_TUP = 0x2B8C610F3fC6F883817637d15514293565C3d08A;
address public constant BTC_POOL_TUP = 0x5CdE36c23f0909960BA4D6E8713257C6191f8C35;
address public constant DAI_POOL_TUP = 0xd5E8f691756c3d7b86FD8A89A06497D38D362540;
address public constant WETH = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
address public constant USDC = 0xaf88d065e77c8cC2239327C5EDb3A432268e5831;
address public constant ARB = 0x912CE59144191C1204E64559FE8253a0e49E6548;
address public constant BTC = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;
address public constant DAI = 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1;
function _isTokenSupported(address token) private pure returns (bool) {
if(
token == WETH ||
token == USDC ||
token == BTC ||
token == DAI ||
token == ARB
){
return true;
}
return false;
}
function _tokenToPoolTUPMapping(address token) private pure returns (Pool){
if(token == WETH){
return Pool(WETH_POOL_TUP);
} else if (token == USDC){
return Pool(USDC_POOL_TUP);
} else if (token == ARB){
return Pool(ARB_POOL_TUP);
} else if (token == BTC){
return Pool(BTC_POOL_TUP);
} else if (token == DAI){
return Pool(DAI_POOL_TUP);
}
revert("Pool not supported");
}
function _withdrawFromPool(Pool pool, IERC20 token, uint256 amount, address user) private {
uint256 userInitialFromTokenDepositBalance = pool.balanceOf(user);
uint256 poolInitialBalance = pool.balanceOf(address(this));
require(userInitialFromTokenDepositBalance >= amount, "Insufficient fromToken deposit balance");
pool.transferFrom(user, address(this), amount);
require(pool.balanceOf(address(this)) - poolInitialBalance == amount, "amountFromToken and post-transfer contract balance mismatch");
require(pool.balanceOf(user) == userInitialFromTokenDepositBalance - amount, "user post-transfer balance is incorrect");
uint256 poolInitialTokenBalance = token.balanceOf(address(this));
pool.withdraw(amount);
require(pool.balanceOf(address(this)) == poolInitialBalance, "Post-withdrawal contract deposit balance must be 0");
require(token.balanceOf(address(this)) == poolInitialTokenBalance + amount, "Post-withdrawal contract fromToken balance is incorrect");
}
function _depositToPool(Pool pool, IERC20 token, uint256 amount, address user) private {
uint256 contractInitialToTokenBalance = token.balanceOf(address(this));
uint256 userInitialToTokenDepositBalance = pool.balanceOf(user);
uint256 poolInitialBalance = pool.balanceOf(address(this));
require(contractInitialToTokenBalance >= amount, "Insufficient contract toToken balance");
token.safeApprove(address(pool), 0);
token.safeApprove(address(pool), amount);
pool.deposit(amount);
require(token.balanceOf(address(this)) == contractInitialToTokenBalance - amount, "Post-deposit contract toToken balance must be 0");
require(pool.balanceOf(address(this)) == poolInitialBalance + amount, "Post-deposit contract deposit balance is incorrect");
pool.transfer(user, amount);
require(token.balanceOf(address(this)) == contractInitialToTokenBalance - amount, "Post-transfer contract deposit balance must be 0");
require(pool.balanceOf(user) == userInitialToTokenDepositBalance + amount, "Post-transfer user deposit balance is incorrect");
}
function _yakSwap(address[] calldata path, address[] calldata adapters, uint256 amountIn, uint256 amountOut) private {
IERC20(path[0]).safeApprove(YY_ROUTER(), 0);
IERC20(path[0]).safeApprove(YY_ROUTER(), amountIn);
IYieldYakRouter router = IYieldYakRouter(YY_ROUTER());
IYieldYakRouter.Trade memory trade = IYieldYakRouter.Trade({
amountIn: amountIn,
amountOut: amountOut,
path: path,
adapters: adapters
});
router.swapNoSplit(trade, address(this), 0);
}
function depositSwap(uint256 amountFromToken, uint256 minAmountToToken, address[] calldata path, address[] calldata adapters) public {
address fromToken = path[0];
address toToken = path[path.length - 1];
require(_isTokenSupported(fromToken), "fromToken not supported");
require(_isTokenSupported(toToken), "toToken not supported");
Pool fromPool = _tokenToPoolTUPMapping(fromToken);
Pool toPool = _tokenToPoolTUPMapping(toToken);
address user = msg.sender;
amountFromToken = Math.min(fromPool.balanceOf(user), amountFromToken);
_withdrawFromPool(fromPool, IERC20(fromToken), amountFromToken, user);
_yakSwap(path, adapters, amountFromToken, minAmountToToken);
_depositToPool(toPool, IERC20(toToken), IERC20(toToken).balanceOf(address(this)), user);
}
function depositSwapParaSwap(
bytes4 selector,
bytes memory data,
address fromToken,
uint256 fromAmount,
address toToken,
uint256 minOut
) public {
require(_isTokenSupported(fromToken), "fromToken not supported");
require(_isTokenSupported(toToken), "toToken not supported");
require(minOut > 0, "minOut needs to be > 0");
require(fromAmount > 0, "Amount of tokens to sell needs to be > 0");
Pool fromPool = _tokenToPoolTUPMapping(fromToken);
Pool toPool = _tokenToPoolTUPMapping(toToken);
address user = msg.sender;
fromAmount = Math.min(fromPool.balanceOf(user), fromAmount);
_withdrawFromPool(fromPool, IERC20(fromToken), fromAmount, user);
IERC20(fromToken).safeApprove(PARA_TRANSFER_PROXY, 0);
IERC20(fromToken).safeApprove(
PARA_TRANSFER_PROXY,
fromAmount
);
(bool success, ) = PARA_ROUTER.call((abi.encodePacked(selector, data)));
require(success, "Swap failed");
uint256 amountOut = IERC20(toToken).balanceOf(address(this));
require(amountOut >= minOut, "Too little received");
_depositToPool(toPool, IERC20(toToken), amountOut, user);
}
function YY_ROUTER() internal virtual pure returns (address) {
return 0xb32C79a25291265eF240Eb32E9faBbc6DcEE3cE3;
}
}
文件 5 的 20：IBorrowersRegistry.sol
pragma solidity 0.8.17;
interface IBorrowersRegistry {
function canBorrow(address _account) external view returns (bool);
function getLoanForOwner(address _owner) external view returns (address);
function getOwnerOfLoan(address _loan) external view returns (address);
}
文件 6 的 20：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}
文件 7 的 20：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 8 的 20：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 9 的 20：IIndex.sol
pragma solidity 0.8.17;
interface IIndex {
function setRate(uint256 _rate) external;
function updateUser(address user) external;
function getIndex() external view returns (uint256);
function getIndexedValue(uint256 value, address user) external view returns (uint256);
}
文件 10 的 20：IPoolRewarder.sol
pragma solidity ^0.8.17;
interface IPoolRewarder {
function stakeFor(uint _amount, address _stakeFor) external;
function withdrawFor(uint _amount, address _unstakeFor) external returns (uint);
function getRewardsFor(address _user) external;
function earned(address _account) external view returns (uint);
function balanceOf(address _account) external view returns (uint);
}
文件 11 的 20：IRatesCalculator.sol
pragma solidity 0.8.17;
interface IRatesCalculator {
function calculateBorrowingRate(uint256 totalLoans, uint256 totalDeposits) external view returns (uint256);
function calculateDepositRate(uint256 totalLoans, uint256 totalDeposits) external view returns (uint256);
}
文件 12 的 20：IYieldYakRouter.sol
pragma solidity ^0.8.17;
interface IYieldYakRouter {
struct Trade {
uint256 amountIn;
uint256 amountOut;
address[] path;
address[] adapters;
}
struct FormattedOffer {
uint256[] amounts;
address[] adapters;
address[] path;
}
function swapNoSplit(
Trade calldata _trade,
address _to,
uint256 _fee
) external;
}文件 13 的 20：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 14 的 20：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 15 的 20：OwnableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
文件 16 的 20：Pool.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@uniswap/lib/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./interfaces/IIndex.sol";
import "./interfaces/IRatesCalculator.sol";
import "./interfaces/IBorrowersRegistry.sol";
import "./interfaces/IPoolRewarder.sol";
import "./VestingDistributor.sol";
contract Pool is OwnableUpgradeable, ReentrancyGuardUpgradeable, IERC20 {
using TransferHelper for address payable;
uint256 public totalSupplyCap;
mapping(address => mapping(address => uint256)) private _allowed;
mapping(address => uint256) internal _deposited;
mapping(address => uint256) public borrowed;
IRatesCalculator public ratesCalculator;
IBorrowersRegistry public borrowersRegistry;
IPoolRewarder public poolRewarder;
IIndex public depositIndex;
IIndex public borrowIndex;
address payable public tokenAddress;
VestingDistributor public vestingDistributor;
uint8 internal _decimals;
function initialize(IRatesCalculator ratesCalculator_, IBorrowersRegistry borrowersRegistry_, IIndex depositIndex_, IIndex borrowIndex_, address payable tokenAddress_, IPoolRewarder poolRewarder_, uint256 _totalSupplyCap) public initializer {
require(AddressUpgradeable.isContract(address(ratesCalculator_))
&& AddressUpgradeable.isContract(address(borrowersRegistry_))
&& AddressUpgradeable.isContract(address(depositIndex_))
&& AddressUpgradeable.isContract(address(borrowIndex_))
&& (AddressUpgradeable.isContract(address(poolRewarder_)) || address(poolRewarder_) == address(0)), "Wrong init arguments");
borrowersRegistry = borrowersRegistry_;
ratesCalculator = ratesCalculator_;
depositIndex = depositIndex_;
borrowIndex = borrowIndex_;
poolRewarder = poolRewarder_;
tokenAddress = tokenAddress_;
totalSupplyCap = _totalSupplyCap;
_decimals = IERC20Metadata(tokenAddress_).decimals();
__Ownable_init();
__ReentrancyGuard_init();
_updateRates();
}
function setTotalSupplyCap(uint256 _newTotalSupplyCap) external onlyOwner {
totalSupplyCap = _newTotalSupplyCap;
}
function setPoolRewarder(IPoolRewarder _poolRewarder) external onlyOwner {
if(!AddressUpgradeable.isContract(address(_poolRewarder)) && address(_poolRewarder) != address(0)) revert NotAContract(address(poolRewarder));
poolRewarder = _poolRewarder;
emit PoolRewarderChanged(address(_poolRewarder), block.timestamp);
}
function setRatesCalculator(IRatesCalculator ratesCalculator_) external onlyOwner {
if(!AddressUpgradeable.isContract(address(ratesCalculator_)) && address(ratesCalculator_) != address(0)) revert NotAContract(address(ratesCalculator_));
ratesCalculator = ratesCalculator_;
if (address(ratesCalculator_) != address(0)) {
_updateRates();
}
emit RatesCalculatorChanged(address(ratesCalculator_), block.timestamp);
}
function setBorrowersRegistry(IBorrowersRegistry borrowersRegistry_) external onlyOwner {
if(!AddressUpgradeable.isContract(address(borrowersRegistry_))) revert NotAContract(address(borrowersRegistry_));
borrowersRegistry = borrowersRegistry_;
emit BorrowersRegistryChanged(address(borrowersRegistry_), block.timestamp);
}
function setVestingDistributor(address _distributor) external onlyOwner {
if(!AddressUpgradeable.isContract(_distributor) && _distributor != address(0)) revert NotAContract(_distributor);
vestingDistributor = VestingDistributor(_distributor);
emit VestingDistributorChanged(_distributor, block.timestamp);
}
function transfer(address recipient, uint256 amount) external override nonReentrant returns (bool) {
if(recipient == address(0)) revert TransferToZeroAddress();
if(recipient == address(this)) revert TransferToPoolAddress();
address account = msg.sender;
_accumulateDepositInterest(account);
(uint256 lockedAmount, uint256 transferrableAmount) = _getAmounts(account);
if(amount > transferrableAmount) revert TransferAmountExceedsBalance(amount, transferrableAmount);
_updateWithdrawn(account, amount, lockedAmount);
unchecked {
_deposited[account] -= amount;
}
_accumulateDepositInterest(recipient);
_deposited[recipient] += amount;
if(address(poolRewarder) != address(0) && amount != 0){
uint256 unstaked = poolRewarder.withdrawFor(amount, account);
if(unstaked > 0) {
poolRewarder.stakeFor(unstaked, recipient);
}
}
emit Transfer(account, recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowed[owner][spender];
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
if(spender == address(0)) revert SpenderZeroAddress();
uint256 newAllowance = _allowed[msg.sender][spender] + addedValue;
_allowed[msg.sender][spender] = newAllowance;
emit Approval(msg.sender, spender, newAllowance);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
if(spender == address(0)) revert SpenderZeroAddress();
uint256 currentAllowance = _allowed[msg.sender][spender];
if(currentAllowance < subtractedValue) revert InsufficientAllowance(subtractedValue, currentAllowance);
uint256 newAllowance = currentAllowance - subtractedValue;
_allowed[msg.sender][spender] = newAllowance;
emit Approval(msg.sender, spender, newAllowance);
return true;
}
function approve(address spender, uint256 amount) external override returns (bool) {
if(spender == address(0)) revert SpenderZeroAddress();
_allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override nonReentrant returns (bool) {
if(_allowed[sender][msg.sender] < amount) revert InsufficientAllowance(amount, _allowed[sender][msg.sender]);
if(recipient == address(0)) revert TransferToZeroAddress();
if(recipient == address(this)) revert TransferToPoolAddress();
_accumulateDepositInterest(sender);
(uint256 lockedAmount, uint256 transferrableAmount) = _getAmounts(sender);
if(amount > transferrableAmount) revert TransferAmountExceedsBalance(amount, transferrableAmount);
_updateWithdrawn(sender, amount, lockedAmount);
_deposited[sender] -= amount;
_allowed[sender][msg.sender] -= amount;
_accumulateDepositInterest(recipient);
_deposited[recipient] += amount;
if(address(poolRewarder) != address(0) && amount != 0){
uint256 unstaked = poolRewarder.withdrawFor(amount, sender);
if(unstaked > 0) {
poolRewarder.stakeFor(unstaked, recipient);
}
}
emit Transfer(sender, recipient, amount);
return true;
}
function deposit(uint256 _amount) public virtual {
depositOnBehalf(_amount, msg.sender);
}
function depositOnBehalf(uint256 _amount, address _of) public virtual nonReentrant {
if(_amount == 0) revert ZeroDepositAmount();
require(_of != address(0), "Address zero");
require(_of != address(this), "Cannot deposit on behalf of pool");
_amount = Math.min(_amount, IERC20(tokenAddress).balanceOf(msg.sender));
_accumulateDepositInterest(_of);
if(totalSupplyCap != 0){
if(_deposited[address(this)] + _amount > totalSupplyCap) revert TotalSupplyCapBreached();
}
_transferToPool(msg.sender, _amount);
_mint(_of, _amount);
_deposited[address(this)] += _amount;
_updateRates();
if (address(poolRewarder) != address(0)) {
poolRewarder.stakeFor(_amount, _of);
}
emit DepositOnBehalfOf(msg.sender, _of, _amount, block.timestamp);
}
function _transferToPool(address from, uint256 amount) internal virtual {
tokenAddress.safeTransferFrom(from, address(this), amount);
}
function _transferFromPool(address to, uint256 amount) internal virtual {
tokenAddress.safeTransfer(to, amount);
}
function withdraw(uint256 _amount) external nonReentrant {
_accumulateDepositInterest(msg.sender);
_amount = Math.min(_amount, _deposited[msg.sender]);
if(_amount > IERC20(tokenAddress).balanceOf(address(this))) revert InsufficientPoolFunds();
if(_amount > _deposited[address(this)]) revert BurnAmountExceedsBalance();
unchecked {
_deposited[address(this)] -= _amount;
}
_burn(msg.sender, _amount);
_updateRates();
_transferFromPool(msg.sender, _amount);
if (address(poolRewarder) != address(0)) {
poolRewarder.withdrawFor(_amount, msg.sender);
}
emit Withdrawal(msg.sender, _amount, block.timestamp);
}
function borrow(uint256 _amount) public virtual canBorrow nonReentrant {
if (_amount > IERC20(tokenAddress).balanceOf(address(this))) revert InsufficientPoolFunds();
_accumulateBorrowingInterest(msg.sender);
borrowed[msg.sender] += _amount;
borrowed[address(this)] += _amount;
_transferFromPool(msg.sender, _amount);
_updateRates();
emit Borrowing(msg.sender, _amount, block.timestamp);
}
function repay(uint256 amount) external nonReentrant {
_accumulateBorrowingInterest(msg.sender);
if(amount > borrowed[msg.sender]) revert RepayingMoreThanWasBorrowed();
_transferToPool(msg.sender, amount);
borrowed[msg.sender] -= amount;
borrowed[address(this)] -= amount;
_updateRates();
emit Repayment(msg.sender, amount, block.timestamp);
}
function getBorrowed(address _user) public view returns (uint256) {
return borrowIndex.getIndexedValue(borrowed[_user], _user);
}
function name() public virtual pure returns(string memory _name){
_name = "";
}
function symbol() public virtual pure returns(string memory _symbol){
_symbol = "";
}
function decimals() public virtual view returns(uint8){
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return balanceOf(address(this));
}
function totalBorrowed() public view returns (uint256) {
return getBorrowed(address(this));
}
function getRewards() external {
poolRewarder.getRewardsFor(msg.sender);
}
function checkRewards() external view returns (uint256) {
return poolRewarder.earned(msg.sender);
}
function getMaxPoolUtilisationForBorrowing() virtual public view returns (uint256) {
return 0.925e18;
}
function balanceOf(address user) public view override returns (uint256) {
return depositIndex.getIndexedValue(_deposited[user], user);
}
function getDepositRate() public view returns (uint256) {
return ratesCalculator.calculateDepositRate(totalBorrowed(), totalSupply());
}
function getBorrowingRate() public view returns (uint256) {
return ratesCalculator.calculateBorrowingRate(totalBorrowed(), totalSupply());
}
function getFullPoolStatus() public view returns (uint256[5] memory) {
return [
totalSupply(),
getDepositRate(),
getBorrowingRate(),
totalBorrowed(),
getMaxPoolUtilisationForBorrowing()
];
}
function recoverSurplus(uint256 amount, address account) public onlyOwner nonReentrant {
uint256 balance = IERC20(tokenAddress).balanceOf(address(this));
uint256 surplus = balance + totalBorrowed() - totalSupply();
if(amount > balance) revert InsufficientPoolFunds();
if(surplus < amount) revert InsufficientSurplus();
_transferFromPool(account, amount);
}
function _mint(address to, uint256 amount) internal {
if(to == address(0)) revert MintToAddressZero();
_deposited[to] += amount;
emit Transfer(address(0), to, amount);
}
function _burn(address account, uint256 amount) internal {
if(amount > _deposited[account]) revert BurnAmountExceedsBalance();
(uint256 lockedAmount, uint256 transferrableAmount) = _getAmounts(account);
if(amount > transferrableAmount) revert BurnAmountExceedsAvailableForUser();
_updateWithdrawn(account, amount, lockedAmount);
unchecked {
_deposited[account] -= amount;
}
emit Transfer(account, address(0), amount);
}
function _getAmounts(address account) internal view returns (uint256 lockedAmount, uint256 transferrableAmount) {
if (address(vestingDistributor) != address(0)) {
lockedAmount = vestingDistributor.locked(account);
if (lockedAmount > 0) {
transferrableAmount = _deposited[account] - (lockedAmount - vestingDistributor.availableToWithdraw(account));
} else {
transferrableAmount = _deposited[account];
}
} else {
transferrableAmount = _deposited[account];
}
}
function _updateWithdrawn(address account, uint256 amount, uint256 lockedAmount) internal {
uint256 availableUnvested = _deposited[account] - lockedAmount;
if (amount > availableUnvested && address(vestingDistributor) != address(0)) {
vestingDistributor.updateWithdrawn(account, amount - availableUnvested);
}
}
function _updateRates() internal {
uint256 _totalBorrowed = totalBorrowed();
uint256 _totalSupply = totalSupply();
if(address(ratesCalculator) == address(0)) revert PoolFrozen();
depositIndex.setRate(ratesCalculator.calculateDepositRate(_totalBorrowed, _totalSupply));
borrowIndex.setRate(ratesCalculator.calculateBorrowingRate(_totalBorrowed, _totalSupply));
}
function _accumulateDepositInterest(address user) internal {
uint256 interest = balanceOf(user) - _deposited[user];
_mint(user, interest);
_deposited[address(this)] = balanceOf(address(this));
emit InterestCollected(user, interest, block.timestamp);
depositIndex.updateUser(user);
depositIndex.updateUser(address(this));
}
function _accumulateBorrowingInterest(address user) internal {
borrowed[user] = getBorrowed(user);
borrowed[address(this)] = getBorrowed(address(this));
borrowIndex.updateUser(user);
borrowIndex.updateUser(address(this));
}
function renounceOwnership() public virtual override {}
modifier canBorrow() {
if(address(borrowersRegistry) == address(0)) revert BorrowersRegistryNotConfigured();
if(!borrowersRegistry.canBorrow(msg.sender)) revert NotAuthorizedToBorrow();
if(totalSupply() == 0) revert InsufficientPoolFunds();
_;
if((totalBorrowed() * 1e18) / totalSupply() > getMaxPoolUtilisationForBorrowing()) revert MaxPoolUtilisationBreached();
}
event Deposit(address indexed user, uint256 value, uint256 timestamp);
event DepositOnBehalfOf(address indexed user, address indexed _of, uint256 value, uint256 timestamp);
event Withdrawal(address indexed user, uint256 value, uint256 timestamp);
event Borrowing(address indexed user, uint256 value, uint256 timestamp);
event Repayment(address indexed user, uint256 value, uint256 timestamp);
event InterestCollected(address indexed user, uint256 value, uint256 timestamp);
event BorrowersRegistryChanged(address indexed registry, uint256 timestamp);
event RatesCalculatorChanged(address indexed calculator, uint256 timestamp);
event PoolRewarderChanged(address indexed poolRewarder, uint256 timestamp);
event VestingDistributorChanged(address indexed distributor, uint256 timestamp);
error NotAuthorizedToBorrow();
error BorrowersRegistryNotConfigured();
error PoolFrozen();
error InsufficientPoolFunds();
error InsufficientSurplus();
error NotAContract(address target);
error SpenderZeroAddress();
error TransferToZeroAddress();
error TransferToPoolAddress();
error TransferAmountExceedsBalance(uint256 amount, uint256 balance);
error InsufficientAllowance(uint256 requested, uint256 allowance);
error TotalSupplyCapBreached();
error ZeroDepositAmount();
error MintToAddressZero();
error BurnAmountExceedsBalance();
error BurnAmountExceedsAvailableForUser();
error RepayingMoreThanWasBorrowed();
error MaxPoolUtilisationBreached();
}文件 17 的 20：ReentrancyGuardUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/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 onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
uint256[49] private __gap;
}
文件 18 的 20：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
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 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 19 的 20：TransferHelper.sol
pragma solidity >=0.6.0;
library TransferHelper {
function safeApprove(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(
success && (data.length == 0 || abi.decode(data, (bool))),
'TransferHelper::safeApprove: approve failed'
);
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(
success && (data.length == 0 || abi.decode(data, (bool))),
'TransferHelper::safeTransfer: transfer failed'
);
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(
success && (data.length == 0 || abi.decode(data, (bool))),
'TransferHelper::transferFrom: transferFrom failed'
);
}
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
}
}
文件 20 的 20：VestingDistributor.sol
pragma solidity 0.8.17;
import "./Pool.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
contract VestingDistributor {
Pool immutable pool;
IERC20Metadata immutable poolToken;
address keeper;
address pendingKeeper;
uint256 totalLockedMultiplied;
address[] public participants;
mapping(address => uint256) public locked;
mapping(address => uint256) public withdrawn;
mapping(address => uint256) public unvestingTime;
mapping(address => uint256) public unlockTimestamp;
mapping(address => uint256) public multiplier;
mapping(uint256 => uint256) rewardAmount;
mapping(uint256 => mapping(address => bool)) rewardDistributed;
mapping(uint256 => uint256) numRewardDistributed;
uint256 lastUpdated;
uint256 updateInterval = 6 hours;
uint256 public constant ONE_DAY = 24 * 3600;
uint256 public constant MIN_VESTING_TIME = ONE_DAY;
uint256 public constant MAX_VESTING_TIME = 30 * ONE_DAY;
modifier onlyPool() {
require(msg.sender == address(pool), "Unauthorized: onlyPool");
_;
}
modifier onlyKeeper() {
require(msg.sender == keeper, "Unauthorized: onlyKeeper");
_;
}
modifier onlyPendingKeeper() {
require(msg.sender == pendingKeeper, "Unauthorized: onlyPendingKeeper");
_;
}
constructor(address poolAddress, address keeperAddress) {
pool = Pool(poolAddress);
poolToken = IERC20Metadata(pool.tokenAddress());
keeper = keeperAddress;
lastUpdated = block.timestamp;
}
function transferKeeper(address keeperAddress) external onlyKeeper {
pendingKeeper = keeperAddress;
}
function acceptKeeper() external onlyPendingKeeper {
keeper = pendingKeeper;
pendingKeeper = address(0);
}
function startVesting(uint256 amount, uint256 time) public {
if (time < MIN_VESTING_TIME || time > MAX_VESTING_TIME) revert InvalidVestingTime();
if (pool.balanceOf(msg.sender) < amount) revert InsufficientPoolBalance();
if (locked[msg.sender] > 0 || unvestingTime[msg.sender] > 0) revert AlreadyLocked();
participants.push(msg.sender);
locked[msg.sender] = amount;
unvestingTime[msg.sender] = time;
uint256 _multiplier = getMultiplier(time);
multiplier[msg.sender] = _multiplier;
totalLockedMultiplied += amount * _multiplier / 1e18;
}
function increaseVesting(uint256 amount) public {
if (locked[msg.sender] == 0 || unvestingTime[msg.sender] == 0) revert UserNotLocked();
if (pool.balanceOf(msg.sender) < locked[msg.sender] + amount) revert InsufficientPoolBalance();
if (unlockTimestamp[msg.sender] > 0) revert TooLate();
locked[msg.sender] += amount;
totalLockedMultiplied += amount * multiplier[msg.sender] / 1e18;
}
function unlock() public {
if (locked[msg.sender] == 0 || unvestingTime[msg.sender] == 0) revert UserNotLocked();
unlockTimestamp[msg.sender] = block.timestamp;
}
function availableToWithdraw(address account) public view returns (uint256) {
if (locked[account] == 0 || unvestingTime[account] == 0) revert UserNotLocked();
if (unlockTimestamp[account] == 0) revert UserLocked();
uint256 timeFromUnlock = block.timestamp - unlockTimestamp[account];
if (timeFromUnlock > unvestingTime[account]) timeFromUnlock = unvestingTime[account];
uint256 initialUnlock = ONE_DAY * locked[account] / (unvestingTime[account] + ONE_DAY);
return initialUnlock + timeFromUnlock * (locked[account] - initialUnlock) / unvestingTime[account];
}
function distributeRewards(uint256 fromIndex, uint256 toIndex) public onlyKeeper {
if (block.timestamp < lastUpdated + updateInterval) revert DistributeTooEarly();
(fromIndex, toIndex) = fromIndex < toIndex ? (fromIndex, toIndex) : (toIndex, fromIndex);
toIndex = toIndex < participants.length ? toIndex : participants.length - 1;
if (rewardAmount[lastUpdated] == 0) {
rewardAmount[lastUpdated] = pool.balanceOf(address(this));
}
uint256 rewards = rewardAmount[lastUpdated];
for (uint256 i = fromIndex; i <= toIndex; i++) {
address participant = participants[i];
if (rewardDistributed[lastUpdated][participant]) {
continue;
}
uint256 participantReward = rewards * (locked[participant] - withdrawn[participant]) * multiplier[participant] / 1e18 / totalLockedMultiplied;
pool.transfer(participant, participantReward);
rewardDistributed[lastUpdated][participant] = true;
++numRewardDistributed[lastUpdated];
if (numRewardDistributed[lastUpdated] == participants.length) {
lastUpdated = block.timestamp;
}
}
}
function updateParticipants(uint256 fromIndex, uint256 toIndex) public onlyKeeper {
(fromIndex, toIndex) = fromIndex < toIndex ? (fromIndex, toIndex) : (toIndex, fromIndex);
toIndex = toIndex < participants.length ? toIndex : participants.length - 1;
for (uint256 i = fromIndex; i <= toIndex;) {
address participant = participants[i];
if (unlockTimestamp[participant] > 0 && (block.timestamp - unlockTimestamp[participant]) > unvestingTime[participant]) {
totalLockedMultiplied -= (locked[participant] - withdrawn[participant]) * multiplier[participant] / 1e18;
unvestingTime[participant] = 0;
locked[participant] = 0;
unlockTimestamp[participant] = 0;
withdrawn[participant] = 0;
multiplier[participant] = 0;
participants[i] = participants[participants.length - 1];
participants.pop();
--toIndex;
} else {
++i;
}
}
}
function updateWithdrawn(address account, uint256 amount) public onlyPool {
withdrawn[account] += amount;
if (withdrawn[account] > locked[account]) {
revert WithdrawMoreThanLocked();
}
totalLockedMultiplied -= amount * multiplier[account] / 1e18;
}
function getMultiplier(uint256 time) public pure returns (uint256){
if (time >= 30 * ONE_DAY) return 2e18;
if (time >= 29 * ONE_DAY) return 1.99e18;
if (time >= 28 * ONE_DAY) return 1.98e18;
if (time >= 27 * ONE_DAY) return 1.97e18;
if (time >= 26 * ONE_DAY) return 1.96e18;
if (time >= 25 * ONE_DAY) return 1.948e18;
if (time >= 24 * ONE_DAY) return 1.936e18;
if (time >= 23 * ONE_DAY) return 1.924e18;
if (time >= 22 * ONE_DAY) return 1.912e18;
if (time >= 21 * ONE_DAY) return 1.9e18;
if (time >= 20 * ONE_DAY) return 1.885e18;
if (time >= 19 * ONE_DAY) return 1.871e18;
if (time >= 18 * ONE_DAY) return 1.856e18;
if (time >= 17 * ONE_DAY) return 1.841e18;
if (time >= 16 * ONE_DAY) return 1.824e18;
if (time >= 15 * ONE_DAY) return 1.806e18;
if (time >= 14 * ONE_DAY) return 1.788e18;
if (time >= 13 * ONE_DAY) return 1.768e18;
if (time >= 12 * ONE_DAY) return 1.746e18;
if (time >= 11 * ONE_DAY) return 1.723e18;
if (time >= 10 * ONE_DAY) return 1.698e18;
if (time >= 9 * ONE_DAY) return 1.67e18;
if (time >= 8 * ONE_DAY) return 1.64e18;
if (time >= 7 * ONE_DAY) return 1.605e18;
if (time >= 6 * ONE_DAY) return 1.566e18;
if (time >= 5 * ONE_DAY) return 1.521e18;
if (time >= 4 * ONE_DAY) return 1.468e18;
if (time >= 3 * ONE_DAY) return 1.4e18;
if (time >= 2 * ONE_DAY) return 1.32e18;
if (time >= 1 * ONE_DAY) return 1.2e18;
return 1e18;
}
error DistributeTooEarly();
error AlreadyLocked();
error InvalidVestingTime();
error InsufficientPoolBalance();
error UserNotLocked();
error UserLocked();
error TooLate();
error WithdrawMoreThanLocked();
}{
"compilationTarget": {
"contracts/DepositSwapArbitrum.sol": "DepositSwapArbitrum"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 10
},
"remappings": []
}[{"inputs":[],"name":"ARB","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ARB_POOL_TUP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BTC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BTC_POOL_TUP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAI","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAI_POOL_TUP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDC_POOL_TUP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH_POOL_TUP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountFromToken","type":"uint256"},{"internalType":"uint256","name":"minAmountToToken","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address[]","name":"adapters","type":"address[]"}],"name":"depositSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"address","name":"toToken","type":"address"},{"internalType":"uint256","name":"minOut","type":"uint256"}],"name":"depositSwapParaSwap","outputs":[],"stateMutability":"nonpayable","type":"function"}]
