编译器
0.8.25+commit.b61c2a91
文件 1 的 31：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 的 31：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;
}
}
文件 3 的 31：Counters.sol
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
文件 4 的 31：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 5 的 31：EIP712.sol
pragma solidity ^0.8.8;
import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
}
文件 6 的 31：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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 += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(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);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 7 的 31：ERC20Permit.sol
pragma solidity ^0.8.0;
import "./IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/cryptography/EIP712.sol";
import "../../../utils/Counters.sol";
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
文件 8 的 31：ERC20Votes.sol
pragma solidity ^0.8.0;
import "./ERC20Permit.sol";
import "../../../interfaces/IERC5805.sol";
import "../../../utils/math/Math.sol";
import "../../../utils/math/SafeCast.sol";
import "../../../utils/cryptography/ECDSA.sol";
abstract contract ERC20Votes is ERC20Permit, IERC5805 {
struct Checkpoint {
uint32 fromBlock;
uint224 votes;
}
bytes32 private constant _DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping(address => address) private _delegates;
mapping(address => Checkpoint[]) private _checkpoints;
Checkpoint[] private _totalSupplyCheckpoints;
function clock() public view virtual override returns (uint48) {
return SafeCast.toUint48(block.number);
}
function CLOCK_MODE() public view virtual override returns (string memory) {
require(clock() == block.number, "ERC20Votes: broken clock mode");
return "mode=blocknumber&from=default";
}
function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {
return _checkpoints[account][pos];
}
function numCheckpoints(address account) public view virtual returns (uint32) {
return SafeCast.toUint32(_checkpoints[account].length);
}
function delegates(address account) public view virtual override returns (address) {
return _delegates[account];
}
function getVotes(address account) public view virtual override returns (uint256) {
uint256 pos = _checkpoints[account].length;
unchecked {
return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
}
}
function getPastVotes(address account, uint256 timepoint) public view virtual override returns (uint256) {
require(timepoint < clock(), "ERC20Votes: future lookup");
return _checkpointsLookup(_checkpoints[account], timepoint);
}
function getPastTotalSupply(uint256 timepoint) public view virtual override returns (uint256) {
require(timepoint < clock(), "ERC20Votes: future lookup");
return _checkpointsLookup(_totalSupplyCheckpoints, timepoint);
}
function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 timepoint) private view returns (uint256) {
uint256 length = ckpts.length;
uint256 low = 0;
uint256 high = length;
if (length > 5) {
uint256 mid = length - Math.sqrt(length);
if (_unsafeAccess(ckpts, mid).fromBlock > timepoint) {
high = mid;
} else {
low = mid + 1;
}
}
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(ckpts, mid).fromBlock > timepoint) {
high = mid;
} else {
low = mid + 1;
}
}
unchecked {
return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes;
}
}
function delegate(address delegatee) public virtual override {
_delegate(_msgSender(), delegatee);
}
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= expiry, "ERC20Votes: signature expired");
address signer = ECDSA.recover(
_hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
v,
r,
s
);
require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce");
_delegate(signer, delegatee);
}
function _maxSupply() internal view virtual returns (uint224) {
return type(uint224).max;
}
function _mint(address account, uint256 amount) internal virtual override {
super._mint(account, amount);
require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes");
_writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
}
function _burn(address account, uint256 amount) internal virtual override {
super._burn(account, amount);
_writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
_moveVotingPower(delegates(from), delegates(to), amount);
}
function _delegate(address delegator, address delegatee) internal virtual {
address currentDelegate = delegates(delegator);
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveVotingPower(currentDelegate, delegatee, delegatorBalance);
}
function _moveVotingPower(address src, address dst, uint256 amount) private {
if (src != dst && amount > 0) {
if (src != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);
emit DelegateVotesChanged(src, oldWeight, newWeight);
}
if (dst != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);
emit DelegateVotesChanged(dst, oldWeight, newWeight);
}
}
}
function _writeCheckpoint(
Checkpoint[] storage ckpts,
function(uint256, uint256) view returns (uint256) op,
uint256 delta
) private returns (uint256 oldWeight, uint256 newWeight) {
uint256 pos = ckpts.length;
unchecked {
Checkpoint memory oldCkpt = pos == 0 ? Checkpoint(0, 0) : _unsafeAccess(ckpts, pos - 1);
oldWeight = oldCkpt.votes;
newWeight = op(oldWeight, delta);
if (pos > 0 && oldCkpt.fromBlock == clock()) {
_unsafeAccess(ckpts, pos - 1).votes = SafeCast.toUint224(newWeight);
} else {
ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(clock()), votes: SafeCast.toUint224(newWeight)}));
}
}
}
function _add(uint256 a, uint256 b) private pure returns (uint256) {
return a + b;
}
function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
return a - b;
}
function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) {
assembly {
mstore(0, ckpts.slot)
result.slot := add(keccak256(0, 0x20), pos)
}
}
}
文件 9 的 31：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);
}
文件 10 的 31：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);
}
文件 11 的 31：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);
}
文件 12 的 31：IERC5267.sol
pragma solidity ^0.8.0;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 13 的 31：IERC5805.sol
pragma solidity ^0.8.0;
import "../governance/utils/IVotes.sol";
import "./IERC6372.sol";
interface IERC5805 is IERC6372, IVotes {}
文件 14 的 31：IERC6372.sol
pragma solidity ^0.8.0;
interface IERC6372 {
function clock() external view returns (uint48);
function CLOCK_MODE() external view returns (string memory);
}
文件 15 的 31：IVirtualStakingRewards.sol
pragma solidity 0.8.25;
interface IVirtualStakingRewards {
function balanceOf(address account) external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function rewardsDistribution() external view returns (address);
function rewardsToken() external view returns (address);
function totalSupply() external view returns (uint256);
function getReward(address user, address to) external returns (uint256);
function stake(address user, uint256 amount) external;
function withdraw(address user, uint256 amount) external;
}
文件 16 的 31：IVotes.sol
pragma solidity ^0.8.0;
interface IVotes {
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
function getVotes(address account) external view returns (uint256);
function getPastVotes(address account, uint256 timepoint) external view returns (uint256);
function getPastTotalSupply(uint256 timepoint) external view returns (uint256);
function delegates(address account) external view returns (address);
function delegate(address delegatee) external;
function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;
}
文件 17 的 31：IVotingEscrow.sol
pragma solidity 0.8.25;
interface IVotingEscrow {
struct Lockup {
uint128 amount;
uint128 duration;
uint128 end;
uint256 points;
bool isVesting;
}
function stakeVesting(uint256 amount, uint256 duration, address to, uint256 startTime) external returns (uint256 lockupId);
function unstakeVesting(address user, uint256 lockupId, bool force) external returns (uint256 amount);
function migrateVestingLock(address oldUser, address newUser, uint256 lockupId)
external
returns (uint256 newLockupId);
function extendVestingLock(address user, uint256 lockupId, uint256 amount, uint256 duration) external;
event Stake(
address indexed user, bool indexed isVesting, uint256 lockupId, uint256 amount, uint256 start, uint256 end, uint256 points
);
event Unstake(
address indexed user, bool indexed isVesting, uint256 lockupId, uint256 amount, uint256 end, uint256 points
);
event Migrated(address indexed oldUser, address indexed newUser, uint256 oldLockupId, uint256 newLockupId);
event Cancelled(address indexed user, uint256 lockupId, uint256 amount, uint256 points);
}
文件 18 的 31：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);
}
}
}
文件 19 的 31：MerkleProof.sol
pragma solidity ^0.8.0;
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
文件 20 的 31：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());
}
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);
}
}
文件 21 的 31：Ownable2Step.sol
pragma solidity ^0.8.0;
import "./Ownable.sol";
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
_transferOwnership(sender);
}
}
文件 22 的 31：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 23 的 31：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));
}
}
文件 24 的 31：ShortStrings.sol
pragma solidity ^0.8.8;
import "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 25 的 31：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 26 的 31：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;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes 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
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 27 的 31：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 28 的 31：TrufMigrator.sol
pragma solidity 0.8.25;
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {TrufVesting} from "./TrufVesting.sol";
import {VotingEscrowTruf} from "./VotingEscrowTruf.sol";
contract TrufMigrator is Ownable2Step {
using SafeERC20 for IERC20;
error InvalidProof();
error AlreadyMigrated();
event Migrated(address indexed user);
bytes32 public root;
IERC20 public trufToken;
TrufVesting public trufVesting;
VotingEscrowTruf public veTRUF;
mapping(address => bool) public hasMigrated;
function initialize(IERC20 _trufToken, TrufVesting _trufVesting, VotingEscrowTruf _veTRUF, bytes32 _root)
external
onlyOwner
{
if (address(trufToken) != address(0)) revert();
root = _root;
trufToken = _trufToken;
trufVesting = _trufVesting;
veTRUF = _veTRUF;
trufToken.approve(address(veTRUF), type(uint256).max);
trufToken.approve(address(trufVesting), type(uint256).max);
}
function migrate(
uint256 trufBalance,
bytes calldata vestingData,
bytes calldata stakingData,
bytes32[] calldata proof
) external {
if (hasMigrated[msg.sender]) revert AlreadyMigrated();
_verify(keccak256(bytes.concat(keccak256(abi.encode(msg.sender, trufBalance, vestingData, stakingData)))), proof);
hasMigrated[msg.sender] = true;
trufToken.safeTransfer(msg.sender, trufBalance);
_migrateVesting(msg.sender, vestingData);
_migrateStaking(msg.sender, stakingData);
emit Migrated(msg.sender);
}
function _migrateVesting(address user, bytes calldata vestingData) internal {
(
uint256[] memory vestingCategoryIds,
uint256[] memory vestingAmounts,
uint256[] memory vestingClaimedAmounts,
uint256[] memory vestingLockedAmounts,
uint64[] memory vestingStartTimes,
uint256[] memory vestingStakingStartTimes,
uint256[] memory vestingStakingDurations
) = abi.decode(vestingData, (uint256[], uint256[], uint256[], uint256[], uint64[], uint256[], uint256[]));
for (uint256 i = 0; i < vestingCategoryIds.length; i++) {
trufVesting.migrate(
vestingCategoryIds[i],
0,
user,
vestingAmounts[i],
vestingClaimedAmounts[i],
vestingLockedAmounts[i],
vestingStartTimes[i],
vestingStakingStartTimes[i],
vestingStakingDurations[i]
);
}
}
function _migrateStaking(address user, bytes calldata stakingData) internal {
(uint256[] memory stakingAmounts, uint256[] memory stakingDurations, uint256[] memory stakingStarts) =
abi.decode(stakingData, (uint256[], uint256[], uint256[]));
for (uint256 i = 0; i < stakingAmounts.length; i++) {
veTRUF.migrate(stakingAmounts[i], stakingDurations[i], user, stakingStarts[i]);
}
}
function _verify(bytes32 data, bytes32[] calldata proof) internal view {
if (MerkleProof.verify(proof, root, data) == false) {
revert InvalidProof();
}
}
function setRoot(bytes32 _root) external onlyOwner {
root = _root;
}
}
文件 29 的 31：TrufVesting.sol
pragma solidity 0.8.25;
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IVotingEscrow} from "../interfaces/IVotingEscrow.sol";
contract TrufVesting is Ownable2Step {
using SafeERC20 for IERC20;
error ZeroAddress();
error ZeroAmount();
error Forbidden(address sender);
error InvalidTimestamp();
error InvalidAmount();
error InvalidVestingCategory(uint256 id);
error InvalidEmissions();
error InvalidVestingInfo(uint256 categoryIdx, uint256 id);
error InvalidUserVesting();
error ClaimAmountExceed();
error UserVestingAlreadySet(uint256 categoryIdx, uint256 vestingId, address user);
error UserVestingDoesNotExists(uint256 categoryIdx, uint256 vestingId, address user);
error MaxAllocationExceed();
error AlreadyVested(uint256 categoryIdx, uint256 vestingId, address user);
error LockExist();
error LockDoesNotExist();
error InvalidInitialReleasePct();
error InvalidInitialReleasePeriod();
error InvalidCliff();
error InvalidPeriod();
error InvalidUnit();
error Initialized();
event VestingCategorySet(uint256 indexed id, string category, uint256 maxAllocation, bool adminClaimable);
event EmissionScheduleSet(uint256 indexed categoryId, uint256[] emissions);
event VestingInfoSet(uint256 indexed categoryId, uint256 indexed id, VestingInfo info);
event UserVestingSet(
uint256 indexed categoryId, uint256 indexed vestingId, address indexed user, uint256 amount, uint64 startTime
);
event UserVestingMigrated(
uint256 indexed categoryId,
uint256 indexed vestingId,
address indexed user,
uint256 amount,
uint256 claimed,
uint256 locked,
uint64 startTime
);
event MigrateUser(
uint256 indexed categoryId, uint256 indexed vestingId, address prevUser, address newUser, uint256 newLockupId
);
event CancelVesting(
uint256 indexed categoryId, uint256 indexed vestingId, address indexed user, bool giveUnclaimed
);
event AdminSet(address indexed admin, bool indexed flag);
event Claimed(uint256 indexed categoryId, uint256 indexed vestingId, address indexed user, uint256 amount);
event VeTrufSet(address indexed veTRUF);
event Staked(
uint256 indexed categoryId,
uint256 indexed vestingId,
address indexed user,
uint256 amount,
uint256 start,
uint256 duration,
uint256 lockupId
);
event ExtendedStaking(
uint256 indexed categoryId, uint256 indexed vestingId, address indexed user, uint256 amount, uint256 duration
);
event Unstaked(uint256 indexed categoryId, uint256 indexed vestingId, address indexed user, uint256 amount);
struct VestingCategory {
string category;
uint256 maxAllocation;
uint256 allocated;
bool adminClaimable;
uint256 totalClaimed;
}
struct VestingInfo {
uint64 initialReleasePct;
uint64 initialReleasePeriod;
uint64 cliff;
uint64 period;
uint64 unit;
}
struct UserVesting {
uint256 amount;
uint256 claimed;
uint256 locked;
uint64 startTime;
}
uint256 public constant DENOMINATOR = 1e18;
uint64 public constant ONE_MONTH = 30 days;
mapping(uint256 => bool) public isInitialized;
IERC20 public immutable trufToken;
address public immutable trufMigrator;
IVotingEscrow public veTRUF;
uint64 public immutable tgeTime;
VestingCategory[] public categories;
mapping(uint256 => uint256[]) public emissionSchedule;
mapping(uint256 => VestingInfo[]) public vestingInfos;
mapping(uint256 => mapping(uint256 => mapping(address => UserVesting))) public userVestings;
mapping(uint256 => mapping(uint256 => mapping(address => uint256))) public lockupIds;
mapping(address => bool) public isAdmin;
modifier onlyAdmin() {
if (!isAdmin[msg.sender] && msg.sender != owner()) {
revert Forbidden(msg.sender);
}
_;
}
constructor(IERC20 _trufToken, address _trufMigrator, uint64 _tgeTime) {
if (address(_trufToken) == address(0)) revert ZeroAddress();
trufToken = _trufToken;
trufMigrator = _trufMigrator;
tgeTime = _tgeTime;
}
function claimable(uint256 categoryId, uint256 vestingId, address user)
public
view
returns (uint256 claimableAmount)
{
if (isInitialized[categoryId] == false) revert Initialized();
UserVesting memory userVesting = userVestings[categoryId][vestingId][user];
VestingInfo memory info = vestingInfos[categoryId][vestingId];
uint64 startTime = userVesting.startTime + info.initialReleasePeriod;
if (startTime > block.timestamp) {
return 0;
}
uint256 totalAmount = userVesting.amount;
uint256 initialRelease = (totalAmount * info.initialReleasePct) / DENOMINATOR;
startTime += info.cliff;
uint256 vestedAmount;
if (startTime > block.timestamp) {
vestedAmount = initialRelease;
} else {
uint64 timeElapsed = ((uint64(block.timestamp) - startTime) / info.unit) * info.unit;
vestedAmount = ((totalAmount - initialRelease) * timeElapsed) / info.period + initialRelease;
}
uint256 maxClaimable = userVesting.amount - userVesting.locked;
if (vestedAmount > maxClaimable) {
vestedAmount = maxClaimable;
}
if (vestedAmount <= userVesting.claimed) {
return 0;
}
claimableAmount = vestedAmount - userVesting.claimed;
uint256 emissionLeft = getEmission(categoryId) - categories[categoryId].totalClaimed;
if (claimableAmount > emissionLeft) {
claimableAmount = emissionLeft;
}
}
function claim(address user, uint256 categoryId, uint256 vestingId, uint256 claimAmount) public {
if (isInitialized[categoryId] == false) revert Initialized();
if (user != msg.sender && (!categories[categoryId].adminClaimable || !isAdmin[msg.sender])) {
revert Forbidden(msg.sender);
}
uint256 claimableAmount = claimable(categoryId, vestingId, user);
if (claimAmount == type(uint256).max) {
claimAmount = claimableAmount;
} else if (claimAmount > claimableAmount) {
revert ClaimAmountExceed();
}
if (claimAmount == 0) {
revert ZeroAmount();
}
categories[categoryId].totalClaimed += claimAmount;
userVestings[categoryId][vestingId][user].claimed += claimAmount;
trufToken.safeTransfer(user, claimAmount);
emit Claimed(categoryId, vestingId, user, claimAmount);
}
function stake(uint256 categoryId, uint256 vestingId, uint256 amount, uint256 duration) external {
_stake(msg.sender, categoryId, vestingId, amount, block.timestamp, duration);
}
function extendStaking(uint256 categoryId, uint256 vestingId, uint256 amount, uint256 duration) external {
if (isInitialized[categoryId] == false) revert Initialized();
uint256 lockupId = lockupIds[categoryId][vestingId][msg.sender];
if (lockupId == 0) {
revert LockDoesNotExist();
}
if (amount != 0) {
UserVesting storage userVesting = userVestings[categoryId][vestingId][msg.sender];
if (amount > userVesting.amount - userVesting.claimed - userVesting.locked) {
revert InvalidAmount();
}
userVesting.locked += amount;
trufToken.safeIncreaseAllowance(address(veTRUF), amount);
}
veTRUF.extendVestingLock(msg.sender, lockupId - 1, amount, duration);
emit ExtendedStaking(categoryId, vestingId, msg.sender, amount, duration);
}
function unstake(uint256 categoryId, uint256 vestingId) external {
if (isInitialized[categoryId] == false) revert Initialized();
uint256 lockupId = lockupIds[categoryId][vestingId][msg.sender];
if (lockupId == 0) {
revert LockDoesNotExist();
}
uint256 amount = veTRUF.unstakeVesting(msg.sender, lockupId - 1, false);
UserVesting storage userVesting = userVestings[categoryId][vestingId][msg.sender];
userVesting.locked -= amount;
delete lockupIds[categoryId][vestingId][msg.sender];
emit Unstaked(categoryId, vestingId, msg.sender, amount);
}
function migrateUser(uint256 categoryId, uint256 vestingId, address prevUser, address newUser) external onlyAdmin {
if (newUser == address(0)) {
revert ZeroAddress();
}
UserVesting storage prevVesting = userVestings[categoryId][vestingId][prevUser];
UserVesting storage newVesting = userVestings[categoryId][vestingId][newUser];
if (newVesting.amount != 0) {
revert UserVestingAlreadySet(categoryId, vestingId, newUser);
}
if (prevVesting.amount == 0) {
revert UserVestingDoesNotExists(categoryId, vestingId, prevUser);
}
newVesting.amount = prevVesting.amount;
newVesting.claimed = prevVesting.claimed;
newVesting.startTime = prevVesting.startTime;
uint256 lockupId = lockupIds[categoryId][vestingId][prevUser];
uint256 newLockupId;
if (lockupId != 0) {
newLockupId = veTRUF.migrateVestingLock(prevUser, newUser, lockupId - 1) + 1;
lockupIds[categoryId][vestingId][newUser] = newLockupId;
delete lockupIds[categoryId][vestingId][prevUser];
newVesting.locked = prevVesting.locked;
}
delete userVestings[categoryId][vestingId][prevUser];
emit MigrateUser(categoryId, vestingId, prevUser, newUser, newLockupId);
}
function cancelVesting(uint256 categoryId, uint256 vestingId, address user, bool giveUnclaimed)
external
onlyAdmin
{
UserVesting storage userVesting = userVestings[categoryId][vestingId][user];
if (userVesting.amount == 0) {
revert UserVestingDoesNotExists(categoryId, vestingId, user);
}
VestingInfo memory vestingInfo = vestingInfos[categoryId][vestingId];
if (
userVesting.startTime + vestingInfo.initialReleasePeriod + vestingInfo.cliff + vestingInfo.period
<= block.timestamp
) {
revert AlreadyVested(categoryId, vestingId, user);
}
uint256 lockupId = lockupIds[categoryId][vestingId][user];
if (lockupId != 0) {
veTRUF.unstakeVesting(user, lockupId - 1, true);
delete lockupIds[categoryId][vestingId][user];
userVesting.locked = 0;
}
VestingCategory storage category = categories[categoryId];
uint256 claimableAmount = claimable(categoryId, vestingId, user);
uint256 unvested = userVesting.amount - (userVesting.claimed + (giveUnclaimed ? claimableAmount : 0));
delete userVestings[categoryId][vestingId][user];
category.allocated -= unvested;
if (giveUnclaimed && claimableAmount != 0) {
trufToken.safeTransfer(user, claimableAmount);
category.totalClaimed += claimableAmount;
emit Claimed(categoryId, vestingId, user, claimableAmount);
}
emit CancelVesting(categoryId, vestingId, user, giveUnclaimed);
}
function setVestingCategory(string calldata category, uint256 maxAllocation, bool adminClaimable)
public
onlyOwner
{
if (maxAllocation == 0) {
revert ZeroAmount();
}
uint256 id = categories.length;
categories.push(VestingCategory(category, maxAllocation, 0, adminClaimable, 0));
emit VestingCategorySet(id, category, maxAllocation, adminClaimable);
}
function setEmissionSchedule(uint256 categoryId, uint256[] memory emissions) public onlyOwner {
if (isInitialized[categoryId]) {
revert Initialized();
}
uint256 maxAllocation = categories[categoryId].maxAllocation;
if (emissions.length == 0 || emissions[emissions.length - 1] != maxAllocation) {
revert InvalidEmissions();
}
delete emissionSchedule[categoryId];
emissionSchedule[categoryId] = emissions;
emit EmissionScheduleSet(categoryId, emissions);
}
function setVestingInfo(uint256 categoryIdx, uint256 id, VestingInfo calldata info) public onlyAdmin {
if (info.initialReleasePct > DENOMINATOR) {
revert InvalidInitialReleasePct();
} else if (info.initialReleasePeriod > info.period) {
revert InvalidInitialReleasePeriod();
} else if (info.cliff > 365 days) {
revert InvalidCliff();
} else if (info.period > 8 * 365 days) {
revert InvalidPeriod();
} else if (info.period % info.unit != 0) {
revert InvalidUnit();
}
if (id == type(uint256).max) {
id = vestingInfos[categoryIdx].length;
vestingInfos[categoryIdx].push(info);
} else {
vestingInfos[categoryIdx][id] = info;
}
emit VestingInfoSet(categoryIdx, id, info);
}
function migrate(
uint256 categoryId,
uint256 vestingId,
address user,
uint256 amount,
uint256 claimed,
uint256 locked,
uint64 vestingStartTime,
uint256 stakingStartTime,
uint256 stakingDuration
) public {
if (msg.sender != trufMigrator) {
revert();
}
if (user == address(0)) {
revert ZeroAddress();
}
if (amount == 0) {
revert ZeroAmount();
}
if (categoryId >= categories.length) {
revert InvalidVestingCategory(categoryId);
}
if (vestingId >= vestingInfos[categoryId].length) {
revert InvalidVestingInfo(categoryId, vestingId);
}
if (isInitialized[categoryId]) {
trufToken.safeTransferFrom(msg.sender, address(this), amount - claimed);
} else if (locked > 0) {
revert Initialized();
}
VestingCategory storage category = categories[categoryId];
UserVesting storage userVesting = userVestings[categoryId][vestingId][user];
if (amount < claimed + locked) {
revert InvalidUserVesting();
}
category.allocated += amount;
category.totalClaimed += claimed;
if (category.allocated > category.maxAllocation) {
revert MaxAllocationExceed();
}
if (vestingStartTime != 0 && vestingStartTime < tgeTime) revert InvalidTimestamp();
userVesting.amount += amount;
userVesting.claimed += claimed;
userVesting.startTime = vestingStartTime == 0 ? tgeTime : vestingStartTime;
emit UserVestingMigrated(categoryId, vestingId, user, amount, claimed, locked, userVesting.startTime);
if (locked > 0) {
_stake(user, categoryId, vestingId, locked, stakingStartTime, stakingDuration);
}
}
function setUserVesting(uint256 categoryId, uint256 vestingId, address user, uint64 startTime, uint256 amount)
public
onlyAdmin
{
if (user == address(0)) {
revert ZeroAddress();
}
if (amount == 0) {
revert ZeroAmount();
}
if (categoryId >= categories.length) {
revert InvalidVestingCategory(categoryId);
}
if (vestingId >= vestingInfos[categoryId].length) {
revert InvalidVestingInfo(categoryId, vestingId);
}
VestingCategory storage category = categories[categoryId];
UserVesting storage userVesting = userVestings[categoryId][vestingId][user];
category.allocated += amount;
category.allocated -= userVesting.amount;
if (category.allocated > category.maxAllocation) {
revert MaxAllocationExceed();
}
if (amount < userVesting.claimed + userVesting.locked) {
revert InvalidUserVesting();
}
if (startTime != 0 && startTime < tgeTime) revert InvalidTimestamp();
userVesting.amount = amount;
userVesting.startTime = startTime == 0 ? tgeTime : startTime;
emit UserVestingSet(categoryId, vestingId, user, amount, userVesting.startTime);
}
function setVeTruf(address _veTRUF) external onlyOwner {
if (_veTRUF == address(0)) {
revert ZeroAddress();
}
veTRUF = IVotingEscrow(_veTRUF);
emit VeTrufSet(_veTRUF);
}
function setAdmin(address _admin, bool _flag) external onlyOwner {
isAdmin[_admin] = _flag;
emit AdminSet(_admin, _flag);
}
function initialize(uint256 _categoryId) external {
if (isInitialized[_categoryId]) {
revert Initialized();
}
isInitialized[_categoryId] = true;
if (_categoryId != 0 && _categoryId != 7) {
trufToken.safeTransferFrom(msg.sender, address(this), categories[_categoryId].maxAllocation);
}
}
function multicall(bytes[] calldata payloads) external {
uint256 len = payloads.length;
for (uint256 i; i < len;) {
(bool success, bytes memory result) = address(this).delegatecall(payloads[i]);
if (!success) {
if (result.length < 68) revert();
assembly {
result := add(result, 0x04)
}
revert(abi.decode(result, (string)));
}
unchecked {
i += 1;
}
}
}
function getEmissionSchedule(uint256 categoryId) external view returns (uint256[] memory emissions) {
emissions = emissionSchedule[categoryId];
}
function getEmission(uint256 categoryId) public view returns (uint256 emissionLimit) {
uint64 _tgeTime = tgeTime;
if (block.timestamp >= _tgeTime) {
uint256 maxAllocation = categories[categoryId].maxAllocation;
if (emissionSchedule[categoryId].length == 0) {
return maxAllocation;
}
uint64 elapsedTime = uint64(block.timestamp) - _tgeTime + ONE_MONTH;
uint64 elapsedMonth = elapsedTime / ONE_MONTH;
if (elapsedMonth >= emissionSchedule[categoryId].length) {
return maxAllocation;
}
uint256 lastMonthEmission = elapsedMonth == 0 ? 0 : emissionSchedule[categoryId][elapsedMonth - 1];
uint256 thisMonthEmission = emissionSchedule[categoryId][elapsedMonth];
uint64 elapsedTimeOfLastMonth = elapsedTime % ONE_MONTH;
emissionLimit =
(thisMonthEmission - lastMonthEmission) * elapsedTimeOfLastMonth / ONE_MONTH + lastMonthEmission;
if (emissionLimit > maxAllocation) {
emissionLimit = maxAllocation;
}
}
}
function _stake(
address user,
uint256 categoryId,
uint256 vestingId,
uint256 amount,
uint256 start,
uint256 duration
) internal {
if (isInitialized[categoryId] == false) revert Initialized();
if (amount == 0) {
revert ZeroAmount();
}
if (lockupIds[categoryId][vestingId][user] != 0) {
revert LockExist();
}
UserVesting storage userVesting = userVestings[categoryId][vestingId][user];
if (amount > userVesting.amount - userVesting.claimed - userVesting.locked) {
revert InvalidAmount();
}
userVesting.locked += amount;
trufToken.safeIncreaseAllowance(address(veTRUF), amount);
uint256 lockupId = veTRUF.stakeVesting(amount, duration, user, start) + 1;
lockupIds[categoryId][vestingId][user] = lockupId;
emit Staked(categoryId, vestingId, user, amount, start, duration, lockupId);
}
}
文件 30 的 31：VotingEscrowTruf.sol
pragma solidity 0.8.25;
import {ERC20Votes} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import {ERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IVirtualStakingRewards} from "../interfaces/IVirtualStakingRewards.sol";
import {IVotingEscrow} from "../interfaces/IVotingEscrow.sol";
contract VotingEscrowTruf is ERC20Votes, IVotingEscrow {
using SafeERC20 for IERC20;
error ZeroAddress();
error ZeroAmount();
error ZeroPoints();
error Forbidden(address sender);
error InvalidAccount();
error TransferDisabled();
error NoAccess();
error LockupAlreadyUnstaked();
error LockupNotEnded();
error NotIncrease();
error NotMigrate();
error TooShort();
error TooLong();
error AlreadyEnded();
uint256 public immutable minStakeDuration;
uint256 public constant MAX_DURATION = 365 days * 3;
mapping(address => Lockup[]) public lockups;
IERC20 public immutable trufToken;
IVirtualStakingRewards public immutable stakingRewards;
address public immutable trufVesting;
address public immutable trufMigrator;
modifier onlyVesting() {
if (msg.sender != trufVesting) {
revert Forbidden(msg.sender);
}
_;
}
modifier onlyMigrator() {
if (msg.sender != trufMigrator) {
revert Forbidden(msg.sender);
}
_;
}
constructor(
address _trufToken,
address _trufVesting,
address _trufMigrator,
uint256 _minStakeDuration,
address _stakingRewards
) ERC20("Voting Escrowed TRUF", "veTRUF") ERC20Permit("veTRUF") {
if (_minStakeDuration > MAX_DURATION) {
revert TooLong();
}
trufToken = IERC20(_trufToken);
trufVesting = _trufVesting;
trufMigrator = _trufMigrator;
minStakeDuration = _minStakeDuration;
stakingRewards = IVirtualStakingRewards(_stakingRewards);
}
function _transfer(address, address, uint256) internal pure override {
revert TransferDisabled();
}
function migrate(uint256 amount, uint256 duration, address to, uint256 start) external onlyMigrator {
_stake(amount, duration, to, start, false);
}
function stake(uint256 amount, uint256 duration, address to) external {
_stake(amount, duration, to, block.timestamp, false);
}
function stakeVesting(uint256 amount, uint256 duration, address to, uint256 start)
external
onlyVesting
returns (uint256 lockupId)
{
if (to == trufVesting) {
revert InvalidAccount();
}
lockupId = _stake(amount, duration, to, start, true);
}
function stake(uint256 amount, uint256 duration) external returns (uint256 lockupId) {
lockupId = _stake(amount, duration, msg.sender, block.timestamp, false);
}
function _stake(uint256 amount, uint256 duration, address to, uint256 start, bool isVesting)
internal
returns (uint256 lockupId)
{
if (to == address(0)) {
revert ZeroAddress();
}
if (amount == 0) {
revert ZeroAmount();
}
uint256 points = previewPoints(amount, duration);
if (points == 0) {
revert ZeroPoints();
}
uint256 end = start + duration;
lockups[to].push(
Lockup({
amount: uint128(amount),
duration: uint128(duration),
end: uint128(end),
points: points,
isVesting: isVesting
})
);
trufToken.safeTransferFrom(msg.sender, address(this), amount);
stakingRewards.stake(to, points);
_mint(to, points);
if (delegates(to) == address(0)) {
_delegate(to, to);
}
lockupId = lockups[to].length - 1;
emit Stake(to, isVesting, lockupId, amount, start, end, points);
}
function unstake(uint256 lockupId) external returns (uint256 amount) {
amount = _unstake(msg.sender, lockupId, false, false);
}
function unstakeVesting(address user, uint256 lockupId, bool force) external onlyVesting returns (uint256 amount) {
amount = _unstake(user, lockupId, true, force);
}
function extendLock(uint256 lockupId, uint256 amount, uint256 duration) external {
_extendLock(msg.sender, lockupId, amount, duration, false);
}
function extendVestingLock(address user, uint256 lockupId, uint256 amount, uint256 duration) external onlyVesting {
_extendLock(user, lockupId, amount, duration, true);
}
function migrateVestingLock(address oldUser, address newUser, uint256 lockupId)
external
onlyVesting
returns (uint256 newLockupId)
{
if (oldUser == newUser) {
revert NotMigrate();
}
if (newUser == address(0)) {
revert ZeroAddress();
}
Lockup memory oldLockup = lockups[oldUser][lockupId];
if (!oldLockup.isVesting) {
revert NoAccess();
}
uint256 points = oldLockup.points;
stakingRewards.withdraw(oldUser, points);
stakingRewards.getReward(oldUser, newUser);
_burn(oldUser, points);
newLockupId = lockups[newUser].length;
lockups[newUser].push(oldLockup);
_mint(newUser, points);
stakingRewards.stake(newUser, points);
delete lockups[oldUser][lockupId];
if (delegates(newUser) == address(0)) {
_delegate(newUser, newUser);
}
emit Migrated(oldUser, newUser, lockupId, newLockupId);
}
function claimReward() external {
stakingRewards.getReward(msg.sender, msg.sender);
}
function previewPoints(uint256 amount, uint256 duration) public view returns (uint256 points) {
if (duration < minStakeDuration) {
revert TooShort();
}
if (duration > MAX_DURATION) {
revert TooLong();
}
points = amount * duration / MAX_DURATION;
}
function _unstake(address user, uint256 lockupId, bool isVesting, bool force) internal returns (uint256 amount) {
Lockup memory lockup = lockups[user][lockupId];
if (lockup.isVesting != isVesting) {
revert NoAccess();
}
amount = lockup.amount;
uint256 end = lockup.end;
uint256 points = lockup.points;
if (end == 0) {
revert LockupAlreadyUnstaked();
}
if (!force && block.timestamp < end) {
revert LockupNotEnded();
}
delete lockups[user][lockupId];
stakingRewards.withdraw(user, points);
_burn(user, points);
trufToken.safeTransfer(msg.sender, amount);
emit Unstake(user, isVesting, lockupId, amount, end, points);
if (block.timestamp < end) {
emit Cancelled(user, lockupId, amount, points);
}
}
function _extendLock(address user, uint256 lockupId, uint256 amount, uint256 duration, bool isVesting) internal {
Lockup memory lockup = lockups[user][lockupId];
if (lockup.isVesting != isVesting) {
revert NoAccess();
}
address _user = user;
uint256 _lockupId = lockupId;
uint256 _amount = amount;
uint256 oldAmount = lockup.amount;
uint256 oldEnd = lockup.end;
if (oldEnd <= block.timestamp) {
revert AlreadyEnded();
}
uint256 oldPoints = lockup.points;
uint256 oldDuration = lockup.duration;
uint256 newEnd = oldEnd + duration;
uint256 newDuration = oldDuration + duration;
if (newDuration > MAX_DURATION) {
revert TooLong();
}
uint256 mintAmount = ((oldAmount * duration) + (_amount * (newEnd - block.timestamp))) / MAX_DURATION;
if (mintAmount == 0) {
revert NotIncrease();
}
uint256 newPoints = oldPoints + mintAmount;
uint256 newAmount = oldAmount + _amount;
lockup.amount = uint128(newAmount);
lockup.end = uint128(newEnd);
lockup.duration = uint128(newDuration);
lockup.points = newPoints;
if (_amount != 0) {
trufToken.safeTransferFrom(msg.sender, address(this), _amount);
}
lockups[_user][_lockupId] = lockup;
stakingRewards.stake(_user, mintAmount);
_mint(_user, mintAmount);
emit Unstake(_user, isVesting, _lockupId, oldAmount, oldEnd, oldPoints);
emit Stake(_user, isVesting, _lockupId, newAmount, newEnd - newDuration, newEnd, newPoints);
}
}
文件 31 的 31：draft-ERC20Permit.sol
pragma solidity ^0.8.0;
import "./ERC20Permit.sol";
{
"compilationTarget": {
"src/token/TrufMigrator.sol": "TrufMigrator"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":@uniswap/v2-periphery/=lib/uniswap-v2-periphery/contracts/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":murky/src/=lib/murky/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/"
]
}[{"inputs":[],"name":"AlreadyMigrated","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Migrated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","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"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasMigrated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_trufToken","type":"address"},{"internalType":"contract TrufVesting","name":"_trufVesting","type":"address"},{"internalType":"contract VotingEscrowTruf","name":"_veTRUF","type":"address"},{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"trufBalance","type":"uint256"},{"internalType":"bytes","name":"vestingData","type":"bytes"},{"internalType":"bytes","name":"stakingData","type":"bytes"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"trufToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"trufVesting","outputs":[{"internalType":"contract TrufVesting","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"veTRUF","outputs":[{"internalType":"contract VotingEscrowTruf","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
