编译器
0.8.17+commit.8df45f5f
文件 1 的 38：AccessControl.sol
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(account),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
文件 2 的 38：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);
}
}
}
文件 3 的 38：Arrays.sol
pragma solidity ^0.8.0;
import "./StorageSlot.sol";
import "./math/Math.sol";
library Arrays {
using StorageSlot for bytes32;
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
if (unsafeAccess(array, mid).value > element) {
high = mid;
} else {
low = mid + 1;
}
}
if (low > 0 && unsafeAccess(array, low - 1).value == element) {
return low - 1;
} else {
return low;
}
}
function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getAddressSlot();
}
function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getBytes32Slot();
}
function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getUint256Slot();
}
}
文件 4 的 38：Bytes32AddressLib.sol
pragma solidity >=0.8.0;
library Bytes32AddressLib {
function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
return address(uint160(uint256(bytesValue)));
}
function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
return bytes32(bytes20(addressValue));
}
}
文件 5 的 38：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 的 38：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;
}
}
文件 7 的 38：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) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
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) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 8 的 38：ERC1155.sol
pragma solidity >=0.8.0;
abstract contract ERC1155 {
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function uri(uint256 id) public view virtual returns (string memory);
function setApprovalForAll(address operator, bool approved) public virtual {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
balanceOf[from][id] -= amount;
balanceOf[to][id] += amount;
emit TransferSingle(msg.sender, from, to, id, amount);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) ==
ERC1155TokenReceiver.onERC1155Received.selector,
"UNSAFE_RECIPIENT"
);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
require(ids.length == amounts.length, "LENGTH_MISMATCH");
require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
uint256 id;
uint256 amount;
for (uint256 i = 0; i < ids.length; ) {
id = ids[i];
amount = amounts[i];
balanceOf[from][id] -= amount;
balanceOf[to][id] += amount;
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, from, to, ids, amounts);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) ==
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
"UNSAFE_RECIPIENT"
);
}
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
require(owners.length == ids.length, "LENGTH_MISMATCH");
balances = new uint256[](owners.length);
unchecked {
for (uint256 i = 0; i < owners.length; ++i) {
balances[i] = balanceOf[owners[i]][ids[i]];
}
}
}
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return
interfaceId == 0x01ffc9a7 ||
interfaceId == 0xd9b67a26 ||
interfaceId == 0x0e89341c;
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
balanceOf[to][id] += amount;
emit TransferSingle(msg.sender, address(0), to, id, amount);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) ==
ERC1155TokenReceiver.onERC1155Received.selector,
"UNSAFE_RECIPIENT"
);
}
function _batchMint(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
uint256 idsLength = ids.length;
require(idsLength == amounts.length, "LENGTH_MISMATCH");
for (uint256 i = 0; i < idsLength; ) {
balanceOf[to][ids[i]] += amounts[i];
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, address(0), to, ids, amounts);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) ==
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
"UNSAFE_RECIPIENT"
);
}
function _batchBurn(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
uint256 idsLength = ids.length;
require(idsLength == amounts.length, "LENGTH_MISMATCH");
for (uint256 i = 0; i < idsLength; ) {
balanceOf[from][ids[i]] -= amounts[i];
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, from, address(0), ids, amounts);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
balanceOf[from][id] -= amount;
emit TransferSingle(msg.sender, from, address(0), id, amount);
}
}
abstract contract ERC1155TokenReceiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external virtual returns (bytes4) {
return ERC1155TokenReceiver.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external virtual returns (bytes4) {
return ERC1155TokenReceiver.onERC1155BatchReceived.selector;
}
}
文件 9 的 38：ERC1155Burnable.sol
pragma solidity ^0.8.0;
import "../ERC1155.sol";
abstract contract ERC1155Burnable is ERC1155 {
function burn(
address account,
uint256 id,
uint256 value
) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_burn(account, id, value);
}
function burnBatch(
address account,
uint256[] memory ids,
uint256[] memory values
) public virtual {
require(
account == _msgSender() || isApprovedForAll(account, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_burnBatch(account, ids, values);
}
}
文件 10 的 38：ERC1155PresetMinterSupply.sol
pragma solidity 0.8.17;
import {ERC1155} from "openzeppelin-contracts/contracts/token/ERC1155/ERC1155.sol";
import {ERC1155Supply} from "openzeppelin-contracts/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import {ERC1155Burnable} from "openzeppelin-contracts/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import {AccessControl} from "openzeppelin-contracts/contracts/access/AccessControl.sol";
import {Context} from "openzeppelin-contracts/contracts/utils/Context.sol";
contract ERC1155PresetMinterSupply is
Context,
AccessControl,
ERC1155Supply,
ERC1155Burnable
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor(string memory uri) ERC1155(uri) {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
}
function mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual {
require(
hasRole(MINTER_ROLE, _msgSender()),
"ERC1155PresetMinterPauser: must have minter role to mint"
);
_mint(to, id, amount, data);
}
function mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual {
require(
hasRole(MINTER_ROLE, _msgSender()),
"ERC1155PresetMinterPauser: must have minter role to mint"
);
_mintBatch(to, ids, amounts, data);
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC1155)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
}
}
文件 11 的 38：ERC1155Solmate.sol
pragma solidity 0.8.17;
import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {AccessControl} from "openzeppelin-contracts/contracts/access/AccessControl.sol";
import {Context} from "openzeppelin-contracts/contracts/utils/Context.sol";
contract ERC1155Solmate is AccessControl, ERC1155 {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
event GrantMinterRole(address minter);
event RevokeMinterRole(address minter);
error ZeroAddress();
error NotMinter();
constructor() {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function grantMinterRole(address minter)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
if (minter == address(0)) revert ZeroAddress();
_grantRole(MINTER_ROLE, minter);
emit GrantMinterRole(minter);
}
function revokeMinterRole(address minter)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
if (hasRole(MINTER_ROLE, minter) == false) revert NotMinter();
_revokeRole(MINTER_ROLE, minter);
emit RevokeMinterRole(minter);
}
function mint(
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external onlyRole(MINTER_ROLE) {
_mint(to, id, amount, data);
}
function mintBatch(
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external onlyRole(MINTER_ROLE) {
_batchMint(to, ids, amounts, data);
}
function burnBatch(
address from,
uint256[] calldata ids,
uint256[] calldata amounts
) external onlyRole(MINTER_ROLE) {
_batchBurn(from, ids, amounts);
}
function burn(
address from,
uint256 id,
uint256 amount
) external onlyRole(MINTER_ROLE) {
_burn(from, id, amount);
}
function uri(uint256 id) public view override returns (string memory) {}
function supportsInterface(bytes4 interfaceId)
public
pure
override(AccessControl, ERC1155)
returns (bool)
{
return
interfaceId == 0x01ffc9a7 ||
interfaceId == 0xd9b67a26 ||
interfaceId == 0x0e89341c;
}
}
文件 12 的 38：ERC1155Supply.sol
pragma solidity ^0.8.0;
import "../ERC1155.sol";
abstract contract ERC1155Supply is ERC1155 {
mapping(uint256 => uint256) private _totalSupply;
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
function exists(uint256 id) public view virtual returns (bool) {
return ERC1155Supply.totalSupply(id) > 0;
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
if (from == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] += amounts[i];
}
}
if (to == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 supply = _totalSupply[id];
require(supply >= amount, "ERC1155: burn amount exceeds totalSupply");
unchecked {
_totalSupply[id] = supply - amount;
}
}
}
}
}
文件 13 的 38：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 14 的 38：ERC20.sol
pragma solidity >=0.8.0;
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)
)
);
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
文件 15 的 38：ERC20SnapshotSolmate.sol
pragma solidity ^0.8.0;
import {Arrays} from "openzeppelin-contracts/contracts/utils/Arrays.sol";
import {Counters} from "openzeppelin-contracts/contracts/utils/Counters.sol";
import {ECDSA} from "openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol";
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(
address indexed owner,
address indexed spender,
uint256 amount
);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount)
public
virtual
returns (bool)
{
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function _approve(
address owner,
address spender,
uint256 amount
) internal {
allowance[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function transfer(address to, uint256 amount)
public
virtual
returns (bool)
{
_beforeTokenTransfer(msg.sender, to, amount);
balanceOf[msg.sender] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
_beforeTokenTransfer(from, to, amount);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max)
allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ECDSA.recover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
require(
recoveredAddress != address(0) && recoveredAddress == owner,
"INVALID_SIGNER"
);
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return
block.chainid == INITIAL_CHAIN_ID
? INITIAL_DOMAIN_SEPARATOR
: computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(
abi.encode(
keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)
)
);
}
function _mint(address to, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), to, amount);
totalSupply += amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
_beforeTokenTransfer(from, address(0), amount);
balanceOf[from] -= amount;
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract ERC20SnapshotSolmate is ERC20 {
using Arrays for uint256[];
using Counters for Counters.Counter;
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping(address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnapshots;
Counters.Counter private _currentSnapshotId;
event Snapshot(uint256 id);
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) ERC20(_name, _symbol, _decimals) {}
function _snapshot() internal virtual returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _getCurrentSnapshotId();
emit Snapshot(currentId);
return currentId;
}
function _getCurrentSnapshotId() internal view virtual returns (uint256) {
return _currentSnapshotId.current();
}
function balanceOfAt(address account, uint256 snapshotId)
public
view
virtual
returns (uint256)
{
(bool snapshotted, uint256 value) = _valueAt(
snapshotId,
_accountBalanceSnapshots[account]
);
return snapshotted ? value : balanceOf[account];
}
function totalSupplyAt(uint256 snapshotId)
public
view
virtual
returns (uint256)
{
(bool snapshotted, uint256 value) = _valueAt(
snapshotId,
_totalSupplySnapshots
);
return snapshotted ? value : totalSupply;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
_updateAccountSnapshot(to);
_updateTotalSupplySnapshot();
} else if (to == address(0)) {
_updateAccountSnapshot(from);
_updateTotalSupplySnapshot();
} else {
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
}
}
function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
private
view
returns (bool, uint256)
{
require(snapshotId > 0, "ERC20Snapshot: id is 0");
require(
snapshotId <= _getCurrentSnapshotId(),
"ERC20Snapshot: nonexistent id"
);
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (index == snapshots.ids.length) {
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf[account]);
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnapshots, totalSupply);
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue)
private
{
uint256 currentId = _getCurrentSnapshotId();
if (_lastSnapshotId(snapshots.ids) < currentId) {
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids)
private
view
returns (uint256)
{
uint256 idsLen = ids.length;
if (idsLen == 0) {
return 0;
} else {
return ids[idsLen - 1];
}
}
}
文件 16 的 38：ERC4626.sol
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
import {SafeTransferLib} from "../utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "../utils/FixedPointMathLib.sol";
abstract contract ERC4626 is ERC20 {
using SafeTransferLib for ERC20;
using FixedPointMathLib for uint256;
event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed caller,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
ERC20 public immutable asset;
constructor(
ERC20 _asset,
string memory _name,
string memory _symbol
) ERC20(_name, _symbol, _asset.decimals()) {
asset = _asset;
}
function deposit(uint256 assets, address receiver) public virtual returns (uint256 shares) {
require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES");
asset.safeTransferFrom(msg.sender, address(this), assets);
_mint(receiver, shares);
emit Deposit(msg.sender, receiver, assets, shares);
afterDeposit(assets, shares);
}
function mint(uint256 shares, address receiver) public virtual returns (uint256 assets) {
assets = previewMint(shares);
asset.safeTransferFrom(msg.sender, address(this), assets);
_mint(receiver, shares);
emit Deposit(msg.sender, receiver, assets, shares);
afterDeposit(assets, shares);
}
function withdraw(
uint256 assets,
address receiver,
address owner
) public virtual returns (uint256 shares) {
shares = previewWithdraw(assets);
if (msg.sender != owner) {
uint256 allowed = allowance[owner][msg.sender];
if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares;
}
beforeWithdraw(assets, shares);
_burn(owner, shares);
emit Withdraw(msg.sender, receiver, owner, assets, shares);
asset.safeTransfer(receiver, assets);
}
function redeem(
uint256 shares,
address receiver,
address owner
) public virtual returns (uint256 assets) {
if (msg.sender != owner) {
uint256 allowed = allowance[owner][msg.sender];
if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares;
}
require((assets = previewRedeem(shares)) != 0, "ZERO_ASSETS");
beforeWithdraw(assets, shares);
_burn(owner, shares);
emit Withdraw(msg.sender, receiver, owner, assets, shares);
asset.safeTransfer(receiver, assets);
}
function totalAssets() public view virtual returns (uint256);
function convertToShares(uint256 assets) public view virtual returns (uint256) {
uint256 supply = totalSupply;
return supply == 0 ? assets : assets.mulDivDown(supply, totalAssets());
}
function convertToAssets(uint256 shares) public view virtual returns (uint256) {
uint256 supply = totalSupply;
return supply == 0 ? shares : shares.mulDivDown(totalAssets(), supply);
}
function previewDeposit(uint256 assets) public view virtual returns (uint256) {
return convertToShares(assets);
}
function previewMint(uint256 shares) public view virtual returns (uint256) {
uint256 supply = totalSupply;
return supply == 0 ? shares : shares.mulDivUp(totalAssets(), supply);
}
function previewWithdraw(uint256 assets) public view virtual returns (uint256) {
uint256 supply = totalSupply;
return supply == 0 ? assets : assets.mulDivUp(supply, totalAssets());
}
function previewRedeem(uint256 shares) public view virtual returns (uint256) {
return convertToAssets(shares);
}
function maxDeposit(address) public view virtual returns (uint256) {
return type(uint256).max;
}
function maxMint(address) public view virtual returns (uint256) {
return type(uint256).max;
}
function maxWithdraw(address owner) public view virtual returns (uint256) {
return convertToAssets(balanceOf[owner]);
}
function maxRedeem(address owner) public view virtual returns (uint256) {
return balanceOf[owner];
}
function beforeWithdraw(uint256 assets, uint256 shares) internal virtual {}
function afterDeposit(uint256 assets, uint256 shares) internal virtual {}
}
文件 17 的 38：FixedPointMathLib.sol
pragma solidity >=0.8.0;
library FixedPointMathLib {
uint256 internal constant MAX_UINT256 = 2**256 - 1;
uint256 internal constant WAD = 1e18;
function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivDown(x, y, WAD);
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivUp(x, y, WAD);
}
function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivDown(x, WAD, y);
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivUp(x, WAD, y);
}
function mulDivDown(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 z) {
assembly {
if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
revert(0, 0)
}
z := div(mul(x, y), denominator)
}
}
function mulDivUp(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 z) {
assembly {
if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
revert(0, 0)
}
z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
}
}
function rpow(
uint256 x,
uint256 n,
uint256 scalar
) internal pure returns (uint256 z) {
assembly {
switch x
case 0 {
switch n
case 0 {
z := scalar
}
default {
z := 0
}
}
default {
switch mod(n, 2)
case 0 {
z := scalar
}
default {
z := x
}
let half := shr(1, scalar)
for {
n := shr(1, n)
} n {
n := shr(1, n)
} {
if shr(128, x) {
revert(0, 0)
}
let xx := mul(x, x)
let xxRound := add(xx, half)
if lt(xxRound, xx) {
revert(0, 0)
}
x := div(xxRound, scalar)
if mod(n, 2) {
let zx := mul(z, x)
if iszero(eq(div(zx, x), z)) {
if iszero(iszero(x)) {
revert(0, 0)
}
}
let zxRound := add(zx, half)
if lt(zxRound, zx) {
revert(0, 0)
}
z := div(zxRound, scalar)
}
}
}
}
}
function sqrt(uint256 x) internal pure returns (uint256 z) {
assembly {
let y := x
z := 181
if iszero(lt(y, 0x10000000000000000000000000000000000)) {
y := shr(128, y)
z := shl(64, z)
}
if iszero(lt(y, 0x1000000000000000000)) {
y := shr(64, y)
z := shl(32, z)
}
if iszero(lt(y, 0x10000000000)) {
y := shr(32, y)
z := shl(16, z)
}
if iszero(lt(y, 0x1000000)) {
y := shr(16, y)
z := shl(8, z)
}
z := shr(18, mul(z, add(y, 65536)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := sub(z, lt(div(x, z), z))
}
}
function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mod(x, y)
}
}
function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
assembly {
r := div(x, y)
}
}
function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(gt(mod(x, y), 0), div(x, y))
}
}
}
文件 18 的 38：IAccessControl.sol
pragma solidity ^0.8.0;
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 19 的 38：IERC1155.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 20 的 38：IERC1155MetadataURI.sol
pragma solidity ^0.8.0;
import "../IERC1155.sol";
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
文件 21 的 38：IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 22 的 38：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 23 的 38：IRLBTRFLY.sol
pragma solidity 0.8.17;
interface IRLBTRFLY {
struct LockedBalance {
uint224 amount;
uint32 unlockTime;
}
function lock(address account, uint256 amount) external;
function lockedBalances(address account)
external
view
returns (
uint256 total,
uint256 unlockable,
uint256 locked,
LockedBalance[] memory lockData
);
function lockedBalanceOf(address account)
external
view
returns (uint256 amount);
function processExpiredLocks(bool relock) external;
function shutdown() external;
}
文件 24 的 38：IRewardDistributor.sol
pragma solidity 0.8.17;
interface IRewardDistributor {
struct Distribution {
address token;
bytes32 merkleRoot;
bytes32 proof;
}
struct Claim {
address token;
address account;
uint256 amount;
bytes32[] merkleProof;
}
function claim(Claim[] calldata claims) external;
function updateRewardsMetadata(Distribution[] calldata distributions)
external;
function claimed(address token, address account)
external
view
returns (uint256 amount);
}
文件 25 的 38：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);
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);
}
}
}
文件 26 的 38：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);
}
}
文件 27 的 38：Pausable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 28 的 38：PirexBtrfly.sol
pragma solidity 0.8.17;
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Bytes32AddressLib} from "solmate/utils/Bytes32AddressLib.sol";
import {PirexBtrflyBase} from "src/PirexBtrflyBase.sol";
import {PxBtrfly} from "src/PxBtrfly.sol";
import {PirexFees} from "src/PirexFees.sol";
import {UnionPirexVault} from "src/vault/UnionPirexVault.sol";
import {ERC1155Solmate} from "src/tokens/ERC1155Solmate.sol";
import {ERC1155PresetMinterSupply} from "src/tokens/ERC1155PresetMinterSupply.sol";
import {IRewardDistributor} from "src/interfaces/IRewardDistributor.sol";
import {IRLBTRFLY} from "src/interfaces/IRLBTRFLY.sol";
contract PirexBtrfly is ReentrancyGuard, PirexBtrflyBase {
using SafeTransferLib for ERC20;
using Bytes32AddressLib for address;
struct EmergencyMigration {
address recipient;
address[] tokens;
}
enum Futures {
Vote,
Reward
}
enum Contract {
PxBtrfly,
PirexFees,
RewardDistributor,
UpxBtrfly,
SpxBtrfly,
VpxBtrfly,
RpxBtrfly,
UnionPirexVault
}
enum Fees {
Reward,
RedemptionMax,
RedemptionMin,
Developers
}
uint32 public constant EPOCH_DURATION = 2 weeks;
uint32 public constant FEE_DENOMINATOR = 1_000_000;
uint32 public constant FEE_MAX = 100_000;
uint32 public constant MAX_REDEMPTION_TIME = 17 weeks;
bytes private constant UNUSED_1155_DATA = "";
PxBtrfly public pxBtrfly;
PirexFees public pirexFees;
IRewardDistributor public rewardDistributor;
ERC1155Solmate public upxBtrfly;
ERC1155Solmate public spxBtrfly;
ERC1155PresetMinterSupply public vpxBtrfly;
ERC1155PresetMinterSupply public rpxBtrfly;
UnionPirexVault public unionPirex;
mapping(Fees => uint32) public fees;
mapping(uint256 => uint256) public redemptions;
mapping(address => address) public rewardForwarding;
mapping(address => bool) public developers;
EmergencyMigration public emergencyMigration;
address public emergencyExecutor;
bool public upxBtrflyDeprecated;
event SetContract(Contract indexed c, address contractAddress);
event SetFee(Fees indexed f, uint32 fee);
event AddDeveloper(address developer);
event RemoveDeveloper(address developer);
event MintFutures(
uint256 rounds,
Futures indexed f,
uint256 assets,
address indexed receiver
);
event Deposit(
uint256 assets,
address indexed receiver,
bool indexed shouldCompound,
address indexed developer
);
event InitiateRedemptions(
uint256[] lockIndexes,
Futures indexed f,
uint256[] assets,
address indexed receiver
);
event Redeem(
uint256[] unlockTimes,
uint256[] assets,
address indexed receiver,
bool legacy
);
event Stake(
uint256 rounds,
Futures indexed f,
uint256 assets,
address indexed receiver
);
event Unstake(uint256 id, uint256 assets, address indexed receiver);
event ClaimReward(address indexed token, uint256 amount);
event RedeemSnapshotRewards(
uint256 indexed epoch,
uint256[] rewardIndexes,
address indexed receiver,
uint256 snapshotBalance,
uint256 snapshotSupply
);
event RedeemFuturesRewards(
uint256 indexed epoch,
address indexed receiver,
bytes32[] rewards
);
event ExchangeFutures(
uint256 indexed epoch,
uint256 amount,
address indexed receiver,
Futures f
);
event SetRewardForwarding(address account, address to);
event UnsetRewardForwarding(address account);
event InitializeEmergencyExecutor(address _emergencyExecutor);
event SetEmergencyMigration(EmergencyMigration _emergencyMigration);
event SetUpxBtrflyDeprecated(bool state);
event ExecuteEmergencyMigration(address recipient, address[] tokens);
error ZeroAmount();
error BeforeUnlock();
error InsufficientBalance();
error AlreadyRedeemed();
error InsufficientRedemptionAllowance();
error PastExchangePeriod();
error InvalidFee();
error BeforeStakingExpiry();
error InvalidEpoch();
error EmptyArray();
error MismatchedArrayLengths();
error NoRewards();
error RedeemClosed();
error AlreadyInitialized();
error NoEmergencyExecutor();
error InvalidEmergencyMigration();
error NotAuthorized();
error NotContract();
error ForwardingNotSet();
constructor(
address _btrflyV2,
address _rlBtrfly,
address _pxBtrfly,
address _upxBtrfly,
address _spxBtrfly,
address _vpxBtrfly,
address _rpxBtrfly,
address _pirexFees,
address _rewardDistributor
) PirexBtrflyBase(_btrflyV2, _rlBtrfly) {
_pause();
if (_pxBtrfly == address(0)) revert ZeroAddress();
if (_pirexFees == address(0)) revert ZeroAddress();
if (_upxBtrfly == address(0)) revert ZeroAddress();
if (_spxBtrfly == address(0)) revert ZeroAddress();
if (_vpxBtrfly == address(0)) revert ZeroAddress();
if (_rpxBtrfly == address(0)) revert ZeroAddress();
if (_rewardDistributor == address(0)) revert ZeroAddress();
pxBtrfly = PxBtrfly(_pxBtrfly);
pirexFees = PirexFees(_pirexFees);
upxBtrfly = ERC1155Solmate(_upxBtrfly);
spxBtrfly = ERC1155Solmate(_spxBtrfly);
vpxBtrfly = ERC1155PresetMinterSupply(_vpxBtrfly);
rpxBtrfly = ERC1155PresetMinterSupply(_rpxBtrfly);
rewardDistributor = IRewardDistributor(_rewardDistributor);
}
function setContract(Contract c, address contractAddress)
external
onlyOwner
{
if (contractAddress == address(0)) revert ZeroAddress();
emit SetContract(c, contractAddress);
if (c == Contract.PxBtrfly) {
pxBtrfly = PxBtrfly(contractAddress);
return;
}
if (c == Contract.PirexFees) {
pirexFees = PirexFees(contractAddress);
return;
}
if (c == Contract.RewardDistributor) {
rewardDistributor = IRewardDistributor(contractAddress);
return;
}
if (c == Contract.UpxBtrfly) {
upxBtrfly = ERC1155Solmate(contractAddress);
return;
}
if (c == Contract.SpxBtrfly) {
spxBtrfly = ERC1155Solmate(contractAddress);
return;
}
if (c == Contract.VpxBtrfly) {
vpxBtrfly = ERC1155PresetMinterSupply(contractAddress);
return;
}
if (c == Contract.RpxBtrfly) {
rpxBtrfly = ERC1155PresetMinterSupply(contractAddress);
return;
}
ERC20 pxBtrflyERC20 = ERC20(address(pxBtrfly));
address oldUnionPirex = address(unionPirex);
if (oldUnionPirex != address(0)) {
pxBtrflyERC20.safeApprove(oldUnionPirex, 0);
}
unionPirex = UnionPirexVault(contractAddress);
pxBtrflyERC20.safeApprove(address(unionPirex), type(uint256).max);
}
function setFee(Fees f, uint32 fee) external onlyOwner {
if (fee > FEE_MAX) revert InvalidFee();
if (f == Fees.RedemptionMax && fee < fees[Fees.RedemptionMin])
revert InvalidFee();
if (f == Fees.RedemptionMin && fee > fees[Fees.RedemptionMax])
revert InvalidFee();
fees[f] = fee;
emit SetFee(f, fee);
}
function addDeveloper(address developer) external onlyOwner {
if (developer == address(0)) revert ZeroAddress();
developers[developer] = true;
emit AddDeveloper(developer);
}
function removeDeveloper(address developer) external onlyOwner {
if (developer == address(0)) revert ZeroAddress();
developers[developer] = false;
emit RemoveDeveloper(developer);
}
function getCurrentEpoch() public view returns (uint256) {
return (block.timestamp / EPOCH_DURATION) * EPOCH_DURATION;
}
function _mintFutures(
uint256 rounds,
Futures f,
uint256 assets,
address receiver
) internal {
emit MintFutures(rounds, f, assets, receiver);
ERC1155PresetMinterSupply token = f == Futures.Vote
? vpxBtrfly
: rpxBtrfly;
uint256 startingEpoch = getCurrentEpoch() + EPOCH_DURATION;
uint256[] memory tokenIds = new uint256[](rounds);
uint256[] memory amounts = new uint256[](rounds);
for (uint256 i; i < rounds; ++i) {
tokenIds[i] = startingEpoch + i * EPOCH_DURATION;
amounts[i] = assets;
}
token.mintBatch(receiver, tokenIds, amounts, UNUSED_1155_DATA);
}
function _redeem(
uint256[] calldata unlockTimes,
uint256[] calldata assets,
address receiver,
bool legacy
) internal {
uint256 unlockLen = unlockTimes.length;
if (unlockLen == 0) revert EmptyArray();
if (unlockLen != assets.length) revert MismatchedArrayLengths();
if (receiver == address(0)) revert ZeroAddress();
emit Redeem(unlockTimes, assets, receiver, legacy);
uint256 totalAssets;
for (uint256 i; i < unlockLen; ++i) {
uint256 asset = assets[i];
if (!legacy && unlockTimes[i] > block.timestamp)
revert BeforeUnlock();
if (asset == 0) revert ZeroAmount();
totalAssets += asset;
}
if (!legacy) {
_lock();
}
outstandingRedemptions -= totalAssets;
upxBtrfly.burnBatch(msg.sender, unlockTimes, assets);
btrflyV2.safeTransfer(receiver, totalAssets);
}
function _redeemSnapshotRewards(
uint256 epoch,
uint256[] memory rewardIndexes,
address account,
address receiver
) internal {
uint256 rewardLen = rewardIndexes.length;
if (epoch == 0) revert InvalidEpoch();
if (rewardLen == 0) revert EmptyArray();
(
uint256 snapshotId,
bytes32[] memory rewards,
uint256[] memory snapshotRewards,
) = pxBtrfly.getEpoch(epoch);
uint256 redeemed = pxBtrfly.getEpochRedeemedSnapshotRewards(
account,
epoch
);
uint256 snapshotBalance = pxBtrfly.balanceOfAt(account, snapshotId);
uint256 snapshotSupply = pxBtrfly.totalSupplyAt(snapshotId);
if (snapshotBalance == 0) revert InsufficientBalance();
emit RedeemSnapshotRewards(
epoch,
rewardIndexes,
receiver,
snapshotBalance,
snapshotSupply
);
for (uint256 i; i < rewardLen; ++i) {
uint256 index = rewardIndexes[i];
uint256 indexRedeemed = (1 << index);
address token = address(uint160(bytes20(rewards[index])));
uint256 rewardAmount = (snapshotRewards[index] * snapshotBalance) /
snapshotSupply;
if ((redeemed & indexRedeemed) != 0) revert AlreadyRedeemed();
if (rewardAmount != 0) {
redeemed |= indexRedeemed;
ERC20(token).safeTransfer(receiver, rewardAmount);
if (token == address(btrflyV2)) {
pendingBaseRewards -= rewardAmount;
}
}
}
pxBtrfly.setEpochRedeemedSnapshotRewards(account, epoch, redeemed);
}
function _redeemFuturesRewards(uint256 epoch, address receiver) internal {
if (epoch == 0) revert InvalidEpoch();
if (epoch > getCurrentEpoch()) revert InvalidEpoch();
if (receiver == address(0)) revert ZeroAddress();
(
,
bytes32[] memory rewards,
,
uint256[] memory futuresRewards
) = pxBtrfly.getEpoch(epoch);
if (rewards.length == 0) revert NoRewards();
emit RedeemFuturesRewards(epoch, receiver, rewards);
uint256 rpxBtrflyBalance = rpxBtrfly.balanceOf(msg.sender, epoch);
if (rpxBtrflyBalance == 0) revert InsufficientBalance();
uint256 rpxBtrflyTotalSupply = rpxBtrfly.totalSupply(epoch);
rpxBtrfly.burn(msg.sender, epoch, rpxBtrflyBalance);
uint256 rLen = rewards.length;
for (uint256 i; i < rLen; ++i) {
address token = address(uint160(bytes20(rewards[i])));
uint256 rewardAmount = (futuresRewards[i] * rpxBtrflyBalance) /
rpxBtrflyTotalSupply;
futuresRewards[i] -= rewardAmount;
ERC20(token).safeTransfer(receiver, rewardAmount);
if (token == address(btrflyV2)) {
pendingBaseRewards -= rewardAmount;
}
}
pxBtrfly.updateEpochFuturesRewards(epoch, futuresRewards);
}
function _getRewardIndexes(uint256 epoch)
internal
view
returns (uint256[] memory rewardIndexes)
{
(, bytes32[] memory rewards, , ) = pxBtrfly.getEpoch(epoch);
uint256 tLen = rewards.length;
rewardIndexes = new uint256[](tLen);
for (uint256 i; i < tLen; ++i) {
rewardIndexes[i] = i;
}
}
function _calculateRewards(
uint32 feePercent,
uint256 snapshotSupply,
uint256 rpxBtrflySupply,
uint256 received
)
internal
pure
returns (
uint256 rewardFee,
uint256 snapshotRewards,
uint256 futuresRewards
)
{
rewardFee = (received * feePercent) / FEE_DENOMINATOR;
uint256 rewards = received - rewardFee;
snapshotRewards =
(rewards * snapshotSupply) /
(snapshotSupply + rpxBtrflySupply);
futuresRewards = rewards - snapshotRewards;
}
function deposit(
uint256 assets,
address receiver,
bool shouldCompound,
address developer
) external whenNotPaused nonReentrant {
if (assets == 0) revert ZeroAmount();
if (receiver == address(0)) revert ZeroAddress();
emit Deposit(assets, receiver, shouldCompound, developer);
pendingLocks += assets;
uint256 developerIncentive = developer != address(0) &&
developers[developer]
? (assets * fees[Fees.Developers]) / FEE_DENOMINATOR
: 0;
pxBtrfly.takeEpochSnapshot();
pxBtrfly.mint(
shouldCompound ? address(this) : receiver,
assets - developerIncentive
);
btrflyV2.safeTransferFrom(msg.sender, address(this), assets);
if (developerIncentive != 0) {
pxBtrfly.mint(developer, developerIncentive);
}
if (shouldCompound) {
assets -= developerIncentive;
unionPirex.deposit(assets, receiver);
}
}
function _initiateRedemption(
IRLBTRFLY.LockedBalance memory lockData,
Futures f,
uint256 assets,
address receiver,
uint256 feeMin,
uint256 feeMax
) internal returns (uint256 feeAmount) {
if (assets == 0) revert ZeroAmount();
if (receiver == address(0)) revert ZeroAddress();
uint256 unlockTime = lockData.unlockTime;
uint256 waitTime = unlockTime - block.timestamp;
if (feeMax != 0) {
uint256 feePercent = feeMax -
(((feeMax - feeMin) * waitTime) / MAX_REDEMPTION_TIME);
feeAmount = (assets * feePercent) / FEE_DENOMINATOR;
}
uint256 postFeeAmount = assets - feeAmount;
redemptions[unlockTime] += postFeeAmount;
if (redemptions[unlockTime] > lockData.amount)
revert InsufficientRedemptionAllowance();
outstandingRedemptions += postFeeAmount;
upxBtrfly.mint(receiver, unlockTime, postFeeAmount, UNUSED_1155_DATA);
uint256 rounds = waitTime / EPOCH_DURATION;
if (
rounds == 0 &&
unlockTime % EPOCH_DURATION != 0 &&
waitTime > (EPOCH_DURATION / 2)
) {
unchecked {
++rounds;
}
}
_mintFutures(rounds, f, assets, receiver);
return feeAmount;
}
function initiateRedemptions(
uint256[] calldata lockIndexes,
Futures f,
uint256[] calldata assets,
address receiver
) external whenNotPaused nonReentrant {
uint256 lockLen = lockIndexes.length;
if (lockLen == 0) revert EmptyArray();
if (lockLen != assets.length) revert MismatchedArrayLengths();
emit InitiateRedemptions(lockIndexes, f, assets, receiver);
(, , , IRLBTRFLY.LockedBalance[] memory lockData) = rlBtrfly
.lockedBalances(address(this));
uint256 totalAssets;
uint256 feeAmount;
uint256 feeMin = fees[Fees.RedemptionMin];
uint256 feeMax = fees[Fees.RedemptionMax];
for (uint256 i; i < lockLen; ++i) {
totalAssets += assets[i];
feeAmount += _initiateRedemption(
lockData[lockIndexes[i]],
f,
assets[i],
receiver,
feeMin,
feeMax
);
}
pxBtrfly.burn(msg.sender, totalAssets - feeAmount);
if (feeAmount != 0) {
pxBtrfly.operatorApprove(msg.sender, address(pirexFees), feeAmount);
pirexFees.distributeFees(msg.sender, address(pxBtrfly), feeAmount);
}
}
function redeem(
uint256[] calldata unlockTimes,
uint256[] calldata assets,
address receiver
) external whenNotPaused nonReentrant {
if (upxBtrflyDeprecated) revert RedeemClosed();
_redeem(unlockTimes, assets, receiver, false);
}
function redeemLegacy(
uint256[] calldata unlockTimes,
uint256[] calldata assets,
address receiver
) external whenPaused nonReentrant {
if (!upxBtrflyDeprecated) revert RedeemClosed();
_redeem(unlockTimes, assets, receiver, true);
}
function stake(
uint256 rounds,
Futures f,
uint256 assets,
address receiver
) external whenNotPaused nonReentrant {
if (rounds == 0) revert ZeroAmount();
if (assets == 0) revert ZeroAmount();
if (receiver == address(0)) revert ZeroAddress();
pxBtrfly.burn(msg.sender, assets);
emit Stake(rounds, f, assets, receiver);
spxBtrfly.mint(
receiver,
getCurrentEpoch() + EPOCH_DURATION * rounds,
assets,
UNUSED_1155_DATA
);
_mintFutures(rounds, f, assets, receiver);
}
function unstake(
uint256 id,
uint256 assets,
address receiver
) external whenNotPaused nonReentrant {
if (id > block.timestamp) revert BeforeStakingExpiry();
if (assets == 0) revert ZeroAmount();
if (receiver == address(0)) revert ZeroAddress();
pxBtrfly.mint(receiver, assets);
emit Unstake(id, assets, receiver);
spxBtrfly.burn(msg.sender, id, assets);
}
function claimRewards(IRewardDistributor.Claim[] calldata claims)
external
whenNotPaused
nonReentrant
{
uint256 tLen = claims.length;
if (tLen == 0) revert EmptyArray();
pxBtrfly.takeEpochSnapshot();
uint256 epoch = getCurrentEpoch();
(uint256 snapshotId, , , ) = pxBtrfly.getEpoch(epoch);
uint256 rpxBtrflySupply = rpxBtrfly.totalSupply(epoch);
for (uint256 i; i < tLen; ++i) {
address token = claims[i].token;
uint256 amount = claims[i].amount;
bytes32[] memory merkleProof = claims[i].merkleProof;
ERC20 t = ERC20(token);
if (token == address(0)) revert ZeroAddress();
uint256 claimable = amount -
pxBtrfly.cumulativeRewardsByToken(token);
if (claimable == 0) revert ZeroAmount();
if (rewardDistributor.claimed(token, address(this)) < amount) {
IRewardDistributor.Claim[]
memory params = new IRewardDistributor.Claim[](1);
params[0].token = token;
params[0].account = address(this);
params[0].amount = amount;
params[0].merkleProof = merkleProof;
rewardDistributor.claim(params);
}
pxBtrfly.updateCumulativeRewardsByToken(token, amount);
emit ClaimReward(token, amount);
(
uint256 rewardFee,
uint256 snapshotRewards,
uint256 futuresRewards
) = _calculateRewards(
fees[Fees.Reward],
pxBtrfly.totalSupplyAt(snapshotId),
rpxBtrflySupply,
claimable
);
if (token == address(btrflyV2)) {
pendingBaseRewards += snapshotRewards + futuresRewards;
}
pxBtrfly.addEpochRewardMetadata(
epoch,
token.fillLast12Bytes(),
snapshotRewards,
futuresRewards
);
t.safeApprove(address(pirexFees), rewardFee);
pirexFees.distributeFees(address(this), token, rewardFee);
}
}
function redeemSnapshotRewards(
uint256 epoch,
uint256[] calldata rewardIndexes,
address receiver
) external whenNotPaused nonReentrant {
if (receiver == address(0)) revert ZeroAddress();
_redeemSnapshotRewards(epoch, rewardIndexes, msg.sender, receiver);
}
function redeemSnapshotRewardsPrivileged(
uint256 epoch,
uint256[] calldata rewardIndexes,
address lpContract
) external whenNotPaused nonReentrant onlyOwner {
address receiver = rewardForwarding[lpContract];
if (receiver == address(0)) revert ForwardingNotSet();
_redeemSnapshotRewards(epoch, rewardIndexes, lpContract, receiver);
}
function bulkRedeemSnapshotRewards(
uint256[] calldata epochs,
address receiver
) external whenNotPaused nonReentrant {
uint256 eLen = epochs.length;
if (eLen == 0) revert EmptyArray();
if (receiver == address(0)) revert ZeroAddress();
for (uint256 i; i < eLen; ++i) {
uint256 epoch = epochs[i];
_redeemSnapshotRewards(
epoch,
_getRewardIndexes(epoch),
msg.sender,
receiver
);
}
}
function bulkRedeemSnapshotRewardsPrivileged(
uint256[] calldata epochs,
address lpContract
) external whenNotPaused nonReentrant onlyOwner {
uint256 eLen = epochs.length;
address receiver = rewardForwarding[lpContract];
if (eLen == 0) revert EmptyArray();
if (receiver == address(0)) revert ForwardingNotSet();
for (uint256 i; i < eLen; ++i) {
uint256 epoch = epochs[i];
_redeemSnapshotRewards(
epoch,
_getRewardIndexes(epoch),
lpContract,
receiver
);
}
}
function redeemFuturesRewards(uint256 epoch, address receiver)
external
whenNotPaused
nonReentrant
{
_redeemFuturesRewards(epoch, receiver);
}
function bulkRedeemFuturesRewards(
uint256[] calldata epochs,
address receiver
) external whenNotPaused nonReentrant {
uint256 eLen = epochs.length;
if (eLen == 0) revert EmptyArray();
for (uint256 i; i < eLen; ++i) {
_redeemFuturesRewards(epochs[i], receiver);
}
}
function exchangeFutures(
uint256 epoch,
uint256 amount,
address receiver,
Futures f
) external whenNotPaused {
if (epoch <= getCurrentEpoch()) revert PastExchangePeriod();
if (amount == 0) revert ZeroAmount();
if (receiver == address(0)) revert ZeroAddress();
ERC1155PresetMinterSupply futuresIn = f == Futures.Vote
? vpxBtrfly
: rpxBtrfly;
ERC1155PresetMinterSupply futuresOut = f == Futures.Vote
? rpxBtrfly
: vpxBtrfly;
emit ExchangeFutures(epoch, amount, receiver, f);
futuresIn.burn(msg.sender, epoch, amount);
futuresOut.mint(receiver, epoch, amount, UNUSED_1155_DATA);
}
function setRewardForwarding(address lpContract, address to)
external
onlyOwner
{
if (lpContract.code.length == 0) revert NotContract();
if (to == address(0)) revert ZeroAddress();
rewardForwarding[lpContract] = to;
emit SetRewardForwarding(lpContract, to);
}
function unsetRewardForwarding(address lpContract) external onlyOwner {
if (lpContract.code.length == 0) revert NotContract();
delete rewardForwarding[lpContract];
emit UnsetRewardForwarding(lpContract);
}
function initializeEmergencyExecutor(address _emergencyExecutor)
external
onlyOwner
whenPaused
{
if (_emergencyExecutor == address(0)) revert ZeroAddress();
if (emergencyExecutor != address(0)) revert AlreadyInitialized();
emergencyExecutor = _emergencyExecutor;
emit InitializeEmergencyExecutor(_emergencyExecutor);
}
function setEmergencyMigration(
EmergencyMigration calldata _emergencyMigration
) external onlyOwner whenPaused {
if (emergencyExecutor == address(0)) revert NoEmergencyExecutor();
if (_emergencyMigration.recipient == address(0))
revert InvalidEmergencyMigration();
if (_emergencyMigration.tokens.length == 0)
revert InvalidEmergencyMigration();
emergencyMigration = _emergencyMigration;
emit SetEmergencyMigration(_emergencyMigration);
}
function executeEmergencyMigration() external whenPaused {
if (msg.sender != emergencyExecutor) revert NotAuthorized();
address migrationRecipient = emergencyMigration.recipient;
if (migrationRecipient == address(0))
revert InvalidEmergencyMigration();
address[] memory migrationTokens = emergencyMigration.tokens;
uint256 tLen = migrationTokens.length;
if (tLen == 0) revert InvalidEmergencyMigration();
uint256 o = outstandingRedemptions;
for (uint256 i; i < tLen; ++i) {
ERC20 token = ERC20(migrationTokens[i]);
uint256 balance = token.balanceOf(address(this));
if (token == btrflyV2) {
balance = balance > o ? balance - o : 0;
}
token.safeTransfer(migrationRecipient, balance);
}
emit ExecuteEmergencyMigration(migrationRecipient, migrationTokens);
}
function setUpxBtrflyDeprecated(bool state) external onlyOwner whenPaused {
upxBtrflyDeprecated = state;
emit SetUpxBtrflyDeprecated(state);
}
}
文件 29 的 38：PirexBtrflyBase.sol
pragma solidity 0.8.17;
import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
import {Pausable} from "openzeppelin-contracts/contracts/security/Pausable.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {IRLBTRFLY} from "./interfaces/IRLBTRFLY.sol";
contract PirexBtrflyBase is Ownable, Pausable {
using SafeTransferLib for ERC20;
ERC20 public immutable btrflyV2;
IRLBTRFLY public rlBtrfly;
uint256 public outstandingRedemptions;
uint256 public pendingBaseRewards;
uint256 public pendingLocks;
event SetLocker(address _rlBtrfly);
error ZeroAddress();
error EmptyString();
constructor(address _btrflyV2, address _rlBtrfly) {
if (_btrflyV2 == address(0)) revert ZeroAddress();
if (_rlBtrfly == address(0)) revert ZeroAddress();
btrflyV2 = ERC20(_btrflyV2);
rlBtrfly = IRLBTRFLY(_rlBtrfly);
btrflyV2.safeApprove(address(rlBtrfly), type(uint256).max);
}
function setLocker(address _rlBtrfly) external onlyOwner {
if (_rlBtrfly == address(0)) revert ZeroAddress();
emit SetLocker(_rlBtrfly);
btrflyV2.safeApprove(address(rlBtrfly), 0);
rlBtrfly = IRLBTRFLY(_rlBtrfly);
btrflyV2.safeApprove(_rlBtrfly, type(uint256).max);
}
function _unlock() internal {
(, uint256 unlockable, , ) = rlBtrfly.lockedBalances(address(this));
if (unlockable != 0) rlBtrfly.processExpiredLocks(false);
}
function _lock() internal {
_unlock();
uint256 balance = btrflyV2.balanceOf(address(this)) - pendingBaseRewards;
bool balanceGreaterThanRedemptions = balance > outstandingRedemptions;
if (balanceGreaterThanRedemptions || pendingLocks != 0) {
uint256 balanceRedemptionsDifference = balanceGreaterThanRedemptions
? balance - outstandingRedemptions
: 0;
rlBtrfly.lock(
address(this),
balanceRedemptionsDifference > pendingLocks
? balanceRedemptionsDifference
: pendingLocks
);
pendingLocks = 0;
}
}
function lock() external whenNotPaused {
_lock();
}
function setPauseState(bool state) external onlyOwner {
if (state) {
_pause();
} else {
_unpause();
}
}
function unlock() external whenPaused onlyOwner {
rlBtrfly.processExpiredLocks(false);
}
function pausedRelock() external whenPaused onlyOwner {
_lock();
}
}
文件 30 的 38：PirexFees.sol
pragma solidity 0.8.17;
import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
contract PirexFees is Ownable {
using SafeTransferLib for ERC20;
enum FeeRecipient {
Treasury,
Contributors
}
uint8 public constant PERCENT_DENOMINATOR = 100;
uint8 public constant MAX_TREASURY_FEE_PERCENT = 75;
uint8 public treasuryPercent = MAX_TREASURY_FEE_PERCENT;
address public treasury;
address public contributors;
event SetFeeRecipient(FeeRecipient f, address recipient);
event SetTreasuryPercent(uint8 _treasuryPercent);
event DistributeFees(address token, uint256 amount);
error ZeroAddress();
error InvalidFeePercent();
constructor(address _treasury, address _contributors) {
if (_treasury == address(0)) revert ZeroAddress();
if (_contributors == address(0)) revert ZeroAddress();
treasury = _treasury;
contributors = _contributors;
}
function setFeeRecipient(FeeRecipient f, address recipient)
external
onlyOwner
{
if (recipient == address(0)) revert ZeroAddress();
emit SetFeeRecipient(f, recipient);
if (f == FeeRecipient.Treasury) {
treasury = recipient;
return;
}
contributors = recipient;
}
function setTreasuryPercent(uint8 _treasuryPercent) external onlyOwner {
if (_treasuryPercent > MAX_TREASURY_FEE_PERCENT)
revert InvalidFeePercent();
treasuryPercent = _treasuryPercent;
emit SetTreasuryPercent(_treasuryPercent);
}
function distributeFees(
address from,
address token,
uint256 amount
) external {
emit DistributeFees(token, amount);
ERC20 t = ERC20(token);
uint256 treasuryDistribution = (amount * treasuryPercent) /
PERCENT_DENOMINATOR;
t.safeTransferFrom(from, treasury, treasuryDistribution);
t.safeTransferFrom(from, contributors, amount - treasuryDistribution);
}
}
文件 31 的 38：PxBtrfly.sol
pragma solidity 0.8.17;
import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
import {Pausable} from "openzeppelin-contracts/contracts/security/Pausable.sol";
import {ERC20SnapshotSolmate} from "src/tokens/ERC20SnapshotSolmate.sol";
contract PxBtrfly is
ERC20SnapshotSolmate("Pirex BTRFLY", "pxBTRFLY", 18),
Ownable
{
struct Epoch {
uint256 snapshotId;
bytes32[] rewards;
uint256[] snapshotRewards;
uint256[] futuresRewards;
mapping(address => uint256) redeemedSnapshotRewards;
}
address public operator;
mapping(uint256 => Epoch) private epochs;
mapping(address => uint256) public cumulativeRewardsByToken;
event SetOperator(address operator);
event UpdateEpochFuturesRewards(
uint256 indexed epoch,
uint256[] futuresRewards
);
error NotAuthorized();
error NoOperator();
error Paused();
error ZeroAddress();
error ZeroAmount();
error InvalidEpoch();
error InvalidFuturesRewards();
error MismatchedFuturesRewards();
modifier onlyOperator() {
if (msg.sender != operator) revert NotAuthorized();
_;
}
modifier onlyOperatorOrNotPaused() {
address _operator = operator;
if (_operator == address(0)) revert NoOperator();
if (msg.sender != _operator && Pausable(_operator).paused())
revert Paused();
_;
}
function setOperator(address _operator) external onlyOwner {
if (_operator == address(0)) revert ZeroAddress();
emit SetOperator(_operator);
if (operator == address(0)) {
uint256 currentEpoch = getCurrentEpoch();
epochs[currentEpoch].snapshotId = _snapshot();
}
operator = _operator;
}
function getCurrentSnapshotId() external view returns (uint256) {
return _getCurrentSnapshotId();
}
function getCurrentEpoch() public view returns (uint256) {
return (block.timestamp / 1209600) * 1209600;
}
function getEpoch(uint256 epoch)
external
view
returns (
uint256 snapshotId,
bytes32[] memory rewards,
uint256[] memory snapshotRewards,
uint256[] memory futuresRewards
)
{
Epoch storage e = epochs[epoch];
return (e.snapshotId, e.rewards, e.snapshotRewards, e.futuresRewards);
}
function getEpochRedeemedSnapshotRewards(address account, uint256 epoch)
external
view
returns (uint256)
{
return epochs[epoch].redeemedSnapshotRewards[account];
}
function addEpochRewardMetadata(
uint256 epoch,
bytes32 token,
uint256 snapshotReward,
uint256 futuresReward
) external onlyOperator {
Epoch storage e = epochs[epoch];
e.rewards.push(token);
e.snapshotRewards.push(snapshotReward);
e.futuresRewards.push(futuresReward);
}
function setEpochRedeemedSnapshotRewards(
address account,
uint256 epoch,
uint256 redeemed
) external onlyOperator {
epochs[epoch].redeemedSnapshotRewards[account] = redeemed;
}
function updateEpochFuturesRewards(
uint256 epoch,
uint256[] memory futuresRewards
) external onlyOperator {
if (epoch == 0) revert InvalidEpoch();
uint256 fLen = epochs[epoch].futuresRewards.length;
if (fLen == 0) revert InvalidEpoch();
if (futuresRewards.length == 0) revert InvalidFuturesRewards();
if (futuresRewards.length != fLen) revert MismatchedFuturesRewards();
epochs[epoch].futuresRewards = futuresRewards;
emit UpdateEpochFuturesRewards(epoch, futuresRewards);
}
function updateCumulativeRewardsByToken(address token, uint256 amount)
external
onlyOperator
{
cumulativeRewardsByToken[token] = amount;
}
function mint(address account, uint256 amount) external onlyOperator {
if (account == address(0)) revert ZeroAddress();
if (amount == 0) revert ZeroAmount();
_mint(account, amount);
}
function burn(address account, uint256 amount) external onlyOperator {
if (account == address(0)) revert ZeroAddress();
if (amount == 0) revert ZeroAmount();
_burn(account, amount);
}
function operatorApprove(
address from,
address to,
uint256 amount
) external onlyOperator {
if (from == address(0)) revert ZeroAddress();
if (to == address(0)) revert ZeroAddress();
if (amount == 0) revert ZeroAmount();
_approve(from, to, amount);
}
function takeEpochSnapshot() external onlyOperatorOrNotPaused {
uint256 currentEpoch = getCurrentEpoch();
if (epochs[currentEpoch].snapshotId == 0) {
epochs[currentEpoch].snapshotId = _snapshot();
}
}
}
文件 32 的 38：ReentrancyGuard.sol
pragma solidity >=0.8.0;
abstract contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() virtual {
require(locked == 1, "REENTRANCY");
locked = 2;
_;
locked = 1;
}
}
文件 33 的 38：SafeTransferLib.sol
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
library SafeTransferLib {
function safeTransferETH(address to, uint256 amount) internal {
bool success;
assembly {
success := call(gas(), to, amount, 0, 0, 0, 0)
}
require(success, "ETH_TRANSFER_FAILED");
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), from)
mstore(add(freeMemoryPointer, 36), to)
mstore(add(freeMemoryPointer, 68), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
)
}
require(success, "TRANSFER_FROM_FAILED");
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "TRANSFER_FAILED");
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "APPROVE_FAILED");
}
}
文件 34 的 38：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
}
}
}
文件 35 的 38：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.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 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);
}
}
文件 36 的 38：UnionPirexStaking.sol
pragma solidity 0.8.17;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
contract UnionPirexStaking is Ownable {
using SafeTransferLib for ERC20;
address public immutable vault;
ERC20 public immutable token;
uint256 public constant rewardsDuration = 14 days;
address public distributor;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public userRewardPerTokenPaid;
uint256 public rewards;
uint256 internal _totalSupply;
constructor(
address _token,
address _distributor,
address _vault
) {
token = ERC20(_token);
distributor = _distributor;
vault = _vault;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function totalSupplyWithRewards() external view returns (uint256, uint256) {
uint256 t = _totalSupply;
return (
t,
((t * (rewardPerToken() - userRewardPerTokenPaid)) / 1e18) + rewards
);
}
function lastTimeRewardApplicable() public view returns (uint256) {
return block.timestamp < periodFinish ? block.timestamp : periodFinish;
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored +
((((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate) *
1e18) / _totalSupply);
}
function earned() public view returns (uint256) {
return
((_totalSupply * (rewardPerToken() - userRewardPerTokenPaid)) /
1e18) + rewards;
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate * rewardsDuration;
}
function stake(uint256 amount) external onlyVault updateReward(vault) {
require(amount > 0, "Cannot stake 0");
_totalSupply += amount;
token.safeTransferFrom(vault, address(this), amount);
emit Staked(amount);
}
function withdraw(uint256 amount) external onlyVault updateReward(vault) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply -= amount;
token.safeTransfer(vault, amount);
emit Withdrawn(amount);
}
function getReward() external onlyVault updateReward(vault) {
uint256 reward = rewards;
if (reward > 0) {
rewards = 0;
token.safeTransfer(vault, reward);
emit RewardPaid(reward);
}
}
function notifyRewardAmount()
external
onlyDistributor
updateReward(address(0))
{
uint256 rewardBalance = token.balanceOf(address(this)) -
_totalSupply -
earned();
rewardRate = rewardBalance / rewardsDuration;
require(rewardRate != 0, "No rewards");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp + rewardsDuration;
emit RewardAdded(rewardBalance);
}
function recoverERC20(address tokenAddress, uint256 tokenAmount)
external
onlyOwner
{
require(
tokenAddress != address(token),
"Cannot withdraw the staking token"
);
ERC20(tokenAddress).safeTransfer(owner(), tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setDistributor(address _distributor) external onlyOwner {
require(_distributor != address(0));
distributor = _distributor;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards = earned();
userRewardPerTokenPaid = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(uint256 amount);
event Withdrawn(uint256 amount);
event RewardPaid(uint256 reward);
event Recovered(address token, uint256 amount);
modifier onlyDistributor() {
require((msg.sender == distributor), "Distributor only");
_;
}
modifier onlyVault() {
require((msg.sender == vault), "Vault only");
_;
}
}
文件 37 的 38：UnionPirexStrategy.sol
pragma solidity 0.8.17;
import {PirexBtrfly} from "src/PirexBtrfly.sol";
import {UnionPirexStaking} from "src/vault/UnionPirexStaking.sol";
contract UnionPirexStrategy is UnionPirexStaking {
PirexBtrfly public immutable pirexBtrfly;
error ZeroAddress();
constructor(
address _pirexBtrfly,
address pxBTRFLY,
address _distributor,
address _vault
) UnionPirexStaking(pxBTRFLY, _distributor, _vault) {
if (_pirexBtrfly == address(0)) revert ZeroAddress();
pirexBtrfly = PirexBtrfly(_pirexBtrfly);
}
function redeemRewards(uint256 epoch, uint256[] calldata rewardIndexes)
external
{
pirexBtrfly.redeemSnapshotRewards(epoch, rewardIndexes, distributor);
}
}
文件 38 的 38：UnionPirexVault.sol
pragma solidity 0.8.17;
import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
import {ERC4626} from "solmate/mixins/ERC4626.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {UnionPirexStaking} from "src/vault/UnionPirexStaking.sol";
contract UnionPirexVault is Ownable, ERC4626 {
using SafeTransferLib for ERC20;
using FixedPointMathLib for uint256;
UnionPirexStaking public strategy;
uint256 public constant MAX_WITHDRAWAL_PENALTY = 500;
uint256 public constant MAX_PLATFORM_FEE = 2000;
uint256 public constant FEE_DENOMINATOR = 10000;
uint256 public withdrawalPenalty = 300;
uint256 public platformFee = 1000;
address public platform;
event Harvest(address indexed caller, uint256 value);
event WithdrawalPenaltyUpdated(uint256 penalty);
event PlatformFeeUpdated(uint256 fee);
event PlatformUpdated(address _platform);
event StrategySet(address _strategy);
error ZeroAddress();
error ExceedsMax();
error AlreadySet();
constructor(address pxBtrfly) ERC4626(ERC20(pxBtrfly), "Autocompounding pxBTRFLY", "apxBTRFLY") {}
function setWithdrawalPenalty(uint256 penalty) external onlyOwner {
if (penalty > MAX_WITHDRAWAL_PENALTY) revert ExceedsMax();
withdrawalPenalty = penalty;
emit WithdrawalPenaltyUpdated(penalty);
}
function setPlatformFee(uint256 fee) external onlyOwner {
if (fee > MAX_PLATFORM_FEE) revert ExceedsMax();
platformFee = fee;
emit PlatformFeeUpdated(fee);
}
function setPlatform(address _platform) external onlyOwner {
if (_platform == address(0)) revert ZeroAddress();
platform = _platform;
emit PlatformUpdated(_platform);
}
function setStrategy(address _strategy) external onlyOwner {
if (_strategy == address(0)) revert ZeroAddress();
if (address(strategy) != address(0)) revert AlreadySet();
strategy = UnionPirexStaking(_strategy);
asset.safeApprove(_strategy, type(uint256).max);
emit StrategySet(_strategy);
}
function totalAssets() public view override returns (uint256) {
(uint256 _totalSupply, uint256 rewards) = strategy
.totalSupplyWithRewards();
return
_totalSupply +
(
rewards == 0
? 0
: (rewards - ((rewards * platformFee) / FEE_DENOMINATOR))
);
}
function beforeWithdraw(uint256 assets, uint256) internal override {
if (assets > strategy.totalSupply()) harvest();
strategy.withdraw(assets);
}
function afterDeposit(uint256 assets, uint256) internal override {
strategy.stake(assets);
}
function previewRedeem(uint256 shares)
public
view
override
returns (uint256)
{
uint256 assets = convertToAssets(shares);
uint256 _totalSupply = totalSupply;
uint256 penalty = (_totalSupply == 0 || _totalSupply - shares == 0)
? 0
: assets.mulDivDown(withdrawalPenalty, FEE_DENOMINATOR);
return assets - penalty;
}
function previewWithdraw(uint256 assets)
public
view
override
returns (uint256)
{
uint256 shares = convertToShares(assets);
uint256 _totalSupply = totalSupply;
return
(_totalSupply == 0 || _totalSupply - shares == 0)
? shares
: (shares * FEE_DENOMINATOR) /
(FEE_DENOMINATOR - withdrawalPenalty);
}
function harvest() public {
strategy.getReward();
uint256 rewards = asset.balanceOf(address(this));
emit Harvest(msg.sender, rewards);
if (rewards != 0) {
uint256 feeAmount = (rewards * platformFee) / FEE_DENOMINATOR;
rewards -= feeAmount;
asset.safeTransfer(platform, feeAmount);
strategy.stake(rewards);
}
}
}
{
"compilationTarget": {
"src/vault/UnionPirexStrategy.sol": "UnionPirexStrategy"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":ds-test/=lib/forge-std/lib/ds-test/src/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":solmate/=lib/solmate/src/"
]
}[{"inputs":[{"internalType":"address","name":"_pirexBtrfly","type":"address"},{"internalType":"address","name":"pxBTRFLY","type":"address"},{"internalType":"address","name":"_distributor","type":"address"},{"internalType":"address","name":"_vault","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"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":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"distributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pirexBtrfly","outputs":[{"internalType":"contract PirexBtrfly","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"epoch","type":"uint256"},{"internalType":"uint256[]","name":"rewardIndexes","type":"uint256[]"}],"name":"redeemRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_distributor","type":"address"}],"name":"setDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupplyWithRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
