文件 1 的 20:Address.sol
pragma solidity ^0.8.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
) internal 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 的 20:BaseStakingPool.sol
pragma solidity 0.8.9;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { FeeCollectionManager } from "./FeeCollectionManager.sol";
abstract contract BaseStakingPool is Ownable, ReentrancyGuard, Initializable
{
using Address for address payable;
using SafeERC20 for IERC20;
struct RewardInfo {
uint256 index;
uint256 rewardBalance;
uint256 rewardPerSec;
uint256 accRewardPerShare18;
}
struct UserRewardInfo {
uint256 accReward;
uint256 rewardDebt18;
}
struct UserInfo1 {
uint256 shares;
mapping(address => UserRewardInfo) userRewardInfo;
}
uint256 public constant MAX_REWARD_TOKENS = 10;
address public factory;
uint256 public totalShares;
uint256 public lastRewardTimestamp;
address[] public rewardToken;
mapping(address => RewardInfo) public rewardInfo;
mapping(address => UserInfo1) public userInfo1;
bool public rewardPerUnit;
uint256 public rewardMultiplier;
modifier collectFee(uint256 _netValue)
{
{
bytes4 _selector = bytes4(msg.data);
uint256 _fixedValueFee = FeeCollectionManager(factory).fixedValueFee(_selector);
require(msg.value == _netValue + _fixedValueFee, "invalid value");
if (_fixedValueFee > 0) {
FeeCollectionManager(factory).feeRecipient().sendValue(_fixedValueFee);
}
}
_;
}
function initialize(address _owner, address _token) public virtual;
function _initialize(address _owner) internal
{
_transferOwnership(_owner);
factory = msg.sender;
lastRewardTimestamp = block.timestamp;
rewardPerUnit = false;
rewardMultiplier = 1e18;
}
function rewardTokenCount() external view returns (uint256 _rewardTokenCount)
{
return rewardToken.length;
}
function userRewardInfo(address _account, address _rewardToken) external view returns (UserRewardInfo memory _userRewardInfo)
{
return userInfo1[_account].userRewardInfo[_rewardToken];
}
function pendingReward(address _account, address _rewardToken) external view returns (uint256 _pendingReward)
{
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
uint256 _accRewardPerShare18 = _rewardInfo.accRewardPerShare18;
if (block.timestamp > lastRewardTimestamp) {
if (totalShares > 0) {
uint256 _reward = ((block.timestamp - lastRewardTimestamp) * _rewardInfo.rewardPerSec * rewardMultiplier) / 1e18;
uint256 _maxReward = freeBalance(_rewardToken);
if (_reward > _maxReward) _reward = _maxReward;
if (_reward > 0) {
_accRewardPerShare18 += _reward * 1e18 / totalShares;
}
}
}
UserInfo1 storage _userInfo = userInfo1[_account];
UserRewardInfo storage _userRewardInfo = _userInfo.userRewardInfo[_rewardToken];
return _userRewardInfo.accReward + (_userInfo.shares * _accRewardPerShare18 - _userRewardInfo.rewardDebt18) / 1e18;
}
function harvestAll() external payable nonReentrant collectFee(0)
{
_harvestAll(msg.sender);
}
function harvest(address _rewardToken) external payable nonReentrant collectFee(0)
{
_harvest(msg.sender, _rewardToken);
}
function addRewardToken(address _rewardToken) external onlyOwner
{
_updatePool();
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
require(_rewardInfo.index == 0, "duplicate token");
uint256 _length = rewardToken.length;
require(_length < MAX_REWARD_TOKENS, "limit reached");
rewardToken.push(_rewardToken);
_rewardInfo.index = _length + 1;
emit AddRewardToken(_rewardToken);
}
function removeRewardToken(address _rewardToken) external onlyOwner
{
_updatePool();
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
uint256 _index = _rewardInfo.index;
require(_index > 0, "unknown token");
require(_rewardInfo.rewardBalance == 0, "pending reward");
_rewardInfo.index = 0;
_rewardInfo.rewardPerSec = 0;
_rewardInfo.accRewardPerShare18 = 0;
uint256 _length = rewardToken.length;
if (_index < _length) {
address _otherRewardToken = rewardToken[_length - 1];
rewardInfo[_otherRewardToken].index = _index;
rewardToken[_index - 1] = _otherRewardToken;
}
rewardToken.pop();
emit RemoveRewardToken(_rewardToken);
}
function updateRewardPerSec(address _rewardToken, uint256 _rewardPerSec) external onlyOwner
{
_updatePool();
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
require(_rewardInfo.index > 0, "unknown token");
_rewardInfo.rewardPerSec = _rewardPerSec;
emit UpdateRewardPerSec(_rewardToken, _rewardPerSec);
}
function updateRewardPerUnit(bool _rewardPerUnit) external onlyOwner
{
_updatePool();
rewardPerUnit = _rewardPerUnit;
rewardMultiplier = _rewardPerUnit ? totalShares : 1e18;
emit UpdateRewardPerUnit(_rewardPerUnit);
}
function addRewardFunds(address _rewardToken, uint256 _amount) external onlyOwner nonReentrant
{
_updatePool();
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
require(_rewardInfo.index > 0, "unknown token");
IERC20(_rewardToken).safeTransferFrom(msg.sender, address(this), _amount);
emit AddRewardFunds(_rewardToken, _amount);
}
function recoverFunds(address _token) external onlyOwner nonReentrant returns (uint256 _amount)
{
_updatePool();
_amount = freeBalance(_token);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit RecoverFunds(_token, _amount);
}
function _harvestAll(address _account) internal
{
UserInfo1 storage _userInfo = userInfo1[_account];
uint256 _shares = _userInfo.shares;
if (_shares > 0) {
_updatePool();
_updateUserReward(_userInfo, _shares, _shares);
}
_harvestAllUserReward(_account, _userInfo);
emit HarvestAll(_account);
}
function _harvest(address _account, address _rewardToken) internal
{
UserInfo1 storage _userInfo = userInfo1[_account];
uint256 _shares = _userInfo.shares;
if (_shares > 0) {
_updatePool();
_updateUserReward(_userInfo, _shares, _shares);
}
_harvestUserReward(_account, _userInfo, _rewardToken);
}
function _deposit(address _account, uint256 _shares) internal
{
if (_shares > 0) {
UserInfo1 storage _userInfo1 = userInfo1[_account];
uint256 _oldShares = _userInfo1.shares;
uint256 _newShares = _oldShares + _shares;
_updatePool();
_updateUserReward(_userInfo1, _oldShares, _newShares);
_userInfo1.shares = _newShares;
totalShares += _shares;
if (rewardPerUnit) {
rewardMultiplier = totalShares;
}
}
}
function _withdraw(address _account, uint256 _shares) internal
{
if (_shares > 0) {
UserInfo1 storage _userInfo1 = userInfo1[_account];
uint256 _oldShares = _userInfo1.shares;
uint256 _newShares = _oldShares - _shares;
_updatePool();
_updateUserReward(_userInfo1, _oldShares, _newShares);
_userInfo1.shares = _newShares;
totalShares -= _shares;
if (rewardPerUnit) {
rewardMultiplier = totalShares;
}
}
}
function _emergencyWithdraw(address _account) internal
{
UserInfo1 storage _userInfo1 = userInfo1[_account];
uint256 _shares = _userInfo1.shares;
if (_shares > 0) {
_discardUserReward(_userInfo1);
_userInfo1.shares = 0;
totalShares -= _shares;
if (rewardPerUnit) {
rewardMultiplier = totalShares;
}
}
}
function _exit(address _account) internal
{
UserInfo1 storage _userInfo1 = userInfo1[_account];
uint256 _shares = _userInfo1.shares;
if (_shares > 0) {
_updatePool();
_updateUserReward(_userInfo1, _shares, 0);
_userInfo1.shares = 0;
totalShares -= _shares;
if (rewardPerUnit) {
rewardMultiplier = totalShares;
}
}
_harvestAllUserReward(_account, _userInfo1);
}
function _adjust(address _account, uint256 _negativeShares, uint256 _positiveShares) internal
{
if (_negativeShares != _positiveShares) {
UserInfo1 storage _userInfo1 = userInfo1[_account];
uint256 _oldShares = _userInfo1.shares;
uint256 _newShares = _oldShares - _negativeShares + _positiveShares;
_updatePool();
_updateUserReward(_userInfo1, _oldShares, _newShares);
_userInfo1.shares = _newShares;
totalShares = totalShares - _negativeShares + _positiveShares;
if (rewardPerUnit) {
rewardMultiplier = totalShares;
}
}
}
function freeBalance(address _token) public view virtual returns(uint256 _balance)
{
_balance = IERC20(_token).balanceOf(address(this));
_balance -= rewardInfo[_token].rewardBalance;
return _balance;
}
function _updatePool() private
{
if (block.timestamp > lastRewardTimestamp) {
if (totalShares > 0) {
uint256 _ellapsed = block.timestamp - lastRewardTimestamp;
uint256 _length = rewardToken.length;
for (uint256 _i = 0; _i < _length; _i++) {
address _rewardToken = rewardToken[_i];
RewardInfo storage _rewardInfo = rewardInfo[_rewardToken];
uint256 _reward = (_ellapsed * _rewardInfo.rewardPerSec * rewardMultiplier) / 1e18;
uint256 _maxReward = freeBalance(_rewardToken);
if (_reward > _maxReward) _reward = _maxReward;
if (_reward > 0) {
_rewardInfo.rewardBalance += _reward;
_rewardInfo.accRewardPerShare18 += _reward * 1e18 / totalShares;
}
}
}
lastRewardTimestamp = block.timestamp;
}
}
function _discardUserReward(UserInfo1 storage _userInfo) private
{
uint256 _length = rewardToken.length;
for (uint256 _i = 0; _i < _length; _i++) {
_userInfo.userRewardInfo[rewardToken[_i]].rewardDebt18 = 0;
}
}
function _updateUserReward(UserInfo1 storage _userInfo, uint256 _oldShares, uint256 _newShares) private
{
uint256 _length = rewardToken.length;
for (uint256 _i = 0; _i < _length; _i++) {
address _rewardToken = rewardToken[_i];
uint256 _accRewardPerShare18 = rewardInfo[_rewardToken].accRewardPerShare18;
UserRewardInfo storage _userRewardInfo = _userInfo.userRewardInfo[_rewardToken];
if (_oldShares > 0) {
_userRewardInfo.accReward += (_oldShares * _accRewardPerShare18 - _userRewardInfo.rewardDebt18) / 1e18;
}
_userRewardInfo.rewardDebt18 = _newShares * _accRewardPerShare18;
}
}
function _harvestAllUserReward(address _account, UserInfo1 storage _userInfo) private
{
uint256 _length = rewardToken.length;
for (uint256 _i = 0; _i < _length; _i++) {
_harvestUserReward(_account, _userInfo, rewardToken[_i]);
}
}
function _harvestUserReward(address _account, UserInfo1 storage _userInfo, address _rewardToken) private
{
UserRewardInfo storage _userRewardInfo = _userInfo.userRewardInfo[_rewardToken];
uint256 _reward = _userRewardInfo.accReward;
if (_reward > 0) {
_userRewardInfo.accReward = 0;
IERC20(_rewardToken).safeTransfer(_account, _reward);
rewardInfo[_rewardToken].rewardBalance -= _reward;
emit Harvest(_account, _rewardToken, _reward);
}
}
event AddRewardToken(address indexed _rewardToken);
event RemoveRewardToken(address indexed _rewardToken);
event UpdateRewardPerSec(address indexed _rewardToken, uint256 _rewardPerSec);
event UpdateRewardPerUnit(bool _rewardPerUnit);
event AddRewardFunds(address indexed _rewardToken, uint256 _amount);
event RecoverFunds(address indexed _token, uint256 _amount);
event HarvestAll(address indexed _account);
event Harvest(address indexed _account, address indexed _rewardToken, uint256 _amount);
}
文件 3 的 20:BaseStakingPoolFactory.sol
pragma solidity 0.8.9;
import { BeaconProxy } from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
import { UpgradeableBeacon } from "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
import { Create2 } from "@openzeppelin/contracts/utils/Create2.sol";
import { BaseStakingPool } from "./BaseStakingPool.sol";
import { FeeCollectionManager } from "./FeeCollectionManager.sol";
abstract contract BaseStakingPoolFactory is UpgradeableBeacon, FeeCollectionManager
{
bytes32 private immutable hash_;
constructor() UpgradeableBeacon(_createPoolImpl())
{
hash_ = keccak256(abi.encodePacked(type(BeaconProxy).creationCode, abi.encode(address(this), new bytes(0))));
}
function _createPoolImpl() internal virtual returns (address _pool);
function computePoolAddress(address _account, uint96 _index) external view returns (address _pool)
{
bytes32 _salt = bytes32(uint256(_index) << 160 | uint256(uint160(_account)));
return Create2.computeAddress(_salt, hash_);
}
function createPool(uint96 _index, address _token) external returns (address _pool)
{
bytes32 _salt = bytes32(uint256(_index) << 160 | uint256(uint160(msg.sender)));
_pool = address(new BeaconProxy{salt: _salt}(address(this), new bytes(0)));
BaseStakingPool(_pool).initialize(msg.sender, _token);
emit CreatePool(msg.sender, _index, _pool, _token);
return _pool;
}
event CreatePool(address indexed _account, uint96 _index, address indexed _pool, address indexed _token);
}
文件 4 的 20:BeaconProxy.sol
pragma solidity ^0.8.0;
import "./IBeacon.sol";
import "../Proxy.sol";
import "../ERC1967/ERC1967Upgrade.sol";
contract BeaconProxy is Proxy, ERC1967Upgrade {
constructor(address beacon, bytes memory data) payable {
assert(_BEACON_SLOT == bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1));
_upgradeBeaconToAndCall(beacon, data, false);
}
function _beacon() internal view virtual returns (address) {
return _getBeacon();
}
function _implementation() internal view virtual override returns (address) {
return IBeacon(_getBeacon()).implementation();
}
function _setBeacon(address beacon, bytes memory data) internal virtual {
_upgradeBeaconToAndCall(beacon, data, false);
}
}
文件 5 的 20:Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 6 的 20:Create2.sol
pragma solidity ^0.8.0;
library Create2 {
function deploy(
uint256 amount,
bytes32 salt,
bytes memory bytecode
) internal returns (address) {
address addr;
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
return addr;
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
return computeAddress(salt, bytecodeHash, address(this));
}
function computeAddress(
bytes32 salt,
bytes32 bytecodeHash,
address deployer
) internal pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint160(uint256(_data)));
}
}
文件 7 的 20:ERC1967Upgrade.sol
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
abstract contract ERC1967Upgrade {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
address oldImplementation = _getImplementation();
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
rollbackTesting.value = true;
Address.functionDelegateCall(
newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation)
);
rollbackTesting.value = false;
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
文件 8 的 20:FeeCollectionManager.sol
pragma solidity 0.8.9;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
abstract contract FeeCollectionManager is Ownable
{
address payable public feeRecipient;
mapping(bytes4 => uint256) public fixedValueFee;
constructor()
{
}
function setFeeRecipient(address payable _feeRecipient) external onlyOwner
{
feeRecipient = _feeRecipient;
emit UpdateFeeRecipient(_feeRecipient);
}
function setFixedValueFee(bytes4[] calldata _selectors, uint256 _fixedValueFee) external onlyOwner
{
for (uint256 _i = 0; _i < _selectors.length; _i++) {
bytes4 _selector = _selectors[_i];
fixedValueFee[_selector] = _fixedValueFee;
emit UpdateFixedValueFee(_selector, _fixedValueFee);
}
}
event UpdateFeeRecipient(address _feeRecipient);
event UpdateFixedValueFee(bytes4 indexed _selector, uint256 _fixedValueFee);
}
文件 9 的 20:IBeacon.sol
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
}
文件 10 的 20:IERC20.sol
pragma solidity ^0.8.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);
}
文件 11 的 20:Initializable.sol
pragma solidity ^0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
文件 12 的 20:LockCycle.sol
pragma solidity 0.8.9;
abstract contract LockCycle
{
struct LockInfo {
uint256 day;
uint256 cycle;
uint256 factor;
}
uint256 public constant MAX_CYCLE = 365;
uint256 public constant LOCK_SCALE = 1e18;
mapping(address => LockInfo) public lockInfo;
function _adjustLock(address _account, uint256 _newCycle) internal returns (uint256 _oldFactor, uint256 _newFactor)
{
uint256 _today = block.timestamp / 1 days;
LockInfo storage _lockInfo = lockInfo[_account];
uint256 _oldCycle = _lockInfo.cycle;
if (_newCycle < _oldCycle) {
uint256 _day = _lockInfo.day;
uint256 _base1 = _day % _oldCycle;
uint256 _base2 = _today % _oldCycle;
uint256 _days = _base2 > _base1 ? _base2 - _base1 : _base2 < _base1 ? _base2 + _oldCycle - _base1 : _day < _today ? _oldCycle : 0;
uint256 _minCycle = _oldCycle - _days;
require(_newCycle >= _minCycle, "below minimum");
}
require(_newCycle <= MAX_CYCLE, "above maximum");
_oldFactor = _lockInfo.factor;
_newFactor = LOCK_SCALE * _newCycle / MAX_CYCLE;
_lockInfo.day = _today;
_lockInfo.cycle = _newCycle;
_lockInfo.factor = _newFactor;
return (_oldFactor, _newFactor);
}
function _checkLock(address _account) internal view returns (uint256 _factor)
{
uint256 _today = block.timestamp / 1 days;
LockInfo storage _lockInfo = lockInfo[_account];
uint256 _cycle = _lockInfo.cycle;
if (_cycle > 0) {
uint256 _day = _lockInfo.day;
require(_today > _day && _today % _cycle == _day % _cycle, "not available");
}
return _lockInfo.factor;
}
function _pushLock(address _account) internal returns (uint256 _factor)
{
uint256 _today = block.timestamp / 1 days;
LockInfo storage _lockInfo = lockInfo[_account];
_lockInfo.day = _today;
return _lockInfo.factor;
}
}
文件 13 的 20:NativeStakingPool.sol
pragma solidity 0.8.9;
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { LockCycle } from "./LockCycle.sol";
import { BaseStakingPool } from "./BaseStakingPool.sol";
contract NativeStakingPool is LockCycle, BaseStakingPool
{
using Address for address payable;
struct UserInfo2 {
uint256 amount;
}
uint256 public stakedBalance;
uint256 public poolMinPerUser;
uint256 public poolMaxPerUser;
mapping(address => UserInfo2) public userInfo2;
constructor(address _owner)
{
initialize(_owner, address(0));
}
function initialize(address _owner, address _stakedToken) public override initializer
{
require(_stakedToken == address(0), "invalid token");
_initialize(_owner);
poolMaxPerUser = type(uint256).max;
}
function lock(uint256 _cycle) external nonReentrant
{
(uint256 _oldFactor, uint256 _newFactor) = _adjustLock(msg.sender, _cycle);
UserInfo1 storage _userInfo1 = userInfo1[msg.sender];
uint256 _shares = _userInfo1.shares;
emit Lock(msg.sender, _cycle, _newFactor);
if (_shares > 0 && _oldFactor != _newFactor) {
_adjust(msg.sender, _shares + _shares * _oldFactor / 1e18, _shares + _shares * _newFactor / 1e18);
}
}
function deposit(uint256 _amount, bool _claimRewards) external payable nonReentrant collectFee(_amount)
{
if (_claimRewards) {
_harvestAll(msg.sender);
}
UserInfo2 storage _userInfo2 = userInfo2[msg.sender];
uint256 _oldAmount = _userInfo2.amount;
uint256 _newAmount = _oldAmount + _amount;
if (_newAmount > 0) {
require(poolMinPerUser <= _newAmount && _newAmount <= poolMaxPerUser, "invalid balance");
}
if (_amount > 0) {
_userInfo2.amount = _newAmount;
stakedBalance += _amount;
}
emit Deposit(msg.sender, _amount);
{
uint256 _factor = _pushLock(msg.sender);
uint256 _shares = _amount;
_deposit(msg.sender, _shares + _shares * _factor / 1e18);
}
}
function withdraw(uint256 _amount, bool _claimRewards) external payable nonReentrant collectFee(0)
{
if (_claimRewards) {
_harvestAll(msg.sender);
}
uint256 _factor = _checkLock(msg.sender);
UserInfo2 storage _userInfo2 = userInfo2[msg.sender];
uint256 _oldAmount = _userInfo2.amount;
require(_amount <= _oldAmount, "insufficient balance");
uint256 _newAmount = _oldAmount - _amount;
if (_newAmount > 0) {
require(poolMinPerUser <= _newAmount && _newAmount <= poolMaxPerUser, "invalid balance");
}
if (_amount > 0) {
_userInfo2.amount = _newAmount;
payable(msg.sender).sendValue(_amount);
stakedBalance -= _amount;
}
emit Withdraw(msg.sender, _amount);
{
uint256 _shares = _amount;
_withdraw(msg.sender, _shares + _shares * _factor / 1e18);
}
}
function emergencyWithdraw() external payable nonReentrant collectFee(0)
{
_checkLock(msg.sender);
UserInfo2 storage _userInfo2 = userInfo2[msg.sender];
uint256 _amount = _userInfo2.amount;
if (_amount > 0) {
_userInfo2.amount = 0;
payable(msg.sender).sendValue(_amount);
stakedBalance -= _amount;
}
emit EmergencyWithdraw(msg.sender, _amount);
_emergencyWithdraw(msg.sender);
}
function exit() external payable nonReentrant collectFee(0)
{
_checkLock(msg.sender);
UserInfo2 storage _userInfo2 = userInfo2[msg.sender];
uint256 _amount = _userInfo2.amount;
if (_amount > 0) {
_userInfo2.amount = 0;
payable(msg.sender).sendValue(_amount);
stakedBalance -= _amount;
}
emit Exit(msg.sender, _amount);
_exit(msg.sender);
}
function updatePoolLimitsPerUser(uint256 _poolMinPerUser, uint256 _poolMaxPerUser) external onlyOwner
{
require(_poolMinPerUser <= _poolMaxPerUser, "invalid limits");
if (stakedBalance > 0) {
require(_poolMinPerUser <= poolMinPerUser && poolMaxPerUser <= _poolMaxPerUser, "unexpanded limits");
}
poolMinPerUser = _poolMinPerUser;
poolMaxPerUser = _poolMaxPerUser;
emit UpdatePoolLimitsPerUser(_poolMinPerUser, _poolMaxPerUser);
}
event Lock(address indexed _account, uint256 _cycle, uint256 _factor);
event Deposit(address indexed _account, uint256 _amount);
event Withdraw(address indexed _account, uint256 _amount);
event EmergencyWithdraw(address indexed _account, uint256 _amount);
event Exit(address indexed _account, uint256 _amount);
event UpdatePoolLimitsPerUser(uint256 _poolMinPerUser, uint256 _poolMaxPerUser);
}
文件 14 的 20:NativeStakingPoolFactory.sol
pragma solidity 0.8.9;
import { BaseStakingPoolFactory } from "./BaseStakingPoolFactory.sol";
import { NativeStakingPool } from "./NativeStakingPool.sol";
contract NativeStakingPoolFactory is BaseStakingPoolFactory
{
function _createPoolImpl() internal override returns (address _pool)
{
return address(new NativeStakingPool(address(0)));
}
}
文件 15 的 20:Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_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 {
_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);
}
}
文件 16 的 20:Proxy.sol
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
文件 17 的 20:ReentrancyGuard.sol
pragma solidity ^0.8.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;
}
}
文件 18 的 20:SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.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 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
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");
uint256 newAllowance = oldAllowance - value;
_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");
}
}
}
文件 19 的 20:StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
文件 20 的 20:UpgradeableBeacon.sol
pragma solidity ^0.8.0;
import "./IBeacon.sol";
import "../../access/Ownable.sol";
import "../../utils/Address.sol";
contract UpgradeableBeacon is IBeacon, Ownable {
address private _implementation;
event Upgraded(address indexed implementation);
constructor(address implementation_) {
_setImplementation(implementation_);
}
function implementation() public view virtual override returns (address) {
return _implementation;
}
function upgradeTo(address newImplementation) public virtual onlyOwner {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "UpgradeableBeacon: implementation is not a contract");
_implementation = newImplementation;
}
}
{
"compilationTarget": {
"contracts/NativeStakingPoolFactory.sol": "NativeStakingPoolFactory"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 88888
},
"remappings": []
}
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_account","type":"address"},{"indexed":false,"internalType":"uint96","name":"_index","type":"uint96"},{"indexed":true,"internalType":"address","name":"_pool","type":"address"},{"indexed":true,"internalType":"address","name":"_token","type":"address"}],"name":"CreatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_feeRecipient","type":"address"}],"name":"UpdateFeeRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"_selector","type":"bytes4"},{"indexed":false,"internalType":"uint256","name":"_fixedValueFee","type":"uint256"}],"name":"UpdateFixedValueFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint96","name":"_index","type":"uint96"}],"name":"computePoolAddress","outputs":[{"internalType":"address","name":"_pool","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint96","name":"_index","type":"uint96"},{"internalType":"address","name":"_token","type":"address"}],"name":"createPool","outputs":[{"internalType":"address","name":"_pool","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"name":"fixedValueFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_feeRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4[]","name":"_selectors","type":"bytes4[]"},{"internalType":"uint256","name":"_fixedValueFee","type":"uint256"}],"name":"setFixedValueFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]