编译器
0.8.24+commit.e11b9ed9
文件 1 的 53：AccessManager.sol
pragma solidity ^0.8.10;
import {OwnableRoles} from "solady/src/auth/OwnableRoles.sol";
import {Initializable} from "solady/src/utils/Initializable.sol";
import {Multicallable} from "solady/src/utils/Multicallable.sol";
import "../Constants.sol" as Constants;
import {Errors} from "../Errors.sol";
contract AccessManager is OwnableRoles, Initializable, Multicallable {
mapping(address target => mapping(bytes4 selector => uint256 roles)) private s_targets;
event TargetFunctionRolesGranted(address indexed target, bytes4 indexed selector, uint256 indexed roles);
event TargetFunctionRolesRevoked(address indexed target, bytes4 indexed selector, uint256 indexed roles);
function initializeOwner(address curator) external initializer {
_initializeOwner(curator);
}
function grantRoles(address user, uint256 roles) public payable override onlyOwnerOrCanCall {
_grantRoles(user, roles);
}
function revokeRoles(address user, uint256 roles) public payable override onlyOwnerOrCanCall {
_removeRoles(user, roles);
}
function grantTargetFunctionRoles(address target, bytes4[] calldata selectors, uint256 roles)
public
payable
onlyOwnerOrCanCall
{
uint256 length = selectors.length;
for (uint256 i = 0; i != length;) {
_grantTargetFunctionRoles(target, selectors[i], roles);
unchecked {
++i;
}
}
}
function revokeTargetFunctionRoles(address target, bytes4[] calldata selectors, uint256 roles)
public
payable
onlyOwnerOrCanCall
{
uint256 length = selectors.length;
for (uint256 i = 0; i != length;) {
_revokeTargetFunctionRoles(target, selectors[i], roles);
unchecked {
++i;
}
}
}
function _grantTargetFunctionRoles(address target, bytes4 selector, uint256 roles) internal {
s_targets[target][selector] = s_targets[target][selector] | roles;
emit TargetFunctionRolesGranted(target, selector, roles);
}
function _revokeTargetFunctionRoles(address target, bytes4 selector, uint256 roles) internal {
s_targets[target][selector] = s_targets[target][selector] & ~roles;
emit TargetFunctionRolesRevoked(target, selector, roles);
}
function canCall(address caller, address target, bytes4 selector) public view returns (bool) {
return hasAnyRole(caller, s_targets[target][selector]);
}
modifier onlyOwnerOrCanCall() {
_checkOwnerOrRoles({roles: s_targets[address(this)][bytes4(msg.data[0:4])]});
_;
}
}
abstract contract AccessManaged {
function i_accessManager() public view virtual returns (AccessManager);
modifier restricted() {
_checkRestricted(i_accessManager());
_;
}
modifier restrictedBy(AccessManager accessManager) {
_checkRestricted(accessManager);
_;
}
function _checkRestricted(AccessManager accessManager) internal view {
if (!accessManager.canCall(msg.sender, address(this), bytes4(msg.data[0:4]))) {
revert Errors.AccessManaged_Restricted();
}
}
}
文件 2 的 53：ApproxValue.sol
pragma solidity ^0.8.24;
import {ApproxValue} from "../Types.sol";
function unwrap(ApproxValue x) pure returns (uint256 result) {
result = ApproxValue.unwrap(x);
}
文件 3 的 53：BaseModule.sol
pragma solidity ^0.8.10;
import {LibClone} from "solady/src/utils/LibClone.sol";
import {Initializable} from "solady/src/utils/Initializable.sol";
import {Factory} from "../Factory.sol";
import {AccessManager, AccessManaged} from "./AccessManager.sol";
import {Errors} from "../Errors.sol";
abstract contract BaseModule is AccessManaged, Initializable {
uint256 constant CWIA_ARG_OFFSET = 0x00;
function VERSION() external pure virtual returns (bytes32);
function i_factory() public view returns (Factory) {
(bool s, bytes memory ret) = i_principalToken().staticcall(abi.encodeWithSignature("i_factory()"));
if (!s) revert Errors.Module_CallFailed();
return Factory(abi.decode(ret, (address)));
}
function i_accessManager() public view override returns (AccessManager) {
(bool s, bytes memory ret) = i_principalToken().staticcall(abi.encodeWithSignature("i_accessManager()"));
if (!s) revert Errors.Module_CallFailed();
return AccessManager(abi.decode(ret, (address)));
}
function i_principalToken() public view returns (address) {
bytes memory arg = LibClone.argsOnClone(address(this), CWIA_ARG_OFFSET, CWIA_ARG_OFFSET + 0x20);
return abi.decode(arg, (address));
}
function initialize() external virtual {
}
}
文件 4 的 53：Constants.sol
pragma solidity ^0.8.10;
uint256 constant BASIS_POINTS = 10_000;
uint256 constant WAD = 1e18;
address constant NATIVE_ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 constant FEE_MANAGER_ROLE = 1 << 0;
uint256 constant FEE_COLLECTOR_ROLE = 1 << 1;
uint256 constant DEV_ROLE = 1 << 2;
uint256 constant PAUSER_ROLE = 1 << 3;
uint256 constant GOVERNANCE_ROLE = 1 << 4;
uint256 constant CONNECTOR_REGISTRY_ROLE = 1 << 5;
uint256 constant TARGET_INDEX = 0;
uint256 constant PT_INDEX = 1;
address constant WETH_ETHEREUM_MAINNET = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint16 constant DEFAULT_SPLIT_RATIO_BPS = uint16(BASIS_POINTS);
文件 5 的 53：Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 6 的 53：CustomRevert.sol
pragma solidity ^0.8.0;
library CustomRevert {
function revertWith(bytes4 selector) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
revert(0, 0x04)
}
}
function revertWith(bytes4 selector, uint256 value) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
mstore(0x04, value)
revert(0, 0x24)
}
}
}
文件 7 的 53：DateTimeLib.sol
pragma solidity ^0.8.4;
library DateTimeLib {
uint256 internal constant MON = 1;
uint256 internal constant TUE = 2;
uint256 internal constant WED = 3;
uint256 internal constant THU = 4;
uint256 internal constant FRI = 5;
uint256 internal constant SAT = 6;
uint256 internal constant SUN = 7;
uint256 internal constant JAN = 1;
uint256 internal constant FEB = 2;
uint256 internal constant MAR = 3;
uint256 internal constant APR = 4;
uint256 internal constant MAY = 5;
uint256 internal constant JUN = 6;
uint256 internal constant JUL = 7;
uint256 internal constant AUG = 8;
uint256 internal constant SEP = 9;
uint256 internal constant OCT = 10;
uint256 internal constant NOV = 11;
uint256 internal constant DEC = 12;
uint256 internal constant MAX_SUPPORTED_YEAR = 0xffffffff;
uint256 internal constant MAX_SUPPORTED_EPOCH_DAY = 0x16d3e098039;
uint256 internal constant MAX_SUPPORTED_TIMESTAMP = 0x1e18549868c76ff;
function dateToEpochDay(uint256 year, uint256 month, uint256 day)
internal
pure
returns (uint256 epochDay)
{
assembly {
year := sub(year, lt(month, 3))
let doy := add(shr(11, add(mul(62719, mod(add(month, 9), 12)), 769)), day)
let yoe := mod(year, 400)
let doe := sub(add(add(mul(yoe, 365), shr(2, yoe)), doy), div(yoe, 100))
epochDay := sub(add(mul(div(year, 400), 146097), doe), 719469)
}
}
function epochDayToDate(uint256 epochDay)
internal
pure
returns (uint256 year, uint256 month, uint256 day)
{
assembly {
epochDay := add(epochDay, 719468)
let doe := mod(epochDay, 146097)
let yoe :=
div(sub(sub(add(doe, div(doe, 36524)), div(doe, 1460)), eq(doe, 146096)), 365)
let doy := sub(doe, sub(add(mul(365, yoe), shr(2, yoe)), div(yoe, 100)))
let mp := div(add(mul(5, doy), 2), 153)
day := add(sub(doy, shr(11, add(mul(mp, 62719), 769))), 1)
month := byte(mp, shl(160, 0x030405060708090a0b0c0102))
year := add(add(yoe, mul(div(epochDay, 146097), 400)), lt(month, 3))
}
}
function dateToTimestamp(uint256 year, uint256 month, uint256 day)
internal
pure
returns (uint256 result)
{
unchecked {
result = dateToEpochDay(year, month, day) * 86400;
}
}
function timestampToDate(uint256 timestamp)
internal
pure
returns (uint256 year, uint256 month, uint256 day)
{
(year, month, day) = epochDayToDate(timestamp / 86400);
}
function dateTimeToTimestamp(
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
) internal pure returns (uint256 result) {
unchecked {
result = dateToEpochDay(year, month, day) * 86400 + hour * 3600 + minute * 60 + second;
}
}
function timestampToDateTime(uint256 timestamp)
internal
pure
returns (
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
)
{
unchecked {
(year, month, day) = epochDayToDate(timestamp / 86400);
uint256 secs = timestamp % 86400;
hour = secs / 3600;
secs = secs % 3600;
minute = secs / 60;
second = secs % 60;
}
}
function isLeapYear(uint256 year) internal pure returns (bool leap) {
assembly {
leap := iszero(and(add(mul(iszero(mod(year, 25)), 12), 3), year))
}
}
function daysInMonth(uint256 year, uint256 month) internal pure returns (uint256 result) {
bool flag = isLeapYear(year);
assembly {
result :=
add(byte(month, shl(152, 0x1f1c1f1e1f1e1f1f1e1f1e1f)), and(eq(month, 2), flag))
}
}
function weekday(uint256 timestamp) internal pure returns (uint256 result) {
unchecked {
result = ((timestamp / 86400 + 3) % 7) + 1;
}
}
function isSupportedDate(uint256 year, uint256 month, uint256 day)
internal
pure
returns (bool result)
{
uint256 md = daysInMonth(year, month);
assembly {
result :=
and(
lt(sub(year, 1970), sub(MAX_SUPPORTED_YEAR, 1969)),
and(lt(sub(month, 1), 12), lt(sub(day, 1), md))
)
}
}
function isSupportedDateTime(
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
) internal pure returns (bool result) {
if (isSupportedDate(year, month, day)) {
assembly {
result := and(lt(hour, 24), and(lt(minute, 60), lt(second, 60)))
}
}
}
function isSupportedEpochDay(uint256 epochDay) internal pure returns (bool result) {
unchecked {
result = epochDay < MAX_SUPPORTED_EPOCH_DAY + 1;
}
}
function isSupportedTimestamp(uint256 timestamp) internal pure returns (bool result) {
unchecked {
result = timestamp < MAX_SUPPORTED_TIMESTAMP + 1;
}
}
function nthWeekdayInMonthOfYearTimestamp(uint256 year, uint256 month, uint256 n, uint256 wd)
internal
pure
returns (uint256 result)
{
uint256 d = dateToEpochDay(year, month, 1);
uint256 md = daysInMonth(year, month);
assembly {
let diff := sub(wd, add(mod(add(d, 3), 7), 1))
let date := add(mul(sub(n, 1), 7), add(mul(gt(diff, 6), 7), diff))
result := mul(mul(86400, add(date, d)), and(lt(date, md), iszero(iszero(n))))
}
}
function mondayTimestamp(uint256 timestamp) internal pure returns (uint256 result) {
uint256 t = timestamp;
assembly {
let day := div(t, 86400)
result := mul(mul(sub(day, mod(add(day, 3), 7)), 86400), gt(t, 345599))
}
}
function isWeekEnd(uint256 timestamp) internal pure returns (bool result) {
result = weekday(timestamp) > FRI;
}
function addYears(uint256 timestamp, uint256 numYears) internal pure returns (uint256 result) {
(uint256 year, uint256 month, uint256 day) = epochDayToDate(timestamp / 86400);
result = _offsetted(year + numYears, month, day, timestamp);
}
function addMonths(uint256 timestamp, uint256 numMonths)
internal
pure
returns (uint256 result)
{
(uint256 year, uint256 month, uint256 day) = epochDayToDate(timestamp / 86400);
month = _sub(month + numMonths, 1);
result = _offsetted(year + month / 12, _add(month % 12, 1), day, timestamp);
}
function addDays(uint256 timestamp, uint256 numDays) internal pure returns (uint256 result) {
result = timestamp + numDays * 86400;
}
function addHours(uint256 timestamp, uint256 numHours) internal pure returns (uint256 result) {
result = timestamp + numHours * 3600;
}
function addMinutes(uint256 timestamp, uint256 numMinutes)
internal
pure
returns (uint256 result)
{
result = timestamp + numMinutes * 60;
}
function addSeconds(uint256 timestamp, uint256 numSeconds)
internal
pure
returns (uint256 result)
{
result = timestamp + numSeconds;
}
function subYears(uint256 timestamp, uint256 numYears) internal pure returns (uint256 result) {
(uint256 year, uint256 month, uint256 day) = epochDayToDate(timestamp / 86400);
result = _offsetted(year - numYears, month, day, timestamp);
}
function subMonths(uint256 timestamp, uint256 numMonths)
internal
pure
returns (uint256 result)
{
(uint256 year, uint256 month, uint256 day) = epochDayToDate(timestamp / 86400);
uint256 yearMonth = _totalMonths(year, month) - _add(numMonths, 1);
result = _offsetted(yearMonth / 12, _add(yearMonth % 12, 1), day, timestamp);
}
function subDays(uint256 timestamp, uint256 numDays) internal pure returns (uint256 result) {
result = timestamp - numDays * 86400;
}
function subHours(uint256 timestamp, uint256 numHours) internal pure returns (uint256 result) {
result = timestamp - numHours * 3600;
}
function subMinutes(uint256 timestamp, uint256 numMinutes)
internal
pure
returns (uint256 result)
{
result = timestamp - numMinutes * 60;
}
function subSeconds(uint256 timestamp, uint256 numSeconds)
internal
pure
returns (uint256 result)
{
result = timestamp - numSeconds;
}
function diffYears(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
toTimestamp - fromTimestamp;
(uint256 fromYear,,) = epochDayToDate(fromTimestamp / 86400);
(uint256 toYear,,) = epochDayToDate(toTimestamp / 86400);
result = _sub(toYear, fromYear);
}
function diffMonths(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
toTimestamp - fromTimestamp;
(uint256 fromYear, uint256 fromMonth,) = epochDayToDate(fromTimestamp / 86400);
(uint256 toYear, uint256 toMonth,) = epochDayToDate(toTimestamp / 86400);
result = _sub(_totalMonths(toYear, toMonth), _totalMonths(fromYear, fromMonth));
}
function diffDays(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
result = (toTimestamp - fromTimestamp) / 86400;
}
function diffHours(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
result = (toTimestamp - fromTimestamp) / 3600;
}
function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
result = (toTimestamp - fromTimestamp) / 60;
}
function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp)
internal
pure
returns (uint256 result)
{
result = toTimestamp - fromTimestamp;
}
function _totalMonths(uint256 numYears, uint256 numMonths)
private
pure
returns (uint256 total)
{
unchecked {
total = numYears * 12 + numMonths;
}
}
function _add(uint256 a, uint256 b) private pure returns (uint256 c) {
unchecked {
c = a + b;
}
}
function _sub(uint256 a, uint256 b) private pure returns (uint256 c) {
unchecked {
c = a - b;
}
}
function _offsetted(uint256 year, uint256 month, uint256 day, uint256 timestamp)
private
pure
returns (uint256 result)
{
uint256 dm = daysInMonth(year, month);
if (day >= dm) {
day = dm;
}
result = dateToEpochDay(year, month, day) * 86400 + (timestamp % 86400);
}
}
文件 8 的 53：DynamicArrayLib.sol
pragma solidity ^0.8.4;
library DynamicArrayLib {
struct DynamicArray {
uint256[] data;
}
uint256 internal constant NOT_FOUND = type(uint256).max;
function malloc(uint256 n) internal pure returns (uint256[] memory result) {
assembly {
result := or(sub(0, shr(32, n)), mload(0x40))
mstore(result, n)
mstore(0x40, add(add(result, 0x20), shl(5, n)))
}
}
function zeroize(uint256[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := a
calldatacopy(add(result, 0x20), calldatasize(), shl(5, mload(result)))
}
}
function get(uint256[] memory a, uint256 i) internal pure returns (uint256 result) {
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
function getUint256(uint256[] memory a, uint256 i) internal pure returns (uint256 result) {
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
function getAddress(uint256[] memory a, uint256 i) internal pure returns (address result) {
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
function getBool(uint256[] memory a, uint256 i) internal pure returns (bool result) {
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
function getBytes32(uint256[] memory a, uint256 i) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(a, 0x20), shl(5, i)))
}
}
function set(uint256[] memory a, uint256 i, uint256 data)
internal
pure
returns (uint256[] memory result)
{
result = a;
assembly {
mstore(add(add(result, 0x20), shl(5, i)), data)
}
}
function set(uint256[] memory a, uint256 i, address data)
internal
pure
returns (uint256[] memory result)
{
result = a;
assembly {
mstore(add(add(result, 0x20), shl(5, i)), shr(96, shl(96, data)))
}
}
function set(uint256[] memory a, uint256 i, bool data)
internal
pure
returns (uint256[] memory result)
{
result = a;
assembly {
mstore(add(add(result, 0x20), shl(5, i)), iszero(iszero(data)))
}
}
function set(uint256[] memory a, uint256 i, bytes32 data)
internal
pure
returns (uint256[] memory result)
{
result = a;
assembly {
mstore(add(add(result, 0x20), shl(5, i)), data)
}
}
function asAddressArray(uint256[] memory a) internal pure returns (address[] memory result) {
assembly {
result := a
}
}
function asBoolArray(uint256[] memory a) internal pure returns (bool[] memory result) {
assembly {
result := a
}
}
function asBytes32Array(uint256[] memory a) internal pure returns (bytes32[] memory result) {
assembly {
result := a
}
}
function toUint256Array(address[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := a
}
}
function toUint256Array(bool[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := a
}
}
function toUint256Array(bytes32[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := a
}
}
function truncate(uint256[] memory a, uint256 n)
internal
pure
returns (uint256[] memory result)
{
assembly {
result := a
mstore(mul(lt(n, mload(result)), result), n)
}
}
function free(uint256[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := a
let n := mload(result)
mstore(shl(6, lt(iszero(n), eq(add(shl(5, add(1, n)), result), mload(0x40)))), result)
mstore(result, 0)
}
}
function hash(uint256[] memory a) internal pure returns (bytes32 result) {
assembly {
result := keccak256(add(a, 0x20), shl(5, mload(a)))
}
}
function slice(uint256[] memory a, uint256 start, uint256 end)
internal
pure
returns (uint256[] memory result)
{
assembly {
let arrayLen := mload(a)
if iszero(gt(arrayLen, end)) { end := arrayLen }
if iszero(gt(arrayLen, start)) { start := arrayLen }
if lt(start, end) {
result := mload(0x40)
let resultLen := sub(end, start)
mstore(result, resultLen)
a := add(a, shl(5, start))
let o := shl(5, resultLen)
mstore(0x40, add(add(result, o), 0x20))
for {} 1 {} {
mstore(add(result, o), mload(add(a, o)))
o := sub(o, 0x20)
if iszero(o) { break }
}
}
}
}
function slice(uint256[] memory a, uint256 start)
internal
pure
returns (uint256[] memory result)
{
result = slice(a, start, type(uint256).max);
}
function copy(uint256[] memory a) internal pure returns (uint256[] memory result) {
assembly {
result := mload(0x40)
let end := add(add(result, 0x20), shl(5, mload(a)))
let o := result
for { let d := sub(a, result) } 1 {} {
mstore(o, mload(add(o, d)))
o := add(0x20, o)
if eq(o, end) { break }
}
mstore(0x40, o)
}
}
function contains(uint256[] memory a, uint256 needle) internal pure returns (bool) {
return ~indexOf(a, needle, 0) != 0;
}
function indexOf(uint256[] memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
result := not(0)
if lt(from, mload(a)) {
let o := add(a, shl(5, from))
let end := add(shl(5, add(1, mload(a))), a)
let c := mload(end)
for { mstore(end, needle) } 1 {} {
o := add(o, 0x20)
if eq(mload(o), needle) { break }
}
mstore(end, c)
if iszero(eq(o, end)) { result := shr(5, sub(o, add(0x20, a))) }
}
}
}
function indexOf(uint256[] memory a, uint256 needle) internal pure returns (uint256 result) {
result = indexOf(a, needle, 0);
}
function lastIndexOf(uint256[] memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
result := not(0)
let n := mload(a)
if n {
if iszero(lt(from, n)) { from := sub(n, 1) }
let o := add(shl(5, add(2, from)), a)
for { mstore(a, needle) } 1 {} {
o := sub(o, 0x20)
if eq(mload(o), needle) { break }
}
mstore(a, n)
if iszero(eq(o, a)) { result := shr(5, sub(o, add(0x20, a))) }
}
}
}
function lastIndexOf(uint256[] memory a, uint256 needle)
internal
pure
returns (uint256 result)
{
result = lastIndexOf(a, needle, NOT_FOUND);
}
function directReturn(uint256[] memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
mstore(retStart, 0x20)
return(retStart, add(0x40, shl(5, mload(a))))
}
}
function length(DynamicArray memory a) internal pure returns (uint256) {
return a.data.length;
}
function wrap(uint256[] memory a) internal pure returns (DynamicArray memory result) {
result.data = a;
}
function wrap(address[] memory a) internal pure returns (DynamicArray memory result) {
assembly {
mstore(result, a)
}
}
function wrap(bool[] memory a) internal pure returns (DynamicArray memory result) {
assembly {
mstore(result, a)
}
}
function wrap(bytes32[] memory a) internal pure returns (DynamicArray memory result) {
assembly {
mstore(result, a)
}
}
function clear(DynamicArray memory a) internal pure returns (DynamicArray memory result) {
_deallocate(result);
result = a;
assembly {
mstore(mload(result), 0)
}
}
function free(DynamicArray memory a) internal pure returns (DynamicArray memory result) {
_deallocate(result);
result = a;
assembly {
let arrData := mload(result)
if iszero(eq(arrData, 0x60)) {
let prime := 8188386068317523
let cap := mload(sub(arrData, 0x20))
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
if lt(iszero(cap), eq(mload(0x40), add(arrData, add(0x20, cap)))) {
mstore(0x40, sub(arrData, 0x20))
}
mstore(result, 0x60)
}
}
}
function resize(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
reserve(result, n);
assembly {
let arrData := mload(result)
let arrLen := mload(arrData)
if iszero(lt(n, arrLen)) {
calldatacopy(
add(arrData, shl(5, add(1, arrLen))), calldatasize(), shl(5, sub(n, arrLen))
)
}
mstore(arrData, n)
}
}
function expand(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
if (n >= a.data.length) {
reserve(result, n);
assembly {
mstore(mload(result), n)
}
}
}
function truncate(DynamicArray memory a, uint256 n)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
mstore(mul(lt(n, mload(mload(result))), mload(result)), n)
}
}
function reserve(DynamicArray memory a, uint256 minimum)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
if iszero(lt(minimum, 0xffffffff)) { invalid() }
for { let arrData := mload(a) } 1 {} {
let prime := 8188386068317523
if eq(arrData, 0x60) {
let newCap := shl(5, add(1, minimum))
let capSlot := mload(0x40)
mstore(capSlot, mul(prime, newCap))
let newArrData := add(0x20, capSlot)
mstore(newArrData, 0)
mstore(0x40, add(newArrData, add(0x20, newCap)))
mstore(a, newArrData)
break
}
let w := not(0x1f)
let cap := mload(add(arrData, w))
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
let newCap := shl(5, minimum)
if iszero(and(gt(minimum, mload(arrData)), gt(newCap, cap))) { break }
if eq(mload(0x40), add(arrData, add(0x20, cap))) {
mstore(add(arrData, w), mul(prime, newCap))
mstore(0x40, add(arrData, add(0x20, newCap)))
break
}
let capSlot := mload(0x40)
let newArrData := add(capSlot, 0x20)
mstore(0x40, add(newArrData, add(0x20, newCap)))
mstore(a, newArrData)
for { let o := add(0x20, shl(5, mload(arrData))) } 1 {} {
mstore(add(newArrData, o), mload(add(arrData, o)))
o := add(o, w)
if iszero(o) { break }
}
mstore(capSlot, mul(prime, newCap))
mstore(newArrData, mload(arrData))
break
}
}
}
function p(DynamicArray memory a, uint256 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
let arrData := mload(a)
let newArrLen := add(mload(arrData), 1)
let newArrBytesLen := shl(5, newArrLen)
let prime := 8188386068317523
let cap := mload(sub(arrData, 0x20))
cap := mul(div(cap, prime), iszero(mod(cap, prime)))
for {} iszero(lt(newArrBytesLen, cap)) {} {
let newCap := add(cap, or(cap, newArrBytesLen))
if iszero(or(xor(mload(0x40), add(arrData, add(0x20, cap))), eq(arrData, 0x60))) {
mstore(sub(arrData, 0x20), mul(prime, newCap))
mstore(0x40, add(arrData, add(0x20, newCap)))
break
}
let newArrData := add(mload(0x40), 0x20)
mstore(0x40, add(newArrData, add(0x20, newCap)))
mstore(a, newArrData)
let w := not(0x1f)
for { let o := newArrBytesLen } 1 {} {
mstore(add(newArrData, o), mload(add(arrData, o)))
o := add(o, w)
if iszero(o) { break }
}
mstore(add(newArrData, w), mul(prime, newCap))
arrData := newArrData
break
}
mstore(add(arrData, newArrBytesLen), data)
mstore(arrData, newArrLen)
}
}
function p(DynamicArray memory a, address data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, uint256(uint160(data)));
}
function p(DynamicArray memory a, bool data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, _toUint(data));
}
function p(DynamicArray memory a, bytes32 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = p(a, uint256(data));
}
function p() internal pure returns (DynamicArray memory result) {}
function p(uint256 data) internal pure returns (DynamicArray memory result) {
p(result, uint256(data));
}
function p(address data) internal pure returns (DynamicArray memory result) {
p(result, uint256(uint160(data)));
}
function p(bool data) internal pure returns (DynamicArray memory result) {
p(result, _toUint(data));
}
function p(bytes32 data) internal pure returns (DynamicArray memory result) {
p(result, uint256(data));
}
function pop(DynamicArray memory a) internal pure returns (uint256 result) {
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
function popUint256(DynamicArray memory a) internal pure returns (uint256 result) {
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
function popAddress(DynamicArray memory a) internal pure returns (address result) {
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
function popBool(DynamicArray memory a) internal pure returns (bool result) {
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
function popBytes32(DynamicArray memory a) internal pure returns (bytes32 result) {
assembly {
let o := mload(a)
let n := mload(o)
result := mload(add(o, shl(5, n)))
mstore(o, sub(n, iszero(iszero(n))))
}
}
function get(DynamicArray memory a, uint256 i) internal pure returns (uint256 result) {
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
function getUint256(DynamicArray memory a, uint256 i) internal pure returns (uint256 result) {
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
function getAddress(DynamicArray memory a, uint256 i) internal pure returns (address result) {
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
function getBool(DynamicArray memory a, uint256 i) internal pure returns (bool result) {
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
function getBytes32(DynamicArray memory a, uint256 i) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(mload(a), 0x20), shl(5, i)))
}
}
function set(DynamicArray memory a, uint256 i, uint256 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), data)
}
}
function set(DynamicArray memory a, uint256 i, address data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), shr(96, shl(96, data)))
}
}
function set(DynamicArray memory a, uint256 i, bool data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), iszero(iszero(data)))
}
}
function set(DynamicArray memory a, uint256 i, bytes32 data)
internal
pure
returns (DynamicArray memory result)
{
_deallocate(result);
result = a;
assembly {
mstore(add(add(mload(result), 0x20), shl(5, i)), data)
}
}
function asUint256Array(DynamicArray memory a)
internal
pure
returns (uint256[] memory result)
{
assembly {
result := mload(a)
}
}
function asAddressArray(DynamicArray memory a)
internal
pure
returns (address[] memory result)
{
assembly {
result := mload(a)
}
}
function asBoolArray(DynamicArray memory a) internal pure returns (bool[] memory result) {
assembly {
result := mload(a)
}
}
function asBytes32Array(DynamicArray memory a)
internal
pure
returns (bytes32[] memory result)
{
assembly {
result := mload(a)
}
}
function slice(DynamicArray memory a, uint256 start, uint256 end)
internal
pure
returns (DynamicArray memory result)
{
result.data = slice(a.data, start, end);
}
function slice(DynamicArray memory a, uint256 start)
internal
pure
returns (DynamicArray memory result)
{
result.data = slice(a.data, start, type(uint256).max);
}
function copy(DynamicArray memory a) internal pure returns (DynamicArray memory result) {
result.data = copy(a.data);
}
function contains(DynamicArray memory a, uint256 needle) internal pure returns (bool) {
return ~indexOf(a.data, needle, 0) != 0;
}
function contains(DynamicArray memory a, address needle) internal pure returns (bool) {
return ~indexOf(a.data, uint160(needle), 0) != 0;
}
function contains(DynamicArray memory a, bytes32 needle) internal pure returns (bool) {
return ~indexOf(a.data, uint256(needle), 0) != 0;
}
function indexOf(DynamicArray memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, needle, from);
}
function indexOf(DynamicArray memory a, address needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, uint160(needle), from);
}
function indexOf(DynamicArray memory a, bytes32 needle, uint256 from)
internal
pure
returns (uint256)
{
return indexOf(a.data, uint256(needle), from);
}
function indexOf(DynamicArray memory a, uint256 needle) internal pure returns (uint256) {
return indexOf(a.data, needle, 0);
}
function indexOf(DynamicArray memory a, address needle) internal pure returns (uint256) {
return indexOf(a.data, uint160(needle), 0);
}
function indexOf(DynamicArray memory a, bytes32 needle) internal pure returns (uint256) {
return indexOf(a.data, uint256(needle), 0);
}
function lastIndexOf(DynamicArray memory a, uint256 needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, needle, from);
}
function lastIndexOf(DynamicArray memory a, address needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, uint160(needle), from);
}
function lastIndexOf(DynamicArray memory a, bytes32 needle, uint256 from)
internal
pure
returns (uint256)
{
return lastIndexOf(a.data, uint256(needle), from);
}
function lastIndexOf(DynamicArray memory a, uint256 needle) internal pure returns (uint256) {
return lastIndexOf(a.data, needle, NOT_FOUND);
}
function lastIndexOf(DynamicArray memory a, address needle) internal pure returns (uint256) {
return lastIndexOf(a.data, uint160(needle), NOT_FOUND);
}
function lastIndexOf(DynamicArray memory a, bytes32 needle) internal pure returns (uint256) {
return lastIndexOf(a.data, uint256(needle), NOT_FOUND);
}
function hash(DynamicArray memory a) internal pure returns (bytes32 result) {
assembly {
result := keccak256(add(mload(a), 0x20), shl(5, mload(mload(a))))
}
}
function directReturn(DynamicArray memory a) internal pure {
assembly {
let arrData := mload(a)
let retStart := sub(arrData, 0x20)
mstore(retStart, 0x20)
return(retStart, add(0x40, shl(5, mload(arrData))))
}
}
function _deallocate(DynamicArray memory result) private pure {
assembly {
mstore(0x40, result)
}
}
function _toUint(bool b) private pure returns (uint256 result) {
assembly {
result := iszero(iszero(b))
}
}
}
文件 9 的 53：ECDSA.sol
pragma solidity ^0.8.4;
library ECDSA {
uint256 internal constant N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141;
uint256 private constant _HALF_N_PLUS_1 =
0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1;
error InvalidSignature();
function recover(bytes32 hash, bytes memory signature) internal view returns (address result) {
assembly {
for { let m := mload(0x40) } 1 {
mstore(0x00, 0x8baa579f)
revert(0x1c, 0x04)
} {
switch mload(signature)
case 64 {
let vs := mload(add(signature, 0x40))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x60, shr(1, shl(1, vs)))
}
case 65 {
mstore(0x20, byte(0, mload(add(signature, 0x60))))
mstore(0x60, mload(add(signature, 0x40)))
}
default { continue }
mstore(0x00, hash)
mstore(0x40, mload(add(signature, 0x20)))
result := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))
mstore(0x60, 0)
mstore(0x40, m)
if returndatasize() { break }
}
}
}
function recoverCalldata(bytes32 hash, bytes calldata signature)
internal
view
returns (address result)
{
assembly {
for { let m := mload(0x40) } 1 {
mstore(0x00, 0x8baa579f)
revert(0x1c, 0x04)
} {
switch signature.length
case 64 {
let vs := calldataload(add(signature.offset, 0x20))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, calldataload(signature.offset))
mstore(0x60, shr(1, shl(1, vs)))
}
case 65 {
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40))))
calldatacopy(0x40, signature.offset, 0x40)
}
default { continue }
mstore(0x00, hash)
result := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))
mstore(0x60, 0)
mstore(0x40, m)
if returndatasize() { break }
}
}
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal view returns (address result) {
assembly {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs)))
result := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))
if iszero(returndatasize()) {
mstore(0x00, 0x8baa579f)
revert(0x1c, 0x04)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (address result)
{
assembly {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
result := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))
if iszero(returndatasize()) {
mstore(0x00, 0x8baa579f)
revert(0x1c, 0x04)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function tryRecover(bytes32 hash, bytes memory signature)
internal
view
returns (address result)
{
assembly {
for { let m := mload(0x40) } 1 {} {
switch mload(signature)
case 64 {
let vs := mload(add(signature, 0x40))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x60, shr(1, shl(1, vs)))
}
case 65 {
mstore(0x20, byte(0, mload(add(signature, 0x60))))
mstore(0x60, mload(add(signature, 0x40)))
}
default { break }
mstore(0x00, hash)
mstore(0x40, mload(add(signature, 0x20)))
pop(staticcall(gas(), 1, 0x00, 0x80, 0x40, 0x20))
mstore(0x60, 0)
result := mload(xor(0x60, returndatasize()))
mstore(0x40, m)
break
}
}
}
function tryRecoverCalldata(bytes32 hash, bytes calldata signature)
internal
view
returns (address result)
{
assembly {
for { let m := mload(0x40) } 1 {} {
switch signature.length
case 64 {
let vs := calldataload(add(signature.offset, 0x20))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, calldataload(signature.offset))
mstore(0x60, shr(1, shl(1, vs)))
}
case 65 {
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40))))
calldatacopy(0x40, signature.offset, 0x40)
}
default { break }
mstore(0x00, hash)
pop(staticcall(gas(), 1, 0x00, 0x80, 0x40, 0x20))
mstore(0x60, 0)
result := mload(xor(0x60, returndatasize()))
mstore(0x40, m)
break
}
}
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (address result)
{
assembly {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs)))
pop(staticcall(gas(), 1, 0x00, 0x80, 0x40, 0x20))
mstore(0x60, 0)
result := mload(xor(0x60, returndatasize()))
mstore(0x40, m)
}
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (address result)
{
assembly {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
pop(staticcall(gas(), 1, 0x00, 0x80, 0x40, 0x20))
mstore(0x60, 0)
result := mload(xor(0x60, returndatasize()))
mstore(0x40, m)
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 result) {
assembly {
mstore(0x20, hash)
mstore(0x00, "\x00\x00\x00\x00\x19Ethereum Signed Message:\n32")
result := keccak256(0x04, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32 result) {
assembly {
let sLength := mload(s)
let o := 0x20
mstore(o, "\x19Ethereum Signed Message:\n")
mstore(0x00, 0x00)
for { let temp := sLength } 1 {} {
o := sub(o, 1)
mstore8(o, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let n := sub(0x3a, o)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0x20))
mstore(s, or(mload(0x00), mload(n)))
result := keccak256(add(s, sub(0x20, n)), add(n, sLength))
mstore(s, sLength)
}
}
function canonicalHash(bytes memory signature) internal pure returns (bytes32 result) {
assembly {
let l := mload(signature)
for {} 1 {} {
mstore(0x00, mload(add(signature, 0x20)))
let s := mload(add(signature, 0x40))
let v := mload(add(signature, 0x41))
if eq(l, 64) {
v := add(shr(255, s), 27)
s := shr(1, shl(1, s))
}
if iszero(lt(s, _HALF_N_PLUS_1)) {
v := xor(v, 7)
s := sub(N, s)
}
mstore(0x21, v)
mstore(0x20, s)
result := keccak256(0x00, 0x41)
mstore(0x21, 0)
break
}
if iszero(lt(sub(l, 64), 2)) {
result := xor(keccak256(add(signature, 0x20), l), 0xd62f1ab2)
}
}
}
function canonicalHashCalldata(bytes calldata signature)
internal
pure
returns (bytes32 result)
{
assembly {
for {} 1 {} {
mstore(0x00, calldataload(signature.offset))
let s := calldataload(add(signature.offset, 0x20))
let v := calldataload(add(signature.offset, 0x21))
if eq(signature.length, 64) {
v := add(shr(255, s), 27)
s := shr(1, shl(1, s))
}
if iszero(lt(s, _HALF_N_PLUS_1)) {
v := xor(v, 7)
s := sub(N, s)
}
mstore(0x21, v)
mstore(0x20, s)
result := keccak256(0x00, 0x41)
mstore(0x21, 0)
break
}
if iszero(lt(sub(signature.length, 64), 2)) {
calldatacopy(mload(0x40), signature.offset, signature.length)
result := xor(keccak256(mload(0x40), signature.length), 0xd62f1ab2)
}
}
}
function canonicalHash(bytes32 r, bytes32 vs) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, r)
let v := add(shr(255, vs), 27)
let s := shr(1, shl(1, vs))
mstore(0x21, v)
mstore(0x20, s)
result := keccak256(0x00, 0x41)
mstore(0x21, 0)
}
}
function canonicalHash(uint8 v, bytes32 r, bytes32 s) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, r)
if iszero(lt(s, _HALF_N_PLUS_1)) {
v := xor(v, 7)
s := sub(N, s)
}
mstore(0x21, v)
mstore(0x20, s)
result := keccak256(0x00, 0x41)
mstore(0x21, 0)
}
}
function emptySignature() internal pure returns (bytes calldata signature) {
assembly {
signature.length := 0
}
}
}
文件 10 的 53：EIP5095.sol
pragma solidity ^0.8.0;
interface EIP5095 {
event Redeem(address indexed owner, address indexed receiver, uint256 underlyings);
function underlying() external view returns (address);
function maturity() external view returns (uint256 timestamp);
function convertToUnderlying(uint256 principal) external view returns (uint256 underlyings);
function convertToPrincipal(uint256 underlyings) external view returns (uint256 principal);
function maxRedeem(address owner) external view returns (uint256);
function previewRedeem(uint256 principal) external view returns (uint256 underlyings);
function redeem(uint256 principal, address receiver, address owner) external returns (uint256 underlyings);
function maxWithdraw(address owner) external view returns (uint256 underlyings);
function previewWithdraw(uint256 underlyings) external view returns (uint256 principal);
function withdraw(uint256 underlyings, address receiver, address owner) external returns (uint256 principal);
}
文件 11 的 53：ERC20.sol
pragma solidity ^0.8.4;
abstract contract ERC20 {
error TotalSupplyOverflow();
error AllowanceOverflow();
error AllowanceUnderflow();
error InsufficientBalance();
error InsufficientAllowance();
error InvalidPermit();
error PermitExpired();
error Permit2AllowanceIsFixedAtInfinity();
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
uint256 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
uint256 private constant _APPROVAL_EVENT_SIGNATURE =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;
uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;
uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;
uint256 private constant _NONCES_SLOT_SEED = 0x38377508;
uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;
bytes32 private constant _DOMAIN_TYPEHASH =
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
bytes32 private constant _DEFAULT_VERSION_HASH =
0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;
bytes32 private constant _PERMIT_TYPEHASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
function name() public view virtual returns (string memory);
function symbol() public view virtual returns (string memory);
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256 result) {
assembly {
result := sload(_TOTAL_SUPPLY_SLOT)
}
}
function balanceOf(address owner) public view virtual returns (uint256 result) {
assembly {
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, owner)
result := sload(keccak256(0x0c, 0x20))
}
}
function allowance(address owner, address spender)
public
view
virtual
returns (uint256 result)
{
if (_givePermit2InfiniteAllowance()) {
if (spender == _PERMIT2) return type(uint256).max;
}
assembly {
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, owner)
result := sload(keccak256(0x0c, 0x34))
}
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
if (_givePermit2InfiniteAllowance()) {
assembly {
if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {
mstore(0x00, 0x3f68539a)
revert(0x1c, 0x04)
}
}
}
assembly {
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x34), amount)
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
}
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
_beforeTokenTransfer(msg.sender, to, amount);
assembly {
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, caller())
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8)
revert(0x1c, 0x04)
}
sstore(fromBalanceSlot, sub(fromBalance, amount))
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))
}
_afterTokenTransfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
_beforeTokenTransfer(from, to, amount);
if (_givePermit2InfiniteAllowance()) {
assembly {
let from_ := shl(96, from)
if iszero(eq(caller(), _PERMIT2)) {
mstore(0x20, caller())
mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
if not(allowance_) {
if gt(amount, allowance_) {
mstore(0x00, 0x13be252b)
revert(0x1c, 0x04)
}
sstore(allowanceSlot, sub(allowance_, amount))
}
}
mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8)
revert(0x1c, 0x04)
}
sstore(fromBalanceSlot, sub(fromBalance, amount))
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
}
} else {
assembly {
let from_ := shl(96, from)
mstore(0x20, caller())
mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
if not(allowance_) {
if gt(amount, allowance_) {
mstore(0x00, 0x13be252b)
revert(0x1c, 0x04)
}
sstore(allowanceSlot, sub(allowance_, amount))
}
mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8)
revert(0x1c, 0x04)
}
sstore(fromBalanceSlot, sub(fromBalance, amount))
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
}
}
_afterTokenTransfer(from, to, amount);
return true;
}
function _constantNameHash() internal view virtual returns (bytes32 result) {}
function _versionHash() internal view virtual returns (bytes32 result) {
result = _DEFAULT_VERSION_HASH;
}
function _incrementNonce(address owner) internal virtual {
assembly {
mstore(0x0c, _NONCES_SLOT_SEED)
mstore(0x00, owner)
let nonceSlot := keccak256(0x0c, 0x20)
sstore(nonceSlot, add(1, sload(nonceSlot)))
}
}
function nonces(address owner) public view virtual returns (uint256 result) {
assembly {
mstore(0x0c, _NONCES_SLOT_SEED)
mstore(0x00, owner)
result := sload(keccak256(0x0c, 0x20))
}
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (_givePermit2InfiniteAllowance()) {
assembly {
if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {
mstore(0x00, 0x3f68539a)
revert(0x1c, 0x04)
}
}
}
bytes32 nameHash = _constantNameHash();
if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));
bytes32 versionHash = _versionHash();
assembly {
if gt(timestamp(), deadline) {
mstore(0x00, 0x1a15a3cc)
revert(0x1c, 0x04)
}
let m := mload(0x40)
owner := shr(96, shl(96, owner))
spender := shr(96, shl(96, spender))
mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)
mstore(0x00, owner)
let nonceSlot := keccak256(0x0c, 0x20)
let nonceValue := sload(nonceSlot)
mstore(m, _DOMAIN_TYPEHASH)
mstore(add(m, 0x20), nameHash)
mstore(add(m, 0x40), versionHash)
mstore(add(m, 0x60), chainid())
mstore(add(m, 0x80), address())
mstore(0x2e, keccak256(m, 0xa0))
mstore(m, _PERMIT_TYPEHASH)
mstore(add(m, 0x20), owner)
mstore(add(m, 0x40), spender)
mstore(add(m, 0x60), value)
mstore(add(m, 0x80), nonceValue)
mstore(add(m, 0xa0), deadline)
mstore(0x4e, keccak256(m, 0xc0))
mstore(0x00, keccak256(0x2c, 0x42))
mstore(0x20, and(0xff, v))
mstore(0x40, r)
mstore(0x60, s)
let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)
if iszero(eq(mload(returndatasize()), owner)) {
mstore(0x00, 0xddafbaef)
revert(0x1c, 0x04)
}
sstore(nonceSlot, add(nonceValue, t))
mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))
sstore(keccak256(0x2c, 0x34), value)
log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {
bytes32 nameHash = _constantNameHash();
if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));
bytes32 versionHash = _versionHash();
assembly {
let m := mload(0x40)
mstore(m, _DOMAIN_TYPEHASH)
mstore(add(m, 0x20), nameHash)
mstore(add(m, 0x40), versionHash)
mstore(add(m, 0x60), chainid())
mstore(add(m, 0x80), address())
result := keccak256(m, 0xa0)
}
}
function _mint(address to, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), to, amount);
assembly {
let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)
let totalSupplyAfter := add(totalSupplyBefore, amount)
if lt(totalSupplyAfter, totalSupplyBefore) {
mstore(0x00, 0xe5cfe957)
revert(0x1c, 0x04)
}
sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))
}
_afterTokenTransfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
_beforeTokenTransfer(from, address(0), amount);
assembly {
mstore(0x0c, _BALANCE_SLOT_SEED)
mstore(0x00, from)
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8)
revert(0x1c, 0x04)
}
sstore(fromBalanceSlot, sub(fromBalance, amount))
sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
}
_afterTokenTransfer(from, address(0), amount);
}
function _transfer(address from, address to, uint256 amount) internal virtual {
_beforeTokenTransfer(from, to, amount);
assembly {
let from_ := shl(96, from)
mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
let fromBalanceSlot := keccak256(0x0c, 0x20)
let fromBalance := sload(fromBalanceSlot)
if gt(amount, fromBalance) {
mstore(0x00, 0xf4d678b8)
revert(0x1c, 0x04)
}
sstore(fromBalanceSlot, sub(fromBalance, amount))
mstore(0x00, to)
let toBalanceSlot := keccak256(0x0c, 0x20)
sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
mstore(0x20, amount)
log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
}
_afterTokenTransfer(from, to, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
if (_givePermit2InfiniteAllowance()) {
if (spender == _PERMIT2) return;
}
assembly {
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, owner)
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
if not(allowance_) {
if gt(amount, allowance_) {
mstore(0x00, 0x13be252b)
revert(0x1c, 0x04)
}
sstore(allowanceSlot, sub(allowance_, amount))
}
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
if (_givePermit2InfiniteAllowance()) {
assembly {
if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {
mstore(0x00, 0x3f68539a)
revert(0x1c, 0x04)
}
}
}
assembly {
let owner_ := shl(96, owner)
mstore(0x20, spender)
mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))
sstore(keccak256(0x0c, 0x34), amount)
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {
return true;
}
}
文件 12 的 53：EfficientHashLib.sol
pragma solidity ^0.8.4;
library EfficientHashLib {
function hash(bytes32 v0) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, v0)
result := keccak256(0x00, 0x20)
}
}
function hash(uint256 v0) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, v0)
result := keccak256(0x00, 0x20)
}
}
function hash(bytes32 v0, bytes32 v1) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, v0)
mstore(0x20, v1)
result := keccak256(0x00, 0x40)
}
}
function hash(uint256 v0, uint256 v1) internal pure returns (bytes32 result) {
assembly {
mstore(0x00, v0)
mstore(0x20, v1)
result := keccak256(0x00, 0x40)
}
}
function hash(bytes32 v0, bytes32 v1, bytes32 v2) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
result := keccak256(m, 0x60)
}
}
function hash(uint256 v0, uint256 v1, uint256 v2) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
result := keccak256(m, 0x60)
}
}
function hash(bytes32 v0, bytes32 v1, bytes32 v2, bytes32 v3)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
result := keccak256(m, 0x80)
}
}
function hash(uint256 v0, uint256 v1, uint256 v2, uint256 v3)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
result := keccak256(m, 0x80)
}
}
function hash(bytes32 v0, bytes32 v1, bytes32 v2, bytes32 v3, bytes32 v4)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
result := keccak256(m, 0xa0)
}
}
function hash(uint256 v0, uint256 v1, uint256 v2, uint256 v3, uint256 v4)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
result := keccak256(m, 0xa0)
}
}
function hash(bytes32 v0, bytes32 v1, bytes32 v2, bytes32 v3, bytes32 v4, bytes32 v5)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
result := keccak256(m, 0xc0)
}
}
function hash(uint256 v0, uint256 v1, uint256 v2, uint256 v3, uint256 v4, uint256 v5)
internal
pure
returns (bytes32 result)
{
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
result := keccak256(m, 0xc0)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
result := keccak256(m, 0xe0)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
result := keccak256(m, 0xe0)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
result := keccak256(m, 0x100)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
result := keccak256(m, 0x100)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
result := keccak256(m, 0x120)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
result := keccak256(m, 0x120)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8,
bytes32 v9
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
result := keccak256(m, 0x140)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8,
uint256 v9
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
result := keccak256(m, 0x140)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8,
bytes32 v9,
bytes32 v10
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
result := keccak256(m, 0x160)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8,
uint256 v9,
uint256 v10
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
result := keccak256(m, 0x160)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8,
bytes32 v9,
bytes32 v10,
bytes32 v11
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
result := keccak256(m, 0x180)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8,
uint256 v9,
uint256 v10,
uint256 v11
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
result := keccak256(m, 0x180)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8,
bytes32 v9,
bytes32 v10,
bytes32 v11,
bytes32 v12
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
mstore(add(m, 0x180), v12)
result := keccak256(m, 0x1a0)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8,
uint256 v9,
uint256 v10,
uint256 v11,
uint256 v12
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
mstore(add(m, 0x180), v12)
result := keccak256(m, 0x1a0)
}
}
function hash(
bytes32 v0,
bytes32 v1,
bytes32 v2,
bytes32 v3,
bytes32 v4,
bytes32 v5,
bytes32 v6,
bytes32 v7,
bytes32 v8,
bytes32 v9,
bytes32 v10,
bytes32 v11,
bytes32 v12,
bytes32 v13
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
mstore(add(m, 0x180), v12)
mstore(add(m, 0x1a0), v13)
result := keccak256(m, 0x1c0)
}
}
function hash(
uint256 v0,
uint256 v1,
uint256 v2,
uint256 v3,
uint256 v4,
uint256 v5,
uint256 v6,
uint256 v7,
uint256 v8,
uint256 v9,
uint256 v10,
uint256 v11,
uint256 v12,
uint256 v13
) internal pure returns (bytes32 result) {
assembly {
let m := mload(0x40)
mstore(m, v0)
mstore(add(m, 0x20), v1)
mstore(add(m, 0x40), v2)
mstore(add(m, 0x60), v3)
mstore(add(m, 0x80), v4)
mstore(add(m, 0xa0), v5)
mstore(add(m, 0xc0), v6)
mstore(add(m, 0xe0), v7)
mstore(add(m, 0x100), v8)
mstore(add(m, 0x120), v9)
mstore(add(m, 0x140), v10)
mstore(add(m, 0x160), v11)
mstore(add(m, 0x180), v12)
mstore(add(m, 0x1a0), v13)
result := keccak256(m, 0x1c0)
}
}
function hash(bytes32[] memory buffer) internal pure returns (bytes32 result) {
assembly {
result := keccak256(add(buffer, 0x20), shl(5, mload(buffer)))
}
}
function set(bytes32[] memory buffer, uint256 i, bytes32 value)
internal
pure
returns (bytes32[] memory)
{
assembly {
mstore(add(buffer, shl(5, add(1, i))), value)
}
return buffer;
}
function set(bytes32[] memory buffer, uint256 i, uint256 value)
internal
pure
returns (bytes32[] memory)
{
assembly {
mstore(add(buffer, shl(5, add(1, i))), value)
}
return buffer;
}
function malloc(uint256 n) internal pure returns (bytes32[] memory buffer) {
assembly {
buffer := mload(0x40)
mstore(buffer, n)
mstore(0x40, add(shl(5, add(1, n)), buffer))
}
}
function free(bytes32[] memory buffer) internal pure {
assembly {
let n := mload(buffer)
mstore(shl(6, lt(iszero(n), eq(add(shl(5, add(1, n)), buffer), mload(0x40)))), buffer)
}
}
function eq(bytes32 a, bytes memory b) internal pure returns (bool result) {
assembly {
result := and(eq(0x20, mload(b)), eq(a, mload(add(b, 0x20))))
}
}
function eq(bytes memory a, bytes32 b) internal pure returns (bool result) {
assembly {
result := and(eq(0x20, mload(a)), eq(b, mload(add(a, 0x20))))
}
}
function hash(bytes memory b, uint256 start, uint256 end)
internal
pure
returns (bytes32 result)
{
assembly {
let n := mload(b)
end := xor(end, mul(xor(end, n), lt(n, end)))
start := xor(start, mul(xor(start, n), lt(n, start)))
result := keccak256(add(add(b, 0x20), start), mul(gt(end, start), sub(end, start)))
}
}
function hash(bytes memory b, uint256 start) internal pure returns (bytes32 result) {
assembly {
let n := mload(b)
start := xor(start, mul(xor(start, n), lt(n, start)))
result := keccak256(add(add(b, 0x20), start), mul(gt(n, start), sub(n, start)))
}
}
function hash(bytes memory b) internal pure returns (bytes32 result) {
assembly {
result := keccak256(add(b, 0x20), mload(b))
}
}
function hashCalldata(bytes calldata b, uint256 start, uint256 end)
internal
pure
returns (bytes32 result)
{
assembly {
end := xor(end, mul(xor(end, b.length), lt(b.length, end)))
start := xor(start, mul(xor(start, b.length), lt(b.length, start)))
let n := mul(gt(end, start), sub(end, start))
calldatacopy(mload(0x40), add(b.offset, start), n)
result := keccak256(mload(0x40), n)
}
}
function hashCalldata(bytes calldata b, uint256 start) internal pure returns (bytes32 result) {
assembly {
start := xor(start, mul(xor(start, b.length), lt(b.length, start)))
let n := mul(gt(b.length, start), sub(b.length, start))
calldatacopy(mload(0x40), add(b.offset, start), n)
result := keccak256(mload(0x40), n)
}
}
function hashCalldata(bytes calldata b) internal pure returns (bytes32 result) {
assembly {
calldatacopy(mload(0x40), b.offset, b.length)
result := keccak256(mload(0x40), b.length)
}
}
function sha2(bytes32 b) internal view returns (bytes32 result) {
assembly {
mstore(0x00, b)
result := mload(staticcall(gas(), 2, 0x00, 0x20, 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2(bytes memory b, uint256 start, uint256 end)
internal
view
returns (bytes32 result)
{
assembly {
let n := mload(b)
end := xor(end, mul(xor(end, n), lt(n, end)))
start := xor(start, mul(xor(start, n), lt(n, start)))
result := mload(staticcall(gas(), 2, add(add(b, 0x20), start),
mul(gt(end, start), sub(end, start)), 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2(bytes memory b, uint256 start) internal view returns (bytes32 result) {
assembly {
let n := mload(b)
start := xor(start, mul(xor(start, n), lt(n, start)))
result := mload(staticcall(gas(), 2, add(add(b, 0x20), start),
mul(gt(n, start), sub(n, start)), 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2(bytes memory b) internal view returns (bytes32 result) {
assembly {
result := mload(staticcall(gas(), 2, add(b, 0x20), mload(b), 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2Calldata(bytes calldata b, uint256 start, uint256 end)
internal
view
returns (bytes32 result)
{
assembly {
end := xor(end, mul(xor(end, b.length), lt(b.length, end)))
start := xor(start, mul(xor(start, b.length), lt(b.length, start)))
let n := mul(gt(end, start), sub(end, start))
calldatacopy(mload(0x40), add(b.offset, start), n)
result := mload(staticcall(gas(), 2, mload(0x40), n, 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2Calldata(bytes calldata b, uint256 start) internal view returns (bytes32 result) {
assembly {
start := xor(start, mul(xor(start, b.length), lt(b.length, start)))
let n := mul(gt(b.length, start), sub(b.length, start))
calldatacopy(mload(0x40), add(b.offset, start), n)
result := mload(staticcall(gas(), 2, mload(0x40), n, 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
function sha2Calldata(bytes calldata b) internal view returns (bytes32 result) {
assembly {
calldatacopy(mload(0x40), b.offset, b.length)
result := mload(staticcall(gas(), 2, mload(0x40), b.length, 0x01, 0x20))
if iszero(returndatasize()) { invalid() }
}
}
}
文件 13 的 53：Errors.sol
pragma solidity ^0.8.10;
library Errors {
error AccessManaged_Restricted();
error Expired();
error NotExpired();
error PrincipalToken_NotFactory();
error PrincipalToken_VerificationFailed(uint256 code);
error PrincipalToken_CollectRewardFailed();
error PrincipalToken_NotApprovedCollector();
error PrincipalToken_OnlyYieldToken();
error PrincipalToken_InsufficientSharesReceived();
error PrincipalToken_UnderlyingTokenBalanceChanged();
error PrincipalToken_Unstoppable();
error PrincipalToken_ProtectedToken();
error YieldToken_OnlyPrincipalToken();
error Module_CallFailed();
error FeeModule_InvalidFeeParam();
error FeeModule_SplitFeeExceedsMaximum();
error FeeModule_SplitFeeMismatchDefault();
error FeeModule_SplitFeeTooLow();
error FeeModule_IssuanceFeeExceedsMaximum();
error FeeModule_PerformanceFeeExceedsMaximum();
error FeeModule_RedemptionFeeExceedsMaximum();
error FeeModule_PostSettlementFeeExceedsMaximum();
error RewardProxy_InconsistentRewardTokens();
error Factory_ModuleNotFound();
error Factory_InvalidExpiry();
error Factory_InvalidPoolDeployer();
error Factory_InvalidModule();
error Factory_FeeModuleRequired();
error Factory_PrincipalTokenNotFound();
error Factory_InvalidModuleType();
error Factory_InvalidAddress();
error Factory_InvalidSuite();
error Factory_CannotUpdateFeeModule();
error Factory_InvalidDecimals();
error PoolDeployer_FailedToDeployPool();
error Zap_LengthMismatch();
error Zap_TransactionTooOld();
error Zap_BadTwoCrypto();
error Zap_BadPrincipalToken();
error Zap_BadCallback();
error Zap_InconsistentETHReceived();
error Zap_InsufficientETH();
error Zap_InsufficientPrincipalOutput();
error Zap_InsufficientTokenOutput();
error Zap_InsufficientUnderlyingOutput();
error Zap_InsufficientYieldTokenOutput();
error Zap_InsufficientPrincipalTokenOutput();
error Zap_DebtExceedsUnderlyingReceived();
error Zap_PullYieldTokenGreaterThanInput();
error Zap_BadPoolDeployer();
error Resolver_ConversionFailed();
error Resolver_InvalidDecimals();
error Resolver_ZeroAddress();
error VCRegistry_ConnectorNotFound();
error ERC4626Connector_InvalidToken();
error ERC4626Connector_InvalidETHAmount();
error ERC4626Connector_UnexpectedETH();
error WrapperConnector_InvalidETHAmount();
error WrapperConnector_UnexpectedETH();
error WrapperFactory_ImplementationNotSet();
error Quoter_ERC4626FallbackCallFailed();
error Quoter_ConnectorInvalidToken();
error Quoter_InsufficientUnderlyingOutput();
error ConversionLib_NegativeYtPrice();
error AggregationRouter_UnsupportedRouter();
error AggregationRouter_SwapFailed();
error AggregationRouter_ZeroReturn();
error AggregationRouter_InvalidMsgValue();
error DefaultConnectorFactory_TargetNotERC4626();
error DefaultConnectorFactory_InvalidToken();
error Lens_LengthMismatch();
error ERC4626Wrapper_TokenNotListed();
}
文件 14 的 53：Events.sol
pragma solidity ^0.8.10;
import "./Types.sol";
library Events {
uint256 constant _YIELD_FEE_ACCRUED_EVENT_SIGNATURE =
0xac693c1b946bcf3ad16baa51b744b990b94ea9c79ac71f2d1b5369a823a7d065;
uint256 constant _YIELD_ACCRUED_EVENT_SIGNATURE = 0xaced61c86c507aa3c2be43553434c6ff191ea7cbbd812491a6ae59abc99d29dc;
uint256 constant _SUPPLY_EVENT_SIGNATURE = 0x69a3ea8e6d6819646fbf2b98e9e8dd6d9cd343852550621038b4d72e4aa6dd37;
uint256 constant _UNITE_EVENT_SIGNATURE = 0xc78456d21b5d71405d0daba05157c90a4a412d7379fd21c3bc8a679b65b13b5f;
uint256 constant _REDEEM_EVENT_SIGNATURE = 0xaee47cdf925cf525fdae94f9777ee5a06cac37e1c41220d0a8a89ed154f62d1c;
uint256 constant _INTEREST_COLLECTED_EVENT_SIGNATURE =
0x54affe52c3988f9c9e1d9d4673ffb7b398832c049d65e63b51326c89255e8529;
uint256 constant _REWARDS_COLLECTED_EVENT_SIGNATURE =
0xc295ddd3f2581ded7ee79ef613567c637f9eabc1c1cf6c107bffaf63461614aa;
uint256 constant _SET_APPROVAL_COLLECTOR_EVENT_SIGNATURE =
0xa3b5109b351b1b1c9b05310b3176941fadf2a0c23d9bd59f5107f23d888202af;
event Deployed(address indexed pt, address indexed yt, address indexed pool, uint256 expiry, address target);
event PrincipalTokenImplementationSet(address indexed ptBlueprint, address indexed ytBlueprint);
event PoolDeployerSet(address indexed deployer, bool enabled);
event AccessManagerImplementationSet(address indexed implementation, bool enabled);
event ResolverBlueprintSet(address indexed resolverBlueprint, bool enabled);
event TreasurySet(address indexed treasury);
event ModuleImplementationSet(
ModuleIndex indexed moduleType, address indexed implementation, bool enableCustomImplementation
);
event ModuleUpdated(ModuleIndex indexed moduleType, address indexed instance, address indexed principalToken);
event YieldFeeAccrued(uint256 fee);
event CuratorFeesCollected(address indexed by, address indexed receiver, uint256 shares, TokenReward[] rewards);
event ProtocolFeesCollected(address indexed by, address indexed receiver, uint256 shares, TokenReward[] rewards);
event YieldAccrued(address indexed account, uint256 interest, uint256 maxscale);
event Supply(address indexed by, address indexed receiver, uint256 shares, uint256 principal);
event Unite(address indexed by, address indexed receiver, uint256 shares, uint256 principal);
event Redeem(
address indexed by, address indexed receiver, address indexed owner, uint256 shares, uint256 principal
);
event InterestCollected(address indexed by, address indexed receiver, address indexed owner, uint256 shares);
event RewardsCollected(
address indexed by, address indexed receiver, address indexed owner, address rewardToken, uint256 rewards
);
event SetApprovalCollector(address indexed owner, address indexed collector, bool approved);
function emitYieldFeeAccrued(uint256 fee) internal {
assembly {
mstore(0x00, fee)
log1(0x00, 0x20, _YIELD_FEE_ACCRUED_EVENT_SIGNATURE)
}
}
function emitYieldAccrued(address account, uint256 interest, uint256 globalIndex) internal {
assembly {
mstore(0x00, interest)
mstore(0x20, globalIndex)
let m := shr(96, not(0))
log2(0x00, 0x40, _YIELD_ACCRUED_EVENT_SIGNATURE, and(m, account))
}
}
function emitSupply(address by, address receiver, uint256 shares, uint256 principal) internal {
assembly {
mstore(0x00, shares)
mstore(0x20, principal)
let m := shr(96, not(0))
log3(0x00, 0x40, _SUPPLY_EVENT_SIGNATURE, and(m, by), and(m, receiver))
}
}
function emitUnite(address by, address receiver, uint256 shares, uint256 principal) internal {
assembly {
mstore(0x00, shares)
mstore(0x20, principal)
let m := shr(96, not(0))
log3(0x00, 0x40, _UNITE_EVENT_SIGNATURE, and(m, by), and(m, receiver))
}
}
function emitRedeem(address by, address receiver, address owner, uint256 shares, uint256 principal) internal {
assembly {
mstore(0x00, shares)
mstore(0x20, principal)
let m := shr(96, not(0))
log4(0x00, 0x40, _REDEEM_EVENT_SIGNATURE, and(m, by), and(m, receiver), and(m, owner))
}
}
function emitInterestCollected(address by, address receiver, address owner, uint256 shares) internal {
assembly {
mstore(0x00, shares)
let m := shr(96, not(0))
log4(0x00, 0x20, _INTEREST_COLLECTED_EVENT_SIGNATURE, and(m, by), and(m, receiver), and(m, owner))
}
}
function emitRewardsCollected(address by, address receiver, address owner, address rewardToken, uint256 rewards)
internal
{
assembly {
let m := shr(96, not(0))
mstore(0x00, and(m, rewardToken))
mstore(0x20, rewards)
log4(0x00, 0x40, _REWARDS_COLLECTED_EVENT_SIGNATURE, and(m, by), and(m, receiver), and(m, owner))
}
}
function emitSetApprovalCollector(address owner, address collector, bool approved) internal {
assembly {
mstore(0x00, iszero(iszero(approved)))
let m := shr(96, not(0))
log3(0x00, 0x20, _SET_APPROVAL_COLLECTOR_EVENT_SIGNATURE, and(m, owner), and(m, collector))
}
}
uint256 constant _ZAP_ADD_LIQUIDITY_SIGNATURE = 0x9e32f0e680e9faeb02a2fc3e7d2827cda9d3cf5b76c1879471c323bf0eddabce;
uint256 constant _ZAP_ADD_LIQUIDITY_ONE_TOKEN_SIGNATURE =
0x7cb19c3f09182abfd1d04b62fd55ffc2117c34c5e56ae0611ce778a785db6a05;
uint256 constant _ZAP_REMOVE_LIQUIDITY_SIGNATURE =
0x6d83a83b5c09cc7a964f9410802c001ffcfe3cd20e5bed47d41da364fd73048a;
uint256 constant _ZAP_REMOVE_LIQUIDITY_ONE_TOKEN_SIGNATURE =
0x85ff7539ec623e1a79d85fa73fdd19d84b48a2c174ea2573537d31b84218cf49;
uint256 constant _ZAP_SWAP_SIGNATURE = 0x6d901733826355a03dd5004731f362a9f053f6476de435133fbff936d04226bf;
uint256 constant _ZAP_SUPPLY_SIGNATURE = 0x9cebfeda04666057d1878b729da376084a1cb1623bafb6107989201b411644a6;
uint256 constant _ZAP_UNITE_SIGNATURE = 0x49000823b8190200215cf672aa160fc7550472c5a70d765fe4f2bd787757b2a4;
uint256 constant _ZAP_REDEEM_SIGNATURE = 0x9e9c3d8bb36eb5f0ab7e30facf1fd3a018b489e86b105830b6aaa72a1e4d0a6c;
event ZapAddLiquidity(
address indexed by,
address indexed receiver,
TwoCrypto indexed twoCrypto,
uint256 liquidity,
uint256 shares,
uint256 principal
);
event ZapAddLiquidityOneToken(
address indexed by,
address indexed receiver,
TwoCrypto indexed twoCrypto,
uint256 liquidity,
uint256 ytOut,
Token tokenIn,
uint256 amountIn
);
function emitZapAddLiquidity(
address by,
address receiver,
TwoCrypto twoCrypto,
uint256 liquidity,
uint256 shares,
uint256 principal
) internal {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, liquidity)
mstore(0x20, shares)
mstore(0x40, principal)
log4(0x00, 0x60, _ZAP_ADD_LIQUIDITY_SIGNATURE, and(m, by), and(m, receiver), and(m, twoCrypto))
mstore(0x40, fmp)
}
}
function emitZapAddLiquidityOneToken(
address by,
address receiver,
TwoCrypto twoCrypto,
uint256 liquidity,
uint256 ytOut,
Token tokenIn,
uint256 amountIn
) internal {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, liquidity)
mstore(0x20, ytOut)
mstore(0x40, and(m, tokenIn))
mstore(0x60, amountIn)
log4(0x00, 0x80, _ZAP_ADD_LIQUIDITY_ONE_TOKEN_SIGNATURE, and(m, by), and(m, receiver), and(m, twoCrypto))
mstore(0x60, 0)
mstore(0x40, fmp)
}
}
event ZapRemoveLiquidity(
address indexed by,
address indexed receiver,
TwoCrypto indexed twoCrypto,
uint256 liquidity,
uint256 shares,
uint256 principal
);
event ZapRemoveLiquidityOneToken(
address indexed by,
address indexed receiver,
TwoCrypto indexed twoCrypto,
uint256 liquidity,
Token tokenOut,
uint256 amountOut
);
function emitZapRemoveLiquidity(
address by,
address receiver,
TwoCrypto twoCrypto,
uint256 liquidity,
uint256 shares,
uint256 principal
) internal {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, liquidity)
mstore(0x20, shares)
mstore(0x40, principal)
log4(0x00, 0x60, _ZAP_REMOVE_LIQUIDITY_SIGNATURE, and(m, by), and(m, receiver), and(m, twoCrypto))
mstore(0x40, fmp)
}
}
function emitZapRemoveLiquidityOneToken(
address by,
address receiver,
TwoCrypto twoCrypto,
uint256 liquidity,
Token tokenOut,
uint256 amountOut
) internal {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, liquidity)
mstore(0x20, and(m, tokenOut))
mstore(0x40, amountOut)
log4(0x00, 0x60, _ZAP_REMOVE_LIQUIDITY_ONE_TOKEN_SIGNATURE, and(m, by), and(m, receiver), and(m, twoCrypto))
mstore(0x40, fmp)
}
}
event ZapSwap(
address indexed by,
address indexed receiver,
TwoCrypto indexed twoCrypto,
Token tokenIn,
uint256 amountIn,
Token tokenOut,
uint256 amountOut
);
function emitZapSwap(
address by,
address receiver,
TwoCrypto twoCrypto,
Token tokenIn,
uint256 amountIn,
Token tokenOut,
uint256 amountOut
) internal {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, and(m, tokenIn))
mstore(0x20, amountIn)
mstore(0x40, and(m, tokenOut))
mstore(0x60, amountOut)
log4(0x00, 0x80, _ZAP_SWAP_SIGNATURE, and(m, by), and(m, receiver), and(m, twoCrypto))
mstore(0x60, 0)
mstore(0x40, fmp)
}
}
event ZapSupply(
address indexed by,
address indexed receiver,
address indexed pt,
uint256 principal,
Token tokenIn,
uint256 amountIn
);
event ZapUnite(
address indexed by,
address indexed receiver,
address indexed pt,
uint256 principal,
Token tokenOut,
uint256 amountOut
);
event ZapRedeem(
address indexed by,
address indexed receiver,
address indexed pt,
uint256 principal,
Token tokenOut,
uint256 amountOut
);
function emitZapSupply(address by, address receiver, address pt, uint256 principal, Token tokenIn, uint256 amountIn)
internal
{
_logZapPrincipalEvent({
signature: _ZAP_SUPPLY_SIGNATURE,
by: by,
receiver: receiver,
pt: pt,
principal: principal,
token: tokenIn,
amount: amountIn
});
}
function emitZapUnite(
address by,
address receiver,
address pt,
uint256 principal,
Token tokenOut,
uint256 amountOut
) internal {
_logZapPrincipalEvent({
signature: _ZAP_UNITE_SIGNATURE,
by: by,
receiver: receiver,
pt: pt,
principal: principal,
token: tokenOut,
amount: amountOut
});
}
function emitZapRedeem(
address by,
address receiver,
address pt,
uint256 principal,
Token tokenOut,
uint256 amountOut
) internal {
_logZapPrincipalEvent({
signature: _ZAP_REDEEM_SIGNATURE,
by: by,
receiver: receiver,
pt: pt,
principal: principal,
token: tokenOut,
amount: amountOut
});
}
function _logZapPrincipalEvent(
uint256 signature,
address by,
address receiver,
address pt,
uint256 principal,
Token token,
uint256 amount
) private {
assembly {
let fmp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, principal)
mstore(0x20, and(m, token))
mstore(0x40, amount)
log4(0x00, 0x60, signature, and(m, by), and(m, receiver), and(m, pt))
mstore(0x40, fmp)
}
}
}
文件 15 的 53：Factory.sol
pragma solidity ^0.8.24;
import {SSTORE2} from "solady/src/utils/SSTORE2.sol";
import {LibClone} from "solady/src/utils/LibClone.sol";
import {LibTransient} from "solady/src/utils/LibTransient.sol";
import {UUPSUpgradeable} from "solady/src/utils/UUPSUpgradeable.sol";
import {EfficientHashLib} from "solady/src/utils/EfficientHashLib.sol";
import "./Types.sol";
import {IPoolDeployer} from "./interfaces/IPoolDeployer.sol";
import {BaseModule} from "./modules/BaseModule.sol";
import {PrincipalToken} from "./tokens/PrincipalToken.sol";
import {AccessManager, AccessManaged} from "./modules/AccessManager.sol";
import {VaultInfoResolver} from "./modules/resolvers/VaultInfoResolver.sol";
import {LibBlueprint} from "./utils/LibBlueprint.sol";
import {ModuleAccessor} from "./utils/ModuleAccessor.sol";
import {Errors} from "./Errors.sol";
import {Events} from "./Events.sol";
import "src/Constants.sol" as Constants;
contract Factory is AccessManaged, UUPSUpgradeable {
uint256 constant ARGS_ON_ERC1967_FACTORY_ARG_OFFSET = 0x00;
uint256 public constant DEFAULT_SPLIT_RATIO_BPS = Constants.DEFAULT_SPLIT_RATIO_BPS;
mapping(address deployer => bool enable) public s_poolDeployers;
mapping(address blueprint => address ytBlueprint) public s_ytBlueprints;
mapping(address blueprint => bool enable) public s_resolverBlueprints;
mapping(address implementation => bool enable) public s_accessManagerImplementations;
mapping(address pool => address deployer) public s_pools;
mapping(address principalToken => address blueprint) public s_principalTokens;
mapping(ModuleIndex moduleType => mapping(address implementation => bool enabled)) public s_modules;
address[] s_poolList;
address public s_treasury;
struct ConstructorArg {
address resolver;
uint256 expiry;
address yt;
address accessManager;
address modules;
}
LibTransient.TBytes internal _tempArgs;
struct Suite {
address accessManagerImpl;
address ptBlueprint;
address resolverBlueprint;
address poolDeployerImpl;
bytes poolArgs;
bytes resolverArgs;
}
struct ModuleParam {
ModuleIndex moduleType;
address implementation;
bytes immutableData;
}
function deploy(Suite calldata suite, ModuleParam[] calldata params, uint256 expiry, address curator)
external
returns (address pt, address yt, address pool)
{
if (
suite.ptBlueprint == address(0) || !s_resolverBlueprints[suite.resolverBlueprint]
|| !s_poolDeployers[suite.poolDeployerImpl] || !s_accessManagerImplementations[suite.accessManagerImpl]
) {
revert Errors.Factory_InvalidSuite();
}
if (expiry <= block.timestamp) revert Errors.Factory_InvalidExpiry();
address resolver = LibBlueprint.create(suite.resolverBlueprint, suite.resolverArgs);
address accessManager = LibClone.clone(suite.accessManagerImpl);
AccessManager(accessManager).initializeOwner(curator);
bytes32 salt =
EfficientHashLib.hash(block.chainid, expiry, uint256(uint160(resolver)), uint256(uint160(msg.sender)));
pt = LibBlueprint.computeCreate2Address(salt, suite.ptBlueprint, "");
{
address pointer = _deployModules(pt, params, true);
yt = LibBlueprint.create(s_ytBlueprints[suite.ptBlueprint], abi.encode(pt));
LibTransient.setCompat(_tempArgs, abi.encode(ConstructorArg(resolver, expiry, yt, accessManager, pointer)));
LibBlueprint.create2(suite.ptBlueprint, salt);
}
address target = VaultInfoResolver(resolver).target();
pool = IPoolDeployer(suite.poolDeployerImpl).deploy(target, pt, suite.poolArgs);
emit Events.Deployed(pt, yt, pool, expiry, target);
s_poolList.push(pool);
s_pools[pool] = suite.poolDeployerImpl;
s_principalTokens[pt] = suite.ptBlueprint;
LibTransient.clearCompat(_tempArgs);
}
function updateModules(address pt, ModuleParam[] calldata params)
external
exists(pt)
restrictedBy(PrincipalToken(pt).i_accessManager())
{
for (uint256 i = 0; i != params.length;) {
if (params[i].moduleType == FEE_MODULE_INDEX) revert Errors.Factory_CannotUpdateFeeModule();
unchecked {
++i;
}
}
address pointer = _deployModules(pt, params, false);
PrincipalToken(pt).setModules(pointer);
}
function _deployModules(address pt, ModuleParam[] calldata params, bool initialize)
internal
returns (address pointer)
{
address[] memory modules =
initialize ? new address[](MAX_MODULES) : ModuleAccessor.read(PrincipalToken(pt).s_modules());
for (uint256 i = 0; i != params.length;) {
ModuleParam calldata param = params[i];
ModuleIndex t = param.moduleType;
if (!isValidImplementation(t, param.implementation)) revert Errors.Factory_InvalidModule();
address instance = LibClone.clone(param.implementation, abi.encode(pt, param.immutableData));
BaseModule(instance).initialize();
ModuleAccessor.set(modules, t, instance);
emit Events.ModuleUpdated(t, instance, pt);
unchecked {
++i;
}
}
if (ModuleAccessor.get(modules, FEE_MODULE_INDEX) == address(0)) {
revert Errors.Factory_FeeModuleRequired();
}
pointer = SSTORE2.write(abi.encode(modules));
}
function setPrincipalTokenBlueprint(address ptBlueprint, address ytBlueprint)
external
restricted
notZeroAddress(ptBlueprint)
{
s_ytBlueprints[ptBlueprint] = ytBlueprint;
emit Events.PrincipalTokenImplementationSet(ptBlueprint, ytBlueprint);
}
function setPoolDeployer(address deployer, bool enable) external restricted notZeroAddress(deployer) {
s_poolDeployers[deployer] = enable;
emit Events.PoolDeployerSet(deployer, enable);
}
function setAccessManagerImplementation(address implementation, bool enable)
external
restricted
notZeroAddress(implementation)
{
s_accessManagerImplementations[implementation] = enable;
emit Events.AccessManagerImplementationSet(implementation, enable);
}
function setResolverBlueprint(address blueprint, bool enable) external restricted notZeroAddress(blueprint) {
s_resolverBlueprints[blueprint] = enable;
emit Events.ResolverBlueprintSet(blueprint, enable);
}
function setModuleImplementation(ModuleIndex moduleType, address implementation, bool enable)
external
restricted
notZeroAddress(implementation)
{
if (!moduleType.isSupportedByFactory()) revert Errors.Factory_InvalidModuleType();
s_modules[moduleType][implementation] = enable;
emit Events.ModuleImplementationSet(moduleType, implementation, enable);
}
function setTreasury(address treasury) external restricted notZeroAddress(treasury) {
s_treasury = treasury;
emit Events.TreasurySet(treasury);
}
function isValidImplementation(ModuleIndex moduleType, address implementation) public view returns (bool) {
return moduleType.isSupportedByFactory() && s_modules[moduleType][implementation];
}
function moduleFor(address principalToken, ModuleIndex moduleType)
public
view
exists(principalToken)
returns (address module)
{
module = ModuleAccessor.get(ModuleAccessor.read(PrincipalToken(principalToken).s_modules()), moduleType);
if (module == address(0)) revert Errors.Factory_ModuleNotFound();
}
function getPoolList() external view returns (address[] memory) {
return s_poolList;
}
function args() external view returns (ConstructorArg memory) {
return abi.decode(LibTransient.getCompat(_tempArgs), (ConstructorArg));
}
function i_accessManager() public view override returns (AccessManager) {
bytes memory arg = LibClone.argsOnERC1967(
address(this), ARGS_ON_ERC1967_FACTORY_ARG_OFFSET, ARGS_ON_ERC1967_FACTORY_ARG_OFFSET + 0x20
);
return AccessManager(abi.decode(arg, (address)));
}
modifier exists(address principalToken) {
if (s_principalTokens[principalToken] == address(0)) {
revert Errors.Factory_PrincipalTokenNotFound();
}
_;
}
modifier notZeroAddress(address implementation) {
if (implementation == address(0)) {
revert Errors.Factory_InvalidAddress();
}
_;
}
function _authorizeUpgrade(address newImplementation) internal override restricted {}
}
文件 16 的 53：FeeModule.sol
pragma solidity ^0.8.10;
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
import {LibClone} from "solady/src/utils/LibClone.sol";
import {FeeParameters, FeePcts} from "../Types.sol";
import {FeePctsLib} from "../utils/FeePctsLib.sol";
import {Errors} from "../Errors.sol";
import {Factory} from "../Factory.sol";
import {BaseModule} from "./BaseModule.sol";
abstract contract FeeModule is BaseModule {
function getFeePcts() external view virtual returns (FeePcts);
}
contract ConstantFeeModule is FeeModule {
using SafeCastLib for uint256;
bytes32 public constant override VERSION = "2.0.0";
uint256 private constant MAX_FEE_BPS = 10_000;
uint256 private constant MAX_SPLIT_RATIO_BPS = 9_500;
FeePcts private s_feePcts;
function initialize() external override initializer {
(, bytes memory args) = abi.decode(LibClone.argsOnClone(address(this)), (address, bytes));
if (args.length != 0x20) revert Errors.FeeModule_InvalidFeeParam();
FeePcts feePcts = abi.decode(args, (FeePcts));
(uint16 splitFee, uint16 issuanceFee, uint16 performanceFee, uint16 redemptionFee, uint16 postSettlementFee) =
FeePctsLib.unpack(feePcts);
if (splitFee != Factory(msg.sender).DEFAULT_SPLIT_RATIO_BPS().toUint16()) {
revert Errors.FeeModule_SplitFeeMismatchDefault();
}
if (issuanceFee > MAX_FEE_BPS) {
revert Errors.FeeModule_IssuanceFeeExceedsMaximum();
}
if (performanceFee > MAX_FEE_BPS) {
revert Errors.FeeModule_PerformanceFeeExceedsMaximum();
}
if (redemptionFee > MAX_FEE_BPS) {
revert Errors.FeeModule_RedemptionFeeExceedsMaximum();
}
if (postSettlementFee > MAX_FEE_BPS) {
revert Errors.FeeModule_PostSettlementFeeExceedsMaximum();
}
s_feePcts = feePcts;
}
function getFeePcts() public view override returns (FeePcts) {
return s_feePcts;
}
function getFeeParams(FeeParameters param) external view returns (uint256) {
if (param == FeeParameters.FEE_SPLIT_RATIO) {
return FeePctsLib.getSplitPctBps(s_feePcts);
} else if (param == FeeParameters.ISSUANCE_FEE) {
return FeePctsLib.getIssuanceFeePctBps(s_feePcts);
} else if (param == FeeParameters.PERFORMANCE_FEE) {
return FeePctsLib.getPerformanceFeePctBps(s_feePcts);
} else if (param == FeeParameters.REDEMPTION_FEE) {
return FeePctsLib.getRedemptionFeePctBps(s_feePcts);
} else if (param == FeeParameters.POST_SETTLEMENT_FEE) {
return FeePctsLib.getPostSettlementFeePctBps(s_feePcts);
}
revert Errors.FeeModule_InvalidFeeParam();
}
function updateFeeSplitRatio(uint256 _splitRatio) external restrictedBy(i_factory().i_accessManager()) {
if (_splitRatio > MAX_SPLIT_RATIO_BPS) {
revert Errors.FeeModule_SplitFeeExceedsMaximum();
}
if (_splitRatio == 0) {
revert Errors.FeeModule_SplitFeeTooLow();
}
s_feePcts = FeePctsLib.updateSplitFeePct(s_feePcts, _splitRatio.toUint16());
}
}
文件 17 的 53：FeePcts.sol
pragma solidity ^0.8.24;
import {FeePcts} from "../Types.sol";
function unwrap(FeePcts x) pure returns (uint256 result) {
result = FeePcts.unwrap(x);
}
文件 18 的 53：FeePctsLib.sol
pragma solidity ^0.8.10;
import {FeePcts} from "../Types.sol";
library FeePctsLib {
uint256 private constant FEE_MASK = 0xFFFF;
uint256 private constant SPLIT_RATIO_OFFSET = 0;
function getSplitPctBps(FeePcts self) internal pure returns (uint16) {
return uint16(FeePcts.unwrap(self));
}
function getIssuanceFeePctBps(FeePcts self) internal pure returns (uint16) {
return uint16(FeePcts.unwrap(self) >> 16);
}
function getPerformanceFeePctBps(FeePcts self) internal pure returns (uint16) {
return uint16(FeePcts.unwrap(self) >> 32);
}
function getRedemptionFeePctBps(FeePcts self) internal pure returns (uint16) {
return uint16(FeePcts.unwrap(self) >> 48);
}
function getPostSettlementFeePctBps(FeePcts self) internal pure returns (uint16) {
return uint16(FeePcts.unwrap(self) >> 64);
}
function unpack(FeePcts self)
internal
pure
returns (
uint16 splitFeePct,
uint16 issuanceFeePct,
uint16 performanceFeePct,
uint16 redemptionFeePct,
uint16 postSettlementFeePct
)
{
uint256 raw = FeePcts.unwrap(self);
splitFeePct = uint16(raw);
issuanceFeePct = uint16(raw >> 16);
performanceFeePct = uint16(raw >> 32);
redemptionFeePct = uint16(raw >> 48);
postSettlementFeePct = uint16(raw >> 64);
return (splitFeePct, issuanceFeePct, performanceFeePct, redemptionFeePct, postSettlementFeePct);
}
function pack(
uint16 splitFeePct,
uint16 issuanceFeePct,
uint16 performanceFeePct,
uint16 redemptionFeePct,
uint16 postSettlementFeePct
) internal pure returns (FeePcts) {
return FeePcts.wrap(
(uint256(postSettlementFeePct) << 64 | uint256(redemptionFeePct) << 48) | (uint256(performanceFeePct) << 32)
| (uint256(issuanceFeePct) << 16) | uint256(splitFeePct)
);
}
function updateSplitFeePct(FeePcts self, uint16 splitFeePct) internal pure returns (FeePcts) {
return
FeePcts.wrap((FeePcts.unwrap(self) & ~(FEE_MASK << SPLIT_RATIO_OFFSET)) | (uint256(splitFeePct) & FEE_MASK));
}
}
文件 19 的 53：FixedPointMathLib.sol
pragma solidity ^0.8.4;
library FixedPointMathLib {
error ExpOverflow();
error FactorialOverflow();
error RPowOverflow();
error MantissaOverflow();
error MulWadFailed();
error SMulWadFailed();
error DivWadFailed();
error SDivWadFailed();
error MulDivFailed();
error DivFailed();
error FullMulDivFailed();
error LnWadUndefined();
error OutOfDomain();
uint256 internal constant WAD = 1e18;
function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if gt(x, div(not(0), y)) {
if y {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
}
z := div(mul(x, y), WAD)
}
}
function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, y)
if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4)
revert(0x1c, 0x04)
}
z := sdiv(z, WAD)
}
}
function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, y), WAD)
}
}
function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, y), WAD)
}
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(eq(div(z, y), x)) {
if y {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
}
z := add(iszero(iszero(mod(z, WAD))), div(z, WAD))
}
}
function rawMulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
function divWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := div(mul(x, WAD), y)
}
}
function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, WAD)
if iszero(mul(y, eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d)
revert(0x1c, 0x04)
}
z := sdiv(z, y)
}
}
function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, WAD), y)
}
}
function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, WAD), y)
}
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function powWad(int256 x, int256 y) internal pure returns (int256) {
return expWad((lnWad(x) * y) / int256(WAD));
}
function expWad(int256 x) internal pure returns (int256 r) {
unchecked {
if (x <= -41446531673892822313) return r;
assembly {
if iszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9)
revert(0x1c, 0x04)
}
}
x = (x << 78) / 5 ** 18;
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
r := sdiv(p, q)
}
r = int256(
(uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)
);
}
}
function lnWad(int256 x) internal pure returns (int256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
if iszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638)
revert(0x1c, 0x04)
}
r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
x := shr(159, shl(r, x))
let p := sub(
sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p := sub(mul(p, x), shl(96, 795164235651350426258249787498))
let q := add(5573035233440673466300451813936, x)
q := add(71694874799317883764090561454958, sar(96, mul(x, q)))
q := add(283447036172924575727196451306956, sar(96, mul(x, q)))
q := add(401686690394027663651624208769553, sar(96, mul(x, q)))
q := add(204048457590392012362485061816622, sar(96, mul(x, q)))
q := add(31853899698501571402653359427138, sar(96, mul(x, q)))
q := add(909429971244387300277376558375, sar(96, mul(x, q)))
p := sdiv(p, q)
p := mul(1677202110996718588342820967067443963516166, p)
p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
r := sar(174, p)
}
}
function lambertW0Wad(int256 x) internal pure returns (int256 w) {
unchecked {
if ((w = x) <= -367879441171442322) revert OutOfDomain();
(int256 wad, int256 p) = (int256(WAD), x);
uint256 c;
uint256 i = 4;
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1;
} else if (w <= -0x3ffffffffffffff) {
i = 32;
}
} else if (uint256(w >> 63) == uint256(0)) {
assembly {
let v := shr(49, w)
let l := shl(3, lt(0xff, v))
l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c := gt(l, 60)
i := add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
assembly {
w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i := add(3, iszero(shr(68, x)))
c := iszero(shr(143, x))
}
if (c == uint256(0)) {
do {
int256 e = expWad(w);
assembly {
let t := mul(w, div(e, wad))
w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i != uint256(0));
assembly {
w := sub(w, sgt(w, 2))
}
return w;
}
}
do {
int256 e = expWad(w);
assembly {
let t := add(w, wad)
let s := sub(mul(w, e), mul(x, wad))
w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
assembly {
w := sub(w, sgt(w, 2))
}
if (c == uint256(0)) return w;
int256 t = w | 1;
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
assembly {
w := sdiv(x, add(wad, t))
}
}
}
function fullMulEq(uint256 a, uint256 b, uint256 x, uint256 y)
internal
pure
returns (bool result)
{
assembly {
result := and(eq(mul(a, b), mul(x, y)), eq(mulmod(x, y, not(0)), mulmod(a, b, not(0))))
}
}
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
for {} 1 {} {
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
let r := mulmod(x, y, d)
let t := and(d, sub(0, d))
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
z :=
mul(
or(mul(sub(p1, gt(r, z)), add(div(sub(0, t), t), 1)), div(sub(z, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
break
}
z := div(z, d)
break
}
}
}
function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internal
pure
returns (uint256 z)
{
assembly {
z := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
let t := and(d, sub(0, d))
let r := mulmod(x, y, d)
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
z :=
mul(
or(mul(sub(p1, gt(r, z)), add(div(sub(0, t), t), 1)), div(sub(z, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
z = fullMulDiv(x, y, d);
assembly {
if mulmod(x, y, d) {
z := add(z, 1)
if iszero(z) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
}
}
}
function fullMulDivN(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
for {} 1 {} {
if iszero(or(iszero(x), eq(div(z, x), y))) {
let k := and(n, 0xff)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
if iszero(shr(k, p1)) {
z := add(shl(sub(256, k), p1), shr(k, z))
break
}
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
z := shr(and(n, 0xff), z)
break
}
}
}
function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := div(z, d)
}
}
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(z, d))), div(z, d))
}
}
function invMod(uint256 a, uint256 n) internal pure returns (uint256 x) {
assembly {
let g := n
let r := mod(a, n)
for { let y := 1 } 1 {} {
let q := div(g, r)
let t := g
g := r
r := sub(t, mul(r, q))
let u := x
x := y
y := sub(u, mul(y, q))
if iszero(r) { break }
}
x := mul(eq(g, 1), add(x, mul(slt(x, 0), n)))
}
}
function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(d) {
mstore(0x00, 0x65244e4e)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(x, d))), div(x, d))
}
}
function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function ternary(bool condition, bytes32 x, bytes32 y) internal pure returns (bytes32 z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function ternary(bool condition, address x, address y) internal pure returns (address z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {
assembly {
z := mul(b, iszero(y))
if x {
z := xor(b, mul(xor(b, x), and(y, 1)))
let half := shr(1, b)
for { y := shr(1, y) } y { y := shr(1, y) } {
let xx := mul(x, x)
let xxRound := add(xx, half)
if or(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
x := div(xxRound, b)
if and(y, 1) {
let zx := mul(z, x)
let zxRound := add(zx, half)
if or(xor(div(zx, x), z), lt(zxRound, zx)) {
if x {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
}
z := div(zxRound, b)
}
}
}
}
}
function sqrt(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 181
let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffffff, shr(r, x))))
z := shl(shr(1, r), z)
z := shr(18, mul(z, add(shr(r, x), 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 cbrt(uint256 x) internal pure returns (uint256 z) {
assembly {
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := sub(z, lt(div(x, mul(z, z)), z))
}
}
function sqrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);
z = (1 + sqrt(x)) * 10 ** 9;
z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;
}
assembly {
z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1)))
}
}
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);
z = (1 + cbrt(x)) * 10 ** 12;
z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;
}
assembly {
let p := x
for {} 1 {} {
if iszero(shr(229, p)) {
if iszero(shr(199, p)) {
p := mul(p, 100000000000000000)
break
}
p := mul(p, 100000000)
break
}
if iszero(shr(249, p)) { p := mul(p, 100) }
break
}
let t := mulmod(mul(z, z), z, p)
z := sub(z, gt(lt(t, shr(1, p)), iszero(t)))
}
}
function factorial(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 1
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2)
revert(0x1c, 0x04)
}
for {} x { x := sub(x, 1) } { z := mul(z, x) }
}
}
function log2(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
function log2Up(uint256 x) internal pure returns (uint256 r) {
r = log2(x);
assembly {
r := add(r, lt(shl(r, 1), x))
}
}
function log10(uint256 x) internal pure returns (uint256 r) {
assembly {
if iszero(lt(x, 100000000000000000000000000000000000000)) {
x := div(x, 100000000000000000000000000000000000000)
r := 38
}
if iszero(lt(x, 100000000000000000000)) {
x := div(x, 100000000000000000000)
r := add(r, 20)
}
if iszero(lt(x, 10000000000)) {
x := div(x, 10000000000)
r := add(r, 10)
}
if iszero(lt(x, 100000)) {
x := div(x, 100000)
r := add(r, 5)
}
r := add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))
}
}
function log10Up(uint256 x) internal pure returns (uint256 r) {
r = log10(x);
assembly {
r := add(r, lt(exp(10, r), x))
}
}
function log256(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(shr(3, r), lt(0xff, shr(r, x)))
}
}
function log256Up(uint256 x) internal pure returns (uint256 r) {
r = log256(x);
assembly {
r := add(r, lt(shl(shl(3, r), 1), x))
}
}
function sci(uint256 x) internal pure returns (uint256 mantissa, uint256 exponent) {
assembly {
mantissa := x
if mantissa {
if iszero(mod(mantissa, 1000000000000000000000000000000000)) {
mantissa := div(mantissa, 1000000000000000000000000000000000)
exponent := 33
}
if iszero(mod(mantissa, 10000000000000000000)) {
mantissa := div(mantissa, 10000000000000000000)
exponent := add(exponent, 19)
}
if iszero(mod(mantissa, 1000000000000)) {
mantissa := div(mantissa, 1000000000000)
exponent := add(exponent, 12)
}
if iszero(mod(mantissa, 1000000)) {
mantissa := div(mantissa, 1000000)
exponent := add(exponent, 6)
}
if iszero(mod(mantissa, 10000)) {
mantissa := div(mantissa, 10000)
exponent := add(exponent, 4)
}
if iszero(mod(mantissa, 100)) {
mantissa := div(mantissa, 100)
exponent := add(exponent, 2)
}
if iszero(mod(mantissa, 10)) {
mantissa := div(mantissa, 10)
exponent := add(exponent, 1)
}
}
}
}
function packSci(uint256 x) internal pure returns (uint256 packed) {
(x, packed) = sci(x);
assembly {
if shr(249, x) {
mstore(0x00, 0xce30380c)
revert(0x1c, 0x04)
}
packed := or(shl(7, x), packed)
}
}
function unpackSci(uint256 packed) internal pure returns (uint256 unpacked) {
unchecked {
unpacked = (packed >> 7) * 10 ** (packed & 0x7f);
}
}
function avg(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = (x & y) + ((x ^ y) >> 1);
}
}
function avg(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = (x >> 1) + (y >> 1) + (x & y & 1);
}
}
function abs(int256 x) internal pure returns (uint256 z) {
unchecked {
z = (uint256(x) + uint256(x >> 255)) ^ uint256(x >> 255);
}
}
function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))
}
}
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(x, y))
}
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), lt(y, x)))
}
}
function min(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), slt(y, x)))
}
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
function max(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), sgt(y, x)))
}
}
function clamp(uint256 x, uint256 minValue, uint256 maxValue)
internal
pure
returns (uint256 z)
{
assembly {
z := xor(x, mul(xor(x, minValue), gt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
for { z := x } y {} {
let t := y
y := mod(z, y)
z := t
}
}
}
function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internal
pure
returns (uint256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internal
pure
returns (int256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b - a),
uint256(t - begin), uint256(end - begin)));
return int256(uint256(a) - fullMulDiv(uint256(a - b),
uint256(t - begin), uint256(end - begin)));
}
}
function isEven(uint256 x) internal pure returns (bool) {
return x & uint256(1) == uint256(0);
}
function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x + y;
}
}
function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x + y;
}
}
function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x - y;
}
}
function rawSub(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x - y;
}
}
function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x * y;
}
}
function rawMul(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x * y;
}
}
function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(x, y)
}
}
function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(x, y)
}
}
function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mod(x, y)
}
}
function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := smod(x, y)
}
}
function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := addmod(x, y, d)
}
}
function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mulmod(x, y, d)
}
}
}
文件 20 的 53：IHook.sol
pragma solidity ^0.8.10;
interface ISupplyHook {
function onSupply(uint256 shares, uint256 principal, bytes calldata data) external;
}
interface IUniteHook {
function onUnite(uint256 shares, uint256 principal, bytes calldata data) external;
}
interface IHook is ISupplyHook, IUniteHook {}
文件 21 的 53：IPoolDeployer.sol
pragma solidity ^0.8.10;
interface IPoolDeployer {
function deploy(address target, address principalToken, bytes calldata initArgs)
external
payable
returns (address);
}
文件 22 的 53：IRewardProxy.sol
pragma solidity ^0.8.10;
import {TokenReward} from "src/Types.sol";
interface IRewardProxy {
function rewardTokens() external view returns (address[] memory);
function collectReward(address rewardProxy) external returns (TokenReward[] memory);
}
文件 23 的 53：Initializable.sol
pragma solidity ^0.8.4;
abstract contract Initializable {
error InvalidInitialization();
error NotInitializing();
event Initialized(uint64 version);
bytes32 private constant _INTIALIZED_EVENT_SIGNATURE =
0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2;
bytes32 private constant _INITIALIZABLE_SLOT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf601132;
constructor() {
require(_initializableSlot() != bytes32(0));
}
function _initializableSlot() internal pure virtual returns (bytes32) {
return _INITIALIZABLE_SLOT;
}
modifier initializer() virtual {
bytes32 s = _initializableSlot();
assembly {
let i := sload(s)
sstore(s, 3)
if i {
if iszero(lt(extcodesize(address()), eq(shr(1, i), 1))) {
mstore(0x00, 0xf92ee8a9)
revert(0x1c, 0x04)
}
s := shl(shl(255, i), s)
}
}
_;
assembly {
if s {
sstore(s, 2)
mstore(0x20, 1)
log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)
}
}
}
modifier reinitializer(uint64 version) virtual {
bytes32 s = _initializableSlot();
assembly {
version := shl(1, and(version, 0xffffffffffffffff))
let i := sload(s)
if iszero(lt(and(i, 1), lt(i, version))) {
mstore(0x00, 0xf92ee8a9)
revert(0x1c, 0x04)
}
sstore(s, or(1, version))
}
_;
assembly {
sstore(s, version)
mstore(0x20, shr(1, version))
log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)
}
}
modifier onlyInitializing() virtual {
_checkInitializing();
_;
}
function _checkInitializing() internal view virtual {
bytes32 s = _initializableSlot();
assembly {
if iszero(and(1, sload(s))) {
mstore(0x00, 0xd7e6bcf8)
revert(0x1c, 0x04)
}
}
}
function _disableInitializers() internal virtual {
bytes32 s = _initializableSlot();
assembly {
let i := sload(s)
if and(i, 1) {
mstore(0x00, 0xf92ee8a9)
revert(0x1c, 0x04)
}
let uint64max := 0xffffffffffffffff
if iszero(eq(shr(1, i), uint64max)) {
sstore(s, shl(1, uint64max))
mstore(0x20, uint64max)
log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)
}
}
}
function _getInitializedVersion() internal view virtual returns (uint64 version) {
bytes32 s = _initializableSlot();
assembly {
version := shr(1, sload(s))
}
}
function _isInitializing() internal view virtual returns (bool result) {
bytes32 s = _initializableSlot();
assembly {
result := and(1, sload(s))
}
}
}
文件 24 的 53：LibApproval.sol
pragma solidity ^0.8.24;
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
abstract contract LibApproval {
uint256 constant _IS_APPROVED_SLOT_SEED = 0xa8fe4407;
function isApproved(address src, address spender) internal view returns (bool approved) {
assembly {
mstore(0x20, spender)
mstore(0x0c, _IS_APPROVED_SLOT_SEED)
mstore(0x00, src)
approved := sload(keccak256(0x0c, 0x34))
}
}
function setApproval(address src, address spender, bool approved) internal {
assembly {
mstore(0x20, spender)
mstore(0x0c, _IS_APPROVED_SLOT_SEED)
mstore(0x00, src)
sstore(keccak256(0x0c, 0x34), approved)
}
}
function approveIfNeeded(address token, address spender) internal {
if (!isApproved(token, spender)) {
setApproval(token, spender, true);
SafeTransferLib.safeApprove(token, spender, type(uint256).max);
}
}
}
文件 25 的 53：LibBlueprint.sol
pragma solidity ^0.8.10;
import {LibBytes} from "solady/src/utils/LibBytes.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
library LibBlueprint {
using SafeCastLib for uint256;
error DeploymentFailed();
error InvalidBlueprint();
function create(address _blueprint) internal returns (address) {
return _create(_blueprint, "");
}
function tryCreate(address _blueprint, bytes memory args) internal returns (address deployed) {
bytes memory initcode = extractCreationCode(_blueprint);
bytes memory deployCode = LibBytes.concat(initcode, args);
assembly {
deployed := create(0, add(deployCode, 32), mload(deployCode))
}
}
function create(address _blueprint, bytes memory args) internal returns (address) {
return _create(_blueprint, args);
}
function create2(address _blueprint, bytes32 salt) internal returns (address) {
return _create2(_blueprint, "", salt);
}
function create2(address _blueprint, bytes memory args, bytes32 salt) internal returns (address) {
return _create2(_blueprint, args, salt);
}
function blueprint(bytes memory initcode) internal pure returns (bytes memory) {
bytes memory blueprint_bytecode = bytes.concat(
hex"fe",
hex"71",
hex"00",
initcode
);
bytes2 len = bytes2(blueprint_bytecode.length.toUint16());
bytes memory deployBytecode = bytes.concat(
hex"61",
len,
hex"3d81600a3d39f3",
blueprint_bytecode
);
return deployBytecode;
}
function deployBlueprint(bytes memory initcode) internal returns (address deployed) {
bytes memory deployBytecode = blueprint(initcode);
assembly {
deployed := create(0, add(deployBytecode, 0x20), mload(deployBytecode))
}
if (deployed == address(0)) revert DeploymentFailed();
}
function _create(address _blueprint, bytes memory args) private returns (address deployed) {
bytes memory initcode = extractCreationCode(_blueprint);
bytes memory deployCode = LibBytes.concat(initcode, args);
assembly {
deployed := create(0, add(deployCode, 32), mload(deployCode))
}
if (deployed == address(0)) revert DeploymentFailed();
}
function _create2(address _blueprint, bytes memory args, bytes32 salt) private returns (address deployed) {
bytes memory initcode = extractCreationCode(_blueprint);
bytes memory deployCode = LibBytes.concat(initcode, args);
assembly {
deployed := create2(0, add(deployCode, 32), mload(deployCode), salt)
}
if (deployed == address(0)) revert DeploymentFailed();
}
function extractCreationCode(address _blueprint) private view returns (bytes memory initcode) {
uint256 size;
uint256 offset = 3;
assembly {
size := extcodesize(_blueprint)
}
if (size <= offset) {
revert InvalidBlueprint();
}
uint256 initcodeSize = size - offset;
initcode = new bytes(initcodeSize);
assembly {
extcodecopy(_blueprint, add(initcode, 32), offset, initcodeSize)
}
}
function computeCreate2Address(bytes32 salt, address _blueprint, bytes memory args)
internal
view
returns (address)
{
bytes32 bytecodeHash = keccak256(LibBytes.concat(extractCreationCode(_blueprint), args));
return computeCreeate2Address(salt, bytecodeHash, address(this));
}
function computeCreeate2Address(bytes32 salt, bytes32 bytecodeHash, address deployer)
internal
pure
returns (address addr)
{
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x40), bytecodeHash)
mstore(add(ptr, 0x20), salt)
mstore(ptr, deployer)
let start := add(ptr, 0x0b)
mstore8(start, 0xff)
addr := keccak256(start, 85)
}
}
}
文件 26 的 53：LibBytes.sol
pragma solidity ^0.8.4;
library LibBytes {
struct BytesStorage {
bytes32 _spacer;
}
uint256 internal constant NOT_FOUND = type(uint256).max;
function set(BytesStorage storage $, bytes memory s) internal {
assembly {
let n := mload(s)
let packed := or(0xff, shl(8, n))
for { let i := 0 } 1 {} {
if iszero(gt(n, 0xfe)) {
i := 0x1f
packed := or(n, shl(8, mload(add(s, i))))
if iszero(gt(n, i)) { break }
}
let o := add(s, 0x20)
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
sstore(add(p, shr(5, i)), mload(add(o, i)))
i := add(i, 0x20)
if iszero(lt(i, n)) { break }
}
break
}
sstore($.slot, packed)
}
}
function setCalldata(BytesStorage storage $, bytes calldata s) internal {
assembly {
let packed := or(0xff, shl(8, s.length))
for { let i := 0 } 1 {} {
if iszero(gt(s.length, 0xfe)) {
i := 0x1f
packed := or(s.length, shl(8, shr(8, calldataload(s.offset))))
if iszero(gt(s.length, i)) { break }
}
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
sstore(add(p, shr(5, i)), calldataload(add(s.offset, i)))
i := add(i, 0x20)
if iszero(lt(i, s.length)) { break }
}
break
}
sstore($.slot, packed)
}
}
function clear(BytesStorage storage $) internal {
delete $._spacer;
}
function isEmpty(BytesStorage storage $) internal view returns (bool) {
return uint256($._spacer) & 0xff == uint256(0);
}
function length(BytesStorage storage $) internal view returns (uint256 result) {
result = uint256($._spacer);
assembly {
let n := and(0xff, result)
result := or(mul(shr(8, result), eq(0xff, n)), mul(n, iszero(eq(0xff, n))))
}
}
function get(BytesStorage storage $) internal view returns (bytes memory result) {
assembly {
result := mload(0x40)
let o := add(result, 0x20)
let packed := sload($.slot)
let n := shr(8, packed)
for { let i := 0 } 1 {} {
if iszero(eq(or(packed, 0xff), packed)) {
mstore(o, packed)
n := and(0xff, packed)
i := 0x1f
if iszero(gt(n, i)) { break }
}
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
mstore(add(o, i), sload(add(p, shr(5, i))))
i := add(i, 0x20)
if iszero(lt(i, n)) { break }
}
break
}
mstore(result, n)
mstore(add(o, n), 0)
mstore(0x40, add(add(o, n), 0x20))
}
}
function replace(bytes memory subject, bytes memory needle, bytes memory replacement)
internal
pure
returns (bytes memory result)
{
assembly {
result := mload(0x40)
let needleLen := mload(needle)
let replacementLen := mload(replacement)
let d := sub(result, subject)
let i := add(subject, 0x20)
mstore(0x00, add(i, mload(subject)))
if iszero(gt(needleLen, mload(subject))) {
let subjectSearchEnd := add(sub(mload(0x00), needleLen), 1)
let h := 0
if iszero(lt(needleLen, 0x20)) { h := keccak256(add(needle, 0x20), needleLen) }
let s := mload(add(needle, 0x20))
for { let m := shl(3, sub(0x20, and(needleLen, 0x1f))) } 1 {} {
let t := mload(i)
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(i, needleLen), h)) {
mstore(add(i, d), t)
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
for { let j := 0 } 1 {} {
mstore(add(add(i, d), j), mload(add(add(replacement, 0x20), j)))
j := add(j, 0x20)
if iszero(lt(j, replacementLen)) { break }
}
d := sub(add(d, replacementLen), needleLen)
if needleLen {
i := add(i, needleLen)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
mstore(add(i, d), t)
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
}
}
let end := mload(0x00)
let n := add(sub(d, add(result, 0x20)), end)
for {} lt(i, end) { i := add(i, 0x20) } { mstore(add(i, d), mload(i)) }
let o := add(i, d)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, n)
}
}
function indexOf(bytes memory subject, bytes memory needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
result := not(0)
for { let subjectLen := mload(subject) } 1 {} {
if iszero(mload(needle)) {
result := from
if iszero(gt(from, subjectLen)) { break }
result := subjectLen
break
}
let needleLen := mload(needle)
let subjectStart := add(subject, 0x20)
subject := add(subjectStart, from)
let end := add(sub(add(subjectStart, subjectLen), needleLen), 1)
let m := shl(3, sub(0x20, and(needleLen, 0x1f)))
let s := mload(add(needle, 0x20))
if iszero(and(lt(subject, end), lt(from, subjectLen))) { break }
if iszero(lt(needleLen, 0x20)) {
for { let h := keccak256(add(needle, 0x20), needleLen) } 1 {} {
if iszero(shr(m, xor(mload(subject), s))) {
if eq(keccak256(subject, needleLen), h) {
result := sub(subject, subjectStart)
break
}
}
subject := add(subject, 1)
if iszero(lt(subject, end)) { break }
}
break
}
for {} 1 {} {
if iszero(shr(m, xor(mload(subject), s))) {
result := sub(subject, subjectStart)
break
}
subject := add(subject, 1)
if iszero(lt(subject, end)) { break }
}
break
}
}
}
function indexOf(bytes memory subject, bytes memory needle) internal pure returns (uint256) {
return indexOf(subject, needle, 0);
}
function lastIndexOf(bytes memory subject, bytes memory needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
for {} 1 {} {
result := not(0)
let needleLen := mload(needle)
if gt(needleLen, mload(subject)) { break }
let w := result
let fromMax := sub(mload(subject), needleLen)
if iszero(gt(fromMax, from)) { from := fromMax }
let end := add(add(subject, 0x20), w)
subject := add(add(subject, 0x20), from)
if iszero(gt(subject, end)) { break }
for { let h := keccak256(add(needle, 0x20), needleLen) } 1 {} {
if eq(keccak256(subject, needleLen), h) {
result := sub(subject, add(end, 1))
break
}
subject := add(subject, w)
if iszero(gt(subject, end)) { break }
}
break
}
}
}
function lastIndexOf(bytes memory subject, bytes memory needle)
internal
pure
returns (uint256)
{
return lastIndexOf(subject, needle, type(uint256).max);
}
function contains(bytes memory subject, bytes memory needle) internal pure returns (bool) {
return indexOf(subject, needle) != NOT_FOUND;
}
function startsWith(bytes memory subject, bytes memory needle)
internal
pure
returns (bool result)
{
assembly {
let n := mload(needle)
let t := eq(keccak256(add(subject, 0x20), n), keccak256(add(needle, 0x20), n))
result := lt(gt(n, mload(subject)), t)
}
}
function endsWith(bytes memory subject, bytes memory needle)
internal
pure
returns (bool result)
{
assembly {
let n := mload(needle)
let notInRange := gt(n, mload(subject))
let t := add(add(subject, 0x20), mul(iszero(notInRange), sub(mload(subject), n)))
result := gt(eq(keccak256(t, n), keccak256(add(needle, 0x20), n)), notInRange)
}
}
function repeat(bytes memory subject, uint256 times)
internal
pure
returns (bytes memory result)
{
assembly {
let l := mload(subject)
if iszero(or(iszero(times), iszero(l))) {
result := mload(0x40)
subject := add(subject, 0x20)
let o := add(result, 0x20)
for {} 1 {} {
for { let j := 0 } 1 {} {
mstore(add(o, j), mload(add(subject, j)))
j := add(j, 0x20)
if iszero(lt(j, l)) { break }
}
o := add(o, l)
times := sub(times, 1)
if iszero(times) { break }
}
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, sub(o, add(result, 0x20)))
}
}
}
function slice(bytes memory subject, uint256 start, uint256 end)
internal
pure
returns (bytes memory result)
{
assembly {
let l := mload(subject)
if iszero(gt(l, end)) { end := l }
if iszero(gt(l, start)) { start := l }
if lt(start, end) {
result := mload(0x40)
let n := sub(end, start)
let i := add(subject, start)
let w := not(0x1f)
for { let j := and(add(n, 0x1f), w) } 1 {} {
mstore(add(result, j), mload(add(i, j)))
j := add(j, w)
if iszero(j) { break }
}
let o := add(add(result, 0x20), n)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, n)
}
}
}
function slice(bytes memory subject, uint256 start)
internal
pure
returns (bytes memory result)
{
result = slice(subject, start, type(uint256).max);
}
function sliceCalldata(bytes calldata subject, uint256 start, uint256 end)
internal
pure
returns (bytes calldata result)
{
assembly {
end := xor(end, mul(xor(end, subject.length), lt(subject.length, end)))
start := xor(start, mul(xor(start, subject.length), lt(subject.length, start)))
result.offset := add(subject.offset, start)
result.length := mul(lt(start, end), sub(end, start))
}
}
function sliceCalldata(bytes calldata subject, uint256 start)
internal
pure
returns (bytes calldata result)
{
assembly {
start := xor(start, mul(xor(start, subject.length), lt(subject.length, start)))
result.offset := add(subject.offset, start)
result.length := mul(lt(start, subject.length), sub(subject.length, start))
}
}
function truncate(bytes memory subject, uint256 n)
internal
pure
returns (bytes memory result)
{
assembly {
result := subject
mstore(mul(lt(n, mload(result)), result), n)
}
}
function truncatedCalldata(bytes calldata subject, uint256 n)
internal
pure
returns (bytes calldata result)
{
assembly {
result.offset := subject.offset
result.length := xor(n, mul(xor(n, subject.length), lt(subject.length, n)))
}
}
function indicesOf(bytes memory subject, bytes memory needle)
internal
pure
returns (uint256[] memory result)
{
assembly {
let searchLen := mload(needle)
if iszero(gt(searchLen, mload(subject))) {
result := mload(0x40)
let i := add(subject, 0x20)
let o := add(result, 0x20)
let subjectSearchEnd := add(sub(add(i, mload(subject)), searchLen), 1)
let h := 0
if iszero(lt(searchLen, 0x20)) { h := keccak256(add(needle, 0x20), searchLen) }
let s := mload(add(needle, 0x20))
for { let m := shl(3, sub(0x20, and(searchLen, 0x1f))) } 1 {} {
let t := mload(i)
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(i, searchLen), h)) {
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
mstore(o, sub(i, add(subject, 0x20)))
o := add(o, 0x20)
i := add(i, searchLen)
if searchLen {
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
}
mstore(result, shr(5, sub(o, add(result, 0x20))))
mstore(0x40, add(o, 0x20))
}
}
}
function split(bytes memory subject, bytes memory delimiter)
internal
pure
returns (bytes[] memory result)
{
uint256[] memory indices = indicesOf(subject, delimiter);
assembly {
let w := not(0x1f)
let indexPtr := add(indices, 0x20)
let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
mstore(add(indicesEnd, w), mload(subject))
mstore(indices, add(mload(indices), 1))
for { let prevIndex := 0 } 1 {} {
let index := mload(indexPtr)
mstore(indexPtr, 0x60)
if iszero(eq(index, prevIndex)) {
let element := mload(0x40)
let l := sub(index, prevIndex)
mstore(element, l)
for { let o := and(add(l, 0x1f), w) } 1 {} {
mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
o := add(o, w)
if iszero(o) { break }
}
mstore(add(add(element, 0x20), l), 0)
mstore(0x40, add(element, and(add(l, 0x3f), w)))
mstore(indexPtr, element)
}
prevIndex := add(index, mload(delimiter))
indexPtr := add(indexPtr, 0x20)
if iszero(lt(indexPtr, indicesEnd)) { break }
}
result := indices
if iszero(mload(delimiter)) {
result := add(indices, 0x20)
mstore(result, sub(mload(indices), 2))
}
}
}
function concat(bytes memory a, bytes memory b) internal pure returns (bytes memory result) {
assembly {
result := mload(0x40)
let w := not(0x1f)
let aLen := mload(a)
for { let o := and(add(aLen, 0x20), w) } 1 {} {
mstore(add(result, o), mload(add(a, o)))
o := add(o, w)
if iszero(o) { break }
}
let bLen := mload(b)
let output := add(result, aLen)
for { let o := and(add(bLen, 0x20), w) } 1 {} {
mstore(add(output, o), mload(add(b, o)))
o := add(o, w)
if iszero(o) { break }
}
let totalLen := add(aLen, bLen)
let last := add(add(result, 0x20), totalLen)
mstore(last, 0)
mstore(result, totalLen)
mstore(0x40, add(last, 0x20))
}
}
function eq(bytes memory a, bytes memory b) internal pure returns (bool result) {
assembly {
result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
function eqs(bytes memory a, bytes32 b) internal pure returns (bool result) {
assembly {
let m := not(shl(7, div(not(iszero(b)), 255)))
let x := not(or(m, or(b, add(m, and(b, m)))))
let r := shl(7, iszero(iszero(shr(128, x))))
r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
}
}
function cmp(bytes memory a, bytes memory b) internal pure returns (int256 result) {
assembly {
let aLen := mload(a)
let bLen := mload(b)
let n := and(xor(aLen, mul(xor(aLen, bLen), lt(bLen, aLen))), not(0x1f))
if n {
for { let i := 0x20 } 1 {} {
let x := mload(add(a, i))
let y := mload(add(b, i))
if iszero(or(xor(x, y), eq(i, n))) {
i := add(i, 0x20)
continue
}
result := sub(gt(x, y), lt(x, y))
break
}
}
if iszero(result) {
let l := 0x201f1e1d1c1b1a191817161514131211100f0e0d0c0b0a090807060504030201
let x := and(mload(add(add(a, 0x20), n)), shl(shl(3, byte(sub(aLen, n), l)), not(0)))
let y := and(mload(add(add(b, 0x20), n)), shl(shl(3, byte(sub(bLen, n), l)), not(0)))
result := sub(gt(x, y), lt(x, y))
if iszero(result) { result := sub(gt(aLen, bLen), lt(aLen, bLen)) }
}
}
}
function directReturn(bytes memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
let retUnpaddedSize := add(mload(a), 0x40)
mstore(add(retStart, retUnpaddedSize), 0)
mstore(retStart, 0x20)
return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
}
}
function directReturn(bytes[] memory a) internal pure {
assembly {
let n := mload(a)
let o := add(a, 0x20)
let u := a
let w := not(0x1f)
for { let i := 0 } iszero(eq(i, n)) { i := add(i, 1) } {
let c := add(o, shl(5, i))
let s := mload(c)
let l := mload(s)
let r := and(l, 0x1f)
let z := add(0x20, and(l, w))
if iszero(lt(lt(s, o), or(iszero(r), iszero(shl(shl(3, r), mload(add(s, z))))))) {
let m := mload(0x40)
mstore(m, l)
for {} 1 {} {
mstore(add(m, z), mload(add(s, z)))
z := add(z, w)
if iszero(z) { break }
}
let e := add(add(m, 0x20), l)
mstore(e, 0)
mstore(0x40, add(e, 0x20))
s := m
}
mstore(c, sub(s, o))
let t := add(l, add(s, 0x20))
if iszero(lt(t, u)) { u := t }
}
let retStart := add(a, w)
mstore(retStart, 0x20)
return(retStart, add(0x40, sub(u, retStart)))
}
}
function load(bytes memory a, uint256 offset) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(a, 0x20), offset))
}
}
function loadCalldata(bytes calldata a, uint256 offset)
internal
pure
returns (bytes32 result)
{
assembly {
result := calldataload(add(a.offset, offset))
}
}
function emptyCalldata() internal pure returns (bytes calldata result) {
assembly {
result.length := 0
}
}
}
文件 27 的 53：LibClone.sol
pragma solidity ^0.8.4;
library LibClone {
bytes32 internal constant CLONE_CODE_HASH =
0x48db2cfdb2853fce0b464f1f93a1996469459df3ab6c812106074c4106a1eb1f;
bytes32 internal constant PUSH0_CLONE_CODE_HASH =
0x67bc6bde1b84d66e267c718ba44cf3928a615d29885537955cb43d44b3e789dc;
bytes32 internal constant CWIA_CODE_HASH =
0x3cf92464268225a4513da40a34d967354684c32cd0edd67b5f668dfe3550e940;
bytes32 internal constant ERC1967_CODE_HASH =
0xaaa52c8cc8a0e3fd27ce756cc6b4e70c51423e9b597b11f32d3e49f8b1fc890d;
bytes32 internal constant ERC1967I_CODE_HASH =
0xce700223c0d4cea4583409accfc45adac4a093b3519998a9cbbe1504dadba6f7;
bytes32 internal constant ERC1967_BEACON_PROXY_CODE_HASH =
0x14044459af17bc4f0f5aa2f658cb692add77d1302c29fe2aebab005eea9d1162;
bytes32 internal constant ERC1967I_BEACON_PROXY_CODE_HASH =
0xf8c46d2793d5aa984eb827aeaba4b63aedcab80119212fce827309788735519a;
error DeploymentFailed();
error SaltDoesNotStartWith();
error ETHTransferFailed();
function clone(address implementation) internal returns (address instance) {
instance = clone(0, implementation);
}
function clone(uint256 value, address implementation) internal returns (address instance) {
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
instance := create(value, 0x0c, 0x35)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x21, 0)
}
}
function cloneDeterministic(address implementation, bytes32 salt)
internal
returns (address instance)
{
instance = cloneDeterministic(0, implementation, salt);
}
function cloneDeterministic(uint256 value, address implementation, bytes32 salt)
internal
returns (address instance)
{
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
instance := create2(value, 0x0c, 0x35, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x21, 0)
}
}
function initCode(address implementation) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x40), 0x5af43d3d93803e602a57fd5bf30000000000000000000000)
mstore(add(c, 0x28), implementation)
mstore(add(c, 0x14), 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
mstore(c, 0x35)
mstore(0x40, add(c, 0x60))
}
}
function initCodeHash(address implementation) internal pure returns (bytes32 hash) {
assembly {
mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)
mstore(0x14, implementation)
mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)
hash := keccak256(0x0c, 0x35)
mstore(0x21, 0)
}
}
function predictDeterministicAddress(address implementation, bytes32 salt, address deployer)
internal
pure
returns (address predicted)
{
bytes32 hash = initCodeHash(implementation);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function clone_PUSH0(address implementation) internal returns (address instance) {
instance = clone_PUSH0(0, implementation);
}
function clone_PUSH0(uint256 value, address implementation)
internal
returns (address instance)
{
assembly {
mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3)
mstore(0x14, implementation)
mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73)
instance := create(value, 0x0e, 0x36)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x24, 0)
}
}
function cloneDeterministic_PUSH0(address implementation, bytes32 salt)
internal
returns (address instance)
{
instance = cloneDeterministic_PUSH0(0, implementation, salt);
}
function cloneDeterministic_PUSH0(uint256 value, address implementation, bytes32 salt)
internal
returns (address instance)
{
assembly {
mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3)
mstore(0x14, implementation)
mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73)
instance := create2(value, 0x0e, 0x36, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x24, 0)
}
}
function initCode_PUSH0(address implementation) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x40), 0x5af43d5f5f3e6029573d5ffd5b3d5ff300000000000000000000)
mstore(add(c, 0x26), implementation)
mstore(add(c, 0x12), 0x602d5f8160095f39f35f5f365f5f37365f73)
mstore(c, 0x36)
mstore(0x40, add(c, 0x60))
}
}
function initCodeHash_PUSH0(address implementation) internal pure returns (bytes32 hash) {
assembly {
mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3)
mstore(0x14, implementation)
mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73)
hash := keccak256(0x0e, 0x36)
mstore(0x24, 0)
}
}
function predictDeterministicAddress_PUSH0(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHash_PUSH0(implementation);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function clone(address implementation, bytes memory args) internal returns (address instance) {
instance = clone(0, implementation, args);
}
function clone(uint256 value, address implementation, bytes memory args)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))
mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)
mstore(add(m, 0x14), implementation)
mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))
instance := create(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37))
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function cloneDeterministic(address implementation, bytes memory args, bytes32 salt)
internal
returns (address instance)
{
instance = cloneDeterministic(0, implementation, args, salt);
}
function cloneDeterministic(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))
mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)
mstore(add(m, 0x14), implementation)
mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))
instance := create2(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function createDeterministicClone(address implementation, bytes memory args, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicClone(0, implementation, args, salt);
}
function createDeterministicClone(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (bool alreadyDeployed, address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))
mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)
mstore(add(m, 0x14), implementation)
mstore(add(m, gt(n, 0xffd2)), add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))
mstore8(0x00, 0xff)
mstore(0x35, keccak256(add(m, 0x0c), add(n, 0x37)))
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
instance := keccak256(0x00, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, add(m, 0x0c), add(n, 0x37), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x35, 0)
}
}
function initCode(address implementation, bytes memory args)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x57), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x37), 0x5af43d82803e903d91602b57fd5bf3)
mstore(add(c, 0x28), implementation)
mstore(add(c, 0x14), add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))
mstore(c, add(0x37, n))
mstore(add(c, add(n, 0x57)), 0)
mstore(0x40, add(c, add(n, 0x77)))
}
}
function initCodeHash(address implementation, bytes memory args)
internal
pure
returns (bytes32 hash)
{
assembly {
let m := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(m, 0x43), i), mload(add(add(args, 0x20), i)))
}
mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)
mstore(add(m, 0x14), implementation)
mstore(m, add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))
hash := keccak256(add(m, 0x0c), add(n, 0x37))
}
}
function predictDeterministicAddress(
address implementation,
bytes memory data,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHash(implementation, data);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function argsOnClone(address instance) internal view returns (bytes memory args) {
assembly {
args := mload(0x40)
mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x2d)))
extcodecopy(instance, add(args, 0x20), 0x2d, add(mload(args), 0x20))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnClone(address instance, uint256 start)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(instance), 0x2d))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(instance, args, add(start, 0x0d), add(l, 0x40))
mstore(args, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(args, add(0x40, mload(args))))
}
}
function argsOnClone(address instance, uint256 start, uint256 end)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(instance, args, add(start, 0x0d), add(d, 0x20))
if iszero(and(0xff, mload(add(args, d)))) {
let n := sub(extcodesize(instance), 0x2d)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(args, d)
mstore(add(add(args, 0x20), d), 0)
mstore(0x40, add(add(args, 0x40), d))
}
}
function deployERC1967(address implementation) internal returns (address instance) {
instance = deployERC1967(0, implementation);
}
function deployERC1967(uint256 value, address implementation)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x20, 0x6009)
mstore(0x1e, implementation)
mstore(0x0a, 0x603d3d8160223d3973)
instance := create(value, 0x21, 0x5f)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function deployDeterministicERC1967(address implementation, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967(0, implementation, salt);
}
function deployDeterministicERC1967(uint256 value, address implementation, bytes32 salt)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x20, 0x6009)
mstore(0x1e, implementation)
mstore(0x0a, 0x603d3d8160223d3973)
instance := create2(value, 0x21, 0x5f, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function createDeterministicERC1967(address implementation, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967(0, implementation, salt);
}
function createDeterministicERC1967(uint256 value, address implementation, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x20, 0x6009)
mstore(0x1e, implementation)
mstore(0x0a, 0x603d3d8160223d3973)
mstore(add(m, 0x35), keccak256(0x21, 0x5f))
mstore(m, shl(88, address()))
mstore8(m, 0xff)
mstore(add(m, 0x15), salt)
instance := keccak256(m, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, 0x21, 0x5f, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function initCodeERC1967(address implementation) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x60), 0x3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f300)
mstore(add(c, 0x40), 0x55f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc)
mstore(add(c, 0x20), or(shl(24, implementation), 0x600951))
mstore(add(c, 0x09), 0x603d3d8160223d3973)
mstore(c, 0x5f)
mstore(0x40, add(c, 0x80))
}
}
function initCodeHashERC1967(address implementation) internal pure returns (bytes32 hash) {
assembly {
let m := mload(0x40)
mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x20, 0x6009)
mstore(0x1e, implementation)
mstore(0x0a, 0x603d3d8160223d3973)
hash := keccak256(0x21, 0x5f)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function predictDeterministicAddressERC1967(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967(implementation);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function deployERC1967(address implementation, bytes memory args)
internal
returns (address instance)
{
instance = deployERC1967(0, implementation, args);
}
function deployERC1967(uint256 value, address implementation, bytes memory args)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))
mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x16, 0x6009)
mstore(0x14, implementation)
mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
instance := create(value, m, add(n, 0x60))
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function deployDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967(0, implementation, args, salt);
}
function deployDeterministicERC1967(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))
mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x16, 0x6009)
mstore(0x14, implementation)
mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
instance := create2(value, m, add(n, 0x60), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function createDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967(0, implementation, args, salt);
}
function createDeterministicERC1967(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (bool alreadyDeployed, address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))
mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x16, 0x6009)
mstore(0x14, implementation)
mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
mstore8(0x00, 0xff)
mstore(0x35, keccak256(m, add(n, 0x60)))
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
instance := keccak256(0x00, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, m, add(n, 0x60), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x35, 0)
}
}
function initCodeERC1967(address implementation, bytes memory args)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x80), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x60), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(add(c, 0x40), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(add(c, 0x20), 0x6009)
mstore(add(c, 0x1e), implementation)
mstore(add(c, 0x0a), add(0x61003d3d8160233d3973, shl(56, n)))
mstore(c, add(n, 0x60))
mstore(add(c, add(n, 0x80)), 0)
mstore(0x40, add(c, add(n, 0xa0)))
}
}
function initCodeHashERC1967(address implementation, bytes memory args)
internal
pure
returns (bytes32 hash)
{
assembly {
let m := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(m, 0x60), i), mload(add(add(args, 0x20), i)))
}
mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)
mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)
mstore(0x16, 0x6009)
mstore(0x14, implementation)
mstore(0x00, add(0x61003d3d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
hash := keccak256(m, add(n, 0x60))
}
}
function predictDeterministicAddressERC1967(
address implementation,
bytes memory args,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967(implementation, args);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function argsOnERC1967(address instance) internal view returns (bytes memory args) {
assembly {
args := mload(0x40)
mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x3d)))
extcodecopy(instance, add(args, 0x20), 0x3d, add(mload(args), 0x20))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnERC1967(address instance, uint256 start)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(instance), 0x3d))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(instance, args, add(start, 0x1d), add(l, 0x40))
mstore(args, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(args, add(0x40, mload(args))))
}
}
function argsOnERC1967(address instance, uint256 start, uint256 end)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(instance, args, add(start, 0x1d), add(d, 0x20))
if iszero(and(0xff, mload(add(args, d)))) {
let n := sub(extcodesize(instance), 0x3d)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(args, d)
mstore(add(add(args, 0x20), d), 0)
mstore(0x40, add(add(args, 0x40), d))
}
}
function deployERC1967I(address implementation) internal returns (address instance) {
instance = deployERC1967I(0, implementation);
}
function deployERC1967I(uint256 value, address implementation)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))
instance := create(value, 0x0c, 0x74)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function deployDeterministicERC1967I(address implementation, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967I(0, implementation, salt);
}
function deployDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))
instance := create2(value, 0x0c, 0x74, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function createDeterministicERC1967I(address implementation, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967I(0, implementation, salt);
}
function createDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))
mstore(add(m, 0x35), keccak256(0x0c, 0x74))
mstore(m, shl(88, address()))
mstore8(m, 0xff)
mstore(add(m, 0x15), salt)
instance := keccak256(m, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, 0x0c, 0x74, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function initCodeERC1967I(address implementation) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x74), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(c, 0x54), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(c, 0x34), 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(add(c, 0x1d), implementation)
mstore(add(c, 0x09), 0x60523d8160223d3973)
mstore(add(c, 0x94), 0)
mstore(c, 0x74)
mstore(0x40, add(c, 0xa0))
}
}
function initCodeHashERC1967I(address implementation) internal pure returns (bytes32 hash) {
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))
hash := keccak256(0x0c, 0x74)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function predictDeterministicAddressERC1967I(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967I(implementation);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function deployERC1967I(address implementation, bytes memory args) internal returns (address) {
return deployERC1967I(0, implementation, args);
}
function deployERC1967I(uint256 value, address implementation, bytes memory args)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))
mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(add(m, 0x14), implementation)
mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))
instance := create(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n))
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function deployDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967I(0, implementation, args, salt);
}
function deployDeterministicERC1967I(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))
mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(add(m, 0x14), implementation)
mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))
instance := create2(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function createDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967I(0, implementation, args, salt);
}
function createDeterministicERC1967I(
uint256 value,
address implementation,
bytes memory args,
bytes32 salt
) internal returns (bool alreadyDeployed, address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x75), n))
mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x16, 0x600f)
mstore(0x14, implementation)
mstore(gt(n, 0xffad), add(0xfe6100523d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
mstore8(0x00, 0xff)
mstore(0x35, keccak256(m, add(n, 0x75)))
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
instance := keccak256(0x00, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, m, add(0x75, n), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x35, 0)
}
}
function initCodeERC1967I(address implementation, bytes memory args)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x75), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(c, 0x55), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(c, 0x35), 0x600f5155f3365814604357363d3d373d3d363d7f360894)
mstore(add(c, 0x1e), implementation)
mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))
mstore(add(c, add(n, 0x95)), 0)
mstore(c, add(0x75, n))
mstore(0x40, add(c, add(n, 0xb5)))
}
}
function initCodeHashERC1967I(address implementation, bytes memory args)
internal
pure
returns (bytes32 hash)
{
assembly {
let m := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(m, 0x75), i), mload(add(add(args, 0x20), i)))
}
mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)
mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)
mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)
mstore(0x16, 0x600f)
mstore(0x14, implementation)
mstore(0x00, add(0x6100523d8160233d3973, shl(56, n)))
mstore(m, mload(0x16))
hash := keccak256(m, add(0x75, n))
}
}
function predictDeterministicAddressERC1967I(
address implementation,
bytes memory args,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967I(implementation, args);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function argsOnERC1967I(address instance) internal view returns (bytes memory args) {
assembly {
args := mload(0x40)
mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52)))
extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnERC1967I(address instance, uint256 start)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))
mstore(args, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnERC1967I(address instance, uint256 start, uint256 end)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))
if iszero(and(0xff, mload(add(args, d)))) {
let n := sub(extcodesize(instance), 0x52)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(args, d)
mstore(add(add(args, 0x20), d), 0)
mstore(0x40, add(add(args, 0x40), d))
}
}
function erc1967Bootstrap() internal returns (address) {
return erc1967Bootstrap(address(this));
}
function erc1967Bootstrap(address authorizedUpgrader) internal returns (address bootstrap) {
bytes memory c = initCodeERC1967Bootstrap(authorizedUpgrader);
bootstrap = predictDeterministicAddress(keccak256(c), bytes32(0), address(this));
assembly {
if iszero(extcodesize(bootstrap)) {
if iszero(create2(0, add(c, 0x20), mload(c), 0)) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
}
function bootstrapERC1967(address instance, address implementation) internal {
assembly {
mstore(0x00, implementation)
if iszero(call(gas(), instance, 0, 0x0c, 0x14, codesize(), 0x00)) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function bootstrapERC1967AndCall(address instance, address implementation, bytes memory data)
internal
{
assembly {
let n := mload(data)
mstore(data, implementation)
if iszero(call(gas(), instance, 0, add(data, 0x0c), add(n, 0x14), codesize(), 0x00)) {
if iszero(returndatasize()) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
returndatacopy(mload(0x40), 0x00, returndatasize())
revert(mload(0x40), returndatasize())
}
mstore(data, n)
}
}
function predictDeterministicAddressERC1967Bootstrap() internal view returns (address) {
return predictDeterministicAddressERC1967Bootstrap(address(this), address(this));
}
function predictDeterministicAddressERC1967Bootstrap(
address authorizedUpgrader,
address deployer
) internal pure returns (address) {
bytes32 hash = initCodeHashERC1967Bootstrap(authorizedUpgrader);
return predictDeterministicAddress(hash, bytes32(0), deployer);
}
function initCodeERC1967Bootstrap(address authorizedUpgrader)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
mstore(add(c, 0x80), 0x3d3560601c5af46047573d6000383e3d38fd0000000000000000000000000000)
mstore(add(c, 0x60), 0xa920a3ca505d382bbc55601436116049575b005b363d3d373d3d601436036014)
mstore(add(c, 0x40), 0x0338573d3560601c7f360894a13ba1a3210667c828492db98dca3e2076cc3735)
mstore(add(c, 0x20), authorizedUpgrader)
mstore(add(c, 0x0c), 0x606880600a3d393df3fe3373)
mstore(c, 0x72)
mstore(0x40, add(c, 0xa0))
}
}
function initCodeHashERC1967Bootstrap(address authorizedUpgrader)
internal
pure
returns (bytes32)
{
return keccak256(initCodeERC1967Bootstrap(authorizedUpgrader));
}
function deployERC1967BeaconProxy(address beacon) internal returns (address instance) {
instance = deployERC1967BeaconProxy(0, beacon);
}
function deployERC1967BeaconProxy(uint256 value, address beacon)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))
instance := create(value, 0x0c, 0x74)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function deployDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967BeaconProxy(0, beacon, salt);
}
function deployDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))
instance := create2(value, 0x0c, 0x74, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function createDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967BeaconProxy(0, beacon, salt);
}
function createDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))
mstore(add(m, 0x35), keccak256(0x0c, 0x74))
mstore(m, shl(88, address()))
mstore8(m, 0xff)
mstore(add(m, 0x15), salt)
instance := keccak256(m, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, 0x0c, 0x74, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function initCodeERC1967BeaconProxy(address beacon) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x74), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(c, 0x54), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(c, 0x34), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(c, 0x1d), beacon)
mstore(add(c, 0x09), 0x60523d8160223d3973)
mstore(add(c, 0x94), 0)
mstore(c, 0x74)
mstore(0x40, add(c, 0xa0))
}
}
function initCodeHashERC1967BeaconProxy(address beacon) internal pure returns (bytes32 hash) {
assembly {
let m := mload(0x40)
mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))
hash := keccak256(0x0c, 0x74)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function predictDeterministicAddressERC1967BeaconProxy(
address beacon,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967BeaconProxy(beacon);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function deployERC1967BeaconProxy(address beacon, bytes memory args)
internal
returns (address instance)
{
instance = deployERC1967BeaconProxy(0, beacon, args);
}
function deployERC1967BeaconProxy(uint256 value, address beacon, bytes memory args)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))
mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))
instance := create(value, add(m, 0x16), add(n, 0x75))
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function deployDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967BeaconProxy(0, beacon, args, salt);
}
function deployDeterministicERC1967BeaconProxy(
uint256 value,
address beacon,
bytes memory args,
bytes32 salt
) internal returns (address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))
mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))
instance := create2(value, add(m, 0x16), add(n, 0x75), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function createDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967BeaconProxy(0, beacon, args, salt);
}
function createDeterministicERC1967BeaconProxy(
uint256 value,
address beacon,
bytes memory args,
bytes32 salt
) internal returns (bool alreadyDeployed, address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))
mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))
mstore8(0x00, 0xff)
mstore(0x35, keccak256(add(m, 0x16), add(n, 0x75)))
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
instance := keccak256(0x00, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, add(m, 0x16), add(n, 0x75), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x35, 0)
}
}
function initCodeERC1967BeaconProxy(address beacon, bytes memory args)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x75), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(c, 0x55), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(c, 0x35), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(c, 0x1e), beacon)
mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))
mstore(c, add(n, 0x75))
mstore(add(c, add(n, 0x95)), 0)
mstore(0x40, add(c, add(n, 0xb5)))
}
}
function initCodeHashERC1967BeaconProxy(address beacon, bytes memory args)
internal
pure
returns (bytes32 hash)
{
assembly {
let m := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(m, 0x8b), i), mload(add(add(args, 0x20), i)))
}
mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)
mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)
mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)
mstore(add(m, 0x14), beacon)
mstore(m, add(0x6100523d8160233d3973, shl(56, n)))
hash := keccak256(add(m, 0x16), add(n, 0x75))
}
}
function predictDeterministicAddressERC1967BeaconProxy(
address beacon,
bytes memory args,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967BeaconProxy(beacon, args);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function argsOnERC1967BeaconProxy(address instance) internal view returns (bytes memory args) {
assembly {
args := mload(0x40)
mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52)))
extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnERC1967BeaconProxy(address instance, uint256 start)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))
mstore(args, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(args, add(0x40, mload(args))))
}
}
function argsOnERC1967BeaconProxy(address instance, uint256 start, uint256 end)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))
if iszero(and(0xff, mload(add(args, d)))) {
let n := sub(extcodesize(instance), 0x52)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(args, d)
mstore(add(add(args, 0x20), d), 0)
mstore(0x40, add(add(args, 0x40), d))
}
}
function deployERC1967IBeaconProxy(address beacon) internal returns (address instance) {
instance = deployERC1967IBeaconProxy(0, beacon);
}
function deployERC1967IBeaconProxy(uint256 value, address beacon)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))
instance := create(value, 0x07, 0x79)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function deployDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967IBeaconProxy(0, beacon, salt);
}
function deployDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))
instance := create2(value, 0x07, 0x79, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function createDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967IBeaconProxy(0, beacon, salt);
}
function createDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))
mstore(add(m, 0x35), keccak256(0x07, 0x79))
mstore(m, shl(88, address()))
mstore8(m, 0xff)
mstore(add(m, 0x15), salt)
instance := keccak256(m, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, 0x07, 0x79, salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x40, m)
mstore(0x60, 0)
}
}
function initCodeERC1967IBeaconProxy(address beacon) internal pure returns (bytes memory c) {
assembly {
c := mload(0x40)
mstore(add(c, 0x79), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(c, 0x59), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(c, 0x39), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(c, 0x1d), beacon)
mstore(add(c, 0x09), 0x60573d8160223d3973)
mstore(add(c, 0x99), 0)
mstore(c, 0x79)
mstore(0x40, add(c, 0xa0))
}
}
function initCodeHashERC1967IBeaconProxy(address beacon) internal pure returns (bytes32 hash) {
assembly {
let m := mload(0x40)
mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))
hash := keccak256(0x07, 0x79)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function predictDeterministicAddressERC1967IBeaconProxy(
address beacon,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function deployERC1967IBeaconProxy(address beacon, bytes memory args)
internal
returns (address instance)
{
instance = deployERC1967IBeaconProxy(0, beacon, args);
}
function deployERC1967IBeaconProxy(uint256 value, address beacon, bytes memory args)
internal
returns (address instance)
{
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))
mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))
instance := create(value, add(m, 0x16), add(n, 0x7a))
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function deployDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)
internal
returns (address instance)
{
instance = deployDeterministicERC1967IBeaconProxy(0, beacon, args, salt);
}
function deployDeterministicERC1967IBeaconProxy(
uint256 value,
address beacon,
bytes memory args,
bytes32 salt
) internal returns (address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))
mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))
instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function createDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)
internal
returns (bool alreadyDeployed, address instance)
{
return createDeterministicERC1967IBeaconProxy(0, beacon, args, salt);
}
function createDeterministicERC1967IBeaconProxy(
uint256 value,
address beacon,
bytes memory args,
bytes32 salt
) internal returns (bool alreadyDeployed, address instance) {
assembly {
let m := mload(0x40)
let n := mload(args)
pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))
mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(m, 0x14), beacon)
mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))
mstore8(0x00, 0xff)
mstore(0x35, keccak256(add(m, 0x16), add(n, 0x7a)))
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
instance := keccak256(0x00, 0x55)
for {} 1 {} {
if iszero(extcodesize(instance)) {
instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
break
}
alreadyDeployed := 1
if iszero(value) { break }
if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
break
}
mstore(0x35, 0)
}
}
function initCodeERC1967IBeaconProxy(address beacon, bytes memory args)
internal
pure
returns (bytes memory c)
{
assembly {
c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x9a), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x7a), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(c, 0x5a), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(c, 0x3a), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(c, 0x1e), beacon)
mstore(add(c, 0x0a), add(0x6100573d8160233d3973, shl(56, n)))
mstore(add(c, add(n, 0x9a)), 0)
mstore(c, add(n, 0x7a))
mstore(0x40, add(c, add(n, 0xba)))
}
}
function initCodeHashERC1967IBeaconProxy(address beacon, bytes memory args)
internal
pure
returns (bytes32 hash)
{
assembly {
let c := mload(0x40)
let n := mload(args)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))
for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {
mstore(add(add(c, 0x90), i), mload(add(add(args, 0x20), i)))
}
mstore(add(c, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)
mstore(add(c, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)
mstore(add(c, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)
mstore(add(c, 0x14), beacon)
mstore(c, add(0x6100573d8160233d3973, shl(56, n)))
hash := keccak256(add(c, 0x16), add(n, 0x7a))
}
}
function predictDeterministicAddressERC1967IBeaconProxy(
address beacon,
bytes memory args,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon, args);
predicted = predictDeterministicAddress(hash, salt, deployer);
}
function argsOnERC1967IBeaconProxy(address instance)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x57)))
extcodecopy(instance, add(args, 0x20), 0x57, add(mload(args), 0x20))
mstore(0x40, add(mload(args), add(args, 0x40)))
}
}
function argsOnERC1967IBeaconProxy(address instance, uint256 start)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(instance), 0x57))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(instance, args, add(start, 0x37), add(l, 0x40))
mstore(args, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(args, add(0x40, mload(args))))
}
}
function argsOnERC1967IBeaconProxy(address instance, uint256 start, uint256 end)
internal
view
returns (bytes memory args)
{
assembly {
args := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(instance, args, add(start, 0x37), add(d, 0x20))
if iszero(and(0xff, mload(add(args, d)))) {
let n := sub(extcodesize(instance), 0x57)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(args, d)
mstore(add(add(args, 0x20), d), 0)
mstore(0x40, add(add(args, 0x40), d))
}
}
function implementationOf(address instance) internal view returns (address result) {
assembly {
for { extcodecopy(instance, 0x00, 0x00, 0x57) } 1 {} {
if mload(0x2d) {
if or(
eq(keccak256(0x00, 0x52), ERC1967I_CODE_HASH),
eq(keccak256(0x00, 0x57), ERC1967I_BEACON_PROXY_CODE_HASH)
) {
pop(staticcall(gas(), instance, 0x00, 0x01, 0x00, 0x20))
result := mload(0x0c)
break
}
}
result := mload(0x0b)
codecopy(0x0b, codesize(), 0x14)
if iszero(xor(keccak256(0x00, 0x2c), CLONE_CODE_HASH)) { break }
mstore(0x0b, result)
result := mload(0x0a)
codecopy(0x0a, codesize(), 0x14)
if iszero(xor(keccak256(0x00, 0x2d), CWIA_CODE_HASH)) { break }
mstore(0x0a, result)
result := mload(0x09)
codecopy(0x09, codesize(), 0x14)
result := shr(xor(keccak256(0x00, 0x2d), PUSH0_CLONE_CODE_HASH), result)
break
}
result := shr(96, result)
mstore(0x37, 0)
}
}
function predictDeterministicAddress(bytes32 hash, bytes32 salt, address deployer)
internal
pure
returns (address predicted)
{
assembly {
mstore8(0x00, 0xff)
mstore(0x35, hash)
mstore(0x01, shl(96, deployer))
mstore(0x15, salt)
predicted := keccak256(0x00, 0x55)
mstore(0x35, 0)
}
}
function checkStartsWith(bytes32 salt, address by) internal pure {
assembly {
if iszero(or(iszero(shr(96, salt)), eq(shr(96, shl(96, by)), shr(96, salt)))) {
mstore(0x00, 0x0c4549ef)
revert(0x1c, 0x04)
}
}
}
function argLoad(bytes memory args, uint256 offset) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(args, 0x20), offset))
}
}
}
文件 28 的 53：LibExpiry.sol
pragma solidity ^0.8.10;
import {EIP5095} from "../interfaces/EIP5095.sol";
library LibExpiry {
function isExpired(uint256 expiry) internal view returns (bool) {
return block.timestamp >= expiry;
}
function isExpired(EIP5095 pt) internal view returns (bool) {
return block.timestamp >= pt.maturity();
}
function isNotExpired(EIP5095 pt) internal view returns (bool) {
return block.timestamp < pt.maturity();
}
}
文件 29 的 53：LibRewardProxy.sol
pragma solidity ^0.8.10;
import {TokenReward} from "../Types.sol";
library LibRewardProxy {
function delegateCallCollectReward(address rewardProxy) internal returns (TokenReward[] memory rewards) {
assembly {
mstore(0x14, rewardProxy)
mstore(0x00, 0x82c97b8d000000000000000000000000)
if iszero(delegatecall(gas(), rewardProxy, 0x10, 0x24, codesize(), 0x00)) {
mstore(0x00, 0x3f12e961)
revert(0x1c, 0x04)
}
let m := mload(0x40)
returndatacopy(m, 0x00, returndatasize())
let t := add(m, mload(m))
let n := mload(t)
let r := add(t, 0x20)
let a := add(m, returndatasize())
if or(shr(64, mload(m)), or(lt(returndatasize(), 0x20), gt(add(r, shl(6, n)), a))) {
revert(codesize(), 0x00)
}
if n {
mstore(a, n)
let o := add(a, 0x20)
mstore(0x40, add(o, shl(5, n)))
rewards := a
for { let i := 0 } 1 {} {
let p := add(r, shl(6, i))
if shr(160, mload(p)) { revert(codesize(), 0x00) }
mstore(add(o, shl(5, i)), p)
i := add(i, 1)
if eq(i, n) { break }
}
}
}
}
}
文件 30 的 53：LibString.sol
pragma solidity ^0.8.4;
import {LibBytes} from "./LibBytes.sol";
library LibString {
struct StringStorage {
bytes32 _spacer;
}
error HexLengthInsufficient();
error TooBigForSmallString();
error StringNot7BitASCII();
uint256 internal constant NOT_FOUND = type(uint256).max;
uint128 internal constant ALPHANUMERIC_7_BIT_ASCII = 0x7fffffe07fffffe03ff000000000000;
uint128 internal constant LETTERS_7_BIT_ASCII = 0x7fffffe07fffffe0000000000000000;
uint128 internal constant LOWERCASE_7_BIT_ASCII = 0x7fffffe000000000000000000000000;
uint128 internal constant UPPERCASE_7_BIT_ASCII = 0x7fffffe0000000000000000;
uint128 internal constant DIGITS_7_BIT_ASCII = 0x3ff000000000000;
uint128 internal constant HEXDIGITS_7_BIT_ASCII = 0x7e0000007e03ff000000000000;
uint128 internal constant OCTDIGITS_7_BIT_ASCII = 0xff000000000000;
uint128 internal constant PRINTABLE_7_BIT_ASCII = 0x7fffffffffffffffffffffff00003e00;
uint128 internal constant PUNCTUATION_7_BIT_ASCII = 0x78000001f8000001fc00fffe00000000;
uint128 internal constant WHITESPACE_7_BIT_ASCII = 0x100003e00;
function set(StringStorage storage $, string memory s) internal {
LibBytes.set(bytesStorage($), bytes(s));
}
function setCalldata(StringStorage storage $, string calldata s) internal {
LibBytes.setCalldata(bytesStorage($), bytes(s));
}
function clear(StringStorage storage $) internal {
delete $._spacer;
}
function isEmpty(StringStorage storage $) internal view returns (bool) {
return uint256($._spacer) & 0xff == uint256(0);
}
function length(StringStorage storage $) internal view returns (uint256) {
return LibBytes.length(bytesStorage($));
}
function get(StringStorage storage $) internal view returns (string memory) {
return string(LibBytes.get(bytesStorage($)));
}
function bytesStorage(StringStorage storage $)
internal
pure
returns (LibBytes.BytesStorage storage casted)
{
assembly {
casted.slot := $.slot
}
}
function toString(uint256 value) internal pure returns (string memory result) {
assembly {
result := add(mload(0x40), 0x80)
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
let w := not(0)
for { let temp := value } 1 {} {
result := add(result, w)
mstore8(result, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toString(int256 value) internal pure returns (string memory result) {
if (value >= 0) return toString(uint256(value));
unchecked {
result = toString(~uint256(value) + 1);
}
assembly {
let n := mload(result)
mstore(result, 0x2d)
result := sub(result, 1)
mstore(result, add(n, 1))
}
}
function toHexString(uint256 value, uint256 byteCount)
internal
pure
returns (string memory result)
{
result = toHexStringNoPrefix(value, byteCount);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(uint256 value, uint256 byteCount)
internal
pure
returns (string memory result)
{
assembly {
result := add(mload(0x40), and(add(shl(1, byteCount), 0x42), not(0x1f)))
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
mstore(0x0f, 0x30313233343536373839616263646566)
let start := sub(result, add(byteCount, byteCount))
let w := not(1)
let temp := value
for {} 1 {} {
result := add(result, w)
mstore8(add(result, 1), mload(and(temp, 15)))
mstore8(result, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(xor(result, start)) { break }
}
if temp {
mstore(0x00, 0x2194895a)
revert(0x1c, 0x04)
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toHexString(uint256 value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toMinimalHexString(uint256 value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let o := eq(byte(0, mload(add(result, 0x20))), 0x30)
let n := add(mload(result), 2)
mstore(add(result, o), 0x3078)
result := sub(add(result, o), 2)
mstore(result, sub(n, o))
}
}
function toMinimalHexStringNoPrefix(uint256 value)
internal
pure
returns (string memory result)
{
result = toHexStringNoPrefix(value);
assembly {
let o := eq(byte(0, mload(add(result, 0x20))), 0x30)
let n := mload(result)
result := add(result, o)
mstore(result, sub(n, o))
}
}
function toHexStringNoPrefix(uint256 value) internal pure returns (string memory result) {
assembly {
result := add(mload(0x40), 0x80)
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
mstore(0x0f, 0x30313233343536373839616263646566)
let w := not(1)
for { let temp := value } 1 {} {
result := add(result, w)
mstore8(add(result, 1), mload(and(temp, 15)))
mstore8(result, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(temp) { break }
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toHexStringChecksummed(address value) internal pure returns (string memory result) {
result = toHexString(value);
assembly {
let mask := shl(6, div(not(0), 255))
let o := add(result, 0x22)
let hashed := and(keccak256(o, 40), mul(34, mask))
let t := shl(240, 136)
for { let i := 0 } 1 {} {
mstore(add(i, i), mul(t, byte(i, hashed)))
i := add(i, 1)
if eq(i, 20) { break }
}
mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
o := add(o, 0x20)
mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
}
}
function toHexString(address value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(address value) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x40, add(result, 0x80))
mstore(0x0f, 0x30313233343536373839616263646566)
result := add(result, 2)
mstore(result, 40)
let o := add(result, 0x20)
mstore(add(o, 40), 0)
value := shl(96, value)
for { let i := 0 } 1 {} {
let p := add(o, add(i, i))
let temp := byte(i, value)
mstore8(add(p, 1), mload(and(temp, 15)))
mstore8(p, mload(shr(4, temp)))
i := add(i, 1)
if eq(i, 20) { break }
}
}
}
function toHexString(bytes memory raw) internal pure returns (string memory result) {
result = toHexStringNoPrefix(raw);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory result) {
assembly {
let n := mload(raw)
result := add(mload(0x40), 2)
mstore(result, add(n, n))
mstore(0x0f, 0x30313233343536373839616263646566)
let o := add(result, 0x20)
let end := add(raw, n)
for {} iszero(eq(raw, end)) {} {
raw := add(raw, 1)
mstore8(add(o, 1), mload(and(mload(raw), 15)))
mstore8(o, mload(and(shr(4, mload(raw)), 15)))
o := add(o, 2)
}
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
function runeCount(string memory s) internal pure returns (uint256 result) {
assembly {
if mload(s) {
mstore(0x00, div(not(0), 255))
mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
let o := add(s, 0x20)
let end := add(o, mload(s))
for { result := 1 } 1 { result := add(result, 1) } {
o := add(o, byte(0, mload(shr(250, mload(o)))))
if iszero(lt(o, end)) { break }
}
}
}
}
function is7BitASCII(string memory s) internal pure returns (bool result) {
assembly {
result := 1
let mask := shl(7, div(not(0), 255))
let n := mload(s)
if n {
let o := add(s, 0x20)
let end := add(o, n)
let last := mload(end)
mstore(end, 0)
for {} 1 {} {
if and(mask, mload(o)) {
result := 0
break
}
o := add(o, 0x20)
if iszero(lt(o, end)) { break }
}
mstore(end, last)
}
}
}
function is7BitASCII(string memory s, uint128 allowed) internal pure returns (bool result) {
assembly {
result := 1
if mload(s) {
let allowed_ := shr(128, shl(128, allowed))
let o := add(s, 0x20)
for { let end := add(o, mload(s)) } 1 {} {
result := and(result, shr(byte(0, mload(o)), allowed_))
o := add(o, 1)
if iszero(and(result, lt(o, end))) { break }
}
}
}
}
function to7BitASCIIAllowedLookup(string memory s) internal pure returns (uint128 result) {
assembly {
if mload(s) {
let o := add(s, 0x20)
for { let end := add(o, mload(s)) } 1 {} {
result := or(result, shl(byte(0, mload(o)), 1))
o := add(o, 1)
if iszero(lt(o, end)) { break }
}
if shr(128, result) {
mstore(0x00, 0xc9807e0d)
revert(0x1c, 0x04)
}
}
}
}
function replace(string memory subject, string memory needle, string memory replacement)
internal
pure
returns (string memory)
{
return string(LibBytes.replace(bytes(subject), bytes(needle), bytes(replacement)));
}
function indexOf(string memory subject, string memory needle, uint256 from)
internal
pure
returns (uint256)
{
return LibBytes.indexOf(bytes(subject), bytes(needle), from);
}
function indexOf(string memory subject, string memory needle) internal pure returns (uint256) {
return LibBytes.indexOf(bytes(subject), bytes(needle), 0);
}
function lastIndexOf(string memory subject, string memory needle, uint256 from)
internal
pure
returns (uint256)
{
return LibBytes.lastIndexOf(bytes(subject), bytes(needle), from);
}
function lastIndexOf(string memory subject, string memory needle)
internal
pure
returns (uint256)
{
return LibBytes.lastIndexOf(bytes(subject), bytes(needle), type(uint256).max);
}
function contains(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.contains(bytes(subject), bytes(needle));
}
function startsWith(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.startsWith(bytes(subject), bytes(needle));
}
function endsWith(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.endsWith(bytes(subject), bytes(needle));
}
function repeat(string memory subject, uint256 times) internal pure returns (string memory) {
return string(LibBytes.repeat(bytes(subject), times));
}
function slice(string memory subject, uint256 start, uint256 end)
internal
pure
returns (string memory)
{
return string(LibBytes.slice(bytes(subject), start, end));
}
function slice(string memory subject, uint256 start) internal pure returns (string memory) {
return string(LibBytes.slice(bytes(subject), start, type(uint256).max));
}
function indicesOf(string memory subject, string memory needle)
internal
pure
returns (uint256[] memory)
{
return LibBytes.indicesOf(bytes(subject), bytes(needle));
}
function split(string memory subject, string memory delimiter)
internal
pure
returns (string[] memory result)
{
bytes[] memory a = LibBytes.split(bytes(subject), bytes(delimiter));
assembly {
result := a
}
}
function concat(string memory a, string memory b) internal pure returns (string memory) {
return string(LibBytes.concat(bytes(a), bytes(b)));
}
function toCase(string memory subject, bool toUpper)
internal
pure
returns (string memory result)
{
assembly {
let n := mload(subject)
if n {
result := mload(0x40)
let o := add(result, 0x20)
let d := sub(subject, result)
let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
for { let end := add(o, n) } 1 {} {
let b := byte(0, mload(add(d, o)))
mstore8(o, xor(and(shr(b, flags), 0x20), b))
o := add(o, 1)
if eq(o, end) { break }
}
mstore(result, n)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
}
function fromSmallString(bytes32 s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
let n := 0
for {} byte(n, s) { n := add(n, 1) } {}
mstore(result, n)
let o := add(result, 0x20)
mstore(o, s)
mstore(add(o, n), 0)
mstore(0x40, add(result, 0x40))
}
}
function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
assembly {
for {} byte(result, s) { result := add(result, 1) } {}
mstore(0x00, s)
mstore(result, 0x00)
result := mload(0x00)
}
}
function toSmallString(string memory s) internal pure returns (bytes32 result) {
assembly {
result := mload(s)
if iszero(lt(result, 33)) {
mstore(0x00, 0xec92f9a3)
revert(0x1c, 0x04)
}
result := shl(shl(3, sub(32, result)), mload(add(s, result)))
}
}
function lower(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, false);
}
function upper(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, true);
}
function escapeHTML(string memory s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
let end := add(s, mload(s))
let o := add(result, 0x20)
mstore(0x1f, 0x900094)
mstore(0x08, 0xc0000000a6ab)
mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
for {} iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(and(shl(c, 1), 0x500000c400000000)) {
mstore8(o, c)
o := add(o, 1)
continue
}
let t := shr(248, mload(c))
mstore(o, mload(and(t, 0x1f)))
o := add(o, shr(5, t))
}
mstore(o, 0)
mstore(result, sub(o, add(result, 0x20)))
mstore(0x40, add(o, 0x20))
}
}
function escapeJSON(string memory s, bool addDoubleQuotes)
internal
pure
returns (string memory result)
{
assembly {
result := mload(0x40)
let o := add(result, 0x20)
if addDoubleQuotes {
mstore8(o, 34)
o := add(1, o)
}
mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
let e := or(shl(0x22, 1), shl(0x5c, 1))
for { let end := add(s, mload(s)) } iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(lt(c, 0x20)) {
if iszero(and(shl(c, 1), e)) {
mstore8(o, c)
o := add(o, 1)
continue
}
mstore8(o, 0x5c)
mstore8(add(o, 1), c)
o := add(o, 2)
continue
}
if iszero(and(shl(c, 1), 0x3700)) {
mstore8(0x1d, mload(shr(4, c)))
mstore8(0x1e, mload(and(c, 15)))
mstore(o, mload(0x19))
o := add(o, 6)
continue
}
mstore8(o, 0x5c)
mstore8(add(o, 1), mload(add(c, 8)))
o := add(o, 2)
}
if addDoubleQuotes {
mstore8(o, 34)
o := add(1, o)
}
mstore(o, 0)
mstore(result, sub(o, add(result, 0x20)))
mstore(0x40, add(o, 0x20))
}
}
function escapeJSON(string memory s) internal pure returns (string memory result) {
result = escapeJSON(s, false);
}
function encodeURIComponent(string memory s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x0f, 0x30313233343536373839414243444546)
let o := add(result, 0x20)
for { let end := add(s, mload(s)) } iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(and(1, shr(c, 0x47fffffe87fffffe03ff678200000000))) {
mstore8(o, 0x25)
mstore8(add(o, 1), mload(and(shr(4, c), 15)))
mstore8(add(o, 2), mload(and(c, 15)))
o := add(o, 3)
continue
}
mstore8(o, c)
o := add(o, 1)
}
mstore(result, sub(o, add(result, 0x20)))
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
function eq(string memory a, string memory b) internal pure returns (bool result) {
assembly {
result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
assembly {
let m := not(shl(7, div(not(iszero(b)), 255)))
let x := not(or(m, or(b, add(m, and(b, m)))))
let r := shl(7, iszero(iszero(shr(128, x))))
r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
}
}
function cmp(string memory a, string memory b) internal pure returns (int256) {
return LibBytes.cmp(bytes(a), bytes(b));
}
function packOne(string memory a) internal pure returns (bytes32 result) {
assembly {
result :=
mul(
mload(add(a, 0x1f)),
lt(sub(mload(a), 1), 0x1f)
)
}
}
function unpackOne(bytes32 packed) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x40, add(result, 0x40))
mstore(result, 0)
mstore(add(result, 0x1f), packed)
mstore(add(add(result, 0x20), mload(result)), 0)
}
}
function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
assembly {
let aLen := mload(a)
result :=
mul(
or(
shl(shl(3, sub(0x1f, aLen)), mload(add(a, aLen))), mload(sub(add(b, 0x1e), aLen))),
lt(sub(add(aLen, mload(b)), 1), 0x1e)
)
}
}
function unpackTwo(bytes32 packed)
internal
pure
returns (string memory resultA, string memory resultB)
{
assembly {
resultA := mload(0x40)
resultB := add(resultA, 0x40)
mstore(0x40, add(resultB, 0x40))
mstore(resultA, 0)
mstore(resultB, 0)
mstore(add(resultA, 0x1f), packed)
mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
mstore(add(add(resultA, 0x20), mload(resultA)), 0)
mstore(add(add(resultB, 0x20), mload(resultB)), 0)
}
}
function directReturn(string memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
let retUnpaddedSize := add(mload(a), 0x40)
mstore(add(retStart, retUnpaddedSize), 0)
mstore(retStart, 0x20)
return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
}
}
}
文件 31 的 53：LibTransient.sol
pragma solidity ^0.8.4;
library LibTransient {
struct TUint256 {
uint256 _spacer;
}
struct TInt256 {
uint256 _spacer;
}
struct TBytes32 {
uint256 _spacer;
}
struct TAddress {
uint256 _spacer;
}
struct TBool {
uint256 _spacer;
}
struct TBytes {
uint256 _spacer;
}
uint256 private constant _LIB_TRANSIENT_COMPAT_SLOT_SEED = 0x5a0b45f2;
function tUint256(bytes32 tSlot) internal pure returns (TUint256 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tUint256(uint256 tSlot) internal pure returns (TUint256 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function get(TUint256 storage ptr) internal view returns (uint256 result) {
assembly {
result := tload(ptr.slot)
}
}
function getCompat(TUint256 storage ptr) internal view returns (uint256 result) {
result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer;
}
function set(TUint256 storage ptr, uint256 value) internal {
assembly {
tstore(ptr.slot, value)
}
}
function setCompat(TUint256 storage ptr, uint256 value) internal {
if (block.chainid == 1) return set(ptr, value);
_compat(ptr)._spacer = value;
}
function clear(TUint256 storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TUint256 storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function inc(TUint256 storage ptr) internal returns (uint256 newValue) {
set(ptr, newValue = get(ptr) + 1);
}
function incCompat(TUint256 storage ptr) internal returns (uint256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) + 1);
}
function inc(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {
set(ptr, newValue = get(ptr) + delta);
}
function incCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) + delta);
}
function dec(TUint256 storage ptr) internal returns (uint256 newValue) {
set(ptr, newValue = get(ptr) - 1);
}
function decCompat(TUint256 storage ptr) internal returns (uint256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) - 1);
}
function dec(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {
set(ptr, newValue = get(ptr) - delta);
}
function decCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) - delta);
}
function incSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {
assembly {
let currentValue := tload(ptr.slot)
newValue := add(currentValue, delta)
if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {
mstore(0x00, 0x4e487b71)
mstore(0x20, 0x11)
revert(0x1c, 0x24)
}
tstore(ptr.slot, newValue)
}
}
function incSignedCompat(TUint256 storage ptr, int256 delta)
internal
returns (uint256 newValue)
{
if (block.chainid == 1) return incSigned(ptr, delta);
ptr = _compat(ptr);
assembly {
let currentValue := sload(ptr.slot)
newValue := add(currentValue, delta)
if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {
mstore(0x00, 0x4e487b71)
mstore(0x20, 0x11)
revert(0x1c, 0x24)
}
sstore(ptr.slot, newValue)
}
}
function decSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {
assembly {
let currentValue := tload(ptr.slot)
newValue := sub(currentValue, delta)
if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {
mstore(0x00, 0x4e487b71)
mstore(0x20, 0x11)
revert(0x1c, 0x24)
}
tstore(ptr.slot, newValue)
}
}
function decSignedCompat(TUint256 storage ptr, int256 delta)
internal
returns (uint256 newValue)
{
if (block.chainid == 1) return decSigned(ptr, delta);
ptr = _compat(ptr);
assembly {
let currentValue := sload(ptr.slot)
newValue := sub(currentValue, delta)
if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {
mstore(0x00, 0x4e487b71)
mstore(0x20, 0x11)
revert(0x1c, 0x24)
}
sstore(ptr.slot, newValue)
}
}
function tInt256(bytes32 tSlot) internal pure returns (TInt256 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tInt256(uint256 tSlot) internal pure returns (TInt256 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function get(TInt256 storage ptr) internal view returns (int256 result) {
assembly {
result := tload(ptr.slot)
}
}
function getCompat(TInt256 storage ptr) internal view returns (int256 result) {
result = block.chainid == 1 ? get(ptr) : int256(_compat(ptr)._spacer);
}
function set(TInt256 storage ptr, int256 value) internal {
assembly {
tstore(ptr.slot, value)
}
}
function setCompat(TInt256 storage ptr, int256 value) internal {
if (block.chainid == 1) return set(ptr, value);
_compat(ptr)._spacer = uint256(value);
}
function clear(TInt256 storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TInt256 storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function inc(TInt256 storage ptr) internal returns (int256 newValue) {
set(ptr, newValue = get(ptr) + 1);
}
function incCompat(TInt256 storage ptr) internal returns (int256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) + 1);
}
function inc(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {
set(ptr, newValue = get(ptr) + delta);
}
function incCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) + delta);
}
function dec(TInt256 storage ptr) internal returns (int256 newValue) {
set(ptr, newValue = get(ptr) - 1);
}
function decCompat(TInt256 storage ptr) internal returns (int256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) - 1);
}
function dec(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {
set(ptr, newValue = get(ptr) - delta);
}
function decCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {
setCompat(ptr, newValue = getCompat(ptr) - delta);
}
function tBytes32(bytes32 tSlot) internal pure returns (TBytes32 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tBytes32(uint256 tSlot) internal pure returns (TBytes32 storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function get(TBytes32 storage ptr) internal view returns (bytes32 result) {
assembly {
result := tload(ptr.slot)
}
}
function getCompat(TBytes32 storage ptr) internal view returns (bytes32 result) {
result = block.chainid == 1 ? get(ptr) : bytes32(_compat(ptr)._spacer);
}
function set(TBytes32 storage ptr, bytes32 value) internal {
assembly {
tstore(ptr.slot, value)
}
}
function setCompat(TBytes32 storage ptr, bytes32 value) internal {
if (block.chainid == 1) return set(ptr, value);
_compat(ptr)._spacer = uint256(value);
}
function clear(TBytes32 storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TBytes32 storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function tAddress(bytes32 tSlot) internal pure returns (TAddress storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tAddress(uint256 tSlot) internal pure returns (TAddress storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function get(TAddress storage ptr) internal view returns (address result) {
assembly {
result := tload(ptr.slot)
}
}
function getCompat(TAddress storage ptr) internal view returns (address result) {
result = block.chainid == 1 ? get(ptr) : address(uint160(_compat(ptr)._spacer));
}
function set(TAddress storage ptr, address value) internal {
assembly {
tstore(ptr.slot, shr(96, shl(96, value)))
}
}
function setCompat(TAddress storage ptr, address value) internal {
if (block.chainid == 1) return set(ptr, value);
_compat(ptr)._spacer = uint160(value);
}
function clear(TAddress storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TAddress storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function tBool(bytes32 tSlot) internal pure returns (TBool storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tBool(uint256 tSlot) internal pure returns (TBool storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function get(TBool storage ptr) internal view returns (bool result) {
assembly {
result := tload(ptr.slot)
}
}
function getCompat(TBool storage ptr) internal view returns (bool result) {
result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer != 0;
}
function set(TBool storage ptr, bool value) internal {
assembly {
tstore(ptr.slot, iszero(iszero(value)))
}
}
function setCompat(TBool storage ptr, bool value) internal {
if (block.chainid == 1) return set(ptr, value);
ptr = _compat(ptr);
assembly {
sstore(ptr.slot, iszero(iszero(value)))
}
}
function clear(TBool storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TBool storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function tBytes(bytes32 tSlot) internal pure returns (TBytes storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function tBytes(uint256 tSlot) internal pure returns (TBytes storage ptr) {
assembly {
ptr.slot := tSlot
}
}
function length(TBytes storage ptr) internal view returns (uint256 result) {
assembly {
result := shr(224, tload(ptr.slot))
}
}
function lengthCompat(TBytes storage ptr) internal view returns (uint256 result) {
if (block.chainid == 1) return length(ptr);
ptr = _compat(ptr);
assembly {
result := shr(224, sload(ptr.slot))
}
}
function get(TBytes storage ptr) internal view returns (bytes memory result) {
assembly {
result := mload(0x40)
mstore(result, 0x00)
mstore(add(result, 0x1c), tload(ptr.slot))
let n := mload(result)
let e := add(add(result, 0x20), n)
if iszero(lt(n, 0x1d)) {
mstore(0x00, ptr.slot)
let d := sub(keccak256(0x00, 0x20), result)
for { let o := add(result, 0x3c) } 1 {} {
mstore(o, tload(add(o, d)))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
mstore(e, 0)
mstore(0x40, add(0x20, e))
}
}
function getCompat(TBytes storage ptr) internal view returns (bytes memory result) {
if (block.chainid == 1) return get(ptr);
ptr = _compat(ptr);
assembly {
result := mload(0x40)
mstore(result, 0x00)
mstore(add(result, 0x1c), sload(ptr.slot))
let n := mload(result)
let e := add(add(result, 0x20), n)
if iszero(lt(n, 0x1d)) {
mstore(0x00, ptr.slot)
let d := sub(keccak256(0x00, 0x20), result)
for { let o := add(result, 0x3c) } 1 {} {
mstore(o, sload(add(o, d)))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
mstore(e, 0)
mstore(0x40, add(0x20, e))
}
}
function set(TBytes storage ptr, bytes memory value) internal {
assembly {
tstore(ptr.slot, mload(add(value, 0x1c)))
if iszero(lt(mload(value), 0x1d)) {
mstore(0x00, ptr.slot)
let e := add(add(value, 0x20), mload(value))
let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)
for { let o := add(value, 0x3c) } 1 {} {
tstore(add(o, d), mload(o))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
}
}
function setCompat(TBytes storage ptr, bytes memory value) internal {
if (block.chainid == 1) return set(ptr, value);
ptr = _compat(ptr);
assembly {
sstore(ptr.slot, mload(add(value, 0x1c)))
if iszero(lt(mload(value), 0x1d)) {
mstore(0x00, ptr.slot)
let e := add(add(value, 0x20), mload(value))
let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)
for { let o := add(value, 0x3c) } 1 {} {
sstore(add(o, d), mload(o))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
}
}
function setCalldata(TBytes storage ptr, bytes calldata value) internal {
assembly {
tstore(ptr.slot, or(shl(224, value.length), shr(32, calldataload(value.offset))))
if iszero(lt(value.length, 0x1d)) {
mstore(0x00, ptr.slot)
let e := add(value.offset, value.length)
let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),
value.offset), 0x20)
for { let o := add(value.offset, 0x1c) } 1 {} {
tstore(add(o, d), calldataload(o))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
}
}
function setCalldataCompat(TBytes storage ptr, bytes calldata value) internal {
if (block.chainid == 1) return setCalldata(ptr, value);
ptr = _compat(ptr);
assembly {
sstore(ptr.slot, or(shl(224, value.length), shr(32, calldataload(value.offset))))
if iszero(lt(value.length, 0x1d)) {
mstore(0x00, ptr.slot)
let e := add(value.offset, value.length)
let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),
value.offset), 0x20)
for { let o := add(value.offset, 0x1c) } 1 {} {
sstore(add(o, d), calldataload(o))
o := add(o, 0x20)
if iszero(lt(o, e)) { break }
}
}
}
}
function clear(TBytes storage ptr) internal {
assembly {
tstore(ptr.slot, 0)
}
}
function clearCompat(TBytes storage ptr) internal {
if (block.chainid == 1) return clear(ptr);
_compat(ptr)._spacer = 0;
}
function _compat(TUint256 storage ptr) private pure returns (TUint256 storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
function _compat(TInt256 storage ptr) private pure returns (TInt256 storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
function _compat(TBytes32 storage ptr) private pure returns (TBytes32 storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
function _compat(TAddress storage ptr) private pure returns (TAddress storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
function _compat(TBool storage ptr) private pure returns (TBool storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
function _compat(TBytes storage ptr) private pure returns (TBytes storage c) {
assembly {
mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)
mstore(0x00, ptr.slot)
c.slot := keccak256(0x00, 0x24)
}
}
}
文件 32 的 53：MetadataReaderLib.sol
pragma solidity ^0.8.4;
library MetadataReaderLib {
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
uint256 internal constant STRING_LIMIT_DEFAULT = 1000;
function readName(address target) internal view returns (string memory) {
return _string(target, _ptr(0x06fdde03), STRING_LIMIT_DEFAULT, GAS_STIPEND_NO_GRIEF);
}
function readName(address target, uint256 limit) internal view returns (string memory) {
return _string(target, _ptr(0x06fdde03), limit, GAS_STIPEND_NO_GRIEF);
}
function readName(address target, uint256 limit, uint256 gasStipend)
internal
view
returns (string memory)
{
return _string(target, _ptr(0x06fdde03), limit, gasStipend);
}
function readSymbol(address target) internal view returns (string memory) {
return _string(target, _ptr(0x95d89b41), STRING_LIMIT_DEFAULT, GAS_STIPEND_NO_GRIEF);
}
function readSymbol(address target, uint256 limit) internal view returns (string memory) {
return _string(target, _ptr(0x95d89b41), limit, GAS_STIPEND_NO_GRIEF);
}
function readSymbol(address target, uint256 limit, uint256 gasStipend)
internal
view
returns (string memory)
{
return _string(target, _ptr(0x95d89b41), limit, gasStipend);
}
function readString(address target, bytes memory data) internal view returns (string memory) {
return _string(target, _ptr(data), STRING_LIMIT_DEFAULT, GAS_STIPEND_NO_GRIEF);
}
function readString(address target, bytes memory data, uint256 limit)
internal
view
returns (string memory)
{
return _string(target, _ptr(data), limit, GAS_STIPEND_NO_GRIEF);
}
function readString(address target, bytes memory data, uint256 limit, uint256 gasStipend)
internal
view
returns (string memory)
{
return _string(target, _ptr(data), limit, gasStipend);
}
function readDecimals(address target) internal view returns (uint8) {
return uint8(_uint(target, _ptr(0x313ce567), GAS_STIPEND_NO_GRIEF));
}
function readDecimals(address target, uint256 gasStipend) internal view returns (uint8) {
return uint8(_uint(target, _ptr(0x313ce567), gasStipend));
}
function readUint(address target, bytes memory data) internal view returns (uint256) {
return _uint(target, _ptr(data), GAS_STIPEND_NO_GRIEF);
}
function readUint(address target, bytes memory data, uint256 gasStipend)
internal
view
returns (uint256)
{
return _uint(target, _ptr(data), gasStipend);
}
function _string(address target, bytes32 ptr, uint256 limit, uint256 gasStipend)
private
view
returns (string memory result)
{
assembly {
function min(x_, y_) -> _z {
_z := xor(x_, mul(xor(x_, y_), lt(y_, x_)))
}
for {} staticcall(gasStipend, target, add(ptr, 0x20), mload(ptr), 0x00, 0x20) {} {
let m := mload(0x40)
let s := add(0x20, m)
if iszero(lt(returndatasize(), 0x40)) {
let o := mload(0x00)
if iszero(gt(o, sub(returndatasize(), 0x20))) {
returndatacopy(m, o, 0x20)
if iszero(gt(mload(m), sub(returndatasize(), add(o, 0x20)))) {
let n := min(mload(m), limit)
mstore(m, n)
returndatacopy(s, add(o, 0x20), n)
mstore(add(s, n), 0)
mstore(0x40, add(0x20, add(s, n)))
result := m
break
}
}
}
let n := min(returndatasize(), limit)
returndatacopy(s, 0, n)
mstore8(add(s, n), 0)
let i := s
for {} byte(0, mload(i)) { i := add(i, 1) } {}
mstore(m, sub(i, s))
mstore(i, 0)
mstore(0x40, add(0x20, i))
result := m
break
}
}
}
function _uint(address target, bytes32 ptr, uint256 gasStipend)
private
view
returns (uint256 result)
{
assembly {
result :=
mul(
mload(0x20),
and(
gt(returndatasize(), 0x1f),
staticcall(gasStipend, target, add(ptr, 0x20), mload(ptr), 0x20, 0x20)
)
)
}
}
function _ptr(uint256 s) private pure returns (bytes32 result) {
assembly {
mstore(0x04, s)
mstore(result, 4)
}
}
function _ptr(bytes memory data) private pure returns (bytes32 result) {
assembly {
result := data
}
}
}
文件 33 的 53：ModuleAccessor.sol
pragma solidity ^0.8.10;
import {SSTORE2} from "solady/src/utils/SSTORE2.sol";
import {ModuleIndex} from "../Types.sol";
library ModuleAccessor {
error ModuleOutOfBounds();
function read(address pointer) internal view returns (address[] memory m) {
bytes memory data = SSTORE2.read(pointer);
assembly {
m := add(data, 0x40)
}
}
function get(address[] memory m, ModuleIndex idx) internal pure returns (address module) {
assembly {
if iszero(lt(idx, mload(m))) {
mstore(0x00, 0x13bec8a3)
revert(0x1c, 0x04)
}
module := mload(add(add(m, 0x20), mul(idx, 0x20)))
}
}
function unsafeGet(address[] memory m, ModuleIndex idx) internal pure returns (address module) {
assembly {
module := mload(add(add(m, 0x20), mul(idx, 0x20)))
}
}
function getOrDefault(address[] memory m, ModuleIndex idx) internal pure returns (address module) {
assembly {
if lt(idx, mload(m)) { module := mload(add(add(m, 0x20), mul(idx, 0x20))) }
}
}
function set(address[] memory m, ModuleIndex idx, address module) internal pure {
assembly {
if iszero(lt(idx, mload(m))) {
mstore(0x00, 0x13bec8a3)
revert(0x1c, 0x04)
}
mstore(add(add(m, 0x20), mul(idx, 0x20)), module)
}
}
}
文件 34 的 53：ModuleIndex.sol
pragma solidity ^0.8.24;
import {ModuleIndex, MAX_MODULES} from "../Types.sol";
function unwrap(ModuleIndex x) pure returns (uint256 result) {
result = ModuleIndex.unwrap(x);
}
function isSupportedByFactory(ModuleIndex x) pure returns (bool result) {
result = ModuleIndex.unwrap(x) < MAX_MODULES;
}
function eq(ModuleIndex x, ModuleIndex y) pure returns (bool result) {
result = ModuleIndex.unwrap(x) == ModuleIndex.unwrap(y);
}
文件 35 的 53：Multicallable.sol
pragma solidity ^0.8.4;
abstract contract Multicallable {
function multicall(bytes[] calldata data) public payable virtual returns (bytes[] memory) {
if (msg.value != 0) revert();
_multicallDirectReturn(_multicall(data));
}
function _multicall(bytes[] calldata data) internal virtual returns (bytes32 results) {
assembly {
results := mload(0x40)
mstore(results, 0x20)
mstore(add(0x20, results), data.length)
let c := add(0x40, results)
let s := c
let end := shl(5, data.length)
calldatacopy(c, data.offset, end)
end := add(c, end)
let m := end
if data.length {
for {} 1 {} {
let o := add(data.offset, mload(c))
calldatacopy(m, add(o, 0x20), calldataload(o))
if iszero(delegatecall(gas(), address(), m, calldataload(o), codesize(), 0x00)) {
returndatacopy(results, 0x00, returndatasize())
revert(results, returndatasize())
}
mstore(c, sub(m, s))
c := add(0x20, c)
mstore(m, returndatasize())
let b := add(m, 0x20)
returndatacopy(b, 0x00, returndatasize())
m := and(add(add(b, returndatasize()), 0x1f), 0xffffffffffffffe0)
mstore(add(b, returndatasize()), 0)
if iszero(lt(c, end)) { break }
}
}
mstore(0x40, m)
results := or(shl(64, sub(m, results)), results)
}
}
function _multicallResultsToBytesArray(bytes32 results)
internal
pure
virtual
returns (bytes[] memory decoded)
{
assembly {
decoded := mload(0x40)
let c := and(0xffffffffffffffff, results)
mstore(decoded, mload(add(c, 0x20)))
let o := add(decoded, 0x20)
let end := add(o, shl(5, mload(decoded)))
mstore(0x40, end)
let s := add(c, 0x40)
let d := sub(s, o)
for {} iszero(eq(o, end)) { o := add(o, 0x20) } { mstore(o, add(mload(add(d, o)), s)) }
}
}
function _multicallDirectReturn(bytes32 results) internal pure virtual {
assembly {
return(and(0xffffffffffffffff, results), shr(64, results))
}
}
}
文件 36 的 53：Ownable.sol
pragma solidity ^0.8.4;
abstract contract Ownable {
error Unauthorized();
error NewOwnerIsZeroAddress();
error NoHandoverRequest();
error AlreadyInitialized();
event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);
event OwnershipHandoverRequested(address indexed pendingOwner);
event OwnershipHandoverCanceled(address indexed pendingOwner);
uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;
uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;
uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;
bytes32 internal constant _OWNER_SLOT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;
uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;
function _guardInitializeOwner() internal pure virtual returns (bool guard) {}
function _initializeOwner(address newOwner) internal virtual {
if (_guardInitializeOwner()) {
assembly {
let ownerSlot := _OWNER_SLOT
if sload(ownerSlot) {
mstore(0x00, 0x0dc149f0)
revert(0x1c, 0x04)
}
newOwner := shr(96, shl(96, newOwner))
sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
} else {
assembly {
newOwner := shr(96, shl(96, newOwner))
sstore(_OWNER_SLOT, newOwner)
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
}
}
function _setOwner(address newOwner) internal virtual {
if (_guardInitializeOwner()) {
assembly {
let ownerSlot := _OWNER_SLOT
newOwner := shr(96, shl(96, newOwner))
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
}
} else {
assembly {
let ownerSlot := _OWNER_SLOT
newOwner := shr(96, shl(96, newOwner))
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
sstore(ownerSlot, newOwner)
}
}
}
function _checkOwner() internal view virtual {
assembly {
if iszero(eq(caller(), sload(_OWNER_SLOT))) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
return 48 * 3600;
}
function transferOwnership(address newOwner) public payable virtual onlyOwner {
assembly {
if iszero(shl(96, newOwner)) {
mstore(0x00, 0x7448fbae)
revert(0x1c, 0x04)
}
}
_setOwner(newOwner);
}
function renounceOwnership() public payable virtual onlyOwner {
_setOwner(address(0));
}
function requestOwnershipHandover() public payable virtual {
unchecked {
uint256 expires = block.timestamp + _ownershipHandoverValidFor();
assembly {
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), expires)
log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
}
}
}
function cancelOwnershipHandover() public payable virtual {
assembly {
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), 0)
log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
}
}
function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
assembly {
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
let handoverSlot := keccak256(0x0c, 0x20)
if gt(timestamp(), sload(handoverSlot)) {
mstore(0x00, 0x6f5e8818)
revert(0x1c, 0x04)
}
sstore(handoverSlot, 0)
}
_setOwner(pendingOwner);
}
function owner() public view virtual returns (address result) {
assembly {
result := sload(_OWNER_SLOT)
}
}
function ownershipHandoverExpiresAt(address pendingOwner)
public
view
virtual
returns (uint256 result)
{
assembly {
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
result := sload(keccak256(0x0c, 0x20))
}
}
modifier onlyOwner() virtual {
_checkOwner();
_;
}
}
文件 37 的 53：OwnableRoles.sol
pragma solidity ^0.8.4;
import {Ownable} from "./Ownable.sol";
abstract contract OwnableRoles is Ownable {
event RolesUpdated(address indexed user, uint256 indexed roles);
uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =
0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;
uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;
function _setRoles(address user, uint256 roles) internal virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
sstore(keccak256(0x0c, 0x20), roles)
log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)
}
}
function _updateRoles(address user, uint256 roles, bool on) internal virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
let roleSlot := keccak256(0x0c, 0x20)
let current := sload(roleSlot)
let updated := or(current, roles)
if iszero(on) { updated := xor(current, and(current, roles)) }
sstore(roleSlot, updated)
log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)
}
}
function _grantRoles(address user, uint256 roles) internal virtual {
_updateRoles(user, roles, true);
}
function _removeRoles(address user, uint256 roles) internal virtual {
_updateRoles(user, roles, false);
}
function _checkRoles(uint256 roles) internal view virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
function _checkOwnerOrRoles(uint256 roles) internal view virtual {
assembly {
if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
}
function _checkRolesOrOwner(uint256 roles) internal view virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
}
function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {
assembly {
for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {
roles := or(shl(mload(add(ordinals, i)), 1), roles)
}
}
}
function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {
assembly {
ordinals := mload(0x40)
let ptr := add(ordinals, 0x20)
let o := 0
for { let t := roles } 1 {} {
mstore(ptr, o)
ptr := add(ptr, shl(5, and(t, 1)))
o := add(o, 1)
t := shr(o, roles)
if iszero(t) { break }
}
mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))
mstore(0x40, ptr)
}
}
function grantRoles(address user, uint256 roles) public payable virtual onlyOwner {
_grantRoles(user, roles);
}
function revokeRoles(address user, uint256 roles) public payable virtual onlyOwner {
_removeRoles(user, roles);
}
function renounceRoles(uint256 roles) public payable virtual {
_removeRoles(msg.sender, roles);
}
function rolesOf(address user) public view virtual returns (uint256 roles) {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
roles := sload(keccak256(0x0c, 0x20))
}
}
function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {
return rolesOf(user) & roles != 0;
}
function hasAllRoles(address user, uint256 roles) public view virtual returns (bool) {
return rolesOf(user) & roles == roles;
}
modifier onlyRoles(uint256 roles) virtual {
_checkRoles(roles);
_;
}
modifier onlyOwnerOrRoles(uint256 roles) virtual {
_checkOwnerOrRoles(roles);
_;
}
modifier onlyRolesOrOwner(uint256 roles) virtual {
_checkRolesOrOwner(roles);
_;
}
uint256 internal constant _ROLE_0 = 1 << 0;
uint256 internal constant _ROLE_1 = 1 << 1;
uint256 internal constant _ROLE_2 = 1 << 2;
uint256 internal constant _ROLE_3 = 1 << 3;
uint256 internal constant _ROLE_4 = 1 << 4;
uint256 internal constant _ROLE_5 = 1 << 5;
uint256 internal constant _ROLE_6 = 1 << 6;
uint256 internal constant _ROLE_7 = 1 << 7;
uint256 internal constant _ROLE_8 = 1 << 8;
uint256 internal constant _ROLE_9 = 1 << 9;
uint256 internal constant _ROLE_10 = 1 << 10;
uint256 internal constant _ROLE_11 = 1 << 11;
uint256 internal constant _ROLE_12 = 1 << 12;
uint256 internal constant _ROLE_13 = 1 << 13;
uint256 internal constant _ROLE_14 = 1 << 14;
uint256 internal constant _ROLE_15 = 1 << 15;
uint256 internal constant _ROLE_16 = 1 << 16;
uint256 internal constant _ROLE_17 = 1 << 17;
uint256 internal constant _ROLE_18 = 1 << 18;
uint256 internal constant _ROLE_19 = 1 << 19;
uint256 internal constant _ROLE_20 = 1 << 20;
uint256 internal constant _ROLE_21 = 1 << 21;
uint256 internal constant _ROLE_22 = 1 << 22;
uint256 internal constant _ROLE_23 = 1 << 23;
uint256 internal constant _ROLE_24 = 1 << 24;
uint256 internal constant _ROLE_25 = 1 << 25;
uint256 internal constant _ROLE_26 = 1 << 26;
uint256 internal constant _ROLE_27 = 1 << 27;
uint256 internal constant _ROLE_28 = 1 << 28;
uint256 internal constant _ROLE_29 = 1 << 29;
uint256 internal constant _ROLE_30 = 1 << 30;
uint256 internal constant _ROLE_31 = 1 << 31;
uint256 internal constant _ROLE_32 = 1 << 32;
uint256 internal constant _ROLE_33 = 1 << 33;
uint256 internal constant _ROLE_34 = 1 << 34;
uint256 internal constant _ROLE_35 = 1 << 35;
uint256 internal constant _ROLE_36 = 1 << 36;
uint256 internal constant _ROLE_37 = 1 << 37;
uint256 internal constant _ROLE_38 = 1 << 38;
uint256 internal constant _ROLE_39 = 1 << 39;
uint256 internal constant _ROLE_40 = 1 << 40;
uint256 internal constant _ROLE_41 = 1 << 41;
uint256 internal constant _ROLE_42 = 1 << 42;
uint256 internal constant _ROLE_43 = 1 << 43;
uint256 internal constant _ROLE_44 = 1 << 44;
uint256 internal constant _ROLE_45 = 1 << 45;
uint256 internal constant _ROLE_46 = 1 << 46;
uint256 internal constant _ROLE_47 = 1 << 47;
uint256 internal constant _ROLE_48 = 1 << 48;
uint256 internal constant _ROLE_49 = 1 << 49;
uint256 internal constant _ROLE_50 = 1 << 50;
uint256 internal constant _ROLE_51 = 1 << 51;
uint256 internal constant _ROLE_52 = 1 << 52;
uint256 internal constant _ROLE_53 = 1 << 53;
uint256 internal constant _ROLE_54 = 1 << 54;
uint256 internal constant _ROLE_55 = 1 << 55;
uint256 internal constant _ROLE_56 = 1 << 56;
uint256 internal constant _ROLE_57 = 1 << 57;
uint256 internal constant _ROLE_58 = 1 << 58;
uint256 internal constant _ROLE_59 = 1 << 59;
uint256 internal constant _ROLE_60 = 1 << 60;
uint256 internal constant _ROLE_61 = 1 << 61;
uint256 internal constant _ROLE_62 = 1 << 62;
uint256 internal constant _ROLE_63 = 1 << 63;
uint256 internal constant _ROLE_64 = 1 << 64;
uint256 internal constant _ROLE_65 = 1 << 65;
uint256 internal constant _ROLE_66 = 1 << 66;
uint256 internal constant _ROLE_67 = 1 << 67;
uint256 internal constant _ROLE_68 = 1 << 68;
uint256 internal constant _ROLE_69 = 1 << 69;
uint256 internal constant _ROLE_70 = 1 << 70;
uint256 internal constant _ROLE_71 = 1 << 71;
uint256 internal constant _ROLE_72 = 1 << 72;
uint256 internal constant _ROLE_73 = 1 << 73;
uint256 internal constant _ROLE_74 = 1 << 74;
uint256 internal constant _ROLE_75 = 1 << 75;
uint256 internal constant _ROLE_76 = 1 << 76;
uint256 internal constant _ROLE_77 = 1 << 77;
uint256 internal constant _ROLE_78 = 1 << 78;
uint256 internal constant _ROLE_79 = 1 << 79;
uint256 internal constant _ROLE_80 = 1 << 80;
uint256 internal constant _ROLE_81 = 1 << 81;
uint256 internal constant _ROLE_82 = 1 << 82;
uint256 internal constant _ROLE_83 = 1 << 83;
uint256 internal constant _ROLE_84 = 1 << 84;
uint256 internal constant _ROLE_85 = 1 << 85;
uint256 internal constant _ROLE_86 = 1 << 86;
uint256 internal constant _ROLE_87 = 1 << 87;
uint256 internal constant _ROLE_88 = 1 << 88;
uint256 internal constant _ROLE_89 = 1 << 89;
uint256 internal constant _ROLE_90 = 1 << 90;
uint256 internal constant _ROLE_91 = 1 << 91;
uint256 internal constant _ROLE_92 = 1 << 92;
uint256 internal constant _ROLE_93 = 1 << 93;
uint256 internal constant _ROLE_94 = 1 << 94;
uint256 internal constant _ROLE_95 = 1 << 95;
uint256 internal constant _ROLE_96 = 1 << 96;
uint256 internal constant _ROLE_97 = 1 << 97;
uint256 internal constant _ROLE_98 = 1 << 98;
uint256 internal constant _ROLE_99 = 1 << 99;
uint256 internal constant _ROLE_100 = 1 << 100;
uint256 internal constant _ROLE_101 = 1 << 101;
uint256 internal constant _ROLE_102 = 1 << 102;
uint256 internal constant _ROLE_103 = 1 << 103;
uint256 internal constant _ROLE_104 = 1 << 104;
uint256 internal constant _ROLE_105 = 1 << 105;
uint256 internal constant _ROLE_106 = 1 << 106;
uint256 internal constant _ROLE_107 = 1 << 107;
uint256 internal constant _ROLE_108 = 1 << 108;
uint256 internal constant _ROLE_109 = 1 << 109;
uint256 internal constant _ROLE_110 = 1 << 110;
uint256 internal constant _ROLE_111 = 1 << 111;
uint256 internal constant _ROLE_112 = 1 << 112;
uint256 internal constant _ROLE_113 = 1 << 113;
uint256 internal constant _ROLE_114 = 1 << 114;
uint256 internal constant _ROLE_115 = 1 << 115;
uint256 internal constant _ROLE_116 = 1 << 116;
uint256 internal constant _ROLE_117 = 1 << 117;
uint256 internal constant _ROLE_118 = 1 << 118;
uint256 internal constant _ROLE_119 = 1 << 119;
uint256 internal constant _ROLE_120 = 1 << 120;
uint256 internal constant _ROLE_121 = 1 << 121;
uint256 internal constant _ROLE_122 = 1 << 122;
uint256 internal constant _ROLE_123 = 1 << 123;
uint256 internal constant _ROLE_124 = 1 << 124;
uint256 internal constant _ROLE_125 = 1 << 125;
uint256 internal constant _ROLE_126 = 1 << 126;
uint256 internal constant _ROLE_127 = 1 << 127;
uint256 internal constant _ROLE_128 = 1 << 128;
uint256 internal constant _ROLE_129 = 1 << 129;
uint256 internal constant _ROLE_130 = 1 << 130;
uint256 internal constant _ROLE_131 = 1 << 131;
uint256 internal constant _ROLE_132 = 1 << 132;
uint256 internal constant _ROLE_133 = 1 << 133;
uint256 internal constant _ROLE_134 = 1 << 134;
uint256 internal constant _ROLE_135 = 1 << 135;
uint256 internal constant _ROLE_136 = 1 << 136;
uint256 internal constant _ROLE_137 = 1 << 137;
uint256 internal constant _ROLE_138 = 1 << 138;
uint256 internal constant _ROLE_139 = 1 << 139;
uint256 internal constant _ROLE_140 = 1 << 140;
uint256 internal constant _ROLE_141 = 1 << 141;
uint256 internal constant _ROLE_142 = 1 << 142;
uint256 internal constant _ROLE_143 = 1 << 143;
uint256 internal constant _ROLE_144 = 1 << 144;
uint256 internal constant _ROLE_145 = 1 << 145;
uint256 internal constant _ROLE_146 = 1 << 146;
uint256 internal constant _ROLE_147 = 1 << 147;
uint256 internal constant _ROLE_148 = 1 << 148;
uint256 internal constant _ROLE_149 = 1 << 149;
uint256 internal constant _ROLE_150 = 1 << 150;
uint256 internal constant _ROLE_151 = 1 << 151;
uint256 internal constant _ROLE_152 = 1 << 152;
uint256 internal constant _ROLE_153 = 1 << 153;
uint256 internal constant _ROLE_154 = 1 << 154;
uint256 internal constant _ROLE_155 = 1 << 155;
uint256 internal constant _ROLE_156 = 1 << 156;
uint256 internal constant _ROLE_157 = 1 << 157;
uint256 internal constant _ROLE_158 = 1 << 158;
uint256 internal constant _ROLE_159 = 1 << 159;
uint256 internal constant _ROLE_160 = 1 << 160;
uint256 internal constant _ROLE_161 = 1 << 161;
uint256 internal constant _ROLE_162 = 1 << 162;
uint256 internal constant _ROLE_163 = 1 << 163;
uint256 internal constant _ROLE_164 = 1 << 164;
uint256 internal constant _ROLE_165 = 1 << 165;
uint256 internal constant _ROLE_166 = 1 << 166;
uint256 internal constant _ROLE_167 = 1 << 167;
uint256 internal constant _ROLE_168 = 1 << 168;
uint256 internal constant _ROLE_169 = 1 << 169;
uint256 internal constant _ROLE_170 = 1 << 170;
uint256 internal constant _ROLE_171 = 1 << 171;
uint256 internal constant _ROLE_172 = 1 << 172;
uint256 internal constant _ROLE_173 = 1 << 173;
uint256 internal constant _ROLE_174 = 1 << 174;
uint256 internal constant _ROLE_175 = 1 << 175;
uint256 internal constant _ROLE_176 = 1 << 176;
uint256 internal constant _ROLE_177 = 1 << 177;
uint256 internal constant _ROLE_178 = 1 << 178;
uint256 internal constant _ROLE_179 = 1 << 179;
uint256 internal constant _ROLE_180 = 1 << 180;
uint256 internal constant _ROLE_181 = 1 << 181;
uint256 internal constant _ROLE_182 = 1 << 182;
uint256 internal constant _ROLE_183 = 1 << 183;
uint256 internal constant _ROLE_184 = 1 << 184;
uint256 internal constant _ROLE_185 = 1 << 185;
uint256 internal constant _ROLE_186 = 1 << 186;
uint256 internal constant _ROLE_187 = 1 << 187;
uint256 internal constant _ROLE_188 = 1 << 188;
uint256 internal constant _ROLE_189 = 1 << 189;
uint256 internal constant _ROLE_190 = 1 << 190;
uint256 internal constant _ROLE_191 = 1 << 191;
uint256 internal constant _ROLE_192 = 1 << 192;
uint256 internal constant _ROLE_193 = 1 << 193;
uint256 internal constant _ROLE_194 = 1 << 194;
uint256 internal constant _ROLE_195 = 1 << 195;
uint256 internal constant _ROLE_196 = 1 << 196;
uint256 internal constant _ROLE_197 = 1 << 197;
uint256 internal constant _ROLE_198 = 1 << 198;
uint256 internal constant _ROLE_199 = 1 << 199;
uint256 internal constant _ROLE_200 = 1 << 200;
uint256 internal constant _ROLE_201 = 1 << 201;
uint256 internal constant _ROLE_202 = 1 << 202;
uint256 internal constant _ROLE_203 = 1 << 203;
uint256 internal constant _ROLE_204 = 1 << 204;
uint256 internal constant _ROLE_205 = 1 << 205;
uint256 internal constant _ROLE_206 = 1 << 206;
uint256 internal constant _ROLE_207 = 1 << 207;
uint256 internal constant _ROLE_208 = 1 << 208;
uint256 internal constant _ROLE_209 = 1 << 209;
uint256 internal constant _ROLE_210 = 1 << 210;
uint256 internal constant _ROLE_211 = 1 << 211;
uint256 internal constant _ROLE_212 = 1 << 212;
uint256 internal constant _ROLE_213 = 1 << 213;
uint256 internal constant _ROLE_214 = 1 << 214;
uint256 internal constant _ROLE_215 = 1 << 215;
uint256 internal constant _ROLE_216 = 1 << 216;
uint256 internal constant _ROLE_217 = 1 << 217;
uint256 internal constant _ROLE_218 = 1 << 218;
uint256 internal constant _ROLE_219 = 1 << 219;
uint256 internal constant _ROLE_220 = 1 << 220;
uint256 internal constant _ROLE_221 = 1 << 221;
uint256 internal constant _ROLE_222 = 1 << 222;
uint256 internal constant _ROLE_223 = 1 << 223;
uint256 internal constant _ROLE_224 = 1 << 224;
uint256 internal constant _ROLE_225 = 1 << 225;
uint256 internal constant _ROLE_226 = 1 << 226;
uint256 internal constant _ROLE_227 = 1 << 227;
uint256 internal constant _ROLE_228 = 1 << 228;
uint256 internal constant _ROLE_229 = 1 << 229;
uint256 internal constant _ROLE_230 = 1 << 230;
uint256 internal constant _ROLE_231 = 1 << 231;
uint256 internal constant _ROLE_232 = 1 << 232;
uint256 internal constant _ROLE_233 = 1 << 233;
uint256 internal constant _ROLE_234 = 1 << 234;
uint256 internal constant _ROLE_235 = 1 << 235;
uint256 internal constant _ROLE_236 = 1 << 236;
uint256 internal constant _ROLE_237 = 1 << 237;
uint256 internal constant _ROLE_238 = 1 << 238;
uint256 internal constant _ROLE_239 = 1 << 239;
uint256 internal constant _ROLE_240 = 1 << 240;
uint256 internal constant _ROLE_241 = 1 << 241;
uint256 internal constant _ROLE_242 = 1 << 242;
uint256 internal constant _ROLE_243 = 1 << 243;
uint256 internal constant _ROLE_244 = 1 << 244;
uint256 internal constant _ROLE_245 = 1 << 245;
uint256 internal constant _ROLE_246 = 1 << 246;
uint256 internal constant _ROLE_247 = 1 << 247;
uint256 internal constant _ROLE_248 = 1 << 248;
uint256 internal constant _ROLE_249 = 1 << 249;
uint256 internal constant _ROLE_250 = 1 << 250;
uint256 internal constant _ROLE_251 = 1 << 251;
uint256 internal constant _ROLE_252 = 1 << 252;
uint256 internal constant _ROLE_253 = 1 << 253;
uint256 internal constant _ROLE_254 = 1 << 254;
uint256 internal constant _ROLE_255 = 1 << 255;
}
文件 38 的 53：Pausable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Pausable is Context {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 39 的 53：PrincipalToken.sol
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
import {DynamicArrayLib} from "solady/src/utils/DynamicArrayLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
import {LibString} from "solady/src/utils/LibString.sol";
import {ECDSA} from "solady/src/utils/ECDSA.sol";
import "../Types.sol";
import {IHook} from "../interfaces/IHook.sol";
import {FeeModule} from "../modules/FeeModule.sol";
import {IRewardProxy} from "../interfaces/IRewardProxy.sol";
import {VerifierModule} from "../modules/VerifierModule.sol";
import {VaultInfoResolver} from "../modules/resolvers/VaultInfoResolver.sol";
import {Factory} from "../Factory.sol";
import {YieldToken} from "./YieldToken.sol";
import {LibRewardProxy} from "../utils/LibRewardProxy.sol";
import {ModuleAccessor} from "../utils/ModuleAccessor.sol";
import {TokenNameLib} from "../utils/TokenNameLib.sol";
import {CustomRevert} from "../utils/CustomRevert.sol";
import {LibExpiry} from "../utils/LibExpiry.sol";
import {Events} from "../Events.sol";
import {Errors} from "../Errors.sol";
import {BASIS_POINTS} from "../Constants.sol";
import {FeePctsLib} from "../utils/FeePctsLib.sol";
import {Snapshot, Yield, YieldMathLib} from "../utils/YieldMathLib.sol";
import {Reward, RewardIndex, RewardMathLib} from "../utils/RewardMathLib.sol";
import {EIP5095} from "../interfaces/EIP5095.sol";
import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
import {ReentrancyGuard} from "solady/src/utils/ReentrancyGuard.sol";
import {ERC20} from "solady/src/tokens/ERC20.sol";
import {AccessManager, AccessManaged} from "../modules/AccessManager.sol";
import {LibApproval} from "../utils/LibApproval.sol";
contract PrincipalToken is ERC20, LibApproval, AccessManaged, Pausable, ReentrancyGuard, EIP5095 {
using CustomRevert for bytes4;
using SafeCastLib for uint256;
using FeePctsLib for FeePcts;
using ModuleAccessor for address[];
using ModuleAccessor for address;
using DynamicArrayLib for uint256[];
bytes32 public constant VERSION = "2.0.0";
bytes32 private constant PERMIT_COLLECTOR_TYPEHASH =
0xabaa81be0e21ab93788e05cd5409517fd2908fd1c16213aab992c623ac2cf0a4;
uint256 private constant _NONCES_SLOT_SEED = 0x38377508;
AccessManager internal immutable _i_accessManager;
uint256 internal immutable i_expiry;
Factory public immutable i_factory;
YieldToken public immutable i_yt;
VaultInfoResolver public immutable i_resolver;
ERC20 public immutable i_asset;
ERC20 internal immutable i_target;
bytes32 internal immutable i_nameHash;
bool internal s_isSettled;
address public s_modules;
Snapshot internal s_snapshot;
LibString.StringStorage internal s_name;
LibString.StringStorage internal s_symbol;
mapping(address account => Yield) internal s_userYields;
uint128 internal s_curatorFee;
uint128 internal s_protocolFee;
struct RewardRecord {
mapping(address account => Reward) userRewards;
uint128 curatorReward;
uint128 protocolReward;
RewardIndex globalIndex;
}
mapping(address reward => RewardRecord) internal s_rewardRecords;
constructor() payable {
Factory.ConstructorArg memory args = Factory(msg.sender).args();
i_factory = Factory(msg.sender);
address target = VaultInfoResolver(args.resolver).target();
i_expiry = args.expiry;
i_resolver = VaultInfoResolver(args.resolver);
i_yt = YieldToken(args.yt);
i_target = ERC20(target);
i_asset = ERC20(VaultInfoResolver(args.resolver).asset());
_i_accessManager = AccessManager(args.accessManager);
s_modules = args.modules;
string memory tokenName = TokenNameLib.principalTokenName(target, i_expiry);
i_nameHash = keccak256(bytes(tokenName));
LibString.set(s_name, tokenName);
LibString.set(s_symbol, TokenNameLib.principalTokenSymbol(target, i_expiry));
}
function supply(uint256 shares, address receiver) external returns (uint256) {
return supply(shares, receiver, "");
}
function supply(uint256 shares, address receiver, bytes memory data)
public
nonReentrant
whenNotPaused
notExpired
returns (uint256)
{
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
(uint256 principal, uint256 fee) = _previewSupply(snapshot, feePcts, shares);
uint256 ytBalance = i_yt.balanceOf(receiver);
_verify(m, shares, principal, receiver);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, receiver, ytBalance);
TokenReward[] memory rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, address(0), 0, receiver, ytBalance);
_supplyWithHook(msg.sender, receiver, shares, principal, data);
return principal;
}
function issue(uint256 principal, address receiver) external returns (uint256) {
return issue(principal, receiver, "");
}
function issue(uint256 principal, address receiver, bytes memory data)
public
nonReentrant
whenNotPaused
notExpired
returns (uint256)
{
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
(uint256 shares, uint256 fee) = _previewIssue(snapshot, feePcts, principal);
uint256 ytBalance = i_yt.balanceOf(receiver);
_verify(m, shares, principal, receiver);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, receiver, ytBalance);
TokenReward[] memory rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, address(0), 0, receiver, ytBalance);
_supplyWithHook(msg.sender, receiver, shares, principal, data);
return shares;
}
function _supplyWithHook(address by, address receiver, uint256 shares, uint256 principal, bytes memory data)
internal
{
uint256 expected = SafeTransferLib.balanceOf(address(i_target), address(this)) + shares;
Events.emitSupply({by: by, receiver: receiver, shares: shares, principal: principal});
if (data.length > 0) {
_mint(receiver, principal);
IHook(by).onSupply(shares, principal, data);
} else {
SafeTransferLib.safeTransferFrom(address(i_target), by, address(this), shares);
_mint(receiver, principal);
}
if (SafeTransferLib.balanceOf(address(i_target), address(this)) < expected) {
Errors.PrincipalToken_InsufficientSharesReceived.selector.revertWith();
}
}
function unite(uint256 shares, address receiver) external returns (uint256) {
return unite(shares, receiver, "");
}
function unite(uint256 shares, address receiver, bytes memory data)
public
nonReentrant
settleIfExpired
returns (uint256)
{
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
uint256 ytBalance = i_yt.balanceOf(msg.sender);
(uint256 principal, uint256 fee) = _previewUnite(snapshot, feePcts, shares);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, msg.sender, ytBalance);
TokenReward[] memory rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, msg.sender, ytBalance, address(0), 0);
_uniteWithHook(msg.sender, receiver, shares, principal, data);
return principal;
}
function combine(uint256 principal, address receiver) external returns (uint256) {
return combine(principal, receiver, "");
}
function combine(uint256 principal, address receiver, bytes memory data)
public
nonReentrant
settleIfExpired
returns (uint256)
{
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
uint256 ytBalance = i_yt.balanceOf(msg.sender);
(uint256 shares, uint256 fee) = _previewCombine(snapshot, feePcts, principal);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, msg.sender, ytBalance);
TokenReward[] memory rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, msg.sender, ytBalance, address(0), 0);
_uniteWithHook(msg.sender, receiver, shares, principal, data);
return shares;
}
function _uniteWithHook(address by, address receiver, uint256 shares, uint256 principal, bytes memory data)
internal
{
Events.emitUnite({by: by, receiver: receiver, shares: shares, principal: principal});
SafeTransferLib.safeTransfer(address(i_target), receiver, shares);
if (data.length > 0) {
IHook(by).onUnite(shares, principal, data);
}
_burn(by, principal);
i_yt.burn(by, principal);
}
function collect(address receiver, address owner)
external
nonReentrant
ownerOrApprovedCollector(owner)
settleIfExpired
returns (uint256, TokenReward[] memory rewards)
{
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
uint256 ytBalance = i_yt.balanceOf(owner);
(uint256 shares, uint256 fee) = _previewCollect(snapshot, feePcts, owner, ytBalance);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, owner, ytBalance);
delete s_userYields[owner].accrued;
Events.emitInterestCollected({by: msg.sender, owner: owner, receiver: receiver, shares: shares});
rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, owner, ytBalance, address(0), 0);
for (uint256 i; i != rewards.length;) {
rewards[i].amount = _collectRewards(rewards[i].token, receiver, owner);
unchecked {
++i;
}
}
SafeTransferLib.safeTransfer(address(i_target), receiver, shares);
return (shares, rewards);
}
function collectRewards(address[] calldata rewardTokens, address receiver, address owner)
external
nonReentrant
ownerOrApprovedCollector(owner)
returns (uint256[] memory result)
{
result = new uint256[](rewardTokens.length);
for (uint256 i; i != rewardTokens.length;) {
DynamicArrayLib.set(result, i, _collectRewards(rewardTokens[i], receiver, owner));
unchecked {
++i;
}
}
}
function _collectRewards(address token, address receiver, address owner) internal returns (uint256 rewards) {
if (token == address(i_target)) Errors.PrincipalToken_ProtectedToken.selector.revertWith();
Reward storage userReward = s_rewardRecords[token].userRewards[owner];
rewards = userReward.accrued;
delete userReward.accrued;
Events.emitRewardsCollected({
by: msg.sender,
owner: owner,
receiver: receiver,
rewardToken: token,
rewards: rewards
});
SafeTransferLib.safeTransfer(token, receiver, rewards);
}
function onYtTransfer(address owner, address receiver, uint256 balanceOfOwner, uint256 balanceOfReceiver)
external
nonReentrant
settleIfExpired
{
if (msg.sender != address(i_yt)) Errors.PrincipalToken_OnlyYieldToken.selector.revertWith();
address[] memory m = ModuleAccessor.read(s_modules);
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(m.unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
uint256 fee = _updateIndex(snapshot, perfFeePct);
_writeState(snapshot, feePcts, fee);
_accrueYield(snapshot, owner, balanceOfOwner);
_accrueYield(snapshot, receiver, balanceOfReceiver);
}
TokenReward[] memory rewards = _delegateCallRewardProxy(m);
_accrueRewards(feePcts, rewards, owner, balanceOfOwner, receiver, balanceOfReceiver);
}
function withdraw(uint256 shares, address receiver, address owner)
external
nonReentrant
expired
settleIfExpired
returns (uint256)
{
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(ModuleAccessor.read(s_modules).unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
(uint256 principal, uint256 fee) = _previewWithdraw(snapshot, feePcts, shares);
_writeState(snapshot, feePcts, fee);
_redeem(msg.sender, owner, receiver, shares, principal);
return principal;
}
function redeem(uint256 principal, address receiver, address owner)
external
nonReentrant
expired
settleIfExpired
returns (uint256)
{
Snapshot memory snapshot = s_snapshot;
FeePcts feePcts = FeeModule(ModuleAccessor.read(s_modules).unsafeGet(FEE_MODULE_INDEX)).getFeePcts();
(uint256 shares, uint256 fee) = _previewRedeem(snapshot, feePcts, principal);
_writeState(snapshot, feePcts, fee);
_redeem(msg.sender, owner, receiver, shares, principal);
return shares;
}
function _redeem(address by, address owner, address receiver, uint256 shares, uint256 principal) internal {
Events.emitRedeem({by: by, owner: owner, receiver: receiver, shares: shares, principal: principal});
if (msg.sender != owner) _spendAllowance(owner, msg.sender, principal);
_burn(owner, principal);
SafeTransferLib.safeTransfer(address(i_target), receiver, shares);
}
function setApprovalCollector(address collector, bool isApproved) external {
_setApprovalCollector(msg.sender, collector, isApproved);
}
function permitCollector(address owner, address collector, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
external
{
assembly {
if gt(timestamp(), deadline) {
mstore(0x00, 0x1a15a3cc)
revert(0x1c, 0x04)
}
}
uint256 nonce = nonces(owner);
bytes32 domainSeparator = DOMAIN_SEPARATOR();
bytes32 digest;
assembly {
let m := mload(0x40)
mstore(m, PERMIT_COLLECTOR_TYPEHASH)
mstore(add(m, 0x20), owner)
mstore(add(m, 0x40), collector)
mstore(add(m, 0x60), nonce)
mstore(add(m, 0x80), deadline)
let structHash := keccak256(m, 0xa0)
mstore(0x00, 0x1901000000000000)
mstore(0x1a, domainSeparator)
mstore(0x3a, structHash)
digest := keccak256(0x18, 0x42)
mstore(0x3a, 0)
}
address signer = ECDSA.recover(digest, v, r, s);
if (signer != owner) InvalidPermit.selector.revertWith();
assembly {
mstore(0x0c, _NONCES_SLOT_SEED)
mstore(0x00, owner)
sstore(keccak256(0x0c, 0x20), add(nonce, 1))
}
_setApprovalCollector(owner, collector, true);
}
function _setApprovalCollector(address owner, address collector, bool isApproved) internal {
setApproval(owner, collector, isApproved);
Events.emitSetApprovalCollector({owner: owner, collector: collector, approved: isApproved});
}
function _writeState(Snapshot memory snapshot, FeePcts feePcts, uint256 fee) internal {
uint256 curatorFee = (fee * feePcts.getSplitPctBps()) / BASIS_POINTS;
s_snapshot = snapshot;
s_curatorFee = (s_curatorFee + curatorFee).toUint128();
s_protocolFee = (s_protocolFee + fee - curatorFee).toUint128();
Events.emitYieldFeeAccrued(fee);
}
function _accrueYield(Snapshot memory snapshot, address user, uint256 ytBalance) internal {
uint256 accrued = YieldMathLib.accrueUserYield(s_userYields, snapshot.globalIndex, user, ytBalance);
Events.emitYieldAccrued(user, accrued, snapshot.globalIndex.unwrap());
}
function _accrueRewards(
FeePcts feePcts,
TokenReward[] memory rewards,
address src,
uint256 srcYtBalance,
address dst,
uint256 dstYtBalance
) internal {
uint256 ytSupply = i_yt.totalSupply();
bool settled = s_isSettled;
for (uint256 i; i != rewards.length;) {
RewardRecord storage record = s_rewardRecords[rewards[i].token];
if (settled) {
uint256 feePct = feePcts.getPostSettlementFeePctBps();
uint256 amount = rewards[i].amount;
uint256 fee = FixedPointMathLib.mulDivUp(amount, feePct, BASIS_POINTS);
uint256 curatorFee = (fee * feePcts.getSplitPctBps()) / BASIS_POINTS;
(uint256 curatorReward, uint256 protocolReward) = (record.curatorReward, record.protocolReward);
rewards[i].amount = amount - fee;
record.curatorReward = (curatorReward + curatorFee).toUint128();
record.protocolReward = (protocolReward + fee - curatorFee).toUint128();
}
(RewardIndex newIndex,) = RewardMathLib.updateIndex(record.globalIndex, ytSupply, rewards[i].amount);
record.globalIndex = newIndex;
if (src != address(0)) RewardMathLib.accrueUserReward(record.userRewards, newIndex, src, srcYtBalance);
if (dst != address(0)) RewardMathLib.accrueUserReward(record.userRewards, newIndex, dst, dstYtBalance);
unchecked {
++i;
}
}
}
function _mint(address to, uint256 amount) internal override {
super._mint(to, amount);
i_yt.mint(to, amount);
}
function _updateIndex(Snapshot memory snapshot, uint256 performanceFeePct) internal view returns (uint256 fee) {
(, fee) = YieldMathLib.updateIndex({
self: snapshot,
scaleFn: i_resolver.scale,
ptSupply: totalSupply(),
ytSupply: i_yt.totalSupply(),
feePctBps: performanceFeePct
});
}
function _previewSupply(Snapshot memory snapshot, FeePcts feePcts, uint256 shares)
internal
view
returns (uint256 principal, uint256 fee)
{
uint256 performanceFee = _updateIndex(snapshot, feePcts.getPerformanceFeePctBps());
uint256 issuanceFee = _feeOnTotal(shares, feePcts.getIssuanceFeePctBps());
principal = YieldMathLib.convertToPrincipal(shares - issuanceFee, snapshot.maxscale, false);
fee = performanceFee + issuanceFee;
}
function _previewIssue(Snapshot memory snapshot, FeePcts feePcts, uint256 principal)
internal
view
returns (uint256 shares, uint256 fee)
{
uint256 performanceFee = _updateIndex(snapshot, feePcts.getPerformanceFeePctBps());
shares = YieldMathLib.convertToUnderlying(principal, snapshot.maxscale, true);
uint256 issuanceFee = _feeOnRaw(shares, feePcts.getIssuanceFeePctBps());
shares += issuanceFee;
fee = performanceFee + issuanceFee;
}
function _previewUnite(Snapshot memory snapshot, FeePcts feePcts, uint256 shares)
internal
view
returns (uint256 principal, uint256 fee)
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
uint256 performanceFee = _updateIndex(snapshot, perfFeePct);
uint256 redemptionFee = _feeOnRaw(shares, feePcts.getRedemptionFeePctBps());
principal = YieldMathLib.convertToPrincipal(shares + redemptionFee, snapshot.maxscale, true);
fee = performanceFee + redemptionFee;
}
function _previewCombine(Snapshot memory snapshot, FeePcts feePcts, uint256 principal)
internal
view
returns (uint256 shares, uint256 fee)
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
uint256 performanceFee = _updateIndex(snapshot, perfFeePct);
shares = YieldMathLib.convertToUnderlying(principal, snapshot.maxscale, false);
uint256 redemptionFee = _feeOnTotal(shares, feePcts.getRedemptionFeePctBps());
shares -= redemptionFee;
fee = performanceFee + redemptionFee;
}
function _previewWithdraw(Snapshot memory snapshot, FeePcts feePcts, uint256 shares)
internal
view
returns (uint256 principal, uint256 fee)
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
uint256 performanceFee = _updateIndex(snapshot, perfFeePct);
uint256 redemptionFee = _feeOnRaw(shares, feePcts.getRedemptionFeePctBps());
principal = YieldMathLib.convertToPrincipal(shares + redemptionFee, snapshot.maxscale, true);
fee = performanceFee + redemptionFee;
}
function _previewRedeem(Snapshot memory snapshot, FeePcts feePcts, uint256 principal)
internal
view
returns (uint256 shares, uint256 fee)
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
uint256 performanceFee = _updateIndex(snapshot, perfFeePct);
shares = YieldMathLib.convertToUnderlying(principal, snapshot.maxscale, false);
uint256 redemptionFee = _feeOnTotal(shares, feePcts.getRedemptionFeePctBps());
shares -= redemptionFee;
fee = performanceFee + redemptionFee;
}
function _previewCollect(Snapshot memory snapshot, FeePcts feePcts, address owner, uint256 ownerYtBalance)
internal
view
returns (uint256 shares, uint256 fee)
{
uint256 perfFeePct = s_isSettled ? feePcts.getPostSettlementFeePctBps() : feePcts.getPerformanceFeePctBps();
fee = _updateIndex(snapshot, perfFeePct);
shares = s_userYields[owner].accrued
+ YieldMathLib.computeAccrueUserYield(s_userYields, snapshot.globalIndex, owner, ownerYtBalance);
}
function _feeOnRaw(uint256 shares, uint256 feeBasisPoints) private pure returns (uint256) {
return FixedPointMathLib.mulDivUp(shares, feeBasisPoints, BASIS_POINTS);
}
function _feeOnTotal(uint256 shares, uint256 feeBasisPoints) private pure returns (uint256) {
return FixedPointMathLib.mulDivUp(shares, feeBasisPoints, feeBasisPoints + BASIS_POINTS);
}
function _delegateCallRewardProxy(address[] memory m) internal returns (TokenReward[] memory rewards) {
address rewardProxy = ModuleAccessor.getOrDefault(m, REWARD_PROXY_MODULE_INDEX);
if (rewardProxy == address(0)) return rewards;
uint256 balanceBefore = SafeTransferLib.balanceOf(address(i_target), address(this));
rewards = LibRewardProxy.delegateCallCollectReward(rewardProxy);
if (SafeTransferLib.balanceOf(address(i_target), address(this)) != balanceBefore) {
Errors.PrincipalToken_UnderlyingTokenBalanceChanged.selector.revertWith();
}
}
function _verify(address[] memory m, uint256 shares, uint256 principal, address receiver) internal view {
VerifierModule verifier = VerifierModule(ModuleAccessor.getOrDefault(m, VERIFIER_MODULE_INDEX));
if (address(verifier) == address(0)) return;
VerificationStatus status = verifier.verify(msg.sig, msg.sender, shares, principal, receiver);
if (status != VerificationStatus.Success) {
Errors.PrincipalToken_VerificationFailed.selector.revertWith(uint256(status));
}
}
modifier settleIfExpired() {
_;
if (_isExpired() && !s_isSettled) s_isSettled = true;
}
function isApprovedCollector(address owner, address collector) public view returns (bool) {
return isApproved(owner, collector);
}
function previewSupply(uint256 shares) external view nonReadReentrant returns (uint256 principal) {
if (_isIssuanceDisabled()) return 0;
(principal,) =
_previewSupply(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), shares);
}
function previewIssue(uint256 principal) external view nonReadReentrant returns (uint256 shares) {
if (_isIssuanceDisabled()) return 0;
(shares,) =
_previewIssue(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), principal);
}
function previewUnite(uint256 shares) external view nonReadReentrant returns (uint256 principal) {
(principal,) =
_previewUnite(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), shares);
}
function previewCombine(uint256 principal) external view nonReadReentrant returns (uint256 shares) {
(shares,) =
_previewCombine(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), principal);
}
function previewCollect(address owner) external view nonReadReentrant returns (uint256 shares) {
(shares,) = _previewCollect(
s_snapshot,
FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(),
owner,
i_yt.balanceOf(owner)
);
}
function previewWithdraw(uint256 shares) external view nonReadReentrant returns (uint256 principal) {
if (!_isExpired()) return 0;
(principal,) =
_previewWithdraw(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), shares);
}
function previewRedeem(uint256 principal) external view nonReadReentrant returns (uint256 shares) {
if (!_isExpired()) return 0;
(shares,) =
_previewRedeem(s_snapshot, FeeModule(s_modules.read().unsafeGet(FEE_MODULE_INDEX)).getFeePcts(), principal);
}
function convertToUnderlying(uint256 principal) public view returns (uint256) {
uint256 maxscale = FixedPointMathLib.max(i_resolver.scale(), s_snapshot.maxscale);
return YieldMathLib.convertToUnderlying(principal, maxscale, false);
}
function convertToPrincipal(uint256 shares) public view returns (uint256) {
uint256 maxscale = FixedPointMathLib.max(i_resolver.scale(), s_snapshot.maxscale);
return YieldMathLib.convertToPrincipal(shares, maxscale, false);
}
function maxSupply(address receiver) public view returns (uint256) {
if (_isIssuanceDisabled()) return 0;
address verifier = ModuleAccessor.getOrDefault(ModuleAccessor.read(s_modules), VERIFIER_MODULE_INDEX);
if (verifier == address(0)) return type(uint256).max;
return VerifierModule(verifier).maxSupply(receiver);
}
function maxIssue(address receiver) external view returns (uint256) {
uint256 maxShares = maxSupply(receiver);
if (maxShares == type(uint256).max) return type(uint256).max;
return convertToPrincipal(maxShares);
}
function maxRedeem(address owner) external view returns (uint256) {
if (!_isExpired()) return 0;
return balanceOf(owner);
}
function maxWithdraw(address owner) external view returns (uint256) {
if (!_isExpired()) return 0;
return convertToUnderlying(balanceOf(owner));
}
function getUserYield(address owner) external view returns (Yield memory) {
return s_userYields[owner];
}
function getUserReward(address reward, address owner) external view returns (Reward memory) {
return s_rewardRecords[reward].userRewards[owner];
}
function getFeeRewards(address reward) external view returns (uint256, uint256) {
return (s_rewardRecords[reward].curatorReward, s_rewardRecords[reward].protocolReward);
}
function getFees() external view returns (uint256, uint256) {
return (s_curatorFee, s_protocolFee);
}
function getRewardGlobalIndex(address reward) external view returns (RewardIndex) {
return s_rewardRecords[reward].globalIndex;
}
function collectCuratorFees(address[] calldata additionalTokens, address feeReceiver)
external
restricted
returns (uint256 shares, TokenReward[] memory rewards)
{
shares = s_curatorFee;
s_curatorFee = 0;
rewards = _collectFeeRewards({additionalTokens: additionalTokens, feeReceiver: feeReceiver, isCurator: true});
SafeTransferLib.safeTransfer(address(i_target), feeReceiver, shares);
emit Events.CuratorFeesCollected(msg.sender, feeReceiver, shares, rewards);
}
function collectProtocolFees(address[] calldata additionalTokens)
external
restrictedBy(i_factory.i_accessManager())
returns (uint256 shares, TokenReward[] memory rewards)
{
address treasury = i_factory.s_treasury();
shares = s_protocolFee;
s_protocolFee = 0;
rewards = _collectFeeRewards({additionalTokens: additionalTokens, feeReceiver: treasury, isCurator: false});
SafeTransferLib.safeTransfer(address(i_target), treasury, shares);
emit Events.ProtocolFeesCollected(msg.sender, treasury, shares, rewards);
}
function _collectFeeRewards(address[] calldata additionalTokens, address feeReceiver, bool isCurator)
internal
returns (TokenReward[] memory rewards)
{
address[] memory rewardTokens;
address rewardProxy = ModuleAccessor.read(s_modules).getOrDefault(REWARD_PROXY_MODULE_INDEX);
if (rewardProxy != address(0)) rewardTokens = IRewardProxy(rewardProxy).rewardTokens();
uint256 k = rewardTokens.length;
rewards = new TokenReward[](k + additionalTokens.length);
for (uint256 i; i != rewards.length;) {
unchecked {
address token = i < k
? DynamicArrayLib.toUint256Array(rewardTokens).getAddress(i)
: additionalTokens[i - k];
RewardRecord storage record = s_rewardRecords[token];
rewards[i].token = token;
if (isCurator) {
rewards[i].amount = record.curatorReward;
record.curatorReward = 0;
} else {
rewards[i].amount = record.protocolReward;
record.protocolReward = 0;
}
SafeTransferLib.safeTransfer(token, feeReceiver, rewards[i].amount);
++i;
}
}
}
function setModules(address modules) external {
if (msg.sender != address(i_factory)) Errors.PrincipalToken_NotFactory.selector.revertWith();
s_modules = modules;
}
function pause() external restricted {
if (i_accessManager().owner() == address(0)) revert Errors.PrincipalToken_Unstoppable();
_pause();
}
function unpause() external restricted {
_unpause();
}
function underlying() external view returns (address) {
return address(i_target);
}
function maturity() external view returns (uint256) {
return i_expiry;
}
function name() public view override returns (string memory _name) {
_name = LibString.get(s_name);
}
function symbol() public view override returns (string memory _symbol) {
_symbol = LibString.get(s_symbol);
}
function decimals() public view override returns (uint8) {
return i_asset.decimals();
}
function isSettled() external view nonReadReentrant returns (bool) {
return s_isSettled;
}
function getSnapshot() external view returns (Snapshot memory) {
return s_snapshot;
}
function _constantNameHash() internal view override returns (bytes32) {
return i_nameHash;
}
modifier ownerOrApprovedCollector(address owner) {
_checkOwnerOrApprovedCollector(owner);
_;
}
function _checkOwnerOrApprovedCollector(address owner) internal view {
if (msg.sender != owner && !isApprovedCollector(owner, msg.sender)) {
Errors.PrincipalToken_NotApprovedCollector.selector.revertWith();
}
}
function _isExpired() internal view returns (bool) {
return LibExpiry.isExpired(i_expiry);
}
function _isIssuanceDisabled() internal view returns (bool) {
return _isExpired() || paused();
}
modifier notExpired() {
if (_isExpired()) Errors.Expired.selector.revertWith();
_;
}
modifier expired() {
if (!_isExpired()) Errors.NotExpired.selector.revertWith();
_;
}
function i_accessManager() public view override returns (AccessManager) {
return _i_accessManager;
}
}
文件 40 的 53：ReentrancyGuard.sol
pragma solidity ^0.8.4;
abstract contract ReentrancyGuard {
error Reentrancy();
uint256 private constant _REENTRANCY_GUARD_SLOT = 0x929eee149b4bd21268;
modifier nonReentrant() virtual {
assembly {
if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {
mstore(0x00, 0xab143c06)
revert(0x1c, 0x04)
}
sstore(_REENTRANCY_GUARD_SLOT, address())
}
_;
assembly {
sstore(_REENTRANCY_GUARD_SLOT, codesize())
}
}
modifier nonReadReentrant() virtual {
assembly {
if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {
mstore(0x00, 0xab143c06)
revert(0x1c, 0x04)
}
}
_;
}
}
文件 41 的 53：RewardMathLib.sol
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
type RewardIndex is uint128;
struct Reward {
RewardIndex userIndex;
uint128 accrued;
}
using {unwrap} for RewardIndex global;
using {eq as ==, add as +, sub as -} for RewardIndex global;
function unwrap(RewardIndex x) pure returns (uint128 result) {
result = RewardIndex.unwrap(x);
}
function wrap(uint128 x) pure returns (RewardIndex result) {
result = RewardIndex.wrap(x);
}
function eq(RewardIndex lhs, RewardIndex rhs) pure returns (bool output) {
assembly {
let m := shr(128, not(0))
output := eq(and(m, lhs), and(m, rhs))
}
}
function add(RewardIndex lhs, RewardIndex rhs) pure returns (RewardIndex output) {
output = wrap(lhs.unwrap() + rhs.unwrap());
}
function sub(RewardIndex lhs, RewardIndex rhs) pure returns (RewardIndex output) {
output = wrap(lhs.unwrap() - rhs.unwrap());
}
library RewardMathLib {
using SafeCastLib for uint256;
function updateIndex(RewardIndex index, uint256 ytSupply, uint256 totalAccrued)
internal
pure
returns (RewardIndex newIndex, uint256 lostReward)
{
if (ytSupply == 0) return (index, totalAccrued);
newIndex = index + RewardIndex.wrap(FixedPointMathLib.divWad(totalAccrued, ytSupply).toUint128());
lostReward = totalAccrued - FixedPointMathLib.mulWad(ytSupply, (newIndex - index).unwrap());
}
function accrueUserReward(
mapping(address user => Reward userReward) storage self,
RewardIndex index,
address account,
uint256 ytBalance
) internal {
RewardIndex prevIndex = self[account].userIndex;
uint256 accrued = FixedPointMathLib.mulWad(ytBalance, RewardIndex.unwrap(index - prevIndex));
self[account].accrued += accrued.toUint128();
self[account].userIndex = index;
}
}
文件 42 的 53：SSTORE2.sol
pragma solidity ^0.8.4;
library SSTORE2 {
uint256 private constant _CREATE3_PROXY_INITCODE = 0x67363d3d37363d34f03d5260086018f3;
bytes32 internal constant CREATE3_PROXY_INITCODE_HASH =
0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;
error DeploymentFailed();
function write(bytes memory data) internal returns (address pointer) {
assembly {
let n := mload(data)
mstore(add(data, gt(n, 0xfffe)), add(0xfe61000180600a3d393df300, shl(0x40, n)))
pointer := create(0, add(data, 0x15), add(n, 0xb))
if iszero(pointer) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(data, n)
}
}
function writeCounterfactual(bytes memory data, bytes32 salt)
internal
returns (address pointer)
{
assembly {
let n := mload(data)
mstore(add(data, gt(n, 0xfffe)), add(0xfe61000180600a3d393df300, shl(0x40, n)))
pointer := create2(0, add(data, 0x15), add(n, 0xb), salt)
if iszero(pointer) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(data, n)
}
}
function writeDeterministic(bytes memory data, bytes32 salt)
internal
returns (address pointer)
{
assembly {
let n := mload(data)
mstore(0x00, _CREATE3_PROXY_INITCODE)
let proxy := create2(0, 0x10, 0x10, salt)
if iszero(proxy) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(0x14, proxy)
mstore(0x00, 0xd694)
mstore8(0x34, 0x01)
pointer := keccak256(0x1e, 0x17)
mstore(add(data, gt(n, 0xfffe)), add(0xfe61000180600a3d393df300, shl(0x40, n)))
if iszero(
mul(
extcodesize(pointer),
call(gas(), proxy, 0, add(data, 0x15), add(n, 0xb), codesize(), 0x00)
)
) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
mstore(data, n)
}
}
function initCodeHash(bytes memory data) internal pure returns (bytes32 hash) {
assembly {
let n := mload(data)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0xfffe))
mstore(data, add(0x61000180600a3d393df300, shl(0x40, n)))
hash := keccak256(add(data, 0x15), add(n, 0xb))
mstore(data, n)
}
}
function predictCounterfactualAddress(bytes memory data, bytes32 salt)
internal
view
returns (address pointer)
{
pointer = predictCounterfactualAddress(data, salt, address(this));
}
function predictCounterfactualAddress(bytes memory data, bytes32 salt, address deployer)
internal
pure
returns (address predicted)
{
bytes32 hash = initCodeHash(data);
assembly {
mstore8(0x00, 0xff)
mstore(0x35, hash)
mstore(0x01, shl(96, deployer))
mstore(0x15, salt)
predicted := keccak256(0x00, 0x55)
mstore(0x35, 0)
}
}
function predictDeterministicAddress(bytes32 salt) internal view returns (address pointer) {
pointer = predictDeterministicAddress(salt, address(this));
}
function predictDeterministicAddress(bytes32 salt, address deployer)
internal
pure
returns (address pointer)
{
assembly {
let m := mload(0x40)
mstore(0x00, deployer)
mstore8(0x0b, 0xff)
mstore(0x20, salt)
mstore(0x40, CREATE3_PROXY_INITCODE_HASH)
mstore(0x14, keccak256(0x0b, 0x55))
mstore(0x40, m)
mstore(0x00, 0xd694)
mstore8(0x34, 0x01)
pointer := keccak256(0x1e, 0x17)
}
}
function read(address pointer) internal view returns (bytes memory data) {
assembly {
data := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(pointer), 0x01))
extcodecopy(pointer, add(data, 0x1f), 0x00, add(n, 0x21))
mstore(data, n)
mstore(0x40, add(n, add(data, 0x40)))
}
}
function read(address pointer, uint256 start) internal view returns (bytes memory data) {
assembly {
data := mload(0x40)
let n := and(0xffffffffff, sub(extcodesize(pointer), 0x01))
let l := sub(n, and(0xffffff, mul(lt(start, n), start)))
extcodecopy(pointer, add(data, 0x1f), start, add(l, 0x21))
mstore(data, mul(sub(n, start), lt(start, n)))
mstore(0x40, add(data, add(0x40, mload(data))))
}
}
function read(address pointer, uint256 start, uint256 end)
internal
view
returns (bytes memory data)
{
assembly {
data := mload(0x40)
if iszero(lt(end, 0xffff)) { end := 0xffff }
let d := mul(sub(end, start), lt(start, end))
extcodecopy(pointer, add(data, 0x1f), start, add(d, 0x01))
if iszero(and(0xff, mload(add(data, d)))) {
let n := sub(extcodesize(pointer), 0x01)
returndatacopy(returndatasize(), returndatasize(), shr(40, n))
d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))
}
mstore(data, d)
mstore(add(add(data, 0x20), d), 0)
mstore(0x40, add(add(data, 0x40), d))
}
}
}
文件 43 的 53：SafeCastLib.sol
pragma solidity ^0.8.4;
library SafeCastLib {
error Overflow();
function toUint8(uint256 x) internal pure returns (uint8) {
if (x >= 1 << 8) _revertOverflow();
return uint8(x);
}
function toUint16(uint256 x) internal pure returns (uint16) {
if (x >= 1 << 16) _revertOverflow();
return uint16(x);
}
function toUint24(uint256 x) internal pure returns (uint24) {
if (x >= 1 << 24) _revertOverflow();
return uint24(x);
}
function toUint32(uint256 x) internal pure returns (uint32) {
if (x >= 1 << 32) _revertOverflow();
return uint32(x);
}
function toUint40(uint256 x) internal pure returns (uint40) {
if (x >= 1 << 40) _revertOverflow();
return uint40(x);
}
function toUint48(uint256 x) internal pure returns (uint48) {
if (x >= 1 << 48) _revertOverflow();
return uint48(x);
}
function toUint56(uint256 x) internal pure returns (uint56) {
if (x >= 1 << 56) _revertOverflow();
return uint56(x);
}
function toUint64(uint256 x) internal pure returns (uint64) {
if (x >= 1 << 64) _revertOverflow();
return uint64(x);
}
function toUint72(uint256 x) internal pure returns (uint72) {
if (x >= 1 << 72) _revertOverflow();
return uint72(x);
}
function toUint80(uint256 x) internal pure returns (uint80) {
if (x >= 1 << 80) _revertOverflow();
return uint80(x);
}
function toUint88(uint256 x) internal pure returns (uint88) {
if (x >= 1 << 88) _revertOverflow();
return uint88(x);
}
function toUint96(uint256 x) internal pure returns (uint96) {
if (x >= 1 << 96) _revertOverflow();
return uint96(x);
}
function toUint104(uint256 x) internal pure returns (uint104) {
if (x >= 1 << 104) _revertOverflow();
return uint104(x);
}
function toUint112(uint256 x) internal pure returns (uint112) {
if (x >= 1 << 112) _revertOverflow();
return uint112(x);
}
function toUint120(uint256 x) internal pure returns (uint120) {
if (x >= 1 << 120) _revertOverflow();
return uint120(x);
}
function toUint128(uint256 x) internal pure returns (uint128) {
if (x >= 1 << 128) _revertOverflow();
return uint128(x);
}
function toUint136(uint256 x) internal pure returns (uint136) {
if (x >= 1 << 136) _revertOverflow();
return uint136(x);
}
function toUint144(uint256 x) internal pure returns (uint144) {
if (x >= 1 << 144) _revertOverflow();
return uint144(x);
}
function toUint152(uint256 x) internal pure returns (uint152) {
if (x >= 1 << 152) _revertOverflow();
return uint152(x);
}
function toUint160(uint256 x) internal pure returns (uint160) {
if (x >= 1 << 160) _revertOverflow();
return uint160(x);
}
function toUint168(uint256 x) internal pure returns (uint168) {
if (x >= 1 << 168) _revertOverflow();
return uint168(x);
}
function toUint176(uint256 x) internal pure returns (uint176) {
if (x >= 1 << 176) _revertOverflow();
return uint176(x);
}
function toUint184(uint256 x) internal pure returns (uint184) {
if (x >= 1 << 184) _revertOverflow();
return uint184(x);
}
function toUint192(uint256 x) internal pure returns (uint192) {
if (x >= 1 << 192) _revertOverflow();
return uint192(x);
}
function toUint200(uint256 x) internal pure returns (uint200) {
if (x >= 1 << 200) _revertOverflow();
return uint200(x);
}
function toUint208(uint256 x) internal pure returns (uint208) {
if (x >= 1 << 208) _revertOverflow();
return uint208(x);
}
function toUint216(uint256 x) internal pure returns (uint216) {
if (x >= 1 << 216) _revertOverflow();
return uint216(x);
}
function toUint224(uint256 x) internal pure returns (uint224) {
if (x >= 1 << 224) _revertOverflow();
return uint224(x);
}
function toUint232(uint256 x) internal pure returns (uint232) {
if (x >= 1 << 232) _revertOverflow();
return uint232(x);
}
function toUint240(uint256 x) internal pure returns (uint240) {
if (x >= 1 << 240) _revertOverflow();
return uint240(x);
}
function toUint248(uint256 x) internal pure returns (uint248) {
if (x >= 1 << 248) _revertOverflow();
return uint248(x);
}
function toInt8(int256 x) internal pure returns (int8) {
unchecked {
if (((1 << 7) + uint256(x)) >> 8 == uint256(0)) return int8(x);
_revertOverflow();
}
}
function toInt16(int256 x) internal pure returns (int16) {
unchecked {
if (((1 << 15) + uint256(x)) >> 16 == uint256(0)) return int16(x);
_revertOverflow();
}
}
function toInt24(int256 x) internal pure returns (int24) {
unchecked {
if (((1 << 23) + uint256(x)) >> 24 == uint256(0)) return int24(x);
_revertOverflow();
}
}
function toInt32(int256 x) internal pure returns (int32) {
unchecked {
if (((1 << 31) + uint256(x)) >> 32 == uint256(0)) return int32(x);
_revertOverflow();
}
}
function toInt40(int256 x) internal pure returns (int40) {
unchecked {
if (((1 << 39) + uint256(x)) >> 40 == uint256(0)) return int40(x);
_revertOverflow();
}
}
function toInt48(int256 x) internal pure returns (int48) {
unchecked {
if (((1 << 47) + uint256(x)) >> 48 == uint256(0)) return int48(x);
_revertOverflow();
}
}
function toInt56(int256 x) internal pure returns (int56) {
unchecked {
if (((1 << 55) + uint256(x)) >> 56 == uint256(0)) return int56(x);
_revertOverflow();
}
}
function toInt64(int256 x) internal pure returns (int64) {
unchecked {
if (((1 << 63) + uint256(x)) >> 64 == uint256(0)) return int64(x);
_revertOverflow();
}
}
function toInt72(int256 x) internal pure returns (int72) {
unchecked {
if (((1 << 71) + uint256(x)) >> 72 == uint256(0)) return int72(x);
_revertOverflow();
}
}
function toInt80(int256 x) internal pure returns (int80) {
unchecked {
if (((1 << 79) + uint256(x)) >> 80 == uint256(0)) return int80(x);
_revertOverflow();
}
}
function toInt88(int256 x) internal pure returns (int88) {
unchecked {
if (((1 << 87) + uint256(x)) >> 88 == uint256(0)) return int88(x);
_revertOverflow();
}
}
function toInt96(int256 x) internal pure returns (int96) {
unchecked {
if (((1 << 95) + uint256(x)) >> 96 == uint256(0)) return int96(x);
_revertOverflow();
}
}
function toInt104(int256 x) internal pure returns (int104) {
unchecked {
if (((1 << 103) + uint256(x)) >> 104 == uint256(0)) return int104(x);
_revertOverflow();
}
}
function toInt112(int256 x) internal pure returns (int112) {
unchecked {
if (((1 << 111) + uint256(x)) >> 112 == uint256(0)) return int112(x);
_revertOverflow();
}
}
function toInt120(int256 x) internal pure returns (int120) {
unchecked {
if (((1 << 119) + uint256(x)) >> 120 == uint256(0)) return int120(x);
_revertOverflow();
}
}
function toInt128(int256 x) internal pure returns (int128) {
unchecked {
if (((1 << 127) + uint256(x)) >> 128 == uint256(0)) return int128(x);
_revertOverflow();
}
}
function toInt136(int256 x) internal pure returns (int136) {
unchecked {
if (((1 << 135) + uint256(x)) >> 136 == uint256(0)) return int136(x);
_revertOverflow();
}
}
function toInt144(int256 x) internal pure returns (int144) {
unchecked {
if (((1 << 143) + uint256(x)) >> 144 == uint256(0)) return int144(x);
_revertOverflow();
}
}
function toInt152(int256 x) internal pure returns (int152) {
unchecked {
if (((1 << 151) + uint256(x)) >> 152 == uint256(0)) return int152(x);
_revertOverflow();
}
}
function toInt160(int256 x) internal pure returns (int160) {
unchecked {
if (((1 << 159) + uint256(x)) >> 160 == uint256(0)) return int160(x);
_revertOverflow();
}
}
function toInt168(int256 x) internal pure returns (int168) {
unchecked {
if (((1 << 167) + uint256(x)) >> 168 == uint256(0)) return int168(x);
_revertOverflow();
}
}
function toInt176(int256 x) internal pure returns (int176) {
unchecked {
if (((1 << 175) + uint256(x)) >> 176 == uint256(0)) return int176(x);
_revertOverflow();
}
}
function toInt184(int256 x) internal pure returns (int184) {
unchecked {
if (((1 << 183) + uint256(x)) >> 184 == uint256(0)) return int184(x);
_revertOverflow();
}
}
function toInt192(int256 x) internal pure returns (int192) {
unchecked {
if (((1 << 191) + uint256(x)) >> 192 == uint256(0)) return int192(x);
_revertOverflow();
}
}
function toInt200(int256 x) internal pure returns (int200) {
unchecked {
if (((1 << 199) + uint256(x)) >> 200 == uint256(0)) return int200(x);
_revertOverflow();
}
}
function toInt208(int256 x) internal pure returns (int208) {
unchecked {
if (((1 << 207) + uint256(x)) >> 208 == uint256(0)) return int208(x);
_revertOverflow();
}
}
function toInt216(int256 x) internal pure returns (int216) {
unchecked {
if (((1 << 215) + uint256(x)) >> 216 == uint256(0)) return int216(x);
_revertOverflow();
}
}
function toInt224(int256 x) internal pure returns (int224) {
unchecked {
if (((1 << 223) + uint256(x)) >> 224 == uint256(0)) return int224(x);
_revertOverflow();
}
}
function toInt232(int256 x) internal pure returns (int232) {
unchecked {
if (((1 << 231) + uint256(x)) >> 232 == uint256(0)) return int232(x);
_revertOverflow();
}
}
function toInt240(int256 x) internal pure returns (int240) {
unchecked {
if (((1 << 239) + uint256(x)) >> 240 == uint256(0)) return int240(x);
_revertOverflow();
}
}
function toInt248(int256 x) internal pure returns (int248) {
unchecked {
if (((1 << 247) + uint256(x)) >> 248 == uint256(0)) return int248(x);
_revertOverflow();
}
}
function toInt8(uint256 x) internal pure returns (int8) {
if (x >= 1 << 7) _revertOverflow();
return int8(int256(x));
}
function toInt16(uint256 x) internal pure returns (int16) {
if (x >= 1 << 15) _revertOverflow();
return int16(int256(x));
}
function toInt24(uint256 x) internal pure returns (int24) {
if (x >= 1 << 23) _revertOverflow();
return int24(int256(x));
}
function toInt32(uint256 x) internal pure returns (int32) {
if (x >= 1 << 31) _revertOverflow();
return int32(int256(x));
}
function toInt40(uint256 x) internal pure returns (int40) {
if (x >= 1 << 39) _revertOverflow();
return int40(int256(x));
}
function toInt48(uint256 x) internal pure returns (int48) {
if (x >= 1 << 47) _revertOverflow();
return int48(int256(x));
}
function toInt56(uint256 x) internal pure returns (int56) {
if (x >= 1 << 55) _revertOverflow();
return int56(int256(x));
}
function toInt64(uint256 x) internal pure returns (int64) {
if (x >= 1 << 63) _revertOverflow();
return int64(int256(x));
}
function toInt72(uint256 x) internal pure returns (int72) {
if (x >= 1 << 71) _revertOverflow();
return int72(int256(x));
}
function toInt80(uint256 x) internal pure returns (int80) {
if (x >= 1 << 79) _revertOverflow();
return int80(int256(x));
}
function toInt88(uint256 x) internal pure returns (int88) {
if (x >= 1 << 87) _revertOverflow();
return int88(int256(x));
}
function toInt96(uint256 x) internal pure returns (int96) {
if (x >= 1 << 95) _revertOverflow();
return int96(int256(x));
}
function toInt104(uint256 x) internal pure returns (int104) {
if (x >= 1 << 103) _revertOverflow();
return int104(int256(x));
}
function toInt112(uint256 x) internal pure returns (int112) {
if (x >= 1 << 111) _revertOverflow();
return int112(int256(x));
}
function toInt120(uint256 x) internal pure returns (int120) {
if (x >= 1 << 119) _revertOverflow();
return int120(int256(x));
}
function toInt128(uint256 x) internal pure returns (int128) {
if (x >= 1 << 127) _revertOverflow();
return int128(int256(x));
}
function toInt136(uint256 x) internal pure returns (int136) {
if (x >= 1 << 135) _revertOverflow();
return int136(int256(x));
}
function toInt144(uint256 x) internal pure returns (int144) {
if (x >= 1 << 143) _revertOverflow();
return int144(int256(x));
}
function toInt152(uint256 x) internal pure returns (int152) {
if (x >= 1 << 151) _revertOverflow();
return int152(int256(x));
}
function toInt160(uint256 x) internal pure returns (int160) {
if (x >= 1 << 159) _revertOverflow();
return int160(int256(x));
}
function toInt168(uint256 x) internal pure returns (int168) {
if (x >= 1 << 167) _revertOverflow();
return int168(int256(x));
}
function toInt176(uint256 x) internal pure returns (int176) {
if (x >= 1 << 175) _revertOverflow();
return int176(int256(x));
}
function toInt184(uint256 x) internal pure returns (int184) {
if (x >= 1 << 183) _revertOverflow();
return int184(int256(x));
}
function toInt192(uint256 x) internal pure returns (int192) {
if (x >= 1 << 191) _revertOverflow();
return int192(int256(x));
}
function toInt200(uint256 x) internal pure returns (int200) {
if (x >= 1 << 199) _revertOverflow();
return int200(int256(x));
}
function toInt208(uint256 x) internal pure returns (int208) {
if (x >= 1 << 207) _revertOverflow();
return int208(int256(x));
}
function toInt216(uint256 x) internal pure returns (int216) {
if (x >= 1 << 215) _revertOverflow();
return int216(int256(x));
}
function toInt224(uint256 x) internal pure returns (int224) {
if (x >= 1 << 223) _revertOverflow();
return int224(int256(x));
}
function toInt232(uint256 x) internal pure returns (int232) {
if (x >= 1 << 231) _revertOverflow();
return int232(int256(x));
}
function toInt240(uint256 x) internal pure returns (int240) {
if (x >= 1 << 239) _revertOverflow();
return int240(int256(x));
}
function toInt248(uint256 x) internal pure returns (int248) {
if (x >= 1 << 247) _revertOverflow();
return int248(int256(x));
}
function toInt256(uint256 x) internal pure returns (int256) {
if (int256(x) >= 0) return int256(x);
_revertOverflow();
}
function toUint256(int256 x) internal pure returns (uint256) {
if (x >= 0) return uint256(x);
_revertOverflow();
}
function _revertOverflow() private pure {
assembly {
mstore(0x00, 0x35278d12)
revert(0x1c, 0x04)
}
}
}
文件 44 的 53：SafeTransferLib.sol
pragma solidity ^0.8.4;
library SafeTransferLib {
error ETHTransferFailed();
error TransferFromFailed();
error TransferFailed();
error ApproveFailed();
error TotalSupplyQueryFailed();
error Permit2Failed();
error Permit2AmountOverflow();
error Permit2ApproveFailed();
error Permit2LockdownFailed();
uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
bytes32 internal constant DAI_DOMAIN_SEPARATOR =
0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
function safeTransferETH(address to, uint256 amount) internal {
assembly {
if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function safeTransferAllETH(address to) internal {
assembly {
if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
assembly {
if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferETH(address to, uint256 amount) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to) internal {
assembly {
if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
function trySafeTransferAllETH(address to, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function trySafeTransferFrom(address token, address from, address to, uint256 amount)
internal
returns (bool success)
{
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
success := lt(or(iszero(extcodesize(token)), returndatasize()), success)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransferAllFrom(address token, address from, address to)
internal
returns (uint256 amount)
{
assembly {
let m := mload(0x40)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x70a08231000000000000000000000000)
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd)
amount := mload(0x60)
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransfer(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0xa9059cbb000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeTransferAll(address token, address to) internal returns (uint256 amount) {
assembly {
mstore(0x00, 0x70a08231)
mstore(0x20, address())
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
mstore(0x14, to)
amount := mload(0x34)
mstore(0x00, 0xa9059cbb000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeApprove(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeApproveWithRetry(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x34, 0)
mstore(0x00, 0x095ea7b3000000000000000000000000)
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00))
mstore(0x34, amount)
success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
}
}
}
mstore(0x34, 0)
}
}
function balanceOf(address token, address account) internal view returns (uint256 amount) {
assembly {
mstore(0x14, account)
mstore(0x00, 0x70a08231000000000000000000000000)
amount :=
mul(
mload(0x20),
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
function totalSupply(address token) internal view returns (uint256 result) {
assembly {
mstore(0x00, 0x18160ddd)
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), token, 0x1c, 0x04, 0x00, 0x20))
) {
mstore(0x00, 0x54cd9435)
revert(0x1c, 0x04)
}
result := mload(0x00)
}
}
function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {
if (!trySafeTransferFrom(token, from, to, amount)) {
permit2TransferFrom(token, from, to, amount);
}
}
function permit2TransferFrom(address token, address from, address to, uint256 amount)
internal
{
assembly {
let m := mload(0x40)
mstore(add(m, 0x74), shr(96, shl(96, token)))
mstore(add(m, 0x54), amount)
mstore(add(m, 0x34), to)
mstore(add(m, 0x20), shl(96, from))
mstore(m, 0x36c78516000000000000000000000000)
let p := PERMIT2
let exists := eq(chainid(), 1)
if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }
if iszero(
and(
call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),
lt(iszero(extcodesize(token)), exists)
)
) {
mstore(0x00, 0x7939f4248757f0fd)
revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
}
}
}
function permit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
bool success;
assembly {
for {} shl(96, xor(token, WETH9)) {} {
mstore(0x00, 0x3644e515)
if iszero(
and(
lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)),
staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
)
) { break }
let m := mload(0x40)
mstore(add(m, 0x34), spender)
mstore(add(m, 0x20), shl(96, owner))
mstore(add(m, 0x74), deadline)
if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
mstore(0x14, owner)
mstore(0x00, 0x7ecebe00000000000000000000000000)
mstore(
add(m, 0x94),
lt(iszero(amount), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
)
mstore(m, 0x8fcbaf0c000000000000000000000000)
mstore(add(m, 0xb4), and(0xff, v))
mstore(add(m, 0xd4), r)
mstore(add(m, 0xf4), s)
success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
break
}
mstore(m, 0xd505accf000000000000000000000000)
mstore(add(m, 0x54), amount)
mstore(add(m, 0x94), and(0xff, v))
mstore(add(m, 0xb4), r)
mstore(add(m, 0xd4), s)
success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
break
}
}
if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
}
function simplePermit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
assembly {
let m := mload(0x40)
mstore(m, 0x927da105)
{
let addressMask := shr(96, not(0))
mstore(add(m, 0x20), and(addressMask, owner))
mstore(add(m, 0x40), and(addressMask, token))
mstore(add(m, 0x60), and(addressMask, spender))
mstore(add(m, 0xc0), and(addressMask, spender))
}
let p := mul(PERMIT2, iszero(shr(160, amount)))
if iszero(
and(
gt(returndatasize(), 0x5f),
staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
)
) {
mstore(0x00, 0x6b836e6b8757f0fd)
revert(add(0x18, shl(2, iszero(p))), 0x04)
}
mstore(m, 0x2b67b570)
mstore(add(m, 0x60), amount)
mstore(add(m, 0x80), 0xffffffffffff)
mstore(add(m, 0xe0), deadline)
mstore(add(m, 0x100), 0x100)
mstore(add(m, 0x120), 0x41)
mstore(add(m, 0x140), r)
mstore(add(m, 0x160), s)
mstore(add(m, 0x180), shl(248, v))
if iszero(
mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {
mstore(0x00, 0x6b836e6b)
revert(0x1c, 0x04)
}
}
}
function permit2Approve(address token, address spender, uint160 amount, uint48 expiration)
internal
{
assembly {
let addressMask := shr(96, not(0))
let m := mload(0x40)
mstore(m, 0x87517c45)
mstore(add(m, 0x20), and(addressMask, token))
mstore(add(m, 0x40), and(addressMask, spender))
mstore(add(m, 0x60), and(addressMask, amount))
mstore(add(m, 0x80), and(0xffffffffffff, expiration))
if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {
mstore(0x00, 0x324f14ae)
revert(0x1c, 0x04)
}
}
}
function permit2Lockdown(address token, address spender) internal {
assembly {
let m := mload(0x40)
mstore(m, 0xcc53287f)
mstore(add(m, 0x20), 0x20)
mstore(add(m, 0x40), 1)
mstore(add(m, 0x60), shr(96, shl(96, token)))
mstore(add(m, 0x80), shr(96, shl(96, spender)))
if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {
mstore(0x00, 0x96b3de23)
revert(0x1c, 0x04)
}
}
}
}
文件 45 的 53：Token.sol
pragma solidity ^0.8.24;
import {ERC20} from "solady/src/tokens/ERC20.sol";
import {Token} from "../Types.sol";
import {NATIVE_ETH} from "../Constants.sol";
function unwrap(Token x) pure returns (address result) {
result = Token.unwrap(x);
}
function erc20(Token token) pure returns (ERC20 result) {
result = ERC20(Token.unwrap(token));
}
function isNative(Token x) pure returns (bool result) {
result = Token.unwrap(x) == NATIVE_ETH;
}
function isNotNative(Token x) pure returns (bool result) {
result = Token.unwrap(x) != NATIVE_ETH;
}
function eq(Token token0, address token1) pure returns (bool result) {
result = Token.unwrap(token0) == token1;
}
function intoToken(address token) pure returns (Token result) {
result = Token.wrap(token);
}
文件 46 的 53：TokenNameLib.sol
pragma solidity ^0.8.10;
import {MetadataReaderLib} from "solady/src/utils/MetadataReaderLib.sol";
import {DateTimeLib} from "solady/src/utils/DateTimeLib.sol";
import {LibString} from "solady/src/utils/LibString.sol";
library TokenNameLib {
using LibString for uint256;
string constant PY_NAME_PREFIX = "NapierV2-";
function principalTokenName(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingName = MetadataReaderLib.readName(target);
return string.concat(PY_NAME_PREFIX, "PT-", underlyingName, "@", expiryToDate(expiry));
}
function principalTokenSymbol(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingSymbol = MetadataReaderLib.readSymbol(target);
return string.concat("PT-", underlyingSymbol, "@", expiryToDate(expiry));
}
function yieldTokenName(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingName = MetadataReaderLib.readName(target);
return string.concat(PY_NAME_PREFIX, "YT-", underlyingName, "@", expiryToDate(expiry));
}
function yieldTokenSymbol(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingSymbol = MetadataReaderLib.readSymbol(target);
return string.concat("YT-", underlyingSymbol, "@", expiryToDate(expiry));
}
function lpTokenName(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingName = MetadataReaderLib.readName(target);
return string.concat("NapierV2-PT/", underlyingName, "@", expiryToDate(expiry));
}
function lpTokenSymbol(address target, uint256 expiry) internal view returns (string memory) {
string memory underlyingSymbol = MetadataReaderLib.readSymbol(target);
return string.concat("NPR-PT/", underlyingSymbol, "@", expiryToDate(expiry));
}
function expiryToDate(uint256 expiry) internal pure returns (string memory) {
(uint256 year, uint256 month, uint256 day) = DateTimeLib.timestampToDate(expiry);
return string.concat(day.toString(), "/", month.toString(), "/", year.toString());
}
}
文件 47 的 53：TwoCrypto.sol
pragma solidity ^0.8.24;
import {TwoCrypto} from "../Types.sol";
function unwrap(TwoCrypto x) pure returns (address result) {
result = TwoCrypto.unwrap(x);
}
文件 48 的 53：Types.sol
pragma solidity ^0.8.24;
import "./types/Token.sol" as TokenType;
import "./types/FeePcts.sol" as FeePctsType;
import "./types/ApproxValue.sol" as ApproxValueType;
import "./types/TwoCrypto.sol" as TwoCryptoType;
import "./types/ModuleIndex.sol" as ModuleIndexType;
type FeePcts is uint256;
using {FeePctsType.unwrap} for FeePcts global;
type ApproxValue is uint256;
using {ApproxValueType.unwrap} for ApproxValue global;
type Token is address;
using {TokenType.unwrap} for Token global;
using {TokenType.erc20} for Token global;
using {TokenType.isNative} for Token global;
using {TokenType.isNotNative} for Token global;
using {TokenType.eq} for Token global;
type TwoCrypto is address;
using {TwoCryptoType.unwrap} for TwoCrypto global;
struct TwoCryptoNGParams {
uint256 A;
uint256 gamma;
uint256 mid_fee;
uint256 out_fee;
uint256 fee_gamma;
uint256 allowed_extra_profit;
uint256 adjustment_step;
uint256 ma_time;
uint256 initial_price;
}
enum FeeParameters {
FEE_SPLIT_RATIO,
ISSUANCE_FEE,
PERFORMANCE_FEE,
REDEMPTION_FEE,
POST_SETTLEMENT_FEE
}
struct TokenReward {
address token;
uint256 amount;
}
using {ModuleIndexType.unwrap} for ModuleIndex global;
using {ModuleIndexType.isSupportedByFactory} for ModuleIndex global;
using {ModuleIndexType.eq as ==} for ModuleIndex global;
type ModuleIndex is uint256;
ModuleIndex constant FEE_MODULE_INDEX = ModuleIndex.wrap(0);
ModuleIndex constant REWARD_PROXY_MODULE_INDEX = ModuleIndex.wrap(1);
ModuleIndex constant VERIFIER_MODULE_INDEX = ModuleIndex.wrap(2);
uint256 constant MAX_MODULES = 3;
enum VerificationStatus {
InvalidArguments,
Success,
SupplyMoreThanMax,
Restricted,
InvalidSelector
}
文件 49 的 53：UUPSUpgradeable.sol
pragma solidity ^0.8.4;
abstract contract UUPSUpgradeable {
error UpgradeFailed();
error UnauthorizedCallContext();
uint256 private immutable __self = uint256(uint160(address(this)));
event Upgraded(address indexed implementation);
uint256 private constant _UPGRADED_EVENT_SIGNATURE =
0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b;
bytes32 internal constant _ERC1967_IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
function _authorizeUpgrade(address newImplementation) internal virtual;
function proxiableUUID() public view virtual notDelegated returns (bytes32) {
return _ERC1967_IMPLEMENTATION_SLOT;
}
function upgradeToAndCall(address newImplementation, bytes calldata data)
public
payable
virtual
onlyProxy
{
_authorizeUpgrade(newImplementation);
assembly {
newImplementation := shr(96, shl(96, newImplementation))
mstore(0x00, returndatasize())
mstore(0x01, 0x52d1902d)
let s := _ERC1967_IMPLEMENTATION_SLOT
if iszero(eq(mload(staticcall(gas(), newImplementation, 0x1d, 0x04, 0x01, 0x20)), s)) {
mstore(0x01, 0x55299b49)
revert(0x1d, 0x04)
}
log2(codesize(), 0x00, _UPGRADED_EVENT_SIGNATURE, newImplementation)
sstore(s, newImplementation)
if data.length {
let m := mload(0x40)
calldatacopy(m, data.offset, data.length)
if iszero(delegatecall(gas(), newImplementation, m, data.length, codesize(), 0x00))
{
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
}
}
}
modifier onlyProxy() {
uint256 s = __self;
assembly {
if eq(s, address()) {
mstore(0x00, 0x9f03a026)
revert(0x1c, 0x04)
}
}
_;
}
modifier notDelegated() {
uint256 s = __self;
assembly {
if iszero(eq(s, address())) {
mstore(0x00, 0x9f03a026)
revert(0x1c, 0x04)
}
}
_;
}
}
文件 50 的 53：VaultInfoResolver.sol
pragma solidity ^0.8.24;
abstract contract VaultInfoResolver {
function asset() public view virtual returns (address);
function target() public view virtual returns (address);
function scale() public view virtual returns (uint256);
function assetDecimals() public view virtual returns (uint8);
function decimals() public view virtual returns (uint8);
function label() public pure virtual returns (bytes32);
}
文件 51 的 53：VerifierModule.sol
pragma solidity ^0.8.10;
import {LibClone} from "solady/src/utils/LibClone.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {VerificationStatus} from "../Types.sol";
import {BaseModule} from "./BaseModule.sol";
import {PrincipalToken} from "src/tokens/PrincipalToken.sol";
abstract contract VerifierModule is BaseModule {
bytes4 constant SUPPLY_SELECTOR = 0x674032b8;
bytes4 constant SUPPLY_WITH_CALLBACK_SELECTOR = 0x5f04dfe2;
bytes4 constant ISSUE_SELECTOR = 0xb696a6ad;
bytes4 constant ISSUE_WITH_CALLBACK_SELECTOR = 0x6d4b055c;
function verify(bytes4 sig, address caller, uint256 shares, uint256 principal, address receiver)
external
view
virtual
returns (VerificationStatus code)
{
sig;
principal;
caller;
if (
(
sig == SUPPLY_SELECTOR || sig == SUPPLY_WITH_CALLBACK_SELECTOR || sig == ISSUE_SELECTOR
|| sig == ISSUE_WITH_CALLBACK_SELECTOR
) && shares > maxSupply(receiver)
) {
return VerificationStatus.SupplyMoreThanMax;
}
return VerificationStatus.Success;
}
function depositCap() public view virtual returns (uint256 maxShares) {
maxShares = type(uint256).max;
}
function maxSupply(address to) public view virtual returns (uint256 maxShares) {
to;
uint256 cap = depositCap();
if (cap == type(uint256).max) return type(uint256).max;
address pt = i_principalToken();
uint256 balance = SafeTransferLib.balanceOf(PrincipalToken(pt).underlying(), pt);
maxShares = FixedPointMathLib.zeroFloorSub(cap, balance);
}
}
contract DepositCapVerifierModule is VerifierModule {
bytes32 public constant override VERSION = "2.0.0";
uint256 internal s_depositCap;
function initialize() external override initializer {
(, bytes memory args) = abi.decode(LibClone.argsOnClone(address(this)), (address, bytes));
s_depositCap = abi.decode(args, (uint256));
}
function setDepositCap(uint256 cap) external restricted {
s_depositCap = cap;
}
function depositCap() public view override returns (uint256 maxShares) {
maxShares = s_depositCap;
}
}
文件 52 的 53：YieldMathLib.sol
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
type YieldIndex is uint128;
struct Snapshot {
uint128 maxscale;
YieldIndex globalIndex;
}
struct Yield {
YieldIndex userIndex;
uint128 accrued;
}
using {unwrap} for YieldIndex global;
using {eq as ==, add as +, sub as -} for YieldIndex global;
function unwrap(YieldIndex x) pure returns (uint128 result) {
result = YieldIndex.unwrap(x);
}
function wrap(uint128 x) pure returns (YieldIndex result) {
result = YieldIndex.wrap(x);
}
function eq(YieldIndex lhs, YieldIndex rhs) pure returns (bool output) {
assembly {
let m := shr(128, not(0))
output := eq(and(m, lhs), and(m, rhs))
}
}
function add(YieldIndex lhs, YieldIndex rhs) pure returns (YieldIndex output) {
output = wrap(lhs.unwrap() + rhs.unwrap());
}
function sub(YieldIndex lhs, YieldIndex rhs) pure returns (YieldIndex output) {
output = wrap(lhs.unwrap() - rhs.unwrap());
}
library YieldMathLib {
using SafeCastLib for uint256;
uint256 constant BASIS_POINTS = 10_000;
function computeTotalYield(uint256 prevMaxscale, uint256 newMaxscale, uint256 supply, uint256 feePctBps)
internal
pure
returns (uint256 accrued, uint256 fee)
{
if (prevMaxscale == 0) return (0, 0);
uint256 totalAccrued = calcYield(prevMaxscale, newMaxscale, supply);
fee = FixedPointMathLib.mulDivUp(totalAccrued, feePctBps, BASIS_POINTS);
accrued = totalAccrued - fee;
}
function updateIndex(
Snapshot memory self,
function () external view returns(uint256) scaleFn,
uint256 ptSupply,
uint256 ytSupply,
uint256 feePctBps
) internal view returns (uint256 totalAccrued, uint256 fee) {
uint256 prevMaxscale = self.maxscale;
uint256 newMaxscale = FixedPointMathLib.max(scaleFn(), prevMaxscale);
(totalAccrued, fee) = computeTotalYield(prevMaxscale, newMaxscale, ptSupply, feePctBps);
self.maxscale = newMaxscale.toUint128();
if (ytSupply == 0) return (totalAccrued, fee);
self.globalIndex =
self.globalIndex + YieldIndex.wrap(FixedPointMathLib.divWad(totalAccrued, ytSupply).toUint128());
}
function accrueUserYield(
mapping(address => Yield) storage self,
YieldIndex index,
address account,
uint256 ytBalance
) internal returns (uint256 accrued) {
accrued = computeAccrueUserYield(self, index, account, ytBalance);
self[account].accrued += accrued.toUint128();
self[account].userIndex = index;
}
function computeAccrueUserYield(
mapping(address => Yield) storage self,
YieldIndex index,
address account,
uint256 ytBalance
) internal view returns (uint256 accrued) {
YieldIndex prevIndex = self[account].userIndex;
accrued = FixedPointMathLib.mulWad(ytBalance, YieldIndex.unwrap(index - prevIndex));
}
function calcYield(uint256 prevMaxscale, uint256 maxscale, uint256 balance) internal pure returns (uint256) {
if (prevMaxscale >= maxscale) return 0;
if (prevMaxscale == 0) return 0;
return ((balance * (maxscale - prevMaxscale)) * 1e18) / (prevMaxscale * maxscale);
}
function convertToPrincipal(uint256 shares, uint256 maxscale, bool roundUp) internal pure returns (uint256) {
return FixedPointMathLib.ternary(
roundUp, FixedPointMathLib.mulWadUp(shares, maxscale), FixedPointMathLib.mulWad(shares, maxscale)
);
}
function convertToUnderlying(uint256 principal, uint256 maxscale, bool roundUp) internal pure returns (uint256) {
return FixedPointMathLib.ternary(
roundUp, FixedPointMathLib.divWadUp(principal, maxscale), FixedPointMathLib.divWad(principal, maxscale)
);
}
}
文件 53 的 53：YieldToken.sol
pragma solidity ^0.8.24;
import {ERC20} from "solady/src/tokens/ERC20.sol";
import {PrincipalToken} from "./PrincipalToken.sol";
import {TokenNameLib} from "../utils/TokenNameLib.sol";
import {Errors} from "../Errors.sol";
contract YieldToken is ERC20 {
PrincipalToken public immutable i_principalToken;
constructor(address _pt) {
i_principalToken = PrincipalToken(_pt);
}
function name() public view override returns (string memory) {
address underlying = _underlying();
uint256 expiry = _maturity();
return TokenNameLib.yieldTokenName(underlying, expiry);
}
function symbol() public view override returns (string memory) {
address underlying = _underlying();
uint256 expiry = _maturity();
return TokenNameLib.yieldTokenSymbol(underlying, expiry);
}
function decimals() public view override returns (uint8) {
return i_principalToken.decimals();
}
function mint(address to, uint256 amount) external {
if (msg.sender != address(i_principalToken)) revert Errors.YieldToken_OnlyPrincipalToken();
_mint(to, amount);
}
function burn(address from, uint256 amount) public {
if (msg.sender != address(i_principalToken)) revert Errors.YieldToken_OnlyPrincipalToken();
_burn(from, amount);
}
function transfer(address to, uint256 amount) public override returns (bool) {
i_principalToken.onYtTransfer(msg.sender, to, balanceOf(msg.sender), balanceOf(to));
return super.transfer(to, amount);
}
function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
i_principalToken.onYtTransfer(from, to, balanceOf(from), balanceOf(to));
return super.transferFrom(from, to, amount);
}
function _underlying() internal view returns (address) {
return i_principalToken.underlying();
}
function _maturity() internal view returns (uint256) {
return i_principalToken.maturity();
}
}
{
"compilationTarget": {
"src/tokens/YieldToken.sol": "YieldToken"
},
"evmVersion": "cancun",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 1
},
"remappings": [
":@openzeppelin/=node_modules/@openzeppelin/",
":forge-std/=node_modules/forge-std/",
":halmos-cheatcodes/=node_modules/halmos-cheatcodes/",
":solady/=node_modules/solady/"
]
}[{"inputs":[{"internalType":"address","name":"_pt","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"Permit2AllowanceIsFixedAtInfinity","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"YieldToken_OnlyPrincipalToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"i_principalToken","outputs":[{"internalType":"contract PrincipalToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
