编译器
0.8.20+commit.a1b79de6
文件 1 的 12：ERC20.sol
pragma solidity ^0.8.4;
abstract contract ERC20 {
error TotalSupplyOverflow();
error AllowanceOverflow();
error AllowanceUnderflow();
error InsufficientBalance();
error InsufficientAllowance();
error InvalidPermit();
error PermitExpired();
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 _VERSION_HASH =
0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;
bytes32 private constant _PERMIT_TYPEHASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
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)
{
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) {
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);
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 add(allowance_, 1) {
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 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 {
bytes32 nameHash = _constantNameHash();
if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));
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), _VERSION_HASH)
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, 0, 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()));
assembly {
let m := mload(0x40)
mstore(m, _DOMAIN_TYPEHASH)
mstore(add(m, 0x20), nameHash)
mstore(add(m, 0x40), _VERSION_HASH)
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 {
assembly {
mstore(0x20, spender)
mstore(0x0c, _ALLOWANCE_SLOT_SEED)
mstore(0x00, owner)
let allowanceSlot := keccak256(0x0c, 0x34)
let allowance_ := sload(allowanceSlot)
if add(allowance_, 1) {
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 {
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 {}
}
文件 2 的 12：ERC4626.sol
pragma solidity ^0.8.4;
import {ERC20} from "./ERC20.sol";
import {FixedPointMathLib} from "../utils/FixedPointMathLib.sol";
import {SafeTransferLib} from "../utils/SafeTransferLib.sol";
abstract contract ERC4626 is ERC20 {
uint8 internal constant _DEFAULT_UNDERLYING_DECIMALS = 18;
uint8 internal constant _DEFAULT_DECIMALS_OFFSET = 0;
error DepositMoreThanMax();
error MintMoreThanMax();
error WithdrawMoreThanMax();
error RedeemMoreThanMax();
event Deposit(address indexed by, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed by,
address indexed to,
address indexed owner,
uint256 assets,
uint256 shares
);
uint256 private constant _DEPOSIT_EVENT_SIGNATURE =
0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7;
uint256 private constant _WITHDRAW_EVENT_SIGNATURE =
0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db;
function asset() public view virtual returns (address);
function _underlyingDecimals() internal view virtual returns (uint8) {
return _DEFAULT_UNDERLYING_DECIMALS;
}
function _decimalsOffset() internal view virtual returns (uint8) {
return _DEFAULT_DECIMALS_OFFSET;
}
function _useVirtualShares() internal view virtual returns (bool) {
return true;
}
function decimals() public view virtual override(ERC20) returns (uint8) {
if (!_useVirtualShares()) return _underlyingDecimals();
return _underlyingDecimals() + _decimalsOffset();
}
function _tryGetAssetDecimals(address underlying)
internal
view
returns (bool success, uint8 result)
{
assembly {
mstore(0x00, 0x313ce567)
success :=
and(
and(lt(mload(0x00), 0x100), gt(returndatasize(), 0x1f)),
staticcall(gas(), underlying, 0x1c, 0x04, 0x00, 0x20)
)
result := mul(mload(0x00), success)
}
}
function totalAssets() public view virtual returns (uint256 assets) {
assets = SafeTransferLib.balanceOf(asset(), address(this));
}
function convertToShares(uint256 assets) public view virtual returns (uint256 shares) {
if (!_useVirtualShares()) {
uint256 supply = totalSupply();
return _eitherIsZero(assets, supply)
? _initialConvertToShares(assets)
: FixedPointMathLib.fullMulDiv(assets, supply, totalAssets());
}
uint256 o = _decimalsOffset();
if (o == 0) {
return FixedPointMathLib.fullMulDiv(assets, totalSupply() + 1, _inc(totalAssets()));
}
return FixedPointMathLib.fullMulDiv(assets, totalSupply() + 10 ** o, _inc(totalAssets()));
}
function convertToAssets(uint256 shares) public view virtual returns (uint256 assets) {
if (!_useVirtualShares()) {
uint256 supply = totalSupply();
return supply == 0
? _initialConvertToAssets(shares)
: FixedPointMathLib.fullMulDiv(shares, totalAssets(), supply);
}
uint256 o = _decimalsOffset();
if (o == 0) {
return FixedPointMathLib.fullMulDiv(shares, totalAssets() + 1, _inc(totalSupply()));
}
return FixedPointMathLib.fullMulDiv(shares, totalAssets() + 1, totalSupply() + 10 ** o);
}
function previewDeposit(uint256 assets) public view virtual returns (uint256 shares) {
shares = convertToShares(assets);
}
function previewMint(uint256 shares) public view virtual returns (uint256 assets) {
if (!_useVirtualShares()) {
uint256 supply = totalSupply();
return supply == 0
? _initialConvertToAssets(shares)
: FixedPointMathLib.fullMulDivUp(shares, totalAssets(), supply);
}
uint256 o = _decimalsOffset();
if (o == 0) {
return FixedPointMathLib.fullMulDivUp(shares, totalAssets() + 1, _inc(totalSupply()));
}
return FixedPointMathLib.fullMulDivUp(shares, totalAssets() + 1, totalSupply() + 10 ** o);
}
function previewWithdraw(uint256 assets) public view virtual returns (uint256 shares) {
if (!_useVirtualShares()) {
uint256 supply = totalSupply();
return _eitherIsZero(assets, supply)
? _initialConvertToShares(assets)
: FixedPointMathLib.fullMulDivUp(assets, supply, totalAssets());
}
uint256 o = _decimalsOffset();
if (o == 0) {
return FixedPointMathLib.fullMulDivUp(assets, totalSupply() + 1, _inc(totalAssets()));
}
return FixedPointMathLib.fullMulDivUp(assets, totalSupply() + 10 ** o, _inc(totalAssets()));
}
function previewRedeem(uint256 shares) public view virtual returns (uint256 assets) {
assets = convertToAssets(shares);
}
function _eitherIsZero(uint256 a, uint256 b) private pure returns (bool result) {
assembly {
result := or(iszero(a), iszero(b))
}
}
function _inc(uint256 x) private pure returns (uint256) {
unchecked {
return x + 1;
}
}
function maxDeposit(address to) public view virtual returns (uint256 maxAssets) {
to = to;
maxAssets = type(uint256).max;
}
function maxMint(address to) public view virtual returns (uint256 maxShares) {
to = to;
maxShares = type(uint256).max;
}
function maxWithdraw(address owner) public view virtual returns (uint256 maxAssets) {
maxAssets = convertToAssets(balanceOf(owner));
}
function maxRedeem(address owner) public view virtual returns (uint256 maxShares) {
maxShares = balanceOf(owner);
}
function deposit(uint256 assets, address to) public virtual returns (uint256 shares) {
if (assets > maxDeposit(to)) _revert(0xb3c61a83);
shares = previewDeposit(assets);
_deposit(msg.sender, to, assets, shares);
}
function mint(uint256 shares, address to) public virtual returns (uint256 assets) {
if (shares > maxMint(to)) _revert(0x6a695959);
assets = previewMint(shares);
_deposit(msg.sender, to, assets, shares);
}
function withdraw(uint256 assets, address to, address owner)
public
virtual
returns (uint256 shares)
{
if (assets > maxWithdraw(owner)) _revert(0x936941fc);
shares = previewWithdraw(assets);
_withdraw(msg.sender, to, owner, assets, shares);
}
function redeem(uint256 shares, address to, address owner)
public
virtual
returns (uint256 assets)
{
if (shares > maxRedeem(owner)) _revert(0x4656425a);
assets = previewRedeem(shares);
_withdraw(msg.sender, to, owner, assets, shares);
}
function _revert(uint256 s) private pure {
assembly {
mstore(0x00, s)
revert(0x1c, 0x04)
}
}
function _deposit(address by, address to, uint256 assets, uint256 shares) internal virtual {
SafeTransferLib.safeTransferFrom(asset(), by, address(this), assets);
_mint(to, shares);
assembly {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log3(0x00, 0x40, _DEPOSIT_EVENT_SIGNATURE, and(m, by), and(m, to))
}
_afterDeposit(assets, shares);
}
function _withdraw(address by, address to, address owner, uint256 assets, uint256 shares)
internal
virtual
{
if (by != owner) _spendAllowance(owner, by, shares);
_beforeWithdraw(assets, shares);
_burn(owner, shares);
SafeTransferLib.safeTransfer(asset(), to, assets);
assembly {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log4(0x00, 0x40, _WITHDRAW_EVENT_SIGNATURE, and(m, by), and(m, to), and(m, owner))
}
}
function _initialConvertToShares(uint256 assets)
internal
view
virtual
returns (uint256 shares)
{
shares = assets;
}
function _initialConvertToAssets(uint256 shares)
internal
view
virtual
returns (uint256 assets)
{
assets = shares;
}
function _beforeWithdraw(uint256 assets, uint256 shares) internal virtual {}
function _afterDeposit(uint256 assets, uint256 shares) internal virtual {}
}
文件 3 的 12：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 mul(y, gt(x, div(not(0), 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 {
if mul(y, gt(x, div(not(0), y))) {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), 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, iszero(mul(WAD, gt(x, 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(and(iszero(iszero(y)), eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d)
revert(0x1c, 0x04)
}
z := sdiv(mul(x, WAD), 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, iszero(mul(WAD, gt(x, 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(WAD);
int256 p = x;
uint256 c;
uint256 i = 4;
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1;
} else if (w <= -0x3ffffffffffffff) {
i = 32;
}
} else if (w >> 63 == 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 == 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 != 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 != 0) {
int256 t = w | 1;
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
assembly {
w := sdiv(x, add(wad, t))
}
}
}
}
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
assembly {
for {} 1 {} {
result := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
if iszero(p1) {
if iszero(d) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
result := div(result, d)
break
}
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
let r := mulmod(x, y, d)
let t := and(d, sub(0, 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)))
result :=
mul(
or(
mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),
div(sub(result, r), t)
),
mul(inv, sub(2, mul(d, inv)))
)
break
}
}
}
function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
result = fullMulDiv(x, y, d);
assembly {
if mulmod(x, y, d) {
result := add(result, 1)
if iszero(result) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
}
}
}
function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(mul(d, iszero(mul(y, gt(x, div(not(0), y)))))) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := div(mul(x, y), d)
}
}
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(mul(d, iszero(mul(y, gt(x, div(not(0), y)))))) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, y), d))), div(mul(x, y), d))
}
}
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 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 iszero(iszero(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 {
z = 10 ** 9;
if (x <= type(uint256).max / 10 ** 36 - 1) {
x *= 10 ** 18;
z = 1;
}
z *= sqrt(x);
}
}
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
z = 10 ** 12;
if (x <= (type(uint256).max / 10 ** 36) * 10 ** 18 - 1) {
if (x >= type(uint256).max / 10 ** 36) {
x *= 10 ** 18;
z = 10 ** 6;
} else {
x *= 10 ** 36;
z = 1;
}
}
z *= cbrt(x);
}
}
function factorial(uint256 x) internal pure returns (uint256 result) {
assembly {
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2)
revert(0x1c, 0x04)
}
for { result := 1 } x { x := sub(x, 1) } { result := mul(result, 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) {
assembly {
z := xor(sar(255, x), add(sar(255, x), x))
}
}
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
assembly {
z := xor(mul(xor(sub(y, x), sub(x, y)), sgt(x, y)), sub(y, x))
}
}
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 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)
}
}
}
文件 4 的 12：IERC20.sol
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
文件 5 的 12：IERC20Metadata.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 6 的 12：IStrategy.sol
pragma solidity ^0.8.19;
import { StrategyData } from "../helpers/VaultTypes.sol";
interface IStrategy {
function ADMIN_ROLE() external view returns (uint256);
function EMERGENCY_ADMIN_ROLE() external view returns (uint256);
function VAULT_ROLE() external view returns (uint256);
function KEEPER_ROLE() external view returns (uint256);
function grantRoles(address user, uint256 roles) external payable;
function revokeRoles(address user, uint256 roles) external payable;
function renounceRoles(uint256 roles) external payable;
function harvest(
uint256 minExpectedBalance,
uint256 minOutputAfterInvestment,
address harvester,
uint256 deadline
)
external;
function setEmergencyExit(uint256 _emergencyExit) external;
function setStrategist(address _newStrategist) external;
function vault() external returns (address);
function underlyingAsset() external returns (address);
function emergencyExit() external returns (uint256);
function liquidate(uint256 amountNeeded) external returns (uint256);
function liquidateExact(uint256 amountNeeded) external returns (uint256);
function delegatedAssets() external view returns (uint256);
function estimatedTotalAssets() external view returns (uint256);
function lastEstimatedTotalAssets() external view returns (uint256);
function strategist() external view returns (address);
function strategyName() external view returns (bytes32);
function isActive() external view returns (bool);
function hasAnyRole(address user, uint256 roles) external view returns (bool result);
function hasAllRoles(address user, uint256 roles) external view returns (bool result);
function rolesOf(address user) external view returns (uint256 roles);
function rolesFromOrdinals(uint8[] memory ordinals) external pure returns (uint256 roles);
function ordinalsFromRoles(uint256 roles) external pure returns (uint8[] memory ordinals);
function previewLiquidate(uint256) external view returns (uint256);
function previewLiquidateExact(uint256) external view returns (uint256);
function maxLiquidate() external view returns (uint256);
function maxLiquidateExact() external view returns (uint256);
function maxSingleTrade() external view returns (uint256);
function minSingleTrade() external view returns (uint256);
function yVault() external view returns (address);
function setMaxSingleTrade(uint256) external;
function setMinSingleTrade(uint256) external;
function unharvestedAmount() external view returns (int256);
function simulateHarvest()
external
returns (
uint256 expectedBalance,
uint256 outputAfterInvestment,
uint256 intendedInvest,
uint256 actualInvest,
uint256 intendedDivest,
uint256 actualDivest
);
}
文件 7 的 12：MaxApyVault.sol
pragma solidity ^0.8.19;
import { StrategyData } from "src/helpers/VaultTypes.sol";
import { OwnableRoles } from "solady/auth/OwnableRoles.sol";
import { IStrategy } from "src/interfaces/IStrategy.sol";
import { IERC20Metadata } from "openzeppelin/token/ERC20/extensions/IERC20Metadata.sol";
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import { ReentrancyGuard } from "./lib/ReentrancyGuard.sol";
import { ERC4626, ERC20 } from "solady/tokens/ERC4626.sol";
contract MaxApyVault is ERC4626, OwnableRoles, ReentrancyGuard {
using SafeTransferLib for address;
uint256 public constant MAXIMUM_STRATEGIES = 20;
uint256 public constant MAX_BPS = 10_000;
uint256 public constant SECS_PER_YEAR = 31_556_952;
uint256 public constant AUTOPILOT_HARVEST_INTERVAL = 1 weeks;
uint256 public constant ADMIN_ROLE = _ROLE_0;
uint256 public constant EMERGENCY_ADMIN_ROLE = _ROLE_1;
uint256 public constant STRATEGY_ROLE = _ROLE_2;
error QueueIsFull();
error VaultInEmergencyShutdownMode();
error StrategyInEmergencyExitMode();
error InvalidZeroAddress();
error StrategyAlreadyActive();
error StrategyNotActive();
error InvalidStrategyVault();
error InvalidStrategyUnderlying();
error InvalidDebtRatio();
error InvalidMinDebtPerHarvest();
error InvalidPerformanceFee();
error InvalidManagementFee();
error StrategyDebtRatioAlreadyZero();
error InvalidQueueOrder();
error VaultDepositLimitExceeded();
error InvalidZeroAmount();
error InvalidZeroShares();
error LossGreaterThanStrategyTotalDebt();
error InvalidReportedGainAndDebtPayment();
error FeesAlreadyAssesed();
event StrategyAdded(
address indexed newStrategy,
uint16 strategyDebtRatio,
uint128 strategyMaxDebtPerHarvest,
uint128 strategyMinDebtPerHarvest,
uint16 strategyPerformanceFee
);
event StrategyRemoved(address indexed strategy);
event EmergencyShutdownUpdated(bool emergencyShutdown);
event AutopilotEnabled(bool isEnabled);
event StrategyRevoked(address indexed strategy);
event StrategyUpdated(
address indexed strategy,
uint16 newDebtRatio,
uint128 newMaxDebtPerHarvest,
uint128 newMinDebtPerHarvest,
uint16 newPerformanceFee
);
event StrategyExited(address indexed strategy, uint256 withdrawn);
event WithdrawalQueueUpdated(address[MAXIMUM_STRATEGIES] withdrawalQueue);
event PerformanceFeeUpdated(uint16 newPerformanceFee);
event ManagementFeeUpdated(uint256 newManagementFee);
event DepositLimitUpdated(uint256 newDepositLimit);
event TreasuryUpdated(address treasury);
event WithdrawFromStrategy(address indexed strategy, uint128 strategyTotalDebt, uint128 loss);
event FeesReported(uint256 managementFee, uint16 performanceFee, uint256 strategistFee, uint256 duration);
event ForceHarvestFailed(address indexed strategy, bytes reason);
event StrategyReported(
address indexed strategy,
uint256 unrealizedGain,
uint256 loss,
uint256 debtPayment,
uint128 strategyTotalUnrealizedGain,
uint128 strategyTotalLoss,
uint128 strategyTotalDebt,
uint256 credit,
uint16 strategyDebtRatio
);
uint256 internal constant _STRATEGY_ADDED_EVENT_SIGNATURE =
0x66277e61c003f7703009ad857a4c4900f9cd3ee44535afe5905f98d53922e0f4;
uint256 internal constant _STRATEGY_REMOVED_EVENT_SIGNATURE =
0x09a1db4b80c32706328728508c941a6b954f31eb5affd32f236c1fd405f8fea4;
uint256 internal constant _EMERGENCY_SHUTDOWN_UPDATED_EVENT_SIGNATURE =
0xa63137c77816d51f856c11ffb11e84757ac9db0ce2569f94edd04c91fe2250a1;
uint256 internal constant _AUTOPILOT_ENABLED_EVENT_SIGNATURE =
0xba59cddbbe4aad399b09d7f484fdd0a4bc54da6a697a48549cbe72d79c66fcb3;
uint256 internal constant _STRATEGY_REVOKED_EVENT_SIGNATURE =
0x4201c688d84c01154d321afa0c72f1bffe9eef53005c9de9d035074e71e9b32a;
uint256 internal constant _STRATEGY_UPDATED_EVENT_SIGNATURE =
0x102a33a8369310733322056f2c0f753209cd77c65b1ce5775c2d6f181e38778f;
uint256 internal constant _WITHDRAWAL_QUEUE_UPDATED_EVENT_SIGNATURE =
0x92fa0b6a2861480bf8c9977f0f9fe1d95c535ba23cbf234f2716fc765aec3be8;
uint256 internal constant _PERFORMANCE_FEE_UPDATED_EVENT_SIGNATURE =
0x0632b4ddf7c06e7e3bc19b7ce92862c7de91b312a392142116fb574a06a47cfd;
uint256 internal constant _MANAGEMENT_FEE_UPDATED_EVENT_SIGNATURE =
0x2147e2bc8c39e67f74b1a9e08896ea1485442096765942206af1f4bc8bcde917;
uint256 internal constant _DEPOSIT_LIMIT_UPDATED_EVENT_SIGNATURE =
0xc512617347fd848ec9d7347c99c10e4fa7059132c92d0445930a7fb0c8252ff5;
uint256 internal constant _TREASURY_UPDATED_EVENT_SIGNATURE =
0x7dae230f18360d76a040c81f050aa14eb9d6dc7901b20fc5d855e2a20fe814d1;
uint256 internal constant _WITHDRAW_FROM_STRATEGY_EVENT_SIGNATURE =
0x8c1171ccd065c6769e1540f65c3c0874e5f7173ccdff7ca293238e69d000bf20;
uint256 internal constant _FEES_REPORTED_EVENT_SIGNATURE =
0x25bf703141a84375d04ea08a0c4a21c7406f300f133e12aef555607b4f3ff238;
uint256 internal constant _STRATEGY_REPORTED_EVENT_SIGNATURE =
0xc2d7e1173e37528dce423c72b129fa1ad2c5d51e50974c64fe13f1928eb27f89;
uint256 private constant _DEPOSIT_EVENT_SIGNATURE =
0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7;
uint256 private constant _WITHDRAW_EVENT_SIGNATURE =
0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db;
uint256 private constant _STRATEGY_EXITED_EVENT_SIGNATURE =
0x2e8aac9e73a32a1b5926e2c5a2820a51deb01ed40212b6346d96db2a178cf433;
bool public emergencyShutdown;
bool public autoPilotEnabled;
uint8 private immutable _decimals;
uint8 public nexHarvestStrategyIndex;
uint256 public depositLimit;
uint256 public debtRatio;
uint256 public totalIdle;
uint256 public totalDebt;
uint256 public lastReport;
address public treasury;
mapping(address => StrategyData) public strategies;
address[MAXIMUM_STRATEGIES] public withdrawalQueue;
uint256 public performanceFee;
uint256 public managementFee;
string private _name;
string private _symbol;
address private immutable _underlyingAsset;
modifier checkRoles(uint256 roles) {
_checkRoles(roles);
_;
}
modifier noEmergencyShutdown() {
if (emergencyShutdown) {
revert VaultInEmergencyShutdownMode();
}
_;
}
constructor(
address admin,
address underlyingAsset_,
string memory name_,
string memory symbol_,
address _treasury
) {
_initializeOwner(admin);
_grantRoles(admin, ADMIN_ROLE);
performanceFee = 1000;
managementFee = 200;
lastReport = block.timestamp;
(bool success, uint8 result) = _tryGetAssetDecimals(underlyingAsset_);
_decimals = success ? result : _DEFAULT_UNDERLYING_DECIMALS;
depositLimit = 10_000_000 * 10 ** _decimals;
treasury = _treasury;
_underlyingAsset = underlyingAsset_;
_name = name_;
_symbol = symbol_;
}
function _forceOneHarvest(address harvester)
internal
returns (address strategy, bool success, bytes memory reason)
{
uint256 l = withdrawalQueue.length;
address[MAXIMUM_STRATEGIES] memory strats = withdrawalQueue;
uint8 i = nexHarvestStrategyIndex > l - 1 ? 0 : nexHarvestStrategyIndex;
bool strategyFound;
for (i; i < l;) {
if (strategies[strats[i]].autoPilot) {
strategy = strats[i];
strategyFound = true;
break;
}
unchecked {
++i;
}
}
unchecked {
if (i >= l - 1 || strats[i + 1] == address(0)) {
nexHarvestStrategyIndex = 0;
} else {
nexHarvestStrategyIndex = ++i;
}
}
if (!strategyFound) return (strategy, true, reason);
try IStrategy(strategy).harvest(0, 0, harvester, block.timestamp) {
success = true;
} catch (bytes memory _reason) {
reason = _reason;
success = false;
}
}
function _reportLoss(address strategy, uint256 loss) internal {
uint128 strategyTotalDebt;
uint16 strategyDebtRatio;
uint256 totalDebt_;
uint256 debtRatio_;
uint256 strategiesSlot;
uint256 slot0Content;
uint256 slot2Content;
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
strategiesSlot := keccak256(0x00, 0x40)
slot0Content := sload(strategiesSlot)
slot2Content := sload(add(strategiesSlot, 2))
strategyDebtRatio := shr(240, shl(240, slot0Content))
strategyTotalDebt := shr(128, shl(128, slot2Content))
if gt(loss, strategyTotalDebt) { loss := strategyTotalDebt }
debtRatio_ := sload(debtRatio.slot)
totalDebt_ := sload(totalDebt.slot)
}
uint256 ratioChange;
if (totalDebt_ > 0) {
ratioChange = Math.min((loss * debtRatio_) / totalDebt_, strategyDebtRatio);
}
assembly {
if gt(ratioChange, debtRatio_) {
revert(0, 0)
}
if gt(loss, totalDebt_) {
revert(0, 0)
}
if gt(ratioChange, strategyDebtRatio) {
revert(0, 0)
}
sstore(debtRatio.slot, sub(debtRatio_, ratioChange))
sstore(totalDebt.slot, sub(totalDebt_, loss))
sstore(
strategiesSlot,
or(
shr(240, shl(240, sub(strategyDebtRatio, ratioChange))),
shl(16, shr(16, slot0Content))
)
)
let strategyTotalLoss := shr(128, slot2Content)
strategyTotalLoss := add(strategyTotalLoss, loss)
if lt(strategyTotalLoss, loss) {
revert(0, 0)
}
slot2Content :=
or(
shl(128, strategyTotalLoss),
shr(128, shl(128, sub(strategyTotalDebt, loss)))
)
sstore(add(strategiesSlot, 2), slot2Content)
}
}
function _assessFees(address strategy, uint256 gain, address managementFeeReceiver) internal returns (uint256) {
bool success;
uint256 slot0Content;
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
slot0Content := sload(keccak256(0x00, 0x40))
if or(eq(shr(208, shl(176, slot0Content)), timestamp()), eq(gain, 0)) { success := 1 }
}
if (success) {
return 0;
}
uint256 duration;
uint256 strategyPerformanceFee;
uint256 computedManagementFee;
uint256 computedStrategistFee;
uint256 computedPerformanceFee;
uint256 totalFee;
assembly ("memory-safe") {
duration := sub(timestamp(), shr(208, shl(128, slot0Content)))
if iszero(duration) {
mstore(0x00, 0x17de0c6e)
revert(0x1c, 0x04)
}
strategyPerformanceFee := shr(240, shl(224, slot0Content))
let managementFee_ := sload(managementFee.slot)
let performanceFee_ := sload(performanceFee.slot)
if iszero(iszero(mul(managementFee_, gt(gain, div(not(0), managementFee_))))) { revert(0, 0) }
computedManagementFee := div(mul(gain, managementFee_), MAX_BPS)
if iszero(iszero(mul(strategyPerformanceFee, gt(gain, div(not(0), strategyPerformanceFee))))) {
revert(0, 0)
}
computedStrategistFee := div(mul(gain, strategyPerformanceFee), MAX_BPS)
if iszero(iszero(mul(performanceFee_, gt(gain, div(not(0), performanceFee_))))) { revert(0, 0) }
computedPerformanceFee := div(mul(gain, performanceFee_), MAX_BPS)
totalFee := add(add(computedManagementFee, computedStrategistFee), computedPerformanceFee)
if gt(totalFee, gain) {
totalFee := gain
}
}
if (totalFee != 0) {
uint256 reward = _issueSharesForAmount(address(this), totalFee);
if (computedStrategistFee != 0) {
uint256 strategistReward;
assembly {
if iszero(iszero(mul(reward, gt(computedStrategistFee, div(not(0), reward))))) { revert(0, 0) }
strategistReward := div(mul(computedStrategistFee, reward), totalFee)
}
address(this).safeTransfer(IStrategy(strategy).strategist(), strategistReward);
}
uint256 cachedBalance = balanceOf(address(this));
if (cachedBalance != 0) {
if (managementFeeReceiver != address(0)) {
address(this).safeTransfer(managementFeeReceiver, cachedBalance * computedManagementFee / totalFee);
cachedBalance = balanceOf(address(this));
}
if (cachedBalance != 0) {
address(this).safeTransfer(treasury, cachedBalance);
}
}
}
assembly ("memory-safe") {
let m := mload(0x40)
mstore(0x00, computedManagementFee)
mstore(0x20, computedPerformanceFee)
mstore(0x40, computedStrategistFee)
mstore(0x60, duration)
log1(0x00, 0x80, _FEES_REPORTED_EVENT_SIGNATURE)
mstore(0x40, m)
mstore(0x60, 0)
}
return totalFee;
}
function _creditAvailable(address strategy) internal view returns (uint256) {
if (emergencyShutdown) return 0;
uint256 vaultTotalAssets = _totalDeposits();
uint256 vaultDebtLimit = _computeDebtLimit(debtRatio, vaultTotalAssets);
uint256 vaultTotalDebt = totalDebt;
bool success;
uint256 slot;
uint256 slot0Content;
uint256 strategyTotalDebt;
uint256 strategyDebtLimit;
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
slot := keccak256(0x00, 0x40)
strategyTotalDebt := shr(128, shl(128, sload(add(slot, 2))))
slot0Content := sload(slot)
let strategyDebtRatio := shr(240, shl(240, slot0Content))
if iszero(iszero(mul(vaultTotalAssets, gt(strategyDebtRatio, div(not(0), vaultTotalAssets))))) {
revert(0, 0)
}
strategyDebtLimit := div(mul(strategyDebtRatio, vaultTotalAssets), MAX_BPS)
if or(gt(strategyTotalDebt, strategyDebtLimit), gt(vaultTotalDebt, vaultDebtLimit)) { success := 1 }
}
if (success) return 0;
uint256 available;
unchecked {
available = Math.min(strategyDebtLimit - strategyTotalDebt, vaultDebtLimit - vaultTotalDebt);
}
available = Math.min(available, totalIdle);
assembly {
if lt(available, shr(128, shl(128, sload(add(slot, 1))))) { success := 1 }
}
if (success) return 0;
uint256 strategyMaxDebtPerHarvest;
assembly {
strategyMaxDebtPerHarvest := shr(128, slot0Content)
}
return Math.min(available, strategyMaxDebtPerHarvest);
}
function _computeDebtLimit(uint256 _debtRatio, uint256 totalAssets_) internal pure returns (uint256 debtLimit) {
assembly {
if iszero(iszero(mul(totalAssets_, gt(_debtRatio, div(not(0), totalAssets_))))) { revert(0, 0) }
debtLimit := div(mul(_debtRatio, totalAssets_), MAX_BPS)
}
}
function _debtOutstanding(address strategy) internal view returns (uint256 _debtOutstanding_) {
uint256 strategyTotalDebt;
uint256 strategyDebtRatio;
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
let slot := keccak256(0x00, 0x40)
strategyTotalDebt := shr(128, shl(128, sload(add(slot, 2))))
strategyDebtRatio := shr(240, shl(240, sload(slot)))
}
if (debtRatio == 0 || emergencyShutdown) return strategyTotalDebt;
uint256 strategyDebtLimit = _computeDebtLimit(strategyDebtRatio, _totalDeposits());
if (strategyDebtLimit >= strategyTotalDebt) {
return 0;
}
unchecked {
_debtOutstanding_ = strategyTotalDebt - strategyDebtLimit;
}
}
function _organizeWithdrawalQueue() internal {
uint256 offset;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = withdrawalQueue[i];
if (strategy == address(0)) {
unchecked {
++offset;
}
} else if (offset > 0) {
withdrawalQueue[i - offset] = strategy;
withdrawalQueue[i] = address(0);
}
unchecked {
++i;
}
}
}
function _revokeStrategy(address strategy, uint256 strategyDebtRatio) internal {
debtRatio -= strategyDebtRatio;
strategies[strategy].strategyDebtRatio = 0;
assembly {
log2(0x00, 0x00, _STRATEGY_REVOKED_EVENT_SIGNATURE, strategy)
}
}
function _issueSharesForAmount(address to, uint256 amount) internal returns (uint256 shares) {
shares = convertToShares(amount);
assembly ("memory-safe") {
if iszero(shares) {
mstore(0x00, 0x5a870a25)
revert(0x1c, 0x04)
}
}
_mint(to, shares);
}
function _eitherIsZero_(uint256 a, uint256 b) internal pure virtual returns (bool result) {
assembly {
result := or(iszero(a), iszero(b))
}
}
function _inc_(uint256 x) internal pure virtual returns (uint256) {
unchecked {
return x + 1;
}
}
function _sub0(uint256 a, uint256 b) internal pure virtual returns (uint256) {
unchecked {
return a - b > a ? 0 : a - b;
}
}
function _underlyingDecimals() internal view override returns (uint8) {
return _decimals;
}
function _decimalsOffset() internal pure override returns (uint8) {
return 6;
}
function _totalAssets() internal view returns (uint256 totalAssets_) {
totalAssets_ = totalIdle;
address[MAXIMUM_STRATEGIES] memory _withdrawalQueue = withdrawalQueue;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = _withdrawalQueue[i];
if (strategy == address(0)) break;
totalAssets_ += IStrategy(strategy).estimatedTotalAssets();
unchecked {
++i;
}
}
}
function _totalDeposits() internal view returns (uint256 totalAssets_) {
assembly {
let totalDebt_ := sload(totalDebt.slot)
totalAssets_ := add(sload(totalIdle.slot), totalDebt_)
if lt(totalAssets_, totalDebt_) { revert(0, 0) }
}
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function asset() public view override returns (address) {
return _underlyingAsset;
}
function totalAssets() public view override returns (uint256) {
return _totalAssets();
}
function totalDeposits() public view returns (uint256) {
return _totalDeposits();
}
function maxDeposit(address ) public view override returns (uint256 maxAssets) {
return _sub0(depositLimit, totalAssets());
}
function maxMint(address ) public view override returns (uint256 maxShares) {
return convertToShares(maxDeposit(address(0)));
}
function maxWithdraw(address owner) public view override returns (uint256 maxAssets) {
return previewRedeem(maxRedeem(owner) * 99 / 100);
}
function sharePrice() external view returns (uint256) {
return convertToAssets(10 ** decimals());
}
function convertToShares(uint256 assets) public view override returns (uint256 shares) {
uint256 o = _decimalsOffset();
return Math.fullMulDiv(assets, totalSupply() + 10 ** o, _inc_(_totalAssets()));
}
function convertToAssets(uint256 shares) public view override returns (uint256 assets) {
uint256 o = _decimalsOffset();
return Math.fullMulDiv(shares, _totalAssets() + 1, totalSupply() + 10 ** o);
}
function previewMint(uint256 shares) public view override returns (uint256 assets) {
uint256 o = _decimalsOffset();
return Math.fullMulDivUp(shares, _totalAssets() + 1, totalSupply() + 10 ** o);
}
function previewWithdraw(uint256 assets) public view override returns (uint256 shares) {
if (assets == 0) return 0;
if (assets == type(uint256).max) assets = convertToAssets(balanceOf(msg.sender));
uint256 _totalAssets_ = _totalAssets();
uint256 vaultBalance = totalIdle;
uint256 o = _decimalsOffset();
shares = Math.fullMulDivUp(assets, totalSupply() + 10 ** o, _inc_(_totalAssets_));
if (assets > vaultBalance) {
uint256 totalLoss;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = withdrawalQueue[i];
if (strategy == address(0)) break;
if (vaultBalance >= assets) break;
uint256 amountRequested = assets - vaultBalance;
amountRequested = Math.min(amountRequested, IStrategy(strategy).maxLiquidateExact());
if (amountRequested == 0) {
unchecked {
++i;
}
continue;
}
uint256 withdrawn = IStrategy(strategy).previewLiquidateExact(amountRequested);
uint256 loss = withdrawn - amountRequested;
vaultBalance += amountRequested;
if (loss != 0) {
totalLoss += loss;
}
unchecked {
++i;
}
}
shares += Math.fullMulDivUp(totalLoss, totalSupply() + 10 ** o, _inc_(_totalAssets_));
}
if (vaultBalance < assets) {
shares += Math.fullMulDivUp(assets - vaultBalance, totalSupply() + 10 ** o, _inc_(_totalAssets_));
}
}
function previewRedeem(uint256 shares) public view override returns (uint256 assets) {
if (shares == 0) return 0;
if (shares == type(uint256).max) shares = balanceOf(msg.sender);
assets = convertToAssets(shares);
uint256 vaultBalance = totalIdle;
if (vaultBalance >= assets) {
return assets;
} else {
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = withdrawalQueue[i];
if (strategy == address(0)) break;
if (vaultBalance >= assets) break;
uint256 amountRequested;
assembly ("memory-safe") {
amountRequested := sub(assets, vaultBalance)
}
amountRequested = Math.min(amountRequested, IStrategy(strategy).maxLiquidate());
if (amountRequested == 0) {
unchecked {
++i;
}
continue;
}
uint256 withdrawn = IStrategy(strategy).previewLiquidate(amountRequested);
uint256 loss = amountRequested - withdrawn;
vaultBalance += withdrawn;
if (loss != 0) {
assets -= loss;
}
unchecked {
++i;
}
}
}
}
function deposit(
uint256 assets,
address receiver
)
public
virtual
override
noEmergencyShutdown
nonReentrant
returns (uint256 shares)
{
uint256 _maxDeposit = maxDeposit(msg.sender);
assembly ("memory-safe") {
if gt(assets, _maxDeposit) {
mstore(0x00, 0x0c11966b)
revert(0x1c, 0x04)
}
}
_deposit(msg.sender, receiver, assets, shares = previewDeposit(assets));
}
function mint(
uint256 shares,
address receiver
)
public
virtual
override
noEmergencyShutdown
nonReentrant
returns (uint256 assets)
{
uint256 _maxMint = maxMint(msg.sender);
assembly ("memory-safe") {
if gt(shares, _maxMint) {
mstore(0x00, 0x0c11966b)
revert(0x1c, 0x04)
}
}
_deposit(msg.sender, receiver, assets = previewMint(shares), shares);
}
function _deposit(address by, address to, uint256 assets, uint256 shares) internal override {
asset().safeTransferFrom(by, address(this), assets);
uint256 totalIdle_;
assembly ("memory-safe") {
if iszero(shl(96, to)) {
mstore(0x00, 0xf6b2911f)
revert(0x1c, 0x04)
}
if iszero(assets) {
mstore(0x00, 0xdd484e70)
revert(0x1c, 0x04)
}
totalIdle_ := sload(totalIdle.slot)
let totalAssets_ := add(totalIdle_, sload(totalDebt.slot))
if lt(totalAssets_, totalIdle_) { revert(0, 0) }
let total := add(totalAssets_, assets)
if lt(total, totalAssets_) { revert(0, 0) }
}
assembly ("memory-safe") {
if iszero(shares) {
mstore(0x00, 0x5a870a25)
revert(0x1c, 0x04)
}
}
_mint(to, shares);
assembly ("memory-safe") {
sstore(totalIdle.slot, add(totalIdle_, assets))
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log3(0x00, 0x40, _DEPOSIT_EVENT_SIGNATURE, and(m, by), and(m, to))
}
if (autoPilotEnabled && lastReport + AUTOPILOT_HARVEST_INTERVAL < block.timestamp) {
(address strategy, bool success, bytes memory reason) = _forceOneHarvest(to);
if (!success) {
emit ForceHarvestFailed(strategy, reason);
}
}
}
function withdraw(
uint256 assets,
address to,
address owner
)
public
override
nonReentrant
returns (uint256 shares)
{
if (assets == type(uint256).max) assets = maxWithdraw(owner);
if (assets > maxWithdraw(owner)) {
assembly ("memory-safe") {
mstore(0x00, 0x936941fc)
revert(0x1c, 0x04)
}
}
shares = _withdraw(msg.sender, to, owner, assets);
}
function redeem(uint256 shares, address to, address owner) public override nonReentrant returns (uint256 assets) {
if (shares == type(uint256).max) shares = maxRedeem(owner);
if (shares > maxRedeem(owner)) {
assembly ("memory-safe") {
mstore(0x00, 0x4656425a)
revert(0x1c, 0x04)
}
}
assets = _redeem(msg.sender, to, owner, shares);
}
function _redeem(address by, address to, address owner, uint256 shares) private returns (uint256 assets) {
if (by != owner) {
_spendAllowance(owner, by, shares);
}
assembly ("memory-safe") {
if iszero(shares) {
mstore(0x00, 0x5a870a25)
revert(0x1c, 0x04)
}
}
assets = convertToAssets(shares);
address underlying = asset();
uint256 vaultBalance = totalIdle;
if (assets > vaultBalance) {
uint256 totalLoss;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = withdrawalQueue[i];
if (strategy == address(0)) break;
if (vaultBalance >= assets) break;
uint256 slotStrategies2;
assembly {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
slotStrategies2 := add(keccak256(0x00, 0x40), 2)
}
uint256 amountRequested;
assembly ("memory-safe") {
amountRequested := sub(assets, vaultBalance)
}
amountRequested = Math.min(amountRequested, IStrategy(strategy).maxLiquidate());
if (amountRequested == 0) {
unchecked {
++i;
}
continue;
}
uint256 preBalance = SafeTransferLib.balanceOf(underlying, address(this));
uint256 withdrawn;
uint256 loss;
try IStrategy(strategy).liquidate(amountRequested) returns (uint256 _loss) {
loss = _loss;
withdrawn = SafeTransferLib.balanceOf(underlying, address(this)) - preBalance;
} catch {
unchecked {
++i;
}
continue;
}
if (withdrawn == 0) {
unchecked {
++i;
}
continue;
}
vaultBalance += withdrawn;
if (loss != 0) {
assets -= loss;
totalLoss += loss;
_reportLoss(strategy, loss);
}
uint256 debtReduction = Math.min(strategies[strategy].strategyTotalDebt, withdrawn);
unchecked {
totalDebt = totalDebt - debtReduction;
}
uint128 strategyTotalDebt = uint128(strategies[strategy].strategyTotalDebt - debtReduction);
strategies[strategy].strategyTotalDebt = strategyTotalDebt;
assembly ("memory-safe") {
mstore(0x00, strategyTotalDebt)
mstore(0x20, loss)
log2(0x00, 0x40, _WITHDRAW_FROM_STRATEGY_EVENT_SIGNATURE, strategy)
}
unchecked {
++i;
}
}
totalIdle = vaultBalance;
assembly ("memory-safe") {
let sum := add(assets, totalLoss)
if lt(sum, assets) {
revert(0, 0)
}
}
}
assembly ("memory-safe") {
if eq(assets, 0x00) {
mstore(0x00, 0xdd484e70)
revert(0x1c, 0x04)
}
}
_burn(owner, shares);
if (assets > totalIdle) {
assets = totalIdle;
}
assembly ("memory-safe") {
if iszero(assets) {
mstore(0x00, 0xdd484e70)
revert(0x1c, 0x04)
}
}
unchecked {
totalIdle -= assets;
}
SafeTransferLib.safeTransfer(underlying, to, assets);
assembly ("memory-safe") {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log4(0x00, 0x40, _WITHDRAW_EVENT_SIGNATURE, and(m, by), and(m, to), and(m, owner))
}
return assets;
}
function _withdraw(address by, address to, address owner, uint256 assets) private returns (uint256 shares) {
assembly ("memory-safe") {
if iszero(assets) {
mstore(0x00, 0xdd484e70)
revert(0x1c, 0x04)
}
}
uint256 _totalAssets_ = _totalAssets();
uint256 vaultBalance = totalIdle;
uint256 o = _decimalsOffset();
address underlying = asset();
shares = Math.fullMulDivUp(assets, totalSupply() + 10 ** o, _inc_(_totalAssets_));
if (assets > vaultBalance) {
uint256 totalLoss;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
address strategy = withdrawalQueue[i];
if (strategy == address(0)) break;
if (vaultBalance >= assets) break;
uint256 amountRequested = assets - vaultBalance;
amountRequested = Math.min(amountRequested, IStrategy(strategy).maxLiquidateExact());
if (amountRequested == 0) {
unchecked {
++i;
}
continue;
}
uint256 preBalance = underlying.balanceOf(address(this));
uint256 withdrawn;
uint256 loss;
try IStrategy(strategy).liquidateExact(amountRequested) returns (uint256 _loss) {
loss = _loss;
withdrawn = SafeTransferLib.balanceOf(underlying, address(this)) - preBalance;
} catch {
unchecked {
++i;
}
continue;
}
if (withdrawn == 0) {
unchecked {
++i;
}
continue;
}
vaultBalance += withdrawn;
if (loss != 0) {
totalLoss += loss;
_reportLoss(strategy, loss);
}
uint256 debtReduction = Math.min(strategies[strategy].strategyTotalDebt, withdrawn);
unchecked {
totalDebt = totalDebt - debtReduction;
}
uint128 strategyTotalDebt = uint128(strategies[strategy].strategyTotalDebt - debtReduction);
strategies[strategy].strategyTotalDebt = strategyTotalDebt;
assembly ("memory-safe") {
mstore(0x00, strategyTotalDebt)
mstore(0x20, loss)
log2(0x00, 0x40, _WITHDRAW_FROM_STRATEGY_EVENT_SIGNATURE, strategy)
}
unchecked {
++i;
}
}
totalIdle = vaultBalance;
shares += Math.fullMulDivUp(totalLoss, totalSupply() + 10 ** o, _inc_(_totalAssets_));
if (vaultBalance < assets) {
shares += Math.fullMulDivUp(assets - vaultBalance, totalSupply() + 10 ** o, _inc_(_totalAssets_));
}
}
if (by != owner) {
_spendAllowance(owner, by, shares);
}
_burn(owner, shares);
if (assets > totalIdle) {
revert();
}
unchecked {
totalIdle -= assets;
}
SafeTransferLib.safeTransfer(underlying, to, assets);
assembly ("memory-safe") {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log4(0x00, 0x40, _WITHDRAW_EVENT_SIGNATURE, and(m, by), and(m, to), and(m, owner))
}
}
function report(
uint128 unrealizedGain,
uint128 loss,
uint128 debtPayment,
address managementFeeReceiver
)
external
checkRoles(STRATEGY_ROLE)
returns (uint256)
{
address underlying = asset();
uint256 senderBalance = SafeTransferLib.balanceOf(underlying, msg.sender);
assembly ("memory-safe") {
if lt(senderBalance, debtPayment) {
mstore(0x00, 0x746feeec)
revert(0x1c, 0x04)
}
}
if (loss > 0) {
_reportLoss(msg.sender, loss);
}
uint256 _totalFees = _assessFees(msg.sender, uint256(unrealizedGain), managementFeeReceiver);
_totalFees;
strategies[msg.sender].strategyTotalUnrealizedGain += unrealizedGain;
uint256 credit = _creditAvailable(msg.sender);
uint256 debt = strategies[msg.sender].strategyTotalDebt;
uint256 totalReportedAmount = debtPayment;
debtPayment = uint128(Math.min(uint256(debtPayment), debt));
if (debtPayment != 0) {
strategies[msg.sender].strategyTotalDebt -= debtPayment;
totalDebt -= debtPayment;
debt -= debtPayment;
}
if (credit != 0) {
strategies[msg.sender].strategyTotalDebt += uint128(credit);
totalDebt += credit;
}
unchecked {
if (credit > totalReportedAmount) {
totalIdle -= (credit - totalReportedAmount);
SafeTransferLib.safeTransfer(underlying, msg.sender, credit - totalReportedAmount);
} else if (totalReportedAmount > credit) {
totalIdle += (totalReportedAmount - credit);
asset().safeTransferFrom(msg.sender, address(this), totalReportedAmount - credit);
}
}
strategies[msg.sender].strategyLastReport = uint48(block.timestamp);
lastReport = block.timestamp;
emit StrategyReported(
msg.sender,
unrealizedGain,
loss,
debtPayment,
strategies[msg.sender].strategyTotalUnrealizedGain,
strategies[msg.sender].strategyTotalLoss,
strategies[msg.sender].strategyTotalDebt,
credit,
strategies[msg.sender].strategyDebtRatio
);
if (strategies[msg.sender].strategyDebtRatio == 0 || emergencyShutdown) {
return IStrategy(msg.sender).estimatedTotalAssets();
}
return _debtOutstanding(msg.sender);
}
function addStrategy(
address newStrategy,
uint256 strategyDebtRatio,
uint256 strategyMaxDebtPerHarvest,
uint256 strategyMinDebtPerHarvest,
uint256 strategyPerformanceFee
)
external
checkRoles(ADMIN_ROLE)
noEmergencyShutdown
{
uint256 slot;
assembly ("memory-safe") {
if sload(add(withdrawalQueue.slot, sub(MAXIMUM_STRATEGIES, 1))) {
mstore(0x00, 0xa3d0cff3)
revert(0x1c, 0x04)
}
if iszero(newStrategy) {
mstore(0x00, 0xf6b2911f)
revert(0x1c, 0x04)
}
mstore(0x00, newStrategy)
mstore(0x20, strategies.slot)
slot := keccak256(0x00, 0x40)
if shr(208, shl(176, sload(slot))) {
mstore(0x00, 0xc976754d)
revert(0x1c, 0x04)
}
}
if (IStrategy(newStrategy).vault() != address(this)) {
assembly ("memory-safe") {
mstore(0x00, 0xac4e0773)
revert(0x1c, 0x04)
}
}
if (IStrategy(newStrategy).underlyingAsset() != asset()) {
assembly ("memory-safe") {
mstore(0x00, 0xf083d3f1)
revert(0x1c, 0x04)
}
}
if (IStrategy(newStrategy).strategist() == address(0)) {
assembly ("memory-safe") {
mstore(0x00, 0xeb8bf8b6)
revert(0x1c, 0x04)
}
}
uint256 debtRatio_;
assembly ("memory-safe") {
debtRatio_ := sload(debtRatio.slot)
let sum := add(debtRatio_, strategyDebtRatio)
if lt(sum, strategyDebtRatio) {
revert(0, 0)
}
if gt(sum, MAX_BPS) {
mstore(0x00, 0x79facb0d)
revert(0x1c, 0x04)
}
if gt(strategyMinDebtPerHarvest, strategyMaxDebtPerHarvest) {
mstore(0x00, 0x5f3bd953)
revert(0x1c, 0x04)
}
if gt(strategyPerformanceFee, 5000) {
mstore(0x00, 0xf14508d0)
revert(0x1c, 0x04)
}
sstore(
slot,
or(
shl(128, strategyMaxDebtPerHarvest),
or(
shl(80, and(0xffffffffffff, timestamp())),
or(
shl(32, and(0xffffffffffff, timestamp())),
or(shl(16, and(0xffff, strategyPerformanceFee)), and(0xffff, strategyDebtRatio))
)
)
)
)
sstore(add(slot, 1), shr(128, shl(128, strategyMinDebtPerHarvest)))
}
_grantRoles(newStrategy, STRATEGY_ROLE);
assembly {
sstore(debtRatio.slot, add(debtRatio_, strategyDebtRatio))
sstore(add(withdrawalQueue.slot, sub(MAXIMUM_STRATEGIES, 1)), newStrategy)
}
_organizeWithdrawalQueue();
assembly ("memory-safe") {
mstore(0x00, strategyDebtRatio)
mstore(0x20, strategyMaxDebtPerHarvest)
mstore(0x40, strategyMinDebtPerHarvest)
mstore(0x60, strategyPerformanceFee)
log2(0x00, 0x80, _STRATEGY_ADDED_EVENT_SIGNATURE, newStrategy)
}
}
function removeStrategy(address strategy) external checkRoles(ADMIN_ROLE) noEmergencyShutdown {
address[MAXIMUM_STRATEGIES] memory cachedWithdrawalQueue = withdrawalQueue;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
if (cachedWithdrawalQueue[i] == strategy) {
withdrawalQueue[i] = address(0);
_removeRoles(strategy, STRATEGY_ROLE);
_organizeWithdrawalQueue();
assembly {
log2(0x00, 0x00, _STRATEGY_REMOVED_EVENT_SIGNATURE, strategy)
}
return;
}
unchecked {
++i;
}
}
}
function revokeStrategy(address strategy) external checkRoles(ADMIN_ROLE) {
uint256 cachedStrategyDebtRatio = strategies[strategy].strategyDebtRatio;
assembly ("memory-safe") {
if iszero(cachedStrategyDebtRatio) {
mstore(0x00, 0xe3a1d5ed)
revert(0x1c, 0x04)
}
}
_removeRoles(strategy, STRATEGY_ROLE);
_revokeStrategy(strategy, cachedStrategyDebtRatio);
}
function exitStrategy(address strategy) external checkRoles(ADMIN_ROLE) {
IStrategy _strategy = IStrategy(strategy);
uint256 _maxWithdraw = _strategy.maxLiquidate();
uint256 loss = _strategy.liquidate(_maxWithdraw);
uint256 withdrawn = _sub0(_maxWithdraw, loss);
uint256 strategyTotalDebt = strategies[strategy].strategyTotalDebt;
uint256 strategyDebtRatio = strategies[strategy].strategyDebtRatio;
totalIdle += withdrawn;
unchecked {
totalDebt -= strategyTotalDebt;
debtRatio -= strategyDebtRatio;
}
strategies[strategy].autoPilot = false;
strategies[strategy].strategyActivation = 0;
strategies[strategy].strategyTotalDebt = 0;
strategies[strategy].strategyDebtRatio = 0;
address[MAXIMUM_STRATEGIES] memory cachedWithdrawalQueue = withdrawalQueue;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
if (cachedWithdrawalQueue[i] == strategy) {
withdrawalQueue[i] = address(0);
_removeRoles(strategy, STRATEGY_ROLE);
_organizeWithdrawalQueue();
assembly {
log2(0x00, 0x00, _STRATEGY_REMOVED_EVENT_SIGNATURE, strategy)
mstore(0x00, withdrawn)
log2(0x00, 0x20, _STRATEGY_EXITED_EVENT_SIGNATURE, strategy)
}
return;
}
unchecked {
++i;
}
}
}
function updateStrategyData(
address strategy,
uint256 newDebtRatio,
uint256 newMaxDebtPerHarvest,
uint256 newMinDebtPerHarvest,
uint256 newPerformanceFee
)
external
checkRoles(ADMIN_ROLE)
{
uint256 slot;
uint256 slotContent;
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
slot := keccak256(0x00, 0x40)
slotContent := sload(slot)
if iszero(shr(208, shl(176, slotContent))) {
mstore(0x00, 0xdc974a98)
revert(0x1c, 0x04)
}
}
if (IStrategy(strategy).emergencyExit() == 2) {
assembly ("memory-safe") {
mstore(0x00, 0x57c7c24f)
revert(0x1c, 0x04)
}
}
assembly ("memory-safe") {
if gt(newMinDebtPerHarvest, newMaxDebtPerHarvest) {
mstore(0x00, 0x5f3bd953)
revert(0x1c, 0x04)
}
if gt(newPerformanceFee, 5000) {
mstore(0x00, 0xf14508d0)
revert(0x1c, 0x04)
}
}
uint256 strategyDebtRatio_;
assembly {
strategyDebtRatio_ := shr(240, shl(240, slotContent))
}
uint256 debtRatio_;
unchecked {
debtRatio_ = debtRatio -= strategyDebtRatio_;
}
assembly ("memory-safe") {
let sum := add(debtRatio_, newDebtRatio)
if lt(sum, debtRatio_) {
revert(0, 0)
}
if gt(sum, MAX_BPS) {
mstore(0x00, 0x79facb0d)
revert(0x1c, 0x04)
}
}
unchecked {
debtRatio = debtRatio_ + newDebtRatio;
}
assembly ("memory-safe") {
sstore(
slot,
or(
and(shl(32, 0xffffffffffffffffffffffff), slotContent),
or(
shl(128, newMaxDebtPerHarvest),
or(shl(16, and(0xffff, newPerformanceFee)), and(0xffff, newDebtRatio))
)
)
)
sstore(
add(slot, 1),
or(
shl(128, shr(128, sload(add(slot, 1)))),
shr(128, shl(128, newMinDebtPerHarvest))
)
)
mstore(0x00, newDebtRatio)
mstore(0x20, newMaxDebtPerHarvest)
mstore(0x40, newMinDebtPerHarvest)
mstore(0x60, newPerformanceFee)
log2(0x00, 0x80, _STRATEGY_UPDATED_EVENT_SIGNATURE, strategy)
}
}
function setWithdrawalQueue(address[MAXIMUM_STRATEGIES] calldata queue) external checkRoles(ADMIN_ROLE) {
address prevStrategy;
for (uint256 i; i < MAXIMUM_STRATEGIES;) {
assembly ("memory-safe") {
let strategy := calldataload(add(4, mul(i, 0x20)))
if and(gt(strategy, 0), and(iszero(prevStrategy), gt(i, 0))) {
mstore(0x00, 0xefb91db4)
revert(0x1c, 0x04)
}
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
if and(iszero(shr(208, shl(176, sload(keccak256(0x00, 0x40))))), gt(strategy, 0)) {
mstore(0x00, 0xdc974a98)
revert(0x1c, 0x04)
}
prevStrategy := strategy
}
unchecked {
++i;
}
}
withdrawalQueue = queue;
emit WithdrawalQueueUpdated(queue);
}
function setPerformanceFee(uint256 _performanceFee) external checkRoles(ADMIN_ROLE) {
assembly ("memory-safe") {
if gt(_performanceFee, 5000) {
mstore(0x00, 0xf14508d0)
revert(0x1c, 0x04)
}
}
performanceFee = _performanceFee;
assembly ("memory-safe") {
mstore(0x00, _performanceFee)
log1(0x00, 0x20, _PERFORMANCE_FEE_UPDATED_EVENT_SIGNATURE)
}
}
function setManagementFee(uint256 _managementFee) external checkRoles(ADMIN_ROLE) {
assembly ("memory-safe") {
if gt(_managementFee, MAX_BPS) {
mstore(0x00, 0x8e9b51ff)
revert(0x1c, 0x04)
}
}
managementFee = _managementFee;
assembly {
mstore(0x00, _managementFee)
log1(0x00, 0x20, _MANAGEMENT_FEE_UPDATED_EVENT_SIGNATURE)
}
}
function setDepositLimit(uint256 _depositLimit) external checkRoles(ADMIN_ROLE) {
depositLimit = _depositLimit;
assembly ("memory-safe") {
mstore(0x00, _depositLimit)
log1(0x00, 0x20, _DEPOSIT_LIMIT_UPDATED_EVENT_SIGNATURE)
}
}
function setEmergencyShutdown(bool _emergencyShutdown) external checkRoles(EMERGENCY_ADMIN_ROLE) {
emergencyShutdown = _emergencyShutdown;
assembly ("memory-safe") {
mstore(0x00, _emergencyShutdown)
log1(0x00, 0x20, _EMERGENCY_SHUTDOWN_UPDATED_EVENT_SIGNATURE)
}
}
function setTreasury(address _treasury) external checkRoles(ADMIN_ROLE) {
treasury = _treasury;
assembly ("memory-safe") {
mstore(0x00, _treasury)
log1(0x00, 0x20, _TREASURY_UPDATED_EVENT_SIGNATURE)
}
}
function setAutopilotEnabled(bool _autoPilotEnabled) external checkRoles(ADMIN_ROLE) {
autoPilotEnabled = _autoPilotEnabled;
assembly ("memory-safe") {
mstore(0x00, _autoPilotEnabled)
log1(0x00, 0x20, _AUTOPILOT_ENABLED_EVENT_SIGNATURE)
}
}
function setAutoPilot(bool _autoPilot) external checkRoles(STRATEGY_ROLE) {
strategies[msg.sender].autoPilot = _autoPilot;
}
function creditAvailable(address strategy) external view returns (uint256) {
return _creditAvailable(strategy);
}
function debtOutstanding(address strategy) external view returns (uint256) {
return _debtOutstanding(strategy);
}
function getStrategyTotalDebt(address strategy) external view returns (uint256 strategyTotalDebt) {
assembly ("memory-safe") {
mstore(0x00, strategy)
mstore(0x20, strategies.slot)
strategyTotalDebt := shr(128, shl(128, sload(add(keccak256(0x00, 0x40), 2))))
}
}
}
文件 8 的 12：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();
_;
}
}
文件 9 的 12：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;
}
文件 10 的 12：ReentrancyGuard.sol
pragma solidity ^0.8.19;
abstract contract ReentrancyGuard {
error ReentrantCall();
uint256 private _status = 1;
modifier nonReentrant() {
assembly {
if eq(sload(_status.slot), 2) {
mstore(0x00, 0x37ed32e8)
revert(0x1c, 0x04)
}
sstore(_status.slot, 0x02)
}
_;
assembly {
sstore(_status.slot, 0x01)
}
}
}
文件 11 的 12：SafeTransferLib.sol
pragma solidity ^0.8.4;
library SafeTransferLib {
error ETHTransferFailed();
error TransferFromFailed();
error TransferFailed();
error ApproveFailed();
error Permit2Failed();
error Permit2AmountOverflow();
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
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 :=
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
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)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x34, 0)
mstore(0x00, 0x095ea7b3000000000000000000000000)
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00))
mstore(0x34, amount)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
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 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), 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), 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(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {
mstore(0x00, 0x6b836e6b)
revert(0x1c, 0x04)
}
}
}
}
文件 12 的 12：VaultTypes.sol
pragma solidity ^0.8.19;
struct StrategyData {
uint16 strategyDebtRatio;
uint16 strategyPerformanceFee;
uint48 strategyActivation;
uint48 strategyLastReport;
uint128 strategyMaxDebtPerHarvest;
uint128 strategyMinDebtPerHarvest;
uint128 strategyTotalUnrealizedGain;
uint128 strategyTotalDebt;
uint128 strategyTotalLoss;
bool autoPilot;
}
{
"compilationTarget": {
"src/MaxApyVault.sol": "MaxApyVault"
},
"evmVersion": "shanghai",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@openzeppelin-contracts-5.0.2/=dependencies/@openzeppelin-contracts-5.0.2/",
":forge-std-1.8.2/=dependencies/forge-std-1.8.2/src/",
":forge-std/=dependencies/forge-std-1.8.2/src/",
":openzeppelin/=dependencies/@openzeppelin-contracts-5.0.2/",
":solady-0.0.201/=dependencies/solady-0.0.201/src/",
":solady/=dependencies/solady-0.0.201/src/"
]
}[{"inputs":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"underlyingAsset_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"DepositMoreThanMax","type":"error"},{"inputs":[],"name":"FeesAlreadyAssesed","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidDebtRatio","type":"error"},{"inputs":[],"name":"InvalidManagementFee","type":"error"},{"inputs":[],"name":"InvalidMinDebtPerHarvest","type":"error"},{"inputs":[],"name":"InvalidPerformanceFee","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"InvalidQueueOrder","type":"error"},{"inputs":[],"name":"InvalidReportedGainAndDebtPayment","type":"error"},{"inputs":[],"name":"InvalidStrategyUnderlying","type":"error"},{"inputs":[],"name":"InvalidStrategyVault","type":"error"},{"inputs":[],"name":"InvalidZeroAddress","type":"error"},{"inputs":[],"name":"InvalidZeroAmount","type":"error"},{"inputs":[],"name":"InvalidZeroShares","type":"error"},{"inputs":[],"name":"LossGreaterThanStrategyTotalDebt","type":"error"},{"inputs":[],"name":"MintMoreThanMax","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"QueueIsFull","type":"error"},{"inputs":[],"name":"RedeemMoreThanMax","type":"error"},{"inputs":[],"name":"ReentrantCall","type":"error"},{"inputs":[],"name":"StrategyAlreadyActive","type":"error"},{"inputs":[],"name":"StrategyDebtRatioAlreadyZero","type":"error"},{"inputs":[],"name":"StrategyInEmergencyExitMode","type":"error"},{"inputs":[],"name":"StrategyNotActive","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"VaultDepositLimitExceeded","type":"error"},{"inputs":[],"name":"VaultInEmergencyShutdownMode","type":"error"},{"inputs":[],"name":"WithdrawMoreThanMax","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":false,"internalType":"bool","name":"isEnabled","type":"bool"}],"name":"AutopilotEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newDepositLimit","type":"uint256"}],"name":"DepositLimitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"emergencyShutdown","type":"bool"}],"name":"EmergencyShutdownUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"managementFee","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"performanceFee","type":"uint16"},{"indexed":false,"internalType":"uint256","name":"strategistFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"}],"name":"FeesReported","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"}],"name":"ForceHarvestFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newManagementFee","type":"uint256"}],"name":"ManagementFeeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"newPerformanceFee","type":"uint16"}],"name":"PerformanceFeeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"roles","type":"uint256"}],"name":"RolesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newStrategy","type":"address"},{"indexed":false,"internalType":"uint16","name":"strategyDebtRatio","type":"uint16"},{"indexed":false,"internalType":"uint128","name":"strategyMaxDebtPerHarvest","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"strategyMinDebtPerHarvest","type":"uint128"},{"indexed":false,"internalType":"uint16","name":"strategyPerformanceFee","type":"uint16"}],"name":"StrategyAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"uint256","name":"withdrawn","type":"uint256"}],"name":"StrategyExited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"}],"name":"StrategyRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"uint256","name":"unrealizedGain","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"loss","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"debtPayment","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"strategyTotalUnrealizedGain","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"strategyTotalLoss","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"strategyTotalDebt","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"credit","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"strategyDebtRatio","type":"uint16"}],"name":"StrategyReported","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"}],"name":"StrategyRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"uint16","name":"newDebtRatio","type":"uint16"},{"indexed":false,"internalType":"uint128","name":"newMaxDebtPerHarvest","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"newMinDebtPerHarvest","type":"uint128"},{"indexed":false,"internalType":"uint16","name":"newPerformanceFee","type":"uint16"}],"name":"StrategyUpdated","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasuryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"uint128","name":"strategyTotalDebt","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"loss","type":"uint128"}],"name":"WithdrawFromStrategy","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[20]","name":"withdrawalQueue","type":"address[20]"}],"name":"WithdrawalQueueUpdated","type":"event"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AUTOPILOT_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EMERGENCY_ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_STRATEGIES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SECS_PER_YEAR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STRATEGY_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newStrategy","type":"address"},{"internalType":"uint256","name":"strategyDebtRatio","type":"uint256"},{"internalType":"uint256","name":"strategyMaxDebtPerHarvest","type":"uint256"},{"internalType":"uint256","name":"strategyMinDebtPerHarvest","type":"uint256"},{"internalType":"uint256","name":"strategyPerformanceFee","type":"uint256"}],"name":"addStrategy","outputs":[],"stateMutability":"nonpayable","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":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoPilotEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"creditAvailable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"debtOutstanding","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debtRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyShutdown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"exitStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"getStrategyTotalDebt","outputs":[{"internalType":"uint256","name":"strategyTotalDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"grantRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAllRoles","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAnyRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastReport","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managementFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"maxAssets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"maxShares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"maxShares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"maxAssets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nexHarvestStrategyIndex","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"","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":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"removeStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"renounceRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint128","name":"unrealizedGain","type":"uint128"},{"internalType":"uint128","name":"loss","type":"uint128"},{"internalType":"uint128","name":"debtPayment","type":"uint128"},{"internalType":"address","name":"managementFeeReceiver","type":"address"}],"name":"report","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"revokeRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"revokeStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_autoPilot","type":"bool"}],"name":"setAutoPilot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_autoPilotEnabled","type":"bool"}],"name":"setAutopilotEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositLimit","type":"uint256"}],"name":"setDepositLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_emergencyShutdown","type":"bool"}],"name":"setEmergencyShutdown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_managementFee","type":"uint256"}],"name":"setManagementFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFee","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[20]","name":"queue","type":"address[20]"}],"name":"setWithdrawalQueue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"strategies","outputs":[{"internalType":"uint16","name":"strategyDebtRatio","type":"uint16"},{"internalType":"uint16","name":"strategyPerformanceFee","type":"uint16"},{"internalType":"uint48","name":"strategyActivation","type":"uint48"},{"internalType":"uint48","name":"strategyLastReport","type":"uint48"},{"internalType":"uint128","name":"strategyMaxDebtPerHarvest","type":"uint128"},{"internalType":"uint128","name":"strategyMinDebtPerHarvest","type":"uint128"},{"internalType":"uint128","name":"strategyTotalUnrealizedGain","type":"uint128"},{"internalType":"uint128","name":"strategyTotalDebt","type":"uint128"},{"internalType":"uint128","name":"strategyTotalLoss","type":"uint128"},{"internalType":"bool","name":"autoPilot","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDebt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalIdle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"},{"internalType":"uint256","name":"newDebtRatio","type":"uint256"},{"internalType":"uint256","name":"newMaxDebtPerHarvest","type":"uint256"},{"internalType":"uint256","name":"newMinDebtPerHarvest","type":"uint256"},{"internalType":"uint256","name":"newPerformanceFee","type":"uint256"}],"name":"updateStrategyData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdrawalQueue","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
