编译器
0.8.26+commit.8a97fa7a
文件 1 的 45：AssetsManager.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "common/Lib.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { SafeCastLib } from "solady/utils/SafeCastLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import {
LiqRequest,
MultiDstMultiVaultStateReq,
MultiDstSingleVaultStateReq,
MultiVaultSFData,
MultiXChainMultiVaultWithdraw,
MultiXChainSingleVaultWithdraw,
SingleDirectMultiVaultStateReq,
SingleDirectSingleVaultStateReq,
SingleVaultSFData,
SingleXChainMultiVaultStateReq,
SingleXChainMultiVaultWithdraw,
SingleXChainSingleVaultStateReq,
SingleXChainSingleVaultWithdraw,
VaultConfig,
VaultData,
VaultLib
} from "types/Lib.sol";
contract AssetsManager is ModuleBase {
using VaultLib for VaultData;
using SafeCastLib for uint256;
using SafeTransferLib for address;
error InsufficientAssets();
error VaultNotListed();
event Invest(uint256 amount);
event Divest(uint256 amount);
event SettleXChainInvest(uint256 indexed superformId, uint256 assets);
event SettleXChainDivest(uint256 assets);
function investSingleDirectSingleVault(
address vaultAddress,
uint256 assets,
uint256 minSharesOut
)
public
onlyRoles(MANAGER_ROLE)
returns (uint256 shares)
{
if (!isVaultListed(vaultAddress)) revert VaultNotListed();
uint256 balanceBefore = vaultAddress.balanceOf(address(this));
ERC4626(vaultAddress).deposit(assets, address(this));
shares = vaultAddress.balanceOf(address(this)) - balanceBefore;
if (shares < minSharesOut) {
revert InsufficientAssets();
}
uint128 amountUint128 = assets.toUint128();
_totalIdle -= amountUint128;
_totalDebt += amountUint128;
vaults[_vaultToSuperformId[vaultAddress]].totalDebt += amountUint128;
emit Invest(assets);
return shares;
}
function investSingleDirectMultiVault(
address[] calldata vaultAddresses,
uint256[] calldata assets,
uint256[] calldata minSharesOuts
)
external
returns (uint256[] memory shares)
{
shares = new uint256[](vaultAddresses.length);
for (uint256 i = 0; i < vaultAddresses.length; ++i) {
shares[i] = investSingleDirectSingleVault(vaultAddresses[i], assets[i], minSharesOuts[i]);
}
}
function investSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 amount = gateway.investSingleXChainSingleVault{ value: msg.value }(req);
uint128 amountUint128 = amount.toUint128();
_totalIdle -= amountUint128;
emit Invest(amount);
}
function investSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.investSingleXChainMultiVault{ value: msg.value }(req);
_totalIdle -= totalAmount.toUint128();
emit Invest(totalAmount);
}
function investMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.investMultiXChainSingleVault{ value: msg.value }(req);
_totalIdle -= totalAmount.toUint128();
emit Invest(totalAmount);
}
function investMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.investMultiXChainMultiVault{ value: msg.value }(req);
_totalIdle -= totalAmount.toUint128();
emit Invest(totalAmount);
}
function divestSingleDirectSingleVault(
address vaultAddress,
uint256 shares,
uint256 minAssetsOut
)
public
onlyRoles(MANAGER_ROLE)
returns (uint256 assets)
{
if (!isVaultListed(vaultAddress)) revert VaultNotListed();
uint256 sharesValue = ERC4626(vaultAddress).convertToAssets(shares).toUint128();
uint256 balanceBefore = asset().balanceOf(address(this));
ERC4626(vaultAddress).redeem(shares, address(this), address(this));
assets = asset().balanceOf(address(this)) - balanceBefore;
if (assets < minAssetsOut) {
revert InsufficientAssets();
}
_totalIdle += assets.toUint128();
_totalDebt = _sub0(_totalDebt, sharesValue).toUint128();
vaults[_vaultToSuperformId[vaultAddress]].totalDebt =
_sub0(vaults[_vaultToSuperformId[vaultAddress]].totalDebt, sharesValue).toUint128();
emit Divest(sharesValue);
return assets;
}
function divestSingleDirectMultiVault(
address[] calldata vaultAddresses,
uint256[] calldata shares,
uint256[] calldata minAssetsOuts
)
external
returns (uint256[] memory assets)
{
assets = new uint256[](vaultAddresses.length);
for (uint256 i = 0; i < vaultAddresses.length; ++i) {
assets[i] = divestSingleDirectSingleVault(vaultAddresses[i], shares[i], minAssetsOuts[i]);
}
}
function divestSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 sharesValue = gateway.divestSingleXChainSingleVault{ value: msg.value }(req, true);
_totalDebt = _sub0(_totalDebt, sharesValue).toUint128();
vaults[req.superformData.superformId].totalDebt =
_sub0(vaults[req.superformData.superformId].totalDebt, sharesValue).toUint128();
emit Divest(sharesValue);
}
function divestSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.divestSingleXChainMultiVault{ value: msg.value }(req, true);
for (uint256 i = 0; i < req.superformsData.superformIds.length;) {
uint256 superformId = req.superformsData.superformIds[i];
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData.amounts[i], asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit Divest(totalAmount);
}
function divestMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.divestMultiXChainSingleVault{ value: msg.value }(req, true);
for (uint256 i = 0; i < req.superformsData.length;) {
uint256 superformId = req.superformsData[i].superformId;
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData[i].amount, asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit Divest(totalAmount);
}
function divestMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req)
external
payable
onlyRoles(MANAGER_ROLE)
{
uint256 totalAmount = gateway.divestMultiXChainMultiVault{ value: msg.value }(req, true);
for (uint256 i = 0; i < req.superformsData.length;) {
uint256[] memory superformIds = req.superformsData[i].superformIds;
for (uint256 j = 0; j < superformIds.length;) {
uint256 superformId = superformIds[j];
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData[i].amounts[j], asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++j;
}
}
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit Divest(totalAmount);
}
function settleXChainInvest(uint256 superformId, uint256 bridgedAssets) public {
if (msg.sender != address(gateway)) revert Unauthorized();
_totalDebt += bridgedAssets.toUint128();
vaults[superformId].totalDebt += bridgedAssets.toUint128();
emit SettleXChainInvest(superformId, bridgedAssets);
}
function settleXChainDivest(uint256 withdrawnAssets) public {
if (msg.sender != address(gateway)) revert Unauthorized();
_totalIdle += withdrawnAssets.toUint128();
emit SettleXChainDivest(withdrawnAssets);
}
function selectors() public pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](14);
s[0] = this.investSingleDirectSingleVault.selector;
s[1] = this.investSingleDirectMultiVault.selector;
s[2] = this.investSingleXChainSingleVault.selector;
s[3] = this.investSingleXChainMultiVault.selector;
s[4] = this.investMultiXChainSingleVault.selector;
s[5] = this.investMultiXChainMultiVault.selector;
s[6] = this.divestSingleDirectSingleVault.selector;
s[7] = this.divestSingleDirectMultiVault.selector;
s[8] = this.divestSingleXChainSingleVault.selector;
s[9] = this.divestSingleXChainMultiVault.selector;
s[10] = this.divestMultiXChainSingleVault.selector;
s[11] = this.divestMultiXChainMultiVault.selector;
s[12] = this.settleXChainInvest.selector;
s[13] = this.settleXChainDivest.selector;
return s;
}
}
文件 2 的 45：DistributorTypes.sol
pragma solidity ^0.8.19;
struct PendingRoot {
bytes32 root;
bytes32 ipfsHash;
uint256 validAt;
}
文件 3 的 45：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 {}
}
文件 4 的 45：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 == uint256(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 == uint256(0)
? _initialConvertToAssets(shares)
: FixedPointMathLib.fullMulDiv(shares, totalAssets(), supply);
}
uint256 o = _decimalsOffset();
if (o == uint256(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 == uint256(0)
? _initialConvertToAssets(shares)
: FixedPointMathLib.fullMulDivUp(shares, totalAssets(), supply);
}
uint256 o = _decimalsOffset();
if (o == uint256(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 == uint256(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 {}
}
文件 5 的 45：ERC7540.sol
pragma solidity ^0.8.19;
import { ERC7540Lib, ERC7540_FilledRequest, ERC7540_Request } from "../types/ERC7540Types.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
abstract contract ERC7540 is ERC4626 {
using SafeTransferLib for address;
using ERC7540Lib for ERC7540_Request;
using ERC7540Lib for ERC7540_FilledRequest;
event DepositRequest(
address indexed controller, address indexed owner, uint256 indexed requestId, address source, uint256 assets
);
event RedeemRequest(
address indexed controller, address indexed owner, uint256 indexed requestId, address source, uint256 shares
);
event FulfillDepositRequest(address indexed controller, uint256 assets, uint256 shares);
event FulfillRedeemRequest(address indexed controller, uint256 shares, uint256 assets);
event OperatorSet(address indexed controller, address indexed operator, bool approved);
error InvalidController();
error InvalidZeroAssets();
error InvalidZeroShares();
error InvalidOperator();
mapping(address => ERC7540_Request) internal _pendingDepositRequest;
mapping(address => ERC7540_Request) internal _pendingRedeemRequest;
mapping(address => ERC7540_FilledRequest) internal _claimableDepositRequest;
mapping(address => ERC7540_FilledRequest) internal _claimableRedeemRequest;
mapping(address controller => mapping(address operator => bool)) public isOperator;
function previewDeposit(uint256 assets) public pure override returns (uint256 shares) {
assets;
shares;
revert();
}
function previewMint(uint256 shares) public pure override returns (uint256 assets) {
shares;
assets;
revert();
}
function previewWithdraw(uint256 assets) public pure override returns (uint256 shares) {
assets;
shares;
revert();
}
function previewRedeem(uint256 shares) public pure override returns (uint256 assets) {
shares;
assets;
revert();
}
function maxDeposit(address to) public view virtual override returns (uint256 assets) {
return _claimableDepositRequest[to].assets;
}
function maxMint(address to) public view virtual override returns (uint256 shares) {
return convertToShares(maxDeposit(to));
}
function maxWithdraw(address owner) public view virtual override returns (uint256 assets) {
return convertToAssets(maxRedeem(owner));
}
function maxRedeem(address owner) public view virtual override returns (uint256 shares) {
return _claimableRedeemRequest[owner].shares;
}
function requestDeposit(
uint256 assets,
address controller,
address owner
)
public
virtual
returns (uint256 requestId)
{
if (assets == 0) revert InvalidZeroAssets();
requestId = _requestDeposit(assets, controller, owner, msg.sender);
}
function requestRedeem(
uint256 shares,
address controller,
address owner
)
public
virtual
returns (uint256 requestId)
{
if (shares == 0) revert InvalidZeroShares();
address sender = isOperator[owner][msg.sender] ? owner : msg.sender;
return _requestRedeem(shares, controller, sender, msg.sender);
}
function deposit(uint256 assets, address receiver) public virtual override returns (uint256 shares) {
return deposit(assets, receiver, msg.sender);
}
function deposit(uint256 assets, address receiver, address controller) public virtual returns (uint256 shares) {
_validateController(controller);
if (assets > maxDeposit(controller)) revert DepositMoreThanMax();
ERC7540_FilledRequest memory claimable = _claimableDepositRequest[controller];
shares = claimable.convertToSharesUp(assets);
(shares,) = _deposit(assets, shares, receiver, controller);
}
function mint(uint256 shares, address receiver) public virtual override returns (uint256 assets) {
return mint(shares, receiver, msg.sender);
}
function mint(uint256 shares, address receiver, address controller) public virtual returns (uint256 assets) {
_validateController(controller);
if (shares > maxMint(controller)) revert MintMoreThanMax();
ERC7540_FilledRequest memory claimable = _claimableDepositRequest[controller];
assets = claimable.convertToAssetsUp(shares);
(, assets) = _deposit(assets, shares, receiver, controller);
}
function redeem(uint256 shares, address to, address controller) public virtual override returns (uint256 assets) {
if (shares > maxRedeem(controller)) revert RedeemMoreThanMax();
_validateController(controller);
ERC7540_FilledRequest memory claimable = _claimableRedeemRequest[controller];
assets = claimable.convertToAssets(shares);
(assets,) = _withdraw(assets, shares, to, controller);
}
function withdraw(
uint256 assets,
address to,
address controller
)
public
virtual
override
returns (uint256 shares)
{
if (assets > maxWithdraw(controller)) revert WithdrawMoreThanMax();
_validateController(controller);
ERC7540_FilledRequest memory claimable = _claimableRedeemRequest[controller];
shares = claimable.convertToSharesUp(assets);
(, shares) = _withdraw(assets, shares, to, controller);
}
function pendingRedeemRequest(address controller) public view virtual returns (uint256) {
return _pendingRedeemRequest[controller].unwrap();
}
function pendingDepositRequest(address controller) public view virtual returns (uint256) {
return _pendingDepositRequest[controller].unwrap();
}
function claimableDepositRequest(address controller) public view virtual returns (uint256) {
return maxDeposit(controller);
}
function claimableRedeemRequest(address controller) public view virtual returns (uint256) {
return maxRedeem(controller);
}
function _deposit(
uint256 assets,
uint256 shares,
address receiver,
address controller
)
internal
virtual
returns (uint256 sharesReturn, uint256 assetsReturn)
{
unchecked {
_claimableDepositRequest[controller].assets -= assets;
_claimableDepositRequest[controller].shares -= shares;
}
_mint(receiver, shares);
assembly {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log3(
0x00,
0x40,
0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7,
and(m, controller),
and(m, receiver)
)
}
return (shares, assets);
}
function _withdraw(
uint256 assets,
uint256 shares,
address receiver,
address controller
)
internal
virtual
returns (uint256 assetsReturn, uint256 sharesReturn)
{
unchecked {
_claimableRedeemRequest[controller].assets -= assets;
_claimableRedeemRequest[controller].shares -= shares;
}
asset().safeTransfer(receiver, assets);
assembly {
mstore(0x00, assets)
mstore(0x20, shares)
let m := shr(96, not(0))
log4(
0x00,
0x40,
0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db,
and(m, controller),
and(m, receiver),
and(m, controller)
)
}
return (assets, shares);
}
function _requestDeposit(
uint256 assets,
address controller,
address owner,
address source
)
internal
virtual
returns (uint256 requestId)
{
source;
asset().safeTransferFrom(source, address(this), assets);
_pendingDepositRequest[controller] = _pendingDepositRequest[controller].add(assets);
emit DepositRequest(controller, owner, requestId, source, assets);
return 0;
}
function _requestRedeem(
uint256 shares,
address controller,
address owner,
address source
)
internal
virtual
returns (uint256 requestId)
{
source;
_transfer(owner, address(this), shares);
_pendingRedeemRequest[controller] = _pendingRedeemRequest[controller].add(shares);
emit RedeemRequest(controller, owner, requestId, source, shares);
return 0;
}
function setOperator(address operator, bool approved) public returns (bool success) {
if (msg.sender == operator) revert InvalidOperator();
isOperator[msg.sender][operator] = approved;
emit OperatorSet(msg.sender, operator, approved);
return true;
}
function _validateController(address controller) private view {
if (msg.sender != controller && !isOperator[controller][msg.sender]) revert InvalidController();
}
function _fulfillDepositRequest(
address controller,
uint256 assetsFulfilled,
uint256 sharesMinted
)
internal
virtual
{
_pendingDepositRequest[controller] = _pendingDepositRequest[controller].sub(assetsFulfilled);
_claimableDepositRequest[controller].assets += assetsFulfilled;
_claimableDepositRequest[controller].shares += sharesMinted;
emit FulfillDepositRequest(controller, assetsFulfilled, sharesMinted);
}
function _fulfillRedeemRequest(
uint256 sharesFulfilled,
uint256 assetsWithdrawn,
address controller,
bool strict
)
internal
virtual
{
if (strict) {
_pendingRedeemRequest[controller] = _pendingRedeemRequest[controller].sub(sharesFulfilled);
} else {
_pendingRedeemRequest[controller] = _pendingRedeemRequest[controller].sub0(sharesFulfilled);
}
_claimableRedeemRequest[controller].assets += assetsWithdrawn;
_claimableRedeemRequest[controller].shares += sharesFulfilled;
emit FulfillRedeemRequest(controller, sharesFulfilled, assetsWithdrawn);
}
}
文件 6 的 45：ERC7540Engine.sol
pragma solidity ^0.8.19;
import { ERC7540ProcessRedeemBase } from "./common/ERC7540ProcessRedeemBase.sol";
import { ProcessRedeemRequestParams } from "types/Lib.sol";
contract ERC7540Engine is ERC7540ProcessRedeemBase {
event FulfillSettledRequest(address indexed controller, uint256 shares, uint256 assets);
function processRedeemRequest(ProcessRedeemRequestParams calldata params)
external
payable
onlyRoles(RELAYER_ROLE)
nonReentrant
{
_processRedeemRequest(
ProcessRedeemRequestConfig(
params.shares == 0 ? pendingRedeemRequest(params.controller) : params.shares,
params.controller,
params.sXsV,
params.sXmV,
params.mXsV,
params.mXmV
)
);
}
function fulfillSettledRequest(address controller, uint256 requestedAssets, uint256 fulfilledAssets) public {
if (msg.sender != address(gateway)) revert Unauthorized();
uint256 shares = convertToShares(requestedAssets);
pendingProcessedShares[controller] = _sub0(pendingProcessedShares[controller], shares);
_fulfillRedeemRequest(shares, fulfilledAssets, controller, false);
emit FulfillSettledRequest(controller, shares, fulfilledAssets);
}
function selectors() public pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](3);
s[0] = this.processRedeemRequest.selector;
s[1] = this.fulfillSettledRequest.selector;
s[2] = this.setDustThreshold.selector;
return s;
}
}
文件 7 的 45：ERC7540EngineBase.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "common/Lib.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import { VaultData, VaultLib } from "types/Lib.sol";
contract ERC7540EngineBase is ModuleBase {
using VaultLib for VaultData;
struct ProcessRedeemRequestCache {
uint256[WITHDRAWAL_QUEUE_SIZE][N_CHAINS] dstVaults;
uint256[WITHDRAWAL_QUEUE_SIZE][N_CHAINS] sharesPerVault;
uint256[WITHDRAWAL_QUEUE_SIZE][N_CHAINS] assetsPerVault;
uint256[N_CHAINS] lens;
uint256 amountToWithdraw;
uint256 sharesFulfilled;
uint256 totalClaimableWithdraw;
uint256 totalAssets;
uint256 totalIdle;
uint256 totalDebt;
uint256 assets;
uint256 shares;
uint256 lastIndex;
bool isSingleChain;
bool isMultiChain;
bool isMultiVault;
}
function _prepareWithdrawalRoute(ProcessRedeemRequestCache memory cache, bool despiseDust) internal view {
_exhaustWithdrawalQueue(cache, localWithdrawalQueue, false, false);
_exhaustWithdrawalQueue(cache, xChainWithdrawalQueue, true, despiseDust);
}
function _exhaustWithdrawalQueue(
ProcessRedeemRequestCache memory cache,
uint256[WITHDRAWAL_QUEUE_SIZE] memory queue,
bool resetValues,
bool despiseDust
)
internal
view
{
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] == 0) {
if (resetValues) {
cache.amountToWithdraw = cache.assets - cache.totalIdle;
}
break;
}
if (resetValues && despiseDust && cache.amountToWithdraw < dustThreshold) {
uint256 amountToWithdraw = cache.amountToWithdraw;
cache.amountToWithdraw = 0;
cache.assets -= amountToWithdraw;
cache.shares -= convertToShares(amountToWithdraw);
break;
}
if (cache.amountToWithdraw == 0) {
break;
}
VaultData memory vault = vaults[queue[i]];
uint256 maxWithdraw = vault.convertToAssets(_sharesBalance(vault), asset(), true);
uint256 withdrawAssets = Math.min(maxWithdraw, cache.amountToWithdraw);
if (withdrawAssets == 0) continue;
uint256 chainIndex = chainIndexes[vault.chainId];
uint256 len = cache.lens[chainIndex];
cache.dstVaults[chainIndex][len] = vault.superformId;
uint256 shares;
if (cache.amountToWithdraw >= maxWithdraw) {
uint256 balance = _sharesBalance(vault);
shares = balance;
} else {
shares = vault.convertToShares(withdrawAssets, asset(), true);
}
if (shares == 0) continue;
cache.sharesPerVault[chainIndex][len] = shares;
cache.assetsPerVault[chainIndex][len] = withdrawAssets;
uint256 debtReduction = Math.min(vault.totalDebt, withdrawAssets);
cache.totalDebt -= debtReduction;
cache.amountToWithdraw -= withdrawAssets;
if (vault.chainId != THIS_CHAIN_ID) {
if (!cache.isSingleChain && !cache.isMultiChain) {
cache.isSingleChain = true;
} else if (cache.isSingleChain) {
uint256 firstChainId;
for (uint256 j = 0; j < N_CHAINS; j++) {
if (cache.lens[j] > 0 && j != chainIndexes[THIS_CHAIN_ID]) {
firstChainId = j;
break;
}
}
if (chainIndex != firstChainId) {
cache.isSingleChain = false;
cache.isMultiChain = true;
}
}
if (cache.lens[chainIndex] >= 1) {
cache.isMultiVault = true;
}
}
unchecked {
cache.lens[chainIndex]++;
}
}
}
function setDustThreshold(uint256 _dustThreshold) external onlyRoles(ADMIN_ROLE) {
dustThreshold = _dustThreshold;
}
}
文件 8 的 45：ERC7540EngineReader.sol
pragma solidity ^0.8.19;
import { ERC7540EngineBase } from "./common/ERC7540EngineBase.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import {
LiqRequest,
MultiDstMultiVaultStateReq,
MultiDstSingleVaultStateReq,
MultiVaultSFData,
MultiXChainMultiVaultWithdraw,
MultiXChainSingleVaultWithdraw,
ProcessRedeemRequestParams,
SingleDirectMultiVaultStateReq,
SingleDirectSingleVaultStateReq,
SingleVaultSFData,
SingleXChainMultiVaultStateReq,
SingleXChainMultiVaultWithdraw,
SingleXChainSingleVaultStateReq,
SingleXChainSingleVaultWithdraw,
VaultData,
VaultLib
} from "types/Lib.sol";
contract ERC7540EngineReader is ERC7540EngineBase {
error InsufficientAvailableAssets();
using VaultLib for VaultData;
function previewWithdrawalRoute(
address controller,
uint256 shares,
bool despiseDust
)
public
view
returns (ProcessRedeemRequestCache memory cachedRoute)
{
if (shares == 0) {
shares = pendingRedeemRequest(controller);
}
cachedRoute.shares = shares;
cachedRoute.assets = convertToAssets(shares);
cachedRoute.totalIdle = _totalIdle;
cachedRoute.totalDebt = _totalDebt;
cachedRoute.totalAssets = totalAssets();
if (cachedRoute.assets > totalWithdrawableAssets()) {
revert InsufficientAvailableAssets();
}
if (cachedRoute.totalIdle >= cachedRoute.assets) {
cachedRoute.sharesFulfilled = shares;
cachedRoute.totalClaimableWithdraw = cachedRoute.assets;
}
else {
cachedRoute.amountToWithdraw = cachedRoute.assets - cachedRoute.totalIdle;
if (cachedRoute.totalIdle > 0) {
cachedRoute.totalClaimableWithdraw = cachedRoute.totalIdle;
cachedRoute.sharesFulfilled = _convertToShares(cachedRoute.totalIdle, cachedRoute.totalAssets);
}
_prepareWithdrawalRoute(cachedRoute, despiseDust);
}
return cachedRoute;
}
function selectors() public pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](1);
s[0] = this.previewWithdrawalRoute.selector;
return s;
}
}
文件 9 的 45：ERC7540EngineSignatures.sol
pragma solidity ^0.8.19;
import { ERC7540ProcessRedeemBase } from "./common/ERC7540ProcessRedeemBase.sol";
import { SignatureCheckerLib } from "solady/utils/SignatureCheckerLib.sol";
import { ProcessRedeemRequestParams } from "types/Lib.sol";
contract ERC7540EngineSignatures is ERC7540ProcessRedeemBase {
error SignatureExpired();
error InvalidSignature();
error InvalidNonce();
function verifySignature(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint256 nonce,
uint8 v,
bytes32 r,
bytes32 s
)
public
view
returns (bool)
{
if (block.timestamp > deadline) {
revert SignatureExpired();
}
if (nonce != nonces(params.controller)) {
revert InvalidNonce();
}
bytes32 paramsHash = computeHash(params, deadline, nonce);
return SignatureCheckerLib.isValidSignatureNow(signerRelayer, paramsHash, abi.encodePacked(r, s, v));
}
function computeHash(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint256 nonce
)
public
pure
returns (bytes32)
{
return keccak256(
abi.encode(
params.controller, params.shares, params.sXsV, params.sXmV, params.mXsV, params.mXmV, deadline, nonce
)
);
}
function processSignedRequest(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
address controller = params.controller;
uint256 nonce = nonces(controller);
if (!verifySignature(params, deadline, nonce, v, r, s)) {
revert InvalidSignature();
}
assembly {
mstore(0x0c, _NONCES_SLOT_SEED)
mstore(0x00, controller)
let nonceSlot := keccak256(0x0c, 0x20)
let nonceValue := sload(nonceSlot)
sstore(nonceSlot, add(nonceValue, 1))
}
_processRedeemRequest(
ProcessRedeemRequestConfig(
params.shares == 0 ? pendingRedeemRequest(params.controller) : params.shares,
params.controller,
params.sXsV,
params.sXmV,
params.mXsV,
params.mXmV
)
);
}
function selectors() public pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](3);
s[0] = this.processSignedRequest.selector;
s[1] = this.verifySignature.selector;
s[2] = this.computeHash.selector;
return s;
}
}
文件 10 的 45：ERC7540ProcessRedeemBase.sol
pragma solidity ^0.8.19;
import { ERC7540EngineBase } from "./ERC7540EngineBase.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import { SafeCastLib } from "solady/utils/SafeCastLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import {
LiqRequest,
MultiVaultSFData,
MultiXChainMultiVaultWithdraw,
MultiXChainSingleVaultWithdraw,
SingleVaultSFData,
SingleXChainMultiVaultWithdraw,
SingleXChainSingleVaultWithdraw,
VaultData
} from "types/Lib.sol";
abstract contract ERC7540ProcessRedeemBase is ERC7540EngineBase {
error InsufficientAvailableAssets();
error InsufficientAssets();
error ExcessiveSharesRequested();
error SharesInProcess();
error AssetsNotLiquidated();
event ProcessRedeemRequest(address indexed controller, uint256 shares);
using SafeCastLib for uint256;
using SafeTransferLib for address;
struct ProcessRedeemRequestConfig {
uint256 shares;
address controller;
SingleXChainSingleVaultWithdraw sXsV;
SingleXChainMultiVaultWithdraw sXmV;
MultiXChainSingleVaultWithdraw mXsV;
MultiXChainMultiVaultWithdraw mXmV;
}
function _processRedeemRequest(ProcessRedeemRequestConfig memory config) internal {
ProcessRedeemRequestCache memory cache;
cache.totalIdle = _totalIdle;
cache.totalDebt = _totalDebt;
uint256 pendingShares = pendingRedeemRequest(config.controller);
if (config.shares > pendingShares) revert ExcessiveSharesRequested();
if (config.shares > pendingShares - pendingProcessedShares[config.controller]) revert SharesInProcess();
cache.assets = convertToAssets(config.shares);
cache.totalAssets = totalAssets();
if (cache.assets > totalWithdrawableAssets()) {
revert InsufficientAvailableAssets();
}
if (cache.totalIdle >= cache.assets) {
cache.sharesFulfilled = config.shares;
cache.totalClaimableWithdraw = cache.assets;
}
else {
cache.amountToWithdraw = cache.assets - cache.totalIdle;
if (cache.totalIdle > 0) {
cache.totalClaimableWithdraw = cache.totalIdle;
cache.sharesFulfilled = _convertToShares(cache.totalIdle, cache.totalAssets);
}
_prepareWithdrawalRoute(cache, false);
_processThisChainWithdrawals(config, cache);
if (cache.isSingleChain) {
_processSingleChainWithdrawals(config, cache);
}
if (cache.isMultiChain) {
if (!cache.isMultiVault) {
_processMultiChainSingleVault(config, cache);
} else {
_processMultiChainMultiVault(config, cache);
}
}
}
_totalIdle = cache.totalIdle.toUint128();
_totalIdle -= cache.totalClaimableWithdraw.toUint128();
_totalDebt = cache.totalDebt.toUint128();
if (totalAssets() > cache.totalAssets - cache.amountToWithdraw) {
revert AssetsNotLiquidated();
}
emit ProcessRedeemRequest(config.controller, config.shares);
pendingProcessedShares[config.controller] += config.shares - cache.sharesFulfilled;
_burn(address(this), config.shares);
_fulfillRedeemRequest(cache.sharesFulfilled, cache.totalClaimableWithdraw, config.controller, true);
}
function _processThisChainWithdrawals(
ProcessRedeemRequestConfig memory config,
ProcessRedeemRequestCache memory cache
)
private
{
uint256 chainIndex = chainIndexes[THIS_CHAIN_ID];
if (cache.lens[chainIndex] == 0) return;
if (cache.lens[chainIndex] == 1) {
uint256 sharesAmount = cache.sharesPerVault[chainIndex][0];
uint256 assetsAmount = cache.assetsPerVault[chainIndex][0];
uint256 superformId = cache.dstVaults[chainIndex][0];
uint256 withdrawn =
_liquidateSingleDirectSingleVault(vaults[superformId].vaultAddress, sharesAmount, 0, address(this));
cache.sharesFulfilled += _convertToShares(assetsAmount, cache.totalAssets);
_reduceVaultDebt(superformId, assetsAmount);
cache.totalClaimableWithdraw += withdrawn;
cache.totalIdle += withdrawn;
} else {
uint256 len = cache.lens[chainIndex];
address[] memory vaultAddresses = new address[](len);
uint256[] memory amounts = new uint256[](len);
uint256 requestedAssets;
for (uint256 i = 0; i < len;) {
vaultAddresses[i] = vaults[cache.dstVaults[chainIndex][i]].vaultAddress;
amounts[i] = cache.sharesPerVault[chainIndex][i];
uint256 superformId = cache.dstVaults[chainIndex][i];
requestedAssets += cache.assetsPerVault[chainIndex][i];
_reduceVaultDebt(superformId, cache.assetsPerVault[chainIndex][i]);
unchecked {
++i;
}
}
uint256 withdrawn = _liquidateSingleDirectMultiVault(
vaultAddresses, amounts, _getEmptyuintArray(amounts.length), address(this)
);
cache.totalClaimableWithdraw += withdrawn;
cache.sharesFulfilled += _convertToShares(requestedAssets, cache.totalAssets);
cache.totalIdle += withdrawn;
}
}
function _processSingleChainWithdrawals(
ProcessRedeemRequestConfig memory config,
ProcessRedeemRequestCache memory cache
)
private
{
if (!cache.isMultiVault) {
uint256 superformId;
uint256 amount;
uint64 chainId;
for (uint256 i = 0; i < N_CHAINS;) {
if (DST_CHAINS[i] == THIS_CHAIN_ID) {
unchecked {
++i;
}
continue;
}
if (cache.lens[i] > 0) {
chainId = DST_CHAINS[i];
uint256 chainIndex = chainIndexes[chainId];
superformId = cache.dstVaults[i][0];
amount = cache.sharesPerVault[i][0];
_liquidateSingleXChainSingleVault(
chainId, superformId, amount, config.controller, config.sXsV, cache.assetsPerVault[i][0]
);
_reduceVaultDebt(superformId, cache.assetsPerVault[chainIndex][0]);
break;
}
unchecked {
++i;
}
}
} else {
uint256[] memory superformIds;
uint256[] memory amounts;
uint64 chainId;
for (uint256 i = 0; i < N_CHAINS;) {
if (DST_CHAINS[i] == THIS_CHAIN_ID) {
unchecked {
++i;
}
continue;
}
if (cache.lens[i] > 0) {
chainId = DST_CHAINS[i];
superformIds = _toDynamicUint256Array(cache.dstVaults[i], cache.lens[i]);
amounts = _toDynamicUint256Array(cache.sharesPerVault[i], cache.lens[i]);
uint256 totalDebtReduction;
for (uint256 j = 0; j < superformIds.length;) {
_reduceVaultDebt(superformIds[j], cache.assetsPerVault[i][j]);
totalDebtReduction += cache.assetsPerVault[i][j];
unchecked {
++j;
}
}
_liquidateSingleXChainMultiVault(
chainId,
superformIds,
amounts,
config.controller,
config.sXmV,
totalDebtReduction,
_toDynamicUint256Array(cache.assetsPerVault[i], cache.lens[i])
);
break;
}
unchecked {
++i;
}
}
}
}
function _processMultiChainSingleVault(
ProcessRedeemRequestConfig memory config,
ProcessRedeemRequestCache memory cache
)
private
{
uint256 chainsLen;
for (uint256 i = 0; i < cache.lens.length;) {
if (cache.lens[i] > 0) chainsLen++;
unchecked {
++i;
}
}
uint8[][] memory ambIds = new uint8[][](chainsLen);
uint64[] memory dstChainIds = new uint64[](chainsLen);
SingleVaultSFData[] memory singleVaultDatas = new SingleVaultSFData[](chainsLen);
uint256 lastChainsIndex;
for (uint256 i = 0; i < N_CHAINS;) {
if (cache.lens[i] > 0) {
dstChainIds[lastChainsIndex] = DST_CHAINS[i];
++lastChainsIndex;
}
unchecked {
++i;
}
}
uint256[] memory totalDebtReductions = new uint256[](chainsLen);
for (uint256 i = 0; i < N_CHAINS;) {
if (cache.lens[i] == 0) {
unchecked {
++i;
}
continue;
}
totalDebtReductions[cache.lastIndex] = cache.assetsPerVault[i][0];
singleVaultDatas[cache.lastIndex] = SingleVaultSFData({
superformId: cache.dstVaults[i][0],
amount: cache.sharesPerVault[i][0],
outputAmount: config.mXsV.outputAmounts[cache.lastIndex],
maxSlippage: config.mXsV.maxSlippages[cache.lastIndex],
liqRequest: config.mXsV.liqRequests[cache.lastIndex],
permit2data: "",
hasDstSwap: config.mXsV.hasDstSwaps[cache.lastIndex],
retain4626: false,
receiverAddress: config.controller,
receiverAddressSP: address(0),
extraFormData: ""
});
ambIds[cache.lastIndex] = config.mXsV.ambIds[cache.lastIndex];
_reduceVaultDebt(cache.dstVaults[i][0], cache.assetsPerVault[i][0]);
cache.lastIndex++;
unchecked {
++i;
}
}
_liquidateMultiDstSingleVault(ambIds, dstChainIds, singleVaultDatas, config.mXsV.value, totalDebtReductions);
}
function _processMultiChainMultiVault(
ProcessRedeemRequestConfig memory config,
ProcessRedeemRequestCache memory cache
)
private
{
uint256 chainsLen;
for (uint256 i = 0; i < cache.lens.length;) {
if (cache.lens[i] > 0) chainsLen++;
unchecked {
++i;
}
}
uint8[][] memory ambIds = new uint8[][](chainsLen);
uint64[] memory dstChainIds = new uint64[](chainsLen);
MultiVaultSFData[] memory multiVaultDatas = new MultiVaultSFData[](chainsLen);
uint256 lastChainsIndex;
for (uint256 i = 0; i < N_CHAINS;) {
if (cache.lens[i] > 0) {
dstChainIds[lastChainsIndex] = DST_CHAINS[i];
++lastChainsIndex;
}
unchecked {
++i;
}
}
uint256[] memory totalDebtReductions = new uint256[](chainsLen);
uint256[][] memory debtReductionsPerVault = new uint256[][](chainsLen);
for (uint256 i = 0; i < N_CHAINS;) {
if (cache.lens[i] == 0) {
unchecked {
++i;
}
continue;
}
bool[] memory emptyBoolArray = _getEmptyBoolArray(cache.lens[i]);
uint256[] memory superformIds = _toDynamicUint256Array(cache.dstVaults[i], cache.lens[i]);
multiVaultDatas[cache.lastIndex] = MultiVaultSFData({
superformIds: superformIds,
amounts: _toDynamicUint256Array(cache.sharesPerVault[i], cache.lens[i]),
outputAmounts: config.mXmV.outputAmounts[cache.lastIndex],
maxSlippages: config.mXmV.maxSlippages[cache.lastIndex],
liqRequests: config.mXmV.liqRequests[cache.lastIndex],
permit2data: "",
hasDstSwaps: config.mXmV.hasDstSwaps[cache.lastIndex],
retain4626s: emptyBoolArray,
receiverAddress: config.controller,
receiverAddressSP: address(0),
extraFormData: ""
});
ambIds[cache.lastIndex] = config.mXmV.ambIds[cache.lastIndex];
debtReductionsPerVault[cache.lastIndex] = _toDynamicUint256Array(cache.sharesPerVault[i], cache.lens[i]);
for (uint256 j = 0; j < superformIds.length;) {
_reduceVaultDebt(superformIds[j], cache.assetsPerVault[i][j]);
totalDebtReductions[cache.lastIndex] += cache.assetsPerVault[i][j];
unchecked {
++j;
}
}
cache.lastIndex++;
unchecked {
++i;
}
}
_liquidateMultiDstMultiVault(
ambIds, dstChainIds, multiVaultDatas, config.mXmV.value, totalDebtReductions, debtReductionsPerVault
);
}
function _reduceVaultDebt(uint256 superformId, uint256 amount) private {
unchecked {
vaults[superformId].totalDebt =
(amount >= vaults[superformId].totalDebt ? 0 : vaults[superformId].totalDebt - amount).toUint128();
}
}
function _liquidateSingleDirectSingleVault(
address vault,
uint256 amount,
uint256 minAmountOut,
address receiver
)
private
returns (uint256 withdrawn)
{
uint256 balanceBefore = asset().balanceOf(address(this));
ERC4626(vault).redeem(amount, address(this), receiver);
withdrawn = asset().balanceOf(address(this)) - balanceBefore;
if (withdrawn < minAmountOut) {
revert InsufficientAssets();
}
}
function _liquidateSingleDirectMultiVault(
address[] memory vaults_,
uint256[] memory amounts,
uint256[] memory minAmountsOut,
address receiver
)
private
returns (uint256 withdrawn)
{
for (uint256 i = 0; i < vaults_.length;) {
withdrawn += _liquidateSingleDirectSingleVault(vaults_[i], amounts[i], minAmountsOut[i], receiver);
unchecked {
++i;
}
}
}
function _liquidateSingleXChainSingleVault(
uint64 chainId,
uint256 superformId,
uint256 amount,
address receiver,
SingleXChainSingleVaultWithdraw memory config,
uint256 totalDebtReduction
)
private
{
gateway.liquidateSingleXChainSingleVault{ value: config.value }(
chainId, superformId, amount, receiver, config, totalDebtReduction
);
}
function _liquidateSingleXChainMultiVault(
uint64 chainId,
uint256[] memory superformIds,
uint256[] memory amounts,
address receiver,
SingleXChainMultiVaultWithdraw memory config,
uint256 totalDebtReduction,
uint256[] memory debtReductionPerVault
)
private
{
gateway.liquidateSingleXChainMultiVault{ value: config.value }(
chainId, superformIds, amounts, receiver, config, totalDebtReduction, debtReductionPerVault
);
}
function _liquidateMultiDstSingleVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
SingleVaultSFData[] memory singleVaultDatas,
uint256 value,
uint256[] memory totalDebtReductions
)
private
{
gateway.liquidateMultiDstSingleVault{ value: value }(ambIds, dstChainIds, singleVaultDatas, totalDebtReductions);
}
function _liquidateMultiDstMultiVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
MultiVaultSFData[] memory multiVaultDatas,
uint256 value,
uint256[] memory totalDebtReduction,
uint256[][] memory debtReductionsPerVault
)
private
{
gateway.liquidateMultiDstMultiVault{ value: value }(
ambIds, dstChainIds, multiVaultDatas, totalDebtReduction, debtReductionsPerVault
);
}
}
文件 11 的 45：ERC7540Types.sol
pragma solidity ^0.8.19;
import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol";
type ERC7540_Request is uint256;
struct ERC7540_FilledRequest {
uint256 assets;
uint256 shares;
}
library ERC7540Lib {
function convertToSharesUp(ERC7540_FilledRequest memory self, uint256 assets) internal pure returns (uint256) {
return FixedPointMathLib.fullMulDivUp(self.shares, assets, self.assets);
}
function convertToShares(ERC7540_FilledRequest memory self, uint256 assets) internal pure returns (uint256) {
return FixedPointMathLib.fullMulDiv(self.shares, assets, self.assets);
}
function convertToAssets(ERC7540_FilledRequest memory self, uint256 shares) internal pure returns (uint256) {
return FixedPointMathLib.fullMulDiv(self.assets, shares, self.shares);
}
function convertToAssetsUp(ERC7540_FilledRequest memory self, uint256 shares) internal pure returns (uint256) {
return FixedPointMathLib.fullMulDivUp(self.assets, shares, self.shares);
}
function add(ERC7540_Request self, uint256 x) internal pure returns (ERC7540_Request) {
return ERC7540_Request.wrap(ERC7540_Request.unwrap(self) + x);
}
function sub(ERC7540_Request self, uint256 x) internal pure returns (ERC7540_Request) {
return ERC7540_Request.wrap(ERC7540_Request.unwrap(self) - x);
}
function sub0(ERC7540_Request self, uint256 x) internal pure returns (ERC7540_Request) {
return ERC7540_Request.wrap(x > ERC7540_Request.unwrap(self) ? 0 : ERC7540_Request.unwrap(self) - x);
}
function unwrap(ERC7540_Request self) internal pure returns (uint256) {
return ERC7540_Request.unwrap(self);
}
}
文件 12 的 45：EmergencyAssetsManager.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "common/Lib.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { SafeCastLib } from "solady/utils/SafeCastLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import {
LiqRequest,
MultiDstMultiVaultStateReq,
MultiDstSingleVaultStateReq,
MultiVaultSFData,
MultiXChainMultiVaultWithdraw,
MultiXChainSingleVaultWithdraw,
SingleDirectMultiVaultStateReq,
SingleDirectSingleVaultStateReq,
SingleVaultSFData,
SingleXChainMultiVaultStateReq,
SingleXChainMultiVaultWithdraw,
SingleXChainSingleVaultStateReq,
SingleXChainSingleVaultWithdraw,
VaultConfig,
VaultData,
VaultLib
} from "types/Lib.sol";
contract EmergencyAssetsManager is ModuleBase {
using VaultLib for VaultData;
using SafeCastLib for uint256;
using SafeTransferLib for address;
error InsufficientAssets();
error VaultNotListed();
event EmergencyDivest(uint256 amount);
event SettleXChainDivest(uint256 assets);
function emergencyDivestSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req)
external
payable
onlyRoles(EMERGENCY_ADMIN_ROLE)
{
uint256 sharesValue = gateway.divestSingleXChainSingleVault{ value: msg.value }(req, false);
_totalDebt = _sub0(_totalDebt, sharesValue).toUint128();
vaults[req.superformData.superformId].totalDebt =
_sub0(vaults[req.superformData.superformId].totalDebt, sharesValue).toUint128();
emit EmergencyDivest(sharesValue);
}
function emergencyDivestSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req)
external
payable
onlyRoles(EMERGENCY_ADMIN_ROLE)
{
uint256 totalAmount = gateway.divestSingleXChainMultiVault{ value: msg.value }(req, false);
for (uint256 i = 0; i < req.superformsData.superformIds.length;) {
uint256 superformId = req.superformsData.superformIds[i];
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData.amounts[i], asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit EmergencyDivest(totalAmount);
}
function emergencyDivestMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req)
external
payable
onlyRoles(EMERGENCY_ADMIN_ROLE)
{
uint256 totalAmount = gateway.divestMultiXChainSingleVault{ value: msg.value }(req, false);
for (uint256 i = 0; i < req.superformsData.length;) {
uint256 superformId = req.superformsData[i].superformId;
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData[i].amount, asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit EmergencyDivest(totalAmount);
}
function emergencyDivestMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req)
external
payable
onlyRoles(EMERGENCY_ADMIN_ROLE)
{
uint256 totalAmount = gateway.divestMultiXChainMultiVault{ value: msg.value }(req, false);
for (uint256 i = 0; i < req.superformsData.length;) {
uint256[] memory superformIds = req.superformsData[i].superformIds;
for (uint256 j = 0; j < superformIds.length;) {
uint256 superformId = superformIds[j];
VaultData memory vault = vaults[superformId];
uint256 divestAmount = vault.convertToAssets(req.superformsData[i].amounts[j], asset(), true);
vault.totalDebt = _sub0(vaults[superformId].totalDebt, divestAmount).toUint128();
vaults[superformId] = vault;
unchecked {
++j;
}
}
unchecked {
++i;
}
}
_totalDebt = _sub0(_totalDebt, totalAmount).toUint128();
emit EmergencyDivest(totalAmount);
}
function selectors() public pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](4);
s[0] = this.emergencyDivestMultiXChainMultiVault.selector;
s[1] = this.emergencyDivestMultiXChainSingleVault.selector;
s[2] = this.emergencyDivestSingleXChainMultiVault.selector;
s[3] = this.emergencyDivestSingleXChainSingleVault.selector;
return s;
}
}
文件 13 的 45：FixedPointMathLib.sol
pragma solidity ^0.8.4;
library FixedPointMathLib {
error ExpOverflow();
error FactorialOverflow();
error RPowOverflow();
error MantissaOverflow();
error MulWadFailed();
error SMulWadFailed();
error DivWadFailed();
error SDivWadFailed();
error MulDivFailed();
error DivFailed();
error FullMulDivFailed();
error LnWadUndefined();
error OutOfDomain();
uint256 internal constant WAD = 1e18;
function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if gt(x, div(not(0), y)) {
if y {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
}
z := div(mul(x, y), WAD)
}
}
function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, y)
if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4)
revert(0x1c, 0x04)
}
z := sdiv(z, WAD)
}
}
function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, y), WAD)
}
}
function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, y), WAD)
}
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if gt(x, div(not(0), y)) {
if 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, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := div(mul(x, WAD), y)
}
}
function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, WAD)
if iszero(mul(y, eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d)
revert(0x1c, 0x04)
}
z := sdiv(z, y)
}
}
function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, WAD), y)
}
}
function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, WAD), y)
}
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function powWad(int256 x, int256 y) internal pure returns (int256) {
return expWad((lnWad(x) * y) / int256(WAD));
}
function expWad(int256 x) internal pure returns (int256 r) {
unchecked {
if (x <= -41446531673892822313) return r;
assembly {
if iszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9)
revert(0x1c, 0x04)
}
}
x = (x << 78) / 5 ** 18;
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
r := sdiv(p, q)
}
r = int256(
(uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)
);
}
}
function lnWad(int256 x) internal pure returns (int256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
if iszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638)
revert(0x1c, 0x04)
}
r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
x := shr(159, shl(r, x))
let p := sub(
sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p := sub(mul(p, x), shl(96, 795164235651350426258249787498))
let q := add(5573035233440673466300451813936, x)
q := add(71694874799317883764090561454958, sar(96, mul(x, q)))
q := add(283447036172924575727196451306956, sar(96, mul(x, q)))
q := add(401686690394027663651624208769553, sar(96, mul(x, q)))
q := add(204048457590392012362485061816622, sar(96, mul(x, q)))
q := add(31853899698501571402653359427138, sar(96, mul(x, q)))
q := add(909429971244387300277376558375, sar(96, mul(x, q)))
p := sdiv(p, q)
p := mul(1677202110996718588342820967067443963516166, p)
p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
r := sar(174, p)
}
}
function lambertW0Wad(int256 x) internal pure returns (int256 w) {
unchecked {
if ((w = x) <= -367879441171442322) revert OutOfDomain();
(int256 wad, int256 p) = (int256(WAD), x);
uint256 c;
uint256 i = 4;
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1;
} else if (w <= -0x3ffffffffffffff) {
i = 32;
}
} else if (uint256(w >> 63) == uint256(0)) {
assembly {
let v := shr(49, w)
let l := shl(3, lt(0xff, v))
l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c := gt(l, 60)
i := add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
assembly {
w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i := add(3, iszero(shr(68, x)))
c := iszero(shr(143, x))
}
if (c == uint256(0)) {
do {
int256 e = expWad(w);
assembly {
let t := mul(w, div(e, wad))
w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i != uint256(0));
assembly {
w := sub(w, sgt(w, 2))
}
return w;
}
}
do {
int256 e = expWad(w);
assembly {
let t := add(w, wad)
let s := sub(mul(w, e), mul(x, wad))
w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
assembly {
w := sub(w, sgt(w, 2))
}
if (c == uint256(0)) return w;
int256 t = w | 1;
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
assembly {
w := sdiv(x, add(wad, t))
}
}
}
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
assembly {
result := mul(x, y)
for {} 1 {} {
if iszero(mul(or(iszero(x), eq(div(result, x), y)), d)) {
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
let r := mulmod(x, y, d)
let t := and(d, sub(0, d))
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
result :=
mul(
or(
mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),
div(sub(result, r), t)
),
mul(sub(2, mul(d, inv)), inv)
)
break
}
result := div(result, d)
break
}
}
}
function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internal
pure
returns (uint256 result)
{
assembly {
result := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
let t := and(d, sub(0, d))
let r := mulmod(x, y, d)
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
result :=
mul(
or(mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)), div(sub(result, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
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 {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := div(z, d)
}
}
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(z, d))), div(z, d))
}
}
function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(d) {
mstore(0x00, 0x65244e4e)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(x, d))), div(x, d))
}
}
function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 result) {
assembly {
result := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {
assembly {
z := mul(b, iszero(y))
if x {
z := xor(b, mul(xor(b, x), and(y, 1)))
let half := shr(1, b)
for { y := shr(1, y) } y { y := shr(1, y) } {
let xx := mul(x, x)
let xxRound := add(xx, half)
if or(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
x := div(xxRound, b)
if and(y, 1) {
let zx := mul(z, x)
let zxRound := add(zx, half)
if or(xor(div(zx, x), z), lt(zxRound, zx)) {
if x {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
}
z := div(zxRound, b)
}
}
}
}
}
function sqrt(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 181
let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffffff, shr(r, x))))
z := shl(shr(1, r), z)
z := shr(18, mul(z, add(shr(r, x), 65536)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := sub(z, lt(div(x, z), z))
}
}
function cbrt(uint256 x) internal pure returns (uint256 z) {
assembly {
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := sub(z, lt(div(x, mul(z, z)), z))
}
}
function sqrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);
z = (1 + sqrt(x)) * 10 ** 9;
z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;
}
assembly {
z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1)))
}
}
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);
z = (1 + cbrt(x)) * 10 ** 12;
z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;
}
assembly {
let p := x
for {} 1 {} {
if iszero(shr(229, p)) {
if iszero(shr(199, p)) {
p := mul(p, 100000000000000000)
break
}
p := mul(p, 100000000)
break
}
if iszero(shr(249, p)) { p := mul(p, 100) }
break
}
let t := mulmod(mul(z, z), z, p)
z := sub(z, gt(lt(t, shr(1, p)), iszero(t)))
}
}
function factorial(uint256 x) internal pure returns (uint256 result) {
assembly {
result := 1
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2)
revert(0x1c, 0x04)
}
for {} 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) {
unchecked {
z = (uint256(x) + uint256(x >> 255)) ^ uint256(x >> 255);
}
}
function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))
}
}
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(x, y))
}
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), lt(y, x)))
}
}
function min(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), slt(y, x)))
}
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
function max(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), sgt(y, x)))
}
}
function clamp(uint256 x, uint256 minValue, uint256 maxValue)
internal
pure
returns (uint256 z)
{
assembly {
z := xor(x, mul(xor(x, minValue), gt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
for { z := x } y {} {
let t := y
y := mod(z, y)
z := t
}
}
}
function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internal
pure
returns (uint256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internal
pure
returns (int256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b - a),
uint256(t - begin), uint256(end - begin)));
return int256(uint256(a) - fullMulDiv(uint256(a - b),
uint256(t - begin), uint256(end - begin)));
}
}
function isEven(uint256 x) internal pure returns (bool) {
return x & uint256(1) == uint256(0);
}
function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x + y;
}
}
function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x + y;
}
}
function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x - y;
}
}
function rawSub(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x - y;
}
}
function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x * y;
}
}
function rawMul(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x * y;
}
}
function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(x, y)
}
}
function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(x, y)
}
}
function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mod(x, y)
}
}
function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := smod(x, y)
}
}
function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := addmod(x, y, d)
}
}
function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mulmod(x, y, d)
}
}
}
文件 14 的 45：IBaseRouter.sol
pragma solidity ^0.8.19;
import "types/Lib.sol";
interface IBaseRouter {
function singleDirectSingleVaultDeposit(SingleDirectSingleVaultStateReq memory req_) external payable;
function singleXChainSingleVaultDeposit(SingleXChainSingleVaultStateReq memory req_) external payable;
function singleDirectMultiVaultDeposit(SingleDirectMultiVaultStateReq memory req_) external payable;
function singleXChainMultiVaultDeposit(SingleXChainMultiVaultStateReq memory req_) external payable;
function multiDstSingleVaultDeposit(MultiDstSingleVaultStateReq calldata req_) external payable;
function multiDstMultiVaultDeposit(MultiDstMultiVaultStateReq calldata req_) external payable;
function singleDirectSingleVaultWithdraw(SingleDirectSingleVaultStateReq memory req_) external payable;
function singleXChainSingleVaultWithdraw(SingleXChainSingleVaultStateReq memory req_) external payable;
function singleDirectMultiVaultWithdraw(SingleDirectMultiVaultStateReq memory req_) external payable;
function singleXChainMultiVaultWithdraw(SingleXChainMultiVaultStateReq memory req_) external payable;
function multiDstSingleVaultWithdraw(MultiDstSingleVaultStateReq calldata req_) external payable;
function multiDstMultiVaultWithdraw(MultiDstMultiVaultStateReq calldata req_) external payable;
function forwardDustToPaymaster(address token_) external;
}
文件 15 的 45：IBridgeValidator.sol
pragma solidity ^0.8.19;
interface IBridgeValidator {
function decodeAmountIn(
bytes calldata txData_,
bool genericSwapDisallowed_
)
external
view
returns (uint256 amount_);
}
文件 16 的 45：IERC1155A.sol
pragma solidity ^0.8.19;
interface IERC1155A {
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(
address[] calldata accounts,
uint256[] calldata ids
)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
)
external;
function allowance(address owner, address operator, uint256 id) external returns (uint256);
}
文件 17 的 45：IERC20.sol
pragma solidity ^0.8.19;
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);
}
文件 18 的 45：IERC20Metadata.sol
pragma solidity ^0.8.19;
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);
}
文件 19 的 45：IERC4626.sol
pragma solidity ^0.8.19;
import { IERC20 } from "./IERC20.sol";
import { IERC20Metadata } from "./IERC20Metadata.sol";
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
function asset() external view returns (address assetTokenAddress);
function totalAssets() external view returns (uint256 totalManagedAssets);
function convertToShares(uint256 assets) external view returns (uint256 shares);
function convertToAssets(uint256 shares) external view returns (uint256 assets);
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
function maxMint(address receiver) external view returns (uint256 maxShares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function mint(uint256 shares, address receiver) external returns (uint256 assets);
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
function maxRedeem(address owner) external view returns (uint256 maxShares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
文件 20 的 45：IHurdleRateOracle.sol
pragma solidity ^0.8.19;
interface IHurdleRateOracle {
function getRate(address asset) external view returns (uint256);
}
文件 21 的 45：IMetaVault.sol
pragma solidity ^0.8.19;
import { ISharePriceOracle } from "./ISharePriceOracle.sol";
import { ERC7540Engine } from "modules/Lib.sol";
import {
LiqRequest,
MultiDstMultiVaultStateReq,
MultiDstSingleVaultStateReq,
MultiVaultSFData,
MultiXChainMultiVaultWithdraw,
MultiXChainSingleVaultWithdraw,
ProcessRedeemRequestParams,
SingleDirectMultiVaultStateReq,
SingleDirectSingleVaultStateReq,
SingleVaultSFData,
SingleXChainMultiVaultStateReq,
SingleXChainMultiVaultWithdraw,
SingleXChainSingleVaultStateReq,
SingleXChainSingleVaultWithdraw,
VaultConfig,
VaultData,
VaultLib
} from "types/Lib.sol";
interface IMetaVault {
function WITHDRAWAL_QUEUE_SIZE() external view returns (uint256);
function SECS_PER_YEAR() external view returns (uint256);
function MAX_BPS() external view returns (uint256);
function ADMIN_ROLE() external view returns (uint256);
function MANAGER_ROLE() external view returns (uint256);
function RELAYER_ROLE() external view returns (uint256);
function ORACLE_ROLE() external view returns (uint256);
function EMERGENCY_ADMIN_ROLE() external view returns (uint256);
function N_CHAINS() external view returns (uint256);
function THIS_CHAIN_ID() external view returns (uint64);
function DST_CHAINS(uint256) external view returns (uint64);
function treasury() external view returns (address);
function signerRelayer() external view returns (address);
function gateway() external view returns (address);
function emergencyShutdown() external view returns (bool);
function localWithdrawalQueue(uint256) external view returns (uint256);
function xChainWithdrawalQueue(uint256) external view returns (uint256);
function performanceFeeExempt(address) external view returns (uint256);
function managementFeeExempt(address) external view returns (uint256);
function oracleFeeExempt(address) external view returns (uint256);
function grantRoles(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function asset() external view returns (address);
function totalAssets() external view returns (uint256 assets);
function totalSupply() external view returns (uint256 assets);
function convertToAssets(uint256) external view returns (uint256);
function convertToShares(uint256) external view returns (uint256);
function convertToSuperPositions(uint256 superformId, uint256 assets) external view returns (uint256);
function totalWithdrawableAssets() external view returns (uint256 assets);
function totalLocalAssets() external view returns (uint256 assets);
function totalXChainAssets() external view returns (uint256 assets);
function sharePrice() external view returns (uint256);
function totalIdle() external view returns (uint256 assets);
function totalDebt() external view returns (uint256 assets);
function totalDeposits() external view returns (uint256 assets);
function managementFee() external view returns (uint256);
function sharesLockTime() external view returns (uint256);
function performanceFee() external view returns (uint256);
function oracleFee() external view returns (uint256);
function hurdleRate() external view returns (uint256);
function lastReport() external view returns (uint256);
function addVault(
uint32 chainId,
uint256 superformId,
address vault,
uint8 vaultDecimals,
ISharePriceOracle oracle
)
external;
function removeVault(uint256 superformId) external;
function rearrangeWithdrawalQueue(uint8 queueType, uint256[30] calldata newOrder) external;
function vaults(uint256) external view returns (uint32, uint256, ISharePriceOracle, uint8, uint128, address);
function isVaultListed(address vaultAddress) external view returns (bool);
function isVaultListed(uint256 superformId) external view returns (bool);
function getVault(uint256 superformId) external view returns (VaultData memory vault);
function setOperator(address, bool) external;
function isOperator(address, address) external view returns (bool);
function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);
function deposit(uint256 assets, address to) external returns (uint256 shares);
function deposit(uint256 assets, address to, address controller) external returns (uint256 shares);
function mint(uint256 shares, address to) external returns (uint256 assets);
function mint(uint256 shares, address to, address controller) external returns (uint256 assets);
function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);
function redeem(uint256 shares, address receiver, address controller) external returns (uint256 assets);
function withdraw(uint256 assets, address receiver, address controller) external returns (uint256 shares);
function positions(address) external view returns (uint256);
function pendingRedeemRequest(address) external view returns (uint256);
function claimableRedeemRequest(address) external view returns (uint256);
function pendingProcessedShares(address) external view returns (uint256);
function pendingDepositRequest(address) external view returns (uint256);
function claimableDepositRequest(address) external view returns (uint256);
function processRedeemRequest(ProcessRedeemRequestParams calldata params) external payable;
function processSignedRequest(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
)
external;
function nonces(address) external view returns (uint256);
function investSingleDirectSingleVault(
address vaultAddress,
uint256 assets,
uint256 minSharesOut
)
external
returns (uint256 shares);
function investSingleDirectMultiVault(
address[] calldata vaultAddresses,
uint256[] calldata assets,
uint256[] calldata minSharesOuts
)
external
returns (uint256[] memory shares);
function investSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req) external payable;
function investSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req) external payable;
function investMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req) external payable;
function investMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req) external payable;
function divestSingleDirectSingleVault(
address vaultAddress,
uint256 shares,
uint256 minAssetsOut
)
external
returns (uint256 assets);
function divestSingleDirectMultiVault(
address[] calldata vaultAddresses,
uint256[] calldata shares,
uint256[] calldata minAssetsOuts
)
external
returns (uint256[] memory assets);
function setFeeExcemption(
address controller,
uint256 managementFeeExcemption,
uint256 performanceFeeExcemption,
uint256 oracleFeeExcemption
)
external;
function sharePriceWaterMark() external view returns (uint256);
function lastRedeem(address) external view returns (uint256);
function divestSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req) external payable;
function divestSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req) external payable;
function divestMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req) external payable;
function divestMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req) external payable;
function emergencyDivestSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req) external payable;
function emergencyDivestSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req) external payable;
function emergencyDivestMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req) external payable;
function emergencyDivestMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req) external payable;
function setEmergencyShutdown(bool _emergencyShutdown) external;
function setGateway(address) external;
function donate(uint256 assets) external;
function setSharesLockTime(uint24 time) external;
function setManagementFee(uint16 _managementFee) external;
function setPerformanceFee(uint16 _performanceFee) external;
function setOracleFee(uint16 _oracleFee) external;
function setRecoveryAddress(address _recoveryAddress) external;
function fulfillSettledRequest(address controller, uint256 requestedAssets, uint256 settledAssets) external;
function settleXChainInvest(uint256 superformId, uint256 bridgedAssets) external;
function settleXChainDivest(uint256 withdrawn) external;
function multicall(bytes[] calldata data) external returns (bytes[] memory);
function addFunction(bytes4, address, bool) external;
function addFunctions(bytes4[] memory, address, bool) external;
function removeFunction(bytes4) external;
function removeFunctions(bytes4[] memory) external;
function lastFeesCharged() external view returns (uint256);
function chargeGlobalFees() external returns (uint256);
function previewWithdrawalRoute(
address controller,
uint256 shares,
bool despiseDust
)
external
view
returns (ERC7540Engine.ProcessRedeemRequestCache memory cachedRoute);
function setDustThreshold(uint256 dustThreshold) external;
function dustThreshold() external view returns (uint256);
function computeHash(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint256 nonce
)
external
pure
returns (bytes32);
function verifySignature(
ProcessRedeemRequestParams calldata params,
uint256 deadline,
uint256 nonce,
uint8 v,
bytes32 r,
bytes32 s
)
external
view
returns (bool);
function onERC1155Received(
address operator,
address from,
uint256 superformId,
uint256 value,
bytes memory data
)
external
returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] memory superformIds,
uint256[] memory values,
bytes memory data
)
external
returns (bytes4);
struct VaultDetailedData {
uint32 chainId;
uint256 superformId;
ISharePriceOracle oracle;
uint8 decimals;
uint128 totalDebt;
address vaultAddress;
uint256 sharesBalance;
uint256 sharePrice;
uint256 totalAssets;
}
function getVaultDetailedData(uint256 superformId) external view returns (VaultDetailedData memory);
function getAllVaultsDetailedData() external view returns (VaultDetailedData[] memory);
struct VaultReturnsData {
uint256 totalReturn;
uint256 hurdleReturn;
uint256 excessReturn;
}
function getLastEpochVaultReturns() external view returns (VaultReturnsData memory);
function totalReturnsPerShare() external view returns (int256);
}
文件 22 的 45：ISharePriceOracle.sol
pragma solidity 0.8.26;
struct VaultReport {
uint256 sharePrice;
uint64 lastUpdate;
uint32 chainId;
address rewardsDelegate;
address vaultAddress;
address asset;
uint256 assetDecimals;
}
struct ChainlinkResponse {
uint256 price;
uint8 decimals;
uint256 timestamp;
uint80 roundId;
uint80 answeredInRound;
}
interface ISharePriceOracle {
event SharePriceUpdated(uint32 indexed srcChainId, address indexed vault, uint256 price, address rewardsDelegate);
event LzEndpointUpdated(address oldEndpoint, address newEndpoint);
event RoleGranted(address account, uint256 role);
event RoleRevoked(address account, uint256 role);
event PriceFeedSet(uint32 indexed chainId, address indexed asset, address priceFeed);
function chainId() external view returns (uint32);
function ADMIN_ROLE() external view returns (uint256);
function ENDPOINT_ROLE() external view returns (uint256);
function hasRole(address account, uint256 role) external view returns (bool);
function getRoles(address account) external view returns (uint256);
function getSharePrices(
address[] calldata vaultAddresses,
address rewardsDelegate
)
external
view
returns (VaultReport[] memory);
function getLatestSharePriceReport(
uint32 _srcChainId,
address _vaultAddress
)
external
view
returns (VaultReport memory);
function getLatestSharePrice(
uint32 _srcChainId,
address _vaultAddress,
address _dstAsset
)
external
view
returns (uint256 price, uint64 timestamp);
function getPriceKey(uint32 _srcChainId, address _vault) external pure returns (bytes32);
function updateSharePrices(uint32 _srcChainId, VaultReport[] calldata _reports) external;
function grantRole(address account, uint256 role) external;
function revokeRole(address account, uint256 role) external;
function setLzEndpoint(address _endpoint) external;
}
文件 23 的 45：ISuperPositions.sol
pragma solidity ^0.8.19;
import { IERC1155A } from "./IERC1155A.sol";
interface ISuperPositions is IERC1155A {
function mintSingle(address receiverAddress_, uint256 id_, uint256 amount_) external;
function mintBatch(address receiverAddress_, uint256[] memory ids_, uint256[] memory amounts_) external;
function burnSingle(address srcSender_, uint256 id_, uint256 amount_) external;
function burnBatch(address srcSender_, uint256[] memory ids_, uint256[] memory amounts_) external;
}
文件 24 的 45：ISuperPositionsReceiver.sol
pragma solidity ^0.8.19;
interface ISuperPositionsReceiver {
event BridgeInitiated(address indexed token, uint256 amount);
event TokenApproval(address indexed token, address indexed spender, uint256 amount);
event TargetWhitelisted(address indexed target, bool status);
error NoTokensTransferred();
error GasLimitExceeded();
error BridgeTransactionFailed();
error SourceChainRecoveryNotAllowed();
error TargetNotWhitelisted();
function sourceChain() external view returns (uint64);
function gateway() external view returns (address);
function superPositions() external view returns (address);
function maxBridgeGasLimit() external view returns (uint256);
function ADMIN_ROLE() external view returns (uint256);
function RECOVERY_ROLE() external view returns (uint256);
function whitelistedTargets(address _target) external view returns (bool status);
function setGateway(address _gateway) external;
function setMaxBridgeGasLimit(uint256 _maxGasLimit) external;
function setTargetWhitelisted(address _target, bool _status) external;
function recoverFunds(address token, uint256 amount, address to) external;
function supportsInterface(bytes4 interfaceId) external pure returns (bool isSupported);
function onERC1155Received(
address operator,
address from,
uint256 superformId,
uint256 value,
bytes memory data
)
external
returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] memory superformIds,
uint256[] memory values,
bytes memory data
)
external
returns (bytes4);
function bridgeToken(
address payable _to,
bytes memory _txData,
address _token,
address _allowanceTarget,
uint256 _amount,
uint256 _gasLimit
)
external;
function hasAllRoles(address user, uint256 roles) external view returns (bool);
function grantRoles(address user, uint256 roles) external;
function revokeRoles(address user, uint256 roles) external;
}
文件 25 的 45：ISuperRegistry.sol
pragma solidity ^0.8.19;
interface ISuperRegistry {
function getBridgeValidator(uint8 bridgeId_) external view returns (address bridgeValidator_);
}
文件 26 的 45：ISuperformFactory.sol
pragma solidity ^0.8.19;
interface ISuperformFactory {
enum PauseStatus {
NON_PAUSED,
PAUSED
}
event FormImplementationAdded(
address indexed formImplementation, uint256 indexed formImplementationId, uint8 indexed formStateRegistryId
);
event SuperformCreated(
uint256 indexed formImplementationId, address indexed vault, uint256 indexed superformId, address superform
);
event SuperRegistrySet(address indexed superRegistry);
event FormImplementationPaused(uint256 indexed formImplementationId, PauseStatus indexed paused);
function getFormCount() external view returns (uint256 forms_);
function getSuperformCount() external view returns (uint256 superforms_);
function getFormImplementation(uint32 formImplementationId_) external view returns (address formImplementation_);
function getFormStateRegistryId(uint32 formImplementationId_) external view returns (uint8 stateRegistryId_);
function isFormImplementationPaused(uint32 formImplementationId_) external view returns (bool paused_);
function getSuperform(uint256 superformId_)
external
pure
returns (address superform_, uint32 formImplementationId_, uint64 chainId_);
function isSuperform(uint256 superformId_) external view returns (bool isSuperform_);
function getAllSuperformsFromVault(address vault_)
external
view
returns (uint256[] memory superformIds_, address[] memory superforms_);
function addFormImplementation(
address formImplementation_,
uint32 formImplementationId_,
uint8 formStateRegistryId_
)
external;
function createSuperform(
uint32 formImplementationId_,
address vault_
)
external
returns (uint256 superformId_, address superform_);
function stateSyncBroadcast(bytes memory data_) external payable;
function changeFormImplementationPauseStatus(
uint32 formImplementationId_,
PauseStatus status_,
bytes memory extraData_
)
external
payable;
}
文件 27 的 45：ISuperformGateway.sol
import { ISuperPositions } from "../interfaces/ISuperPositions.sol";
import {
MultiDstMultiVaultStateReq,
MultiDstSingleVaultStateReq,
MultiVaultSFData,
SingleDirectMultiVaultStateReq,
SingleDirectSingleVaultStateReq,
SingleVaultSFData,
SingleXChainMultiVaultStateReq,
SingleXChainSingleVaultStateReq
} from "../types/SuperformTypes.sol";
import { SingleXChainMultiVaultWithdraw, SingleXChainSingleVaultWithdraw } from "../types/VaultTypes.sol";
interface ISuperformGateway {
function getRequestsQueue() external view returns (bytes32[] memory requestIds);
function recoveryAddress() external view returns (address);
function grantRoles(address, uint256) external;
function ADMIN_ROLE() external view returns (uint256);
function RELAYER_ROLE() external view returns (uint256);
function setRecoveryAddress(address _newRecoveryAddress) external;
function superPositions() external view returns (ISuperPositions);
function notifyRefund(uint256 superformId, uint256 amount) external;
function notifyBatchRefund(uint256[] calldata superformIds, uint256[] calldata values) external;
function totalpendingXChainInvests() external view returns (uint256);
function totalPendingXChainWithdraws() external view returns (uint256);
function totalPendingXChainDivests() external view returns (uint256);
function balanceOf(address account, uint256 superformId) external view returns (uint256);
function investSingleXChainSingleVault(SingleXChainSingleVaultStateReq calldata req)
external
payable
returns (uint256 amount);
function investSingleXChainMultiVault(SingleXChainMultiVaultStateReq calldata req)
external
payable
returns (uint256 totalAmount);
function investMultiXChainSingleVault(MultiDstSingleVaultStateReq calldata req)
external
payable
returns (uint256 totalAmount);
function investMultiXChainMultiVault(MultiDstMultiVaultStateReq calldata req)
external
payable
returns (uint256 totalAmount);
function divestSingleXChainSingleVault(
SingleXChainSingleVaultStateReq calldata req,
bool useReceivers
)
external
payable
returns (uint256 sharesValue);
function divestSingleXChainMultiVault(
SingleXChainMultiVaultStateReq calldata req,
bool useReceivers
)
external
payable
returns (uint256 totalAmount);
function divestMultiXChainSingleVault(
MultiDstSingleVaultStateReq calldata req,
bool useReceivers
)
external
payable
returns (uint256 totalAmount);
function divestMultiXChainMultiVault(
MultiDstMultiVaultStateReq calldata req,
bool useReceivers
)
external
payable
returns (uint256 totalAmount);
function liquidateSingleXChainSingleVault(
uint64 chainId,
uint256 superformId,
uint256 amount,
address receiver,
SingleXChainSingleVaultWithdraw memory config,
uint256 totalRequestedAssets
)
external
payable;
function liquidateSingleXChainMultiVault(
uint64 chainId,
uint256[] memory superformIds,
uint256[] memory amounts,
address receiver,
SingleXChainMultiVaultWithdraw memory config,
uint256 totalRequestedAssets,
uint256[] memory requestedAssetsPerVault
)
external
payable;
function liquidateMultiDstSingleVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
SingleVaultSFData[] memory singleVaultDatas,
uint256[] memory totalRequestedAssets
)
external
payable;
function liquidateMultiDstMultiVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
MultiVaultSFData[] memory multiVaultDatas,
uint256[] memory totalRequestedAssets,
uint256[][] memory requestedAssetsPerVault
)
external
payable;
function supportsInterface(bytes4 interfaceId) external pure returns (bool isSupported);
function onERC1155Received(
address operator,
address from,
uint256 superformId,
uint256 value,
bytes memory data
)
external
returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] memory superformIds,
uint256[] memory values,
bytes memory data
)
external
returns (bytes4);
function settleLiquidation(bytes32 key, bool force) external;
function notifyFailedInvest(uint256 superformId, uint256 refundedAssets) external;
function getReceiver(bytes32 key) external returns (address receiverAddress);
function receivers(bytes32 key) external view returns (address receiverAddress);
function settleDivest(bytes32 key, uint256 assets, bool force) external;
function previewIdDivestSingleXChainSingleVault(SingleXChainSingleVaultStateReq memory req)
external
view
returns (bytes32[] memory requestIds);
function previewIdDivestSingleXChainMultiVault(SingleXChainMultiVaultStateReq memory req)
external
view
returns (bytes32[] memory requestIds);
function previewIdDivestMultiXChainSingleVault(MultiDstSingleVaultStateReq memory req)
external
view
returns (bytes32[] memory requestIds);
function previewIdDivestMultiXChainMultiVault(MultiDstMultiVaultStateReq memory req)
external
view
returns (bytes32[] memory requestIds);
function previewLiquidateSingleXChainSingleVault(
uint64 chainId,
uint256 superformId,
uint256 amount,
address receiver,
SingleXChainSingleVaultWithdraw memory config,
uint256 totalRequestedAssets,
uint256[] memory requestedAssetsPerVault
)
external
view
returns (bytes32[] memory requestIds);
function previewLiquidateSingleXChainMultiVault(
uint64 chainId,
uint256[] memory superformIds,
uint256[] memory amounts,
address receiver,
SingleXChainMultiVaultWithdraw memory config,
uint256 totalRequestedAssets,
uint256[] memory requestedAssetsPerVault
)
external
view
returns (bytes32[] memory requestIds);
function previewLiquidateMultiDstSingleVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
SingleVaultSFData[] memory singleVaultDatas,
uint256[] memory totalRequestedAssets
)
external
view
returns (bytes32[] memory requestIds);
function previewLiquidateMultiDstMultiVault(
uint8[][] memory ambIds,
uint64[] memory dstChainIds,
MultiVaultSFData[] memory multiVaultDatas,
uint256[] memory totalRequestedAssets,
uint256[][] memory totalRequestedAssetsPerVault
)
external
view
returns (bytes32[] memory requestIds);
function addFunction(bytes4, address, bool) external;
function addFunctions(bytes4[] memory, address, bool) external;
function removeFunction(bytes4) external;
function removeFunctions(bytes4[] memory) external;
function requests(bytes32 key) external view returns (address, uint256, address);
}
文件 28 的 45：Lib.sol
pragma solidity ^0.8.19;
import { ERC7540Engine } from "./ERC7540Engine.sol";
import { ERC7540EngineReader } from "./ERC7540EngineReader.sol";
import { ERC7540EngineSignatures } from "./ERC7540EngineSignatures.sol";
文件 29 的 45：MetaVault.sol
pragma solidity ^0.8.19;
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import { Multicallable } from "solady/utils/Multicallable.sol";
import { SafeCastLib } from "solady/utils/SafeCastLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import { MetaVaultBase, MultiFacetProxy } from "common/Lib.sol";
import { IHurdleRateOracle, ISharePriceOracle, ISuperformGateway } from "interfaces/Lib.sol";
import { NoDelegateCall } from "lib/Lib.sol";
import { VaultConfig, VaultData, VaultLib, VaultReport } from "types/Lib.sol";
contract MetaVault is MetaVaultBase, Multicallable, NoDelegateCall {
using SafeCastLib for uint256;
using SafeTransferLib for address;
using VaultLib for VaultData;
using Math for uint256;
event AssessFees(address indexed controller, uint256 managementFees, uint256 performanceFees, uint256 oracleFees);
event AddVault(uint64 indexed chainId, address vault);
event RemoveVault(uint64 indexed chainId, address vault);
event SetSharesLockTime(uint24 time);
event SetManagementFee(uint16 fee);
event SetPerformanceFee(uint16 fee);
event SetOracleFee(uint16 fee);
event EmergencyShutdown(bool enabled);
event TreasuryUpdated(address indexed treasury);
error InvalidQueueType();
error DuplicateVaultInOrder();
error VaultCountMismatch();
error MissingVaultFromCurrentQueue();
error NewVaultNotInCurrentQueue();
error VaultAlreadyListed();
error InsufficientAvailableAssets();
error RequestNotSettled();
error RedeemNotProcessed();
error SharesLocked();
error VaultShutdown();
error SharesBalanceNotZero();
error InvalidSuperformId();
error InvalidVaultAddress();
error MaxQueueSizeExceeded();
error InvalidZeroAddress();
modifier noEmergencyShutdown() {
if (emergencyShutdown) {
revert VaultShutdown();
}
_;
}
modifier updateGlobalWatermark() {
_;
uint256 sp = sharePrice();
assembly {
let spwm := sload(sharePriceWaterMark.slot)
if lt(spwm, sp) { sstore(sharePriceWaterMark.slot, sp) }
}
}
constructor(VaultConfig memory config) MultiFacetProxy(ADMIN_ROLE) {
_asset = config.asset;
_name = config.name;
_symbol = config.symbol;
treasury = config.treasury;
isOperator[treasury][address(this)] = true;
emit OperatorSet(treasury, address(this), true);
managementFee = config.managementFee;
performanceFee = config.performanceFee;
oracleFee = config.oracleFee;
sharesLockTime = config.sharesLockTime;
lastReport = block.timestamp;
_hurdleRateOracle = config.hurdleRateOracle;
(bool success, uint8 result) = _tryGetAssetDecimals(config.asset);
_decimals = success ? result : _DEFAULT_UNDERLYING_DECIMALS;
THIS_CHAIN_ID = uint64(block.chainid);
for (uint256 i = 0; i != N_CHAINS; i++) {
chainIndexes[DST_CHAINS[i]] = i;
}
lastFeesCharged = block.timestamp;
_initializeOwner(config.owner);
_grantRoles(config.owner, ADMIN_ROLE);
signerRelayer = config.signerRelayer;
sharePriceWaterMark = 10 ** decimals();
}
function requestDeposit(
uint256 assets,
address controller,
address owner
)
public
override
noDelegateCall
noEmergencyShutdown
returns (uint256 requestId)
{
if (owner != msg.sender) revert InvalidOperator();
requestId = super.requestDeposit(assets, controller, owner);
_fulfillDepositRequest(controller, assets, convertToShares(assets));
}
function deposit(uint256 assets, address to) public override returns (uint256 shares) {
return deposit(assets, to, msg.sender);
}
function deposit(
uint256 assets,
address to,
address controller
)
public
override
noDelegateCall
noEmergencyShutdown
returns (uint256 shares)
{
uint256 sharesBalance = balanceOf(to);
shares = super.deposit(assets, to, controller);
_lockShares(controller, sharesBalance, shares);
_afterDeposit(assets, shares);
return shares;
}
function mint(uint256 shares, address to) public override returns (uint256 assets) {
return mint(shares, to, msg.sender);
}
function mint(
uint256 shares,
address to,
address controller
)
public
override
noDelegateCall
noEmergencyShutdown
returns (uint256 assets)
{
uint256 sharesBalance = balanceOf(to);
assets = super.mint(shares, to, controller);
_lockShares(controller, sharesBalance, shares);
_afterDeposit(assets, shares);
}
function _deposit(
uint256 assets,
uint256 shares,
address receiver,
address controller
)
internal
override
returns (uint256 assetsReturn, uint256 sharesReturn)
{
_updatePosition(controller, shares);
if (lastRedeem[controller] == 0) lastRedeem[controller] = block.timestamp;
return super._deposit(assets, shares, receiver, controller);
}
function requestRedeem(
uint256 shares,
address controller,
address owner
)
public
override
noDelegateCall
noEmergencyShutdown
returns (uint256 requestId)
{
_checkSharesLocked(controller);
requestId = super.requestRedeem(shares, controller, owner);
}
function redeem(
uint256 shares,
address receiver,
address controller
)
public
override
noDelegateCall
nonReentrant
returns (uint256 assets)
{
assets = super.redeem(shares, receiver, controller);
}
function withdraw(
uint256 assets,
address receiver,
address controller
)
public
override
noDelegateCall
nonReentrant
returns (uint256 shares)
{
return super.withdraw(assets, receiver, controller);
}
struct TempWithdrawData {
uint256 entrySharePrice;
uint256 currentSharePrice;
int256 assetsDelta;
uint256 duration;
uint256 performanceFeeExempt;
uint256 managementFeeExempt;
uint256 oracleFeeExempt;
uint256 performanceFees;
uint256 managementFees;
uint256 oracleFees;
uint256 totalFees;
}
function _withdraw(
uint256 assets,
uint256 shares,
address receiver,
address controller
)
internal
override
returns (uint256 assetsReturn, uint256 sharesReturn)
{
TempWithdrawData memory temp;
temp.entrySharePrice = positions[controller];
temp.currentSharePrice = sharePrice();
unchecked {
_claimableRedeemRequest[controller].assets -= assets;
_claimableRedeemRequest[controller].shares -= shares;
}
temp.duration = block.timestamp - Math.max(lastRedeem[controller], lastFeesCharged);
lastRedeem[controller] = block.timestamp;
temp.performanceFeeExempt = performanceFeeExempt[controller];
temp.managementFeeExempt = managementFeeExempt[controller];
temp.oracleFeeExempt = oracleFeeExempt[controller];
temp.managementFees =
(assets * temp.duration).fullMulDiv(_sub0(managementFee, temp.managementFeeExempt), SECS_PER_YEAR) / MAX_BPS;
temp.oracleFees =
(assets * temp.duration).fullMulDiv(_sub0(oracleFee, temp.oracleFeeExempt), SECS_PER_YEAR) / MAX_BPS;
assets -= temp.managementFees + temp.oracleFees;
temp.totalFees += temp.managementFees + temp.oracleFees;
temp.assetsDelta = int256(assets) - (int256(shares) * int256(temp.entrySharePrice) / int256(10 ** decimals()));
if (temp.assetsDelta > 0) {
uint256 totalReturn = uint256(temp.assetsDelta);
uint256 hurdleReturn = (assets * hurdleRate()).fullMulDiv(temp.duration, SECS_PER_YEAR) / MAX_BPS;
uint256 excessReturn;
if (temp.currentSharePrice > sharePriceWaterMark && totalReturn > hurdleReturn) {
excessReturn = totalReturn - hurdleReturn;
temp.performanceFees = excessReturn * _sub0(performanceFee, temp.performanceFeeExempt) / MAX_BPS;
}
temp.totalFees += temp.performanceFees;
}
if (temp.totalFees > 0) {
_mint(treasury, convertToShares(temp.totalFees));
_afterDeposit(temp.totalFees, 0);
}
uint256 totalAssetsAfterFee = assets - temp.totalFees;
asset().safeTransfer(receiver, totalAssetsAfterFee);
{
uint256 managementFees = temp.managementFees;
uint256 performanceFees = temp.performanceFees;
uint256 oracleFees = temp.oracleFees;
assembly {
let mp := mload(0x40)
mstore(0x00, totalAssetsAfterFee)
mstore(0x20, shares)
let m := shr(96, not(0))
log4(
0x00,
0x40,
0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db,
and(m, controller),
and(m, receiver),
and(m, controller)
)
mstore(0x00, managementFees)
mstore(0x20, performanceFees)
mstore(0x40, oracleFees)
log2(0x00, 0x60, 0xa443e1db11cb46c65620e8e21d4830a6b9b444fa4c350f0dd0024b8a5a6b6ef5, and(m, controller))
mstore(0x40, mp)
mstore(0x60, 0)
}
}
return (totalAssetsAfterFee, shares);
}
function chargeGlobalFees() external updateGlobalWatermark onlyRoles(MANAGER_ROLE) returns (uint256) {
uint256 currentSharePrice = sharePrice();
uint256 lastSharePrice = sharePriceWaterMark;
uint256 duration = block.timestamp - lastFeesCharged;
uint256 currentTotalAssets = totalAssets();
uint256 lastTotalAssets = totalSupply().fullMulDiv(lastSharePrice, 10 ** decimals());
uint256 managementFees = (currentTotalAssets * duration).fullMulDiv(managementFee, SECS_PER_YEAR) / MAX_BPS;
uint256 oracleFees = (currentTotalAssets * duration).fullMulDiv(oracleFee, SECS_PER_YEAR) / MAX_BPS;
uint256 totalFees = managementFees + oracleFees;
uint256 performanceFees;
currentTotalAssets += managementFees + oracleFees;
lastFeesCharged = block.timestamp;
int256 assetsDelta = int256(currentTotalAssets) - int256(lastTotalAssets);
if (assetsDelta > 0) {
uint256 excessReturn;
uint256 hurdleReturn = (lastTotalAssets * hurdleRate()).fullMulDiv(duration, SECS_PER_YEAR) / MAX_BPS;
uint256 totalReturn = uint256(assetsDelta);
if (currentSharePrice > sharePriceWaterMark && totalReturn > hurdleReturn) {
excessReturn = totalReturn - hurdleReturn;
performanceFees = excessReturn * performanceFee / MAX_BPS;
}
totalFees += performanceFees;
}
if (totalFees > 0) {
_mint(treasury, convertToShares(totalFees));
}
assembly {
let mp := mload(0x40)
let m := shr(96, not(0))
mstore(0x00, managementFees)
mstore(0x20, performanceFees)
mstore(0x40, oracleFees)
log2(0x00, 0x60, 0xa443e1db11cb46c65620e8e21d4830a6b9b444fa4c350f0dd0024b8a5a6b6ef5, and(m, address()))
mstore(0x40, mp)
mstore(0x60, 0)
}
return totalFees;
}
function addVault(
uint32 chainId,
uint256 superformId,
address vault,
uint8 vaultDecimals,
ISharePriceOracle oracle
)
external
onlyRoles(MANAGER_ROLE)
{
if (superformId == 0) revert InvalidSuperformId();
if (isVaultListed(vault)) revert VaultAlreadyListed();
vaults[superformId].chainId = chainId;
vaults[superformId].superformId = superformId;
vaults[superformId].vaultAddress = vault;
vaults[superformId].decimals = vaultDecimals;
vaults[superformId].oracle = oracle;
uint192 lastSharePrice = vaults[superformId].sharePrice(asset()).toUint192();
if (lastSharePrice == 0) revert();
_vaultToSuperformId[vault] = superformId;
bool found;
if (chainId == THIS_CHAIN_ID) {
uint256[WITHDRAWAL_QUEUE_SIZE] memory queue = localWithdrawalQueue;
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] == 0) {
localWithdrawalQueue[i] = superformId;
found = true;
break;
}
}
asset().safeApprove(vault, type(uint256).max);
} else {
uint256[WITHDRAWAL_QUEUE_SIZE] memory queue = xChainWithdrawalQueue;
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] == 0) {
xChainWithdrawalQueue[i] = superformId;
found = true;
break;
}
}
}
if (!found) revert MaxQueueSizeExceeded();
emit AddVault(chainId, vault);
}
function removeVault(uint256 superformId) external onlyRoles(MANAGER_ROLE) {
if (superformId == 0) revert InvalidSuperformId();
VaultData memory vault = vaults[superformId];
if (vault.convertToAssets(_sharesBalance(vaults[superformId]), asset(), true) > dustThreshold) {
revert SharesBalanceNotZero();
}
uint64 chainId = vault.chainId;
address vaultAddress = vault.vaultAddress;
delete vaults[superformId];
delete _vaultToSuperformId[vaultAddress];
if (chainId == THIS_CHAIN_ID) {
uint256[WITHDRAWAL_QUEUE_SIZE] memory queue = localWithdrawalQueue;
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] == superformId) {
localWithdrawalQueue[i] = 0;
_organizeWithdrawalQueue(localWithdrawalQueue);
break;
}
}
asset().safeApprove(vaultAddress, 0);
} else {
uint256[WITHDRAWAL_QUEUE_SIZE] memory queue = xChainWithdrawalQueue;
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] == superformId) {
xChainWithdrawalQueue[i] = 0;
_organizeWithdrawalQueue(xChainWithdrawalQueue);
break;
}
}
}
emit RemoveVault(chainId, vaultAddress);
}
function rearrangeWithdrawalQueue(
uint8 queueType,
uint256[WITHDRAWAL_QUEUE_SIZE] calldata newOrder
)
external
onlyRoles(MANAGER_ROLE)
{
uint256[WITHDRAWAL_QUEUE_SIZE] storage queue;
if (queueType == 0) {
queue = localWithdrawalQueue;
} else if (queueType == 1) {
queue = xChainWithdrawalQueue;
} else {
revert InvalidQueueType();
}
uint256[] memory currentVaults = new uint256[](WITHDRAWAL_QUEUE_SIZE);
uint256[] memory newVaults = new uint256[](WITHDRAWAL_QUEUE_SIZE);
uint256 currentCount;
uint256 newCount;
for (uint256 i = 0; i < WITHDRAWAL_QUEUE_SIZE; i++) {
if (queue[i] != 0) {
currentVaults[currentCount++] = queue[i];
}
}
for (uint256 i = 0; i < WITHDRAWAL_QUEUE_SIZE; i++) {
if (newOrder[i] != 0) {
for (uint256 j = 0; j < newCount; j++) {
if (newVaults[j] == newOrder[i]) revert DuplicateVaultInOrder();
}
newVaults[newCount++] = newOrder[i];
}
}
if (currentCount != newCount) revert VaultCountMismatch();
for (uint256 i = 0; i < currentCount; i++) {
bool found = false;
for (uint256 j = 0; j < newCount; j++) {
if (currentVaults[i] == newVaults[j]) {
found = true;
break;
}
}
if (!found) revert MissingVaultFromCurrentQueue();
}
for (uint256 i = 0; i < WITHDRAWAL_QUEUE_SIZE; i++) {
queue[i] = newOrder[i];
}
}
function _organizeWithdrawalQueue(uint256[WITHDRAWAL_QUEUE_SIZE] storage queue) internal {
uint256 offset;
for (uint256 i; i < WITHDRAWAL_QUEUE_SIZE;) {
uint256 vault = queue[i];
if (vault == 0) {
unchecked {
++offset;
}
} else if (offset > 0) {
queue[i - offset] = vault;
queue[i] = 0;
}
unchecked {
++i;
}
}
}
function donate(uint256 assets) external {
asset().safeTransferFrom(msg.sender, address(this), assets);
_afterDeposit(assets, 0);
}
function _updatePosition(address controller, uint256 mintedShares) internal {
uint256 averageEntryPrice = positions[controller];
uint256 currentSharePrice = sharePrice();
uint256 sharesBalance = balanceOf(controller);
if (averageEntryPrice == 0 || sharesBalance == 0) {
positions[controller] = currentSharePrice;
} else {
uint256 totalCost = sharesBalance * averageEntryPrice + mintedShares * currentSharePrice;
uint256 newTotalAmount = sharesBalance + mintedShares;
uint256 newAverageEntryPrice = totalCost / newTotalAmount;
positions[controller] = newAverageEntryPrice;
}
}
function _afterDeposit(uint256 assets, uint256 ) internal override {
uint128 assetsUint128 = assets.toUint128();
_totalIdle += assetsUint128;
}
function _checkSharesLocked(address controller) private view {
if (block.timestamp < _depositLockCheckPoint[controller] + sharesLockTime) revert SharesLocked();
}
function _lockShares(address controller, uint256 sharesBalance, uint256 newShares) private {
uint256 newBalance = sharesBalance + newShares;
if (sharesBalance == 0) {
_depositLockCheckPoint[controller] = block.timestamp;
} else {
_depositLockCheckPoint[controller] = ((_depositLockCheckPoint[controller] * sharesBalance) / newBalance)
+ ((block.timestamp * newShares) / newBalance);
}
}
function supportsInterface(bytes4 interfaceId) public pure returns (bool isSupported) {
if (interfaceId == 0x4e2312e0) return true;
}
function convertToSuperPositions(uint256 superformId, uint256 assets) external view returns (uint256) {
return vaults[superformId].convertToShares(assets, asset(), false);
}
function onERC1155Received(
address operator,
address from,
uint256 superformId,
uint256 value,
bytes memory data
)
public
returns (bytes4)
{
operator;
value;
if (msg.sender != address(gateway.superPositions())) revert Unauthorized();
if (data.length > 0 && from == address(gateway)) {
(address controller, uint256 refundedAssets) = abi.decode(data, (address, uint256));
if (refundedAssets != 0) {
_totalDebt += refundedAssets.toUint128();
uint256 shares = _convertToShares(refundedAssets, totalAssets() - refundedAssets);
if (controller != address(0)) {
pendingProcessedShares[controller] = _sub0(pendingProcessedShares[controller], shares);
_mint(address(this), shares);
}
vaults[superformId].totalDebt += refundedAssets.toUint128();
}
}
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] memory superformIds,
uint256[] memory values,
bytes memory data
)
public
returns (bytes4)
{
operator;
values;
data;
superformIds;
if (msg.sender != address(gateway.superPositions())) revert Unauthorized();
if (from != address(gateway)) revert Unauthorized();
return this.onERC1155BatchReceived.selector;
}
}
文件 30 的 45：MetaVaultAdmin.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "common/Lib.sol";
import { IHurdleRateOracle } from "interfaces/IHurdleRateOracle.sol";
import { ISharePriceOracle } from "interfaces/ISharePriceOracle.sol";
import { ISuperformGateway } from "interfaces/ISuperformGateway.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import { VaultData } from "types/Lib.sol";
contract MetaVaultAdmin is ModuleBase {
using SafeTransferLib for address;
error FeeExceedsMaximum();
error InvalidSharesLockTime();
error InvalidZeroAddress();
error InvalidOracleAddress();
event GatewayUpdated(address indexed oldGateway, address indexed newGateway);
event HurdleRateOracleUpdated(address indexed oldOracle, address indexed newOracle);
event VaultOracleUpdated(uint256 indexed superformId, address indexed oldOracle, address indexed newOracle);
event SetSharesLockTime(uint24 time);
event SetManagementFee(uint16 fee);
event SetPerformanceFee(uint16 fee);
event SetOracleFee(uint16 fee);
event TreasuryUpdated(address indexed treasury);
event EmergencyShutdown(bool enabled);
function setGateway(ISuperformGateway _gateway) external onlyRoles(ADMIN_ROLE) {
address oldGateway = address(gateway);
if (oldGateway != address(0)) {
gateway.superPositions().setApprovalForAll(oldGateway, false);
asset().safeApprove(oldGateway, 0);
}
gateway = _gateway;
asset().safeApprove(address(_gateway), type(uint256).max);
gateway.superPositions().setApprovalForAll(address(_gateway), true);
emit GatewayUpdated(oldGateway, address(_gateway));
}
function setHurdleRateOracle(IHurdleRateOracle hurdleRateOracle) external onlyRoles(ADMIN_ROLE) {
address oldOracle = address(_hurdleRateOracle);
_hurdleRateOracle = hurdleRateOracle;
emit HurdleRateOracleUpdated(oldOracle, address(hurdleRateOracle));
}
function setVaultOracle(uint256 superformId, ISharePriceOracle oracle) external onlyRoles(ADMIN_ROLE) {
if (address(oracle) == address(0)) revert InvalidOracleAddress();
address oldOracle = address(vaults[superformId].oracle);
vaults[superformId].oracle = oracle;
emit VaultOracleUpdated(superformId, oldOracle, address(oracle));
}
function setSharesLockTime(uint24 _time) external onlyRoles(ADMIN_ROLE) {
if (_time > MAX_TIME) revert InvalidSharesLockTime();
sharesLockTime = _time;
emit SetSharesLockTime(_time);
}
function setTreasury(address _treasury) external onlyRoles(ADMIN_ROLE) {
if (_treasury == address(0)) revert InvalidZeroAddress();
address oldTreasury = treasury;
treasury = _treasury;
emit TreasuryUpdated(_treasury);
}
function setManagementFee(uint16 _managementFee) external onlyRoles(ADMIN_ROLE) {
if (_managementFee > MAX_FEE) revert FeeExceedsMaximum();
managementFee = _managementFee;
emit SetManagementFee(_managementFee);
}
function setPerformanceFee(uint16 _performanceFee) external onlyRoles(ADMIN_ROLE) {
if (_performanceFee > MAX_FEE) revert FeeExceedsMaximum();
performanceFee = _performanceFee;
emit SetPerformanceFee(_performanceFee);
}
function setOracleFee(uint16 _oracleFee) external onlyRoles(ADMIN_ROLE) {
if (_oracleFee > MAX_FEE) revert FeeExceedsMaximum();
oracleFee = _oracleFee;
emit SetOracleFee(_oracleFee);
}
function setFeeExcemption(
address controller,
uint256 managementFeeExcemption,
uint256 performanceFeeExcemption,
uint256 oracleFeeExcemption
)
external
onlyRoles(ADMIN_ROLE)
{
performanceFeeExempt[controller] = performanceFeeExcemption;
managementFeeExempt[controller] = managementFeeExcemption;
oracleFeeExempt[controller] = oracleFeeExcemption;
}
function setEmergencyShutdown(bool _emergencyShutdown) external onlyRoles(EMERGENCY_ADMIN_ROLE) {
emergencyShutdown = _emergencyShutdown;
emit EmergencyShutdown(_emergencyShutdown);
}
function selectors() external pure returns (bytes4[] memory) {
bytes4[] memory s = new bytes4[](10);
s[0] = this.setGateway.selector;
s[1] = this.setHurdleRateOracle.selector;
s[2] = this.setVaultOracle.selector;
s[3] = this.setSharesLockTime.selector;
s[4] = this.setTreasury.selector;
s[5] = this.setManagementFee.selector;
s[6] = this.setPerformanceFee.selector;
s[7] = this.setOracleFee.selector;
s[8] = this.setFeeExcemption.selector;
s[9] = this.setEmergencyShutdown.selector;
return s;
}
}
文件 31 的 45：MetaVaultBase.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "./ModuleBase.sol";
import { MultiFacetProxy } from "./MultiFacetProxy.sol";
abstract contract MetaVaultBase is ModuleBase, MultiFacetProxy { }
文件 32 的 45：MetaVaultReader.sol
pragma solidity ^0.8.19;
import { ModuleBase } from "common/Lib.sol";
import { ISharePriceOracle } from "../interfaces/ISharePriceOracle.sol";
import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol";
import { VaultData, VaultLib } from "types/Lib.sol";
contract MetaVaultReader is ModuleBase {
using VaultLib for VaultData;
using FixedPointMathLib for uint256;
struct VaultDetailedData {
uint32 chainId;
uint256 superformId;
ISharePriceOracle oracle;
uint8 decimals;
uint128 totalDebt;
address vaultAddress;
uint256 sharesBalance;
uint256 sharePrice;
uint256 totalAssets;
}
function getVaultDetailedData(uint256 superformId) public view returns (VaultDetailedData memory) {
VaultData memory vault = vaults[superformId];
uint256 sharesBalance = _sharesBalance(vault);
uint256 totalAssets = vault.convertToAssets(sharesBalance, asset(), true);
uint256 sharePrice = vault.sharePrice(asset());
return VaultDetailedData(
vault.chainId,
vault.superformId,
vault.oracle,
vault.decimals,
vault.totalDebt,
vault.vaultAddress,
sharesBalance,
sharePrice,
totalAssets
);
}
function getAllVaultsDetailedData() public view returns (VaultDetailedData[] memory) {
uint256 localCount;
uint256 xChainCount;
for (uint256 i = 0; i < WITHDRAWAL_QUEUE_SIZE; i++) {
if (vaults[localWithdrawalQueue[i]].vaultAddress != address(0)) localCount++;
if (vaults[xChainWithdrawalQueue[i]].vaultAddress != address(0)) xChainCount++;
}
VaultDetailedData[] memory allVaultData = new VaultDetailedData[](localCount + xChainCount);
uint256 currentIndex;
for (uint256 i = 0; i < localCount; i++) {
allVaultData[currentIndex] = getVaultDetailedData(localWithdrawalQueue[i]);
currentIndex++;
}
for (uint256 i = 0; i < xChainCount; i++) {
allVaultData[currentIndex] = getVaultDetailedData(xChainWithdrawalQueue[i]);
currentIndex++;
}
return allVaultData;
}
struct VaultReturnsData {
uint256 totalReturn;
uint256 hurdleReturn;
uint256 excessReturn;
}
function getLastEpochVaultReturns() public view returns (VaultReturnsData memory) {
uint256 currentSharePrice = sharePrice();
uint256 lastSharePrice = sharePriceWaterMark;
uint256 duration = block.timestamp - lastFeesCharged;
uint256 currentTotalAssets = totalAssets();
uint256 lastTotalAssets = totalSupply().fullMulDiv(lastSharePrice, 10 ** decimals());
uint256 hurdleReturn = (lastTotalAssets * hurdleRate()).fullMulDiv(duration, SECS_PER_YEAR) / MAX_BPS;
int256 assetsDelta = int256(currentTotalAssets) - int256(lastTotalAssets);
uint256 totalReturn = assetsDelta > 0 ? uint256(assetsDelta) : 0;
uint256 excessReturn = 0;
if (totalReturn > hurdleReturn && currentSharePrice > sharePriceWaterMark) {
excessReturn = totalReturn - hurdleReturn;
}
return VaultReturnsData(totalReturn, hurdleReturn, excessReturn);
}
function totalReturnsPerShare() public view returns (int256) {
return int256(sharePrice()) - int256(10 ** decimals());
}
function selectors() external pure returns (bytes4[] memory) {
bytes4[] memory _selectors = new bytes4[](4);
_selectors[0] = this.getVaultDetailedData.selector;
_selectors[1] = this.getAllVaultsDetailedData.selector;
_selectors[2] = this.getLastEpochVaultReturns.selector;
_selectors[3] = this.totalReturnsPerShare.selector;
return _selectors;
}
}
文件 33 的 45：ModuleBase.sol
pragma solidity ^0.8.19;
import { IHurdleRateOracle } from "../interfaces/IHurdleRateOracle.sol";
import { ISuperformGateway } from "../interfaces/ISuperformGateway.sol";
import { ERC7540, ReentrancyGuard } from "lib/Lib.sol";
import { OwnableRoles } from "solady/auth/OwnableRoles.sol";
import { FixedPointMathLib as Math } from "solady/utils/FixedPointMathLib.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { VaultData, VaultLib } from "types/Lib.sol";
contract ModuleBase is OwnableRoles, ERC7540, ReentrancyGuard {
using VaultLib for VaultData;
uint256 public constant WITHDRAWAL_QUEUE_SIZE = 30;
uint256 public constant SECS_PER_YEAR = 31_556_952;
uint256 public constant MAX_BPS = 10_000;
uint256 public constant ADMIN_ROLE = _ROLE_0;
uint256 public constant EMERGENCY_ADMIN_ROLE = _ROLE_1;
uint256 public constant ORACLE_ROLE = _ROLE_2;
uint256 public constant MANAGER_ROLE = _ROLE_3;
uint256 public constant RELAYER_ROLE = _ROLE_4;
uint64 public THIS_CHAIN_ID;
uint256 public constant N_CHAINS = 7;
uint16 constant MAX_FEE = 10_000;
uint256 public MAX_TIME = 172_800;
uint256 internal constant _NONCES_SLOT_SEED = 0x38377508;
mapping(address => uint256 averageEntryPrice) public positions;
uint128 internal _totalIdle;
uint128 internal _totalDebt;
uint8 _decimals;
uint16 public managementFee;
uint16 public performanceFee;
uint16 public oracleFee;
uint24 public sharesLockTime;
bool public emergencyShutdown;
address public treasury;
address internal _asset;
address public signerRelayer;
ISuperformGateway public gateway;
string internal _name;
string internal _symbol;
uint256[WITHDRAWAL_QUEUE_SIZE] public localWithdrawalQueue;
uint256[WITHDRAWAL_QUEUE_SIZE] public xChainWithdrawalQueue;
IHurdleRateOracle internal _hurdleRateOracle;
uint256 public lastReport;
uint256 public lastFeesCharged;
uint256 public sharePriceWaterMark;
uint256 public dustThreshold;
uint64[N_CHAINS] public DST_CHAINS = [
1,
137,
56,
10,
8453,
42_161,
43_114
];
mapping(address => uint256) internal _depositLockCheckPoint;
mapping(uint256 => VaultData) public vaults;
mapping(address => uint256) _vaultToSuperformId;
mapping(address controller => uint256 nonce) internal _controllerNonces;
mapping(uint64 => uint256) internal chainIndexes;
mapping(address controller => uint256) public performanceFeeExempt;
mapping(address controller => uint256) public managementFeeExempt;
mapping(address controller => uint256) public oracleFeeExempt;
mapping(address controller => uint256) public lastRedeem;
mapping(address controller => uint256) public pendingProcessedShares;
function _sub0(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
return a - b > a ? 0 : a - b;
}
}
function _sharesBalance(VaultData memory data) internal view returns (uint256 shares) {
if (data.chainId == THIS_CHAIN_ID) {
return ERC4626(data.vaultAddress).balanceOf(address(this));
} else {
return gateway.balanceOf(address(this), data.superformId);
}
}
function _inc_(uint256 x) internal pure returns (uint256) {
unchecked {
return x + 1;
}
}
function _eitherIsZero_(uint256 a, uint256 b) internal pure returns (bool result) {
assembly {
result := or(iszero(a), iszero(b))
}
}
function _getEmptyuintArray(uint256 len) internal pure returns (uint256[] memory) {
return new uint256[](len);
}
function _underlyingDecimals() internal view override returns (uint8) {
return _decimals;
}
function _toDynamicUint256Array(
uint256[WITHDRAWAL_QUEUE_SIZE] memory arr,
uint256 len
)
internal
pure
returns (uint256[] memory dynArr)
{
dynArr = new uint256[](len);
for (uint256 i = 0; i < len; ++i) {
dynArr[i] = arr[i];
}
}
function _getEmptyBoolArray(uint256 len) internal pure returns (bool[] memory) {
return new bool[](len);
}
function _convertToShares(uint256 assets, uint256 _totalAssets) internal view returns (uint256 shares) {
if (!_useVirtualShares()) {
uint256 supply = totalSupply();
return _eitherIsZero_(assets, supply)
? _initialConvertToShares(assets)
: Math.fullMulDiv(assets, supply, _totalAssets);
}
uint256 o = _decimalsOffset();
if (o == uint256(0)) {
return Math.fullMulDiv(assets, totalSupply() + 1, _inc_(_totalAssets));
}
return Math.fullMulDiv(assets, totalSupply() + 10 ** o, _inc_(_totalAssets));
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function sharePrice() public view returns (uint256) {
return convertToAssets(10 ** decimals());
}
function hurdleRate() public view returns (uint256) {
return _hurdleRateOracle.getRate(asset());
}
function isVaultListed(address vaultAddress) public view returns (bool) {
return _vaultToSuperformId[vaultAddress] != 0;
}
function isVaultListed(uint256 superformId) public view returns (bool) {
return vaults[superformId].vaultAddress != address(0);
}
function getVault(uint256 superformId) public view returns (VaultData memory vault) {
return vaults[superformId];
}
function asset() public view override returns (address) {
return _asset;
}
function totalAssets() public view override returns (uint256 assets) {
return gateway.totalpendingXChainInvests() + gateway.totalPendingXChainDivests() + totalWithdrawableAssets();
}
function totalDeposits() public view returns (uint256 assets) {
return totalIdle() + totalDebt();
}
function totalWithdrawableAssets() public view returns (uint256 assets) {
return totalLocalAssets() + totalXChainAssets();
}
function totalLocalAssets() public view returns (uint256 assets) {
assets = _totalIdle;
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE;) {
VaultData memory vault = vaults[localWithdrawalQueue[i]];
if (vault.vaultAddress == address(0)) break;
assets += vault.convertToAssets(_sharesBalance(vault), asset(), false);
++i;
}
return assets;
}
function totalXChainAssets() public view returns (uint256 assets) {
for (uint256 i = 0; i != WITHDRAWAL_QUEUE_SIZE;) {
VaultData memory vault = vaults[xChainWithdrawalQueue[i]];
if (vault.vaultAddress == address(0)) break;
assets += vault.convertToAssets(_sharesBalance(vault), asset(), false);
++i;
}
return assets;
}
function totalIdle() public view returns (uint256 assets) {
return _totalIdle;
}
function totalDebt() public view returns (uint256 assets) {
return _totalDebt;
}
}
文件 34 的 45：MultiFacetProxy.sol
pragma solidity ^0.8.19;
import { Proxy } from "openzeppelin-contracts/proxy/Proxy.sol";
import { OwnableRoles } from "solady/auth/OwnableRoles.sol";
contract MultiFacetProxy is Proxy, OwnableRoles {
mapping(bytes4 => address) selectorToImplementation;
constructor(uint256 _proxyAdminRole) {
assembly {
sstore(0x4fa563f6ad0f2ba943d6492a5a9c8ec6e039cc68444fb93b0b51ea1d78a61ef8, _proxyAdminRole)
}
}
function _proxyAdminRole() internal view returns (uint256 role) {
assembly {
role := sload(0x4fa563f6ad0f2ba943d6492a5a9c8ec6e039cc68444fb93b0b51ea1d78a61ef8)
}
}
function addFunction(
bytes4 selector,
address implementation,
bool forceOverride
)
public
onlyRoles(_proxyAdminRole())
{
if (!forceOverride) {
if (selectorToImplementation[selector] != address(0)) revert();
}
selectorToImplementation[selector] = implementation;
}
function addFunctions(bytes4[] calldata selectors, address implementation, bool forceOverride) public {
for (uint256 i = 0; i < selectors.length; i++) {
addFunction(selectors[i], implementation, forceOverride);
}
}
function removeFunction(bytes4 selector) public onlyRoles(_proxyAdminRole()) {
delete selectorToImplementation[selector];
}
function removeFunctions(bytes4[] calldata selectors) public {
for (uint256 i = 0; i < selectors.length; i++) {
removeFunction(selectors[i]);
}
}
function _implementation() internal view override returns (address) {
bytes4 selector = msg.sig;
address implementation = selectorToImplementation[selector];
if (implementation == address(0)) revert();
return implementation;
}
}
文件 35 的 45：Multicallable.sol
pragma solidity ^0.8.4;
abstract contract Multicallable {
function multicall(bytes[] calldata data) public virtual returns (bytes[] memory) {
assembly {
mstore(0x00, 0x20)
mstore(0x20, data.length)
if iszero(data.length) { return(0x00, 0x40) }
let results := 0x40
let end := shl(5, data.length)
calldatacopy(0x40, data.offset, end)
let resultsOffset := end
end := add(results, end)
for {} 1 {} {
let o := add(data.offset, mload(results))
let m := add(resultsOffset, 0x40)
calldatacopy(
m,
add(o, 0x20),
calldataload(o)
)
if iszero(delegatecall(gas(), address(), m, calldataload(o), codesize(), 0x00)) {
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
mstore(results, resultsOffset)
results := add(results, 0x20)
mstore(m, returndatasize())
returndatacopy(add(m, 0x20), 0x00, returndatasize())
resultsOffset :=
and(add(add(resultsOffset, returndatasize()), 0x3f), 0xffffffffffffffe0)
if iszero(lt(results, end)) { break }
}
return(0x00, add(resultsOffset, 0x40))
}
}
}
文件 36 的 45：NoDelegateCall.sol
pragma solidity ^0.8.0;
abstract contract NoDelegateCall {
error DelegateCallNotAllowed();
constructor() {
assembly {
sstore(0xa203c8cf3ff5695cb1e2caee14320584cc3e0e4b039b8fa3ae49b5e0568c699d, address())
}
}
function checkNotDelegateCall() private view {
if (address(this) != _getOriginalAddress()) revert DelegateCallNotAllowed();
}
function _getOriginalAddress() private view returns (address original) {
assembly {
original := sload(0xa203c8cf3ff5695cb1e2caee14320584cc3e0e4b039b8fa3ae49b5e0568c699d)
}
}
modifier noDelegateCall() {
checkNotDelegateCall();
_;
}
}
文件 37 的 45：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();
_;
}
}
文件 38 的 45：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;
}
文件 39 的 45：Proxy.sol
pragma solidity ^0.8.20;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
}
文件 40 的 45：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)
}
}
}
文件 41 的 45：SafeCastLib.sol
pragma solidity ^0.8.4;
library SafeCastLib {
error Overflow();
function toUint8(uint256 x) internal pure returns (uint8) {
if (x >= 1 << 8) _revertOverflow();
return uint8(x);
}
function toUint16(uint256 x) internal pure returns (uint16) {
if (x >= 1 << 16) _revertOverflow();
return uint16(x);
}
function toUint24(uint256 x) internal pure returns (uint24) {
if (x >= 1 << 24) _revertOverflow();
return uint24(x);
}
function toUint32(uint256 x) internal pure returns (uint32) {
if (x >= 1 << 32) _revertOverflow();
return uint32(x);
}
function toUint40(uint256 x) internal pure returns (uint40) {
if (x >= 1 << 40) _revertOverflow();
return uint40(x);
}
function toUint48(uint256 x) internal pure returns (uint48) {
if (x >= 1 << 48) _revertOverflow();
return uint48(x);
}
function toUint56(uint256 x) internal pure returns (uint56) {
if (x >= 1 << 56) _revertOverflow();
return uint56(x);
}
function toUint64(uint256 x) internal pure returns (uint64) {
if (x >= 1 << 64) _revertOverflow();
return uint64(x);
}
function toUint72(uint256 x) internal pure returns (uint72) {
if (x >= 1 << 72) _revertOverflow();
return uint72(x);
}
function toUint80(uint256 x) internal pure returns (uint80) {
if (x >= 1 << 80) _revertOverflow();
return uint80(x);
}
function toUint88(uint256 x) internal pure returns (uint88) {
if (x >= 1 << 88) _revertOverflow();
return uint88(x);
}
function toUint96(uint256 x) internal pure returns (uint96) {
if (x >= 1 << 96) _revertOverflow();
return uint96(x);
}
function toUint104(uint256 x) internal pure returns (uint104) {
if (x >= 1 << 104) _revertOverflow();
return uint104(x);
}
function toUint112(uint256 x) internal pure returns (uint112) {
if (x >= 1 << 112) _revertOverflow();
return uint112(x);
}
function toUint120(uint256 x) internal pure returns (uint120) {
if (x >= 1 << 120) _revertOverflow();
return uint120(x);
}
function toUint128(uint256 x) internal pure returns (uint128) {
if (x >= 1 << 128) _revertOverflow();
return uint128(x);
}
function toUint136(uint256 x) internal pure returns (uint136) {
if (x >= 1 << 136) _revertOverflow();
return uint136(x);
}
function toUint144(uint256 x) internal pure returns (uint144) {
if (x >= 1 << 144) _revertOverflow();
return uint144(x);
}
function toUint152(uint256 x) internal pure returns (uint152) {
if (x >= 1 << 152) _revertOverflow();
return uint152(x);
}
function toUint160(uint256 x) internal pure returns (uint160) {
if (x >= 1 << 160) _revertOverflow();
return uint160(x);
}
function toUint168(uint256 x) internal pure returns (uint168) {
if (x >= 1 << 168) _revertOverflow();
return uint168(x);
}
function toUint176(uint256 x) internal pure returns (uint176) {
if (x >= 1 << 176) _revertOverflow();
return uint176(x);
}
function toUint184(uint256 x) internal pure returns (uint184) {
if (x >= 1 << 184) _revertOverflow();
return uint184(x);
}
function toUint192(uint256 x) internal pure returns (uint192) {
if (x >= 1 << 192) _revertOverflow();
return uint192(x);
}
function toUint200(uint256 x) internal pure returns (uint200) {
if (x >= 1 << 200) _revertOverflow();
return uint200(x);
}
function toUint208(uint256 x) internal pure returns (uint208) {
if (x >= 1 << 208) _revertOverflow();
return uint208(x);
}
function toUint216(uint256 x) internal pure returns (uint216) {
if (x >= 1 << 216) _revertOverflow();
return uint216(x);
}
function toUint224(uint256 x) internal pure returns (uint224) {
if (x >= 1 << 224) _revertOverflow();
return uint224(x);
}
function toUint232(uint256 x) internal pure returns (uint232) {
if (x >= 1 << 232) _revertOverflow();
return uint232(x);
}
function toUint240(uint256 x) internal pure returns (uint240) {
if (x >= 1 << 240) _revertOverflow();
return uint240(x);
}
function toUint248(uint256 x) internal pure returns (uint248) {
if (x >= 1 << 248) _revertOverflow();
return uint248(x);
}
function toInt8(int256 x) internal pure returns (int8) {
unchecked {
if (((1 << 7) + uint256(x)) >> 8 == uint256(0)) return int8(x);
_revertOverflow();
}
}
function toInt16(int256 x) internal pure returns (int16) {
unchecked {
if (((1 << 15) + uint256(x)) >> 16 == uint256(0)) return int16(x);
_revertOverflow();
}
}
function toInt24(int256 x) internal pure returns (int24) {
unchecked {
if (((1 << 23) + uint256(x)) >> 24 == uint256(0)) return int24(x);
_revertOverflow();
}
}
function toInt32(int256 x) internal pure returns (int32) {
unchecked {
if (((1 << 31) + uint256(x)) >> 32 == uint256(0)) return int32(x);
_revertOverflow();
}
}
function toInt40(int256 x) internal pure returns (int40) {
unchecked {
if (((1 << 39) + uint256(x)) >> 40 == uint256(0)) return int40(x);
_revertOverflow();
}
}
function toInt48(int256 x) internal pure returns (int48) {
unchecked {
if (((1 << 47) + uint256(x)) >> 48 == uint256(0)) return int48(x);
_revertOverflow();
}
}
function toInt56(int256 x) internal pure returns (int56) {
unchecked {
if (((1 << 55) + uint256(x)) >> 56 == uint256(0)) return int56(x);
_revertOverflow();
}
}
function toInt64(int256 x) internal pure returns (int64) {
unchecked {
if (((1 << 63) + uint256(x)) >> 64 == uint256(0)) return int64(x);
_revertOverflow();
}
}
function toInt72(int256 x) internal pure returns (int72) {
unchecked {
if (((1 << 71) + uint256(x)) >> 72 == uint256(0)) return int72(x);
_revertOverflow();
}
}
function toInt80(int256 x) internal pure returns (int80) {
unchecked {
if (((1 << 79) + uint256(x)) >> 80 == uint256(0)) return int80(x);
_revertOverflow();
}
}
function toInt88(int256 x) internal pure returns (int88) {
unchecked {
if (((1 << 87) + uint256(x)) >> 88 == uint256(0)) return int88(x);
_revertOverflow();
}
}
function toInt96(int256 x) internal pure returns (int96) {
unchecked {
if (((1 << 95) + uint256(x)) >> 96 == uint256(0)) return int96(x);
_revertOverflow();
}
}
function toInt104(int256 x) internal pure returns (int104) {
unchecked {
if (((1 << 103) + uint256(x)) >> 104 == uint256(0)) return int104(x);
_revertOverflow();
}
}
function toInt112(int256 x) internal pure returns (int112) {
unchecked {
if (((1 << 111) + uint256(x)) >> 112 == uint256(0)) return int112(x);
_revertOverflow();
}
}
function toInt120(int256 x) internal pure returns (int120) {
unchecked {
if (((1 << 119) + uint256(x)) >> 120 == uint256(0)) return int120(x);
_revertOverflow();
}
}
function toInt128(int256 x) internal pure returns (int128) {
unchecked {
if (((1 << 127) + uint256(x)) >> 128 == uint256(0)) return int128(x);
_revertOverflow();
}
}
function toInt136(int256 x) internal pure returns (int136) {
unchecked {
if (((1 << 135) + uint256(x)) >> 136 == uint256(0)) return int136(x);
_revertOverflow();
}
}
function toInt144(int256 x) internal pure returns (int144) {
unchecked {
if (((1 << 143) + uint256(x)) >> 144 == uint256(0)) return int144(x);
_revertOverflow();
}
}
function toInt152(int256 x) internal pure returns (int152) {
unchecked {
if (((1 << 151) + uint256(x)) >> 152 == uint256(0)) return int152(x);
_revertOverflow();
}
}
function toInt160(int256 x) internal pure returns (int160) {
unchecked {
if (((1 << 159) + uint256(x)) >> 160 == uint256(0)) return int160(x);
_revertOverflow();
}
}
function toInt168(int256 x) internal pure returns (int168) {
unchecked {
if (((1 << 167) + uint256(x)) >> 168 == uint256(0)) return int168(x);
_revertOverflow();
}
}
function toInt176(int256 x) internal pure returns (int176) {
unchecked {
if (((1 << 175) + uint256(x)) >> 176 == uint256(0)) return int176(x);
_revertOverflow();
}
}
function toInt184(int256 x) internal pure returns (int184) {
unchecked {
if (((1 << 183) + uint256(x)) >> 184 == uint256(0)) return int184(x);
_revertOverflow();
}
}
function toInt192(int256 x) internal pure returns (int192) {
unchecked {
if (((1 << 191) + uint256(x)) >> 192 == uint256(0)) return int192(x);
_revertOverflow();
}
}
function toInt200(int256 x) internal pure returns (int200) {
unchecked {
if (((1 << 199) + uint256(x)) >> 200 == uint256(0)) return int200(x);
_revertOverflow();
}
}
function toInt208(int256 x) internal pure returns (int208) {
unchecked {
if (((1 << 207) + uint256(x)) >> 208 == uint256(0)) return int208(x);
_revertOverflow();
}
}
function toInt216(int256 x) internal pure returns (int216) {
unchecked {
if (((1 << 215) + uint256(x)) >> 216 == uint256(0)) return int216(x);
_revertOverflow();
}
}
function toInt224(int256 x) internal pure returns (int224) {
unchecked {
if (((1 << 223) + uint256(x)) >> 224 == uint256(0)) return int224(x);
_revertOverflow();
}
}
function toInt232(int256 x) internal pure returns (int232) {
unchecked {
if (((1 << 231) + uint256(x)) >> 232 == uint256(0)) return int232(x);
_revertOverflow();
}
}
function toInt240(int256 x) internal pure returns (int240) {
unchecked {
if (((1 << 239) + uint256(x)) >> 240 == uint256(0)) return int240(x);
_revertOverflow();
}
}
function toInt248(int256 x) internal pure returns (int248) {
unchecked {
if (((1 << 247) + uint256(x)) >> 248 == uint256(0)) return int248(x);
_revertOverflow();
}
}
function toInt8(uint256 x) internal pure returns (int8) {
if (x >= 1 << 7) _revertOverflow();
return int8(int256(x));
}
function toInt16(uint256 x) internal pure returns (int16) {
if (x >= 1 << 15) _revertOverflow();
return int16(int256(x));
}
function toInt24(uint256 x) internal pure returns (int24) {
if (x >= 1 << 23) _revertOverflow();
return int24(int256(x));
}
function toInt32(uint256 x) internal pure returns (int32) {
if (x >= 1 << 31) _revertOverflow();
return int32(int256(x));
}
function toInt40(uint256 x) internal pure returns (int40) {
if (x >= 1 << 39) _revertOverflow();
return int40(int256(x));
}
function toInt48(uint256 x) internal pure returns (int48) {
if (x >= 1 << 47) _revertOverflow();
return int48(int256(x));
}
function toInt56(uint256 x) internal pure returns (int56) {
if (x >= 1 << 55) _revertOverflow();
return int56(int256(x));
}
function toInt64(uint256 x) internal pure returns (int64) {
if (x >= 1 << 63) _revertOverflow();
return int64(int256(x));
}
function toInt72(uint256 x) internal pure returns (int72) {
if (x >= 1 << 71) _revertOverflow();
return int72(int256(x));
}
function toInt80(uint256 x) internal pure returns (int80) {
if (x >= 1 << 79) _revertOverflow();
return int80(int256(x));
}
function toInt88(uint256 x) internal pure returns (int88) {
if (x >= 1 << 87) _revertOverflow();
return int88(int256(x));
}
function toInt96(uint256 x) internal pure returns (int96) {
if (x >= 1 << 95) _revertOverflow();
return int96(int256(x));
}
function toInt104(uint256 x) internal pure returns (int104) {
if (x >= 1 << 103) _revertOverflow();
return int104(int256(x));
}
function toInt112(uint256 x) internal pure returns (int112) {
if (x >= 1 << 111) _revertOverflow();
return int112(int256(x));
}
function toInt120(uint256 x) internal pure returns (int120) {
if (x >= 1 << 119) _revertOverflow();
return int120(int256(x));
}
function toInt128(uint256 x) internal pure returns (int128) {
if (x >= 1 << 127) _revertOverflow();
return int128(int256(x));
}
function toInt136(uint256 x) internal pure returns (int136) {
if (x >= 1 << 135) _revertOverflow();
return int136(int256(x));
}
function toInt144(uint256 x) internal pure returns (int144) {
if (x >= 1 << 143) _revertOverflow();
return int144(int256(x));
}
function toInt152(uint256 x) internal pure returns (int152) {
if (x >= 1 << 151) _revertOverflow();
return int152(int256(x));
}
function toInt160(uint256 x) internal pure returns (int160) {
if (x >= 1 << 159) _revertOverflow();
return int160(int256(x));
}
function toInt168(uint256 x) internal pure returns (int168) {
if (x >= 1 << 167) _revertOverflow();
return int168(int256(x));
}
function toInt176(uint256 x) internal pure returns (int176) {
if (x >= 1 << 175) _revertOverflow();
return int176(int256(x));
}
function toInt184(uint256 x) internal pure returns (int184) {
if (x >= 1 << 183) _revertOverflow();
return int184(int256(x));
}
function toInt192(uint256 x) internal pure returns (int192) {
if (x >= 1 << 191) _revertOverflow();
return int192(int256(x));
}
function toInt200(uint256 x) internal pure returns (int200) {
if (x >= 1 << 199) _revertOverflow();
return int200(int256(x));
}
function toInt208(uint256 x) internal pure returns (int208) {
if (x >= 1 << 207) _revertOverflow();
return int208(int256(x));
}
function toInt216(uint256 x) internal pure returns (int216) {
if (x >= 1 << 215) _revertOverflow();
return int216(int256(x));
}
function toInt224(uint256 x) internal pure returns (int224) {
if (x >= 1 << 223) _revertOverflow();
return int224(int256(x));
}
function toInt232(uint256 x) internal pure returns (int232) {
if (x >= 1 << 231) _revertOverflow();
return int232(int256(x));
}
function toInt240(uint256 x) internal pure returns (int240) {
if (x >= 1 << 239) _revertOverflow();
return int240(int256(x));
}
function toInt248(uint256 x) internal pure returns (int248) {
if (x >= 1 << 247) _revertOverflow();
return int248(int256(x));
}
function toInt256(uint256 x) internal pure returns (int256) {
if (int256(x) >= 0) return int256(x);
_revertOverflow();
}
function toUint256(int256 x) internal pure returns (uint256) {
if (x >= 0) return uint256(x);
_revertOverflow();
}
function _revertOverflow() private pure {
assembly {
mstore(0x00, 0x35278d12)
revert(0x1c, 0x04)
}
}
}
文件 42 的 45：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)
}
}
}
}
文件 43 的 45：SignatureCheckerLib.sol
pragma solidity ^0.8.4;
library SignatureCheckerLib {
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x40, mload(add(signature, 0x20)))
if eq(mload(signature), 64) {
let vs := mload(add(signature, 0x40))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x60, shr(1, shl(1, vs)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
if eq(mload(signature), 65) {
mstore(0x20, byte(0, mload(add(signature, 0x60))))
mstore(0x60, mload(add(signature, 0x40)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
mstore(0x60, 0)
mstore(0x40, m)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
let n := add(0x20, mload(signature))
pop(staticcall(gas(), 4, signature, n, add(m, 0x44), n))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(returndatasize(), 0x44),
d,
0x20
)
)
break
}
}
}
function isValidSignatureNowCalldata(address signer, bytes32 hash, bytes calldata signature)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
if eq(signature.length, 64) {
let vs := calldataload(add(signature.offset, 0x20))
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, calldataload(signature.offset))
mstore(0x60, shr(1, shl(1, vs)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
if eq(signature.length, 65) {
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40))))
calldatacopy(0x40, signature.offset, 0x40)
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
mstore(0x60, 0)
mstore(0x40, m)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), signature.length)
calldatacopy(add(m, 0x64), signature.offset, signature.length)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(signature.length, 0x64),
d,
0x20
)
)
break
}
}
}
function isValidSignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), mload(0x60))
mstore8(add(m, 0xa4), mload(0x20))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
}
function isValidSignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), s)
mstore8(add(m, 0xa4), v)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes memory signature)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
let n := add(0x20, mload(signature))
pop(staticcall(gas(), 4, signature, n, add(m, 0x44), n))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(returndatasize(), 0x44),
d,
0x20
)
)
}
}
function isValidERC1271SignatureNowCalldata(
address signer,
bytes32 hash,
bytes calldata signature
) internal view returns (bool isValid) {
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), signature.length)
calldatacopy(add(m, 0x64), signature.offset, signature.length)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(signature.length, 0x64),
d,
0x20
)
)
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), shr(1, shl(1, vs)))
mstore8(add(m, 0xa4), add(shr(255, vs), 27))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), s)
mstore8(add(m, 0xa4), v)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
}
}
function isValidERC6492SignatureNowAllowSideEffects(
address signer,
bytes32 hash,
bytes memory signature
) internal returns (bool isValid) {
assembly {
function callIsValidSignature(signer_, hash_, signature_) -> _isValid {
let m_ := mload(0x40)
let f_ := shl(224, 0x1626ba7e)
mstore(m_, f_)
mstore(add(m_, 0x04), hash_)
let d_ := add(m_, 0x24)
mstore(d_, 0x40)
let n_ := add(0x20, mload(signature_))
pop(staticcall(gas(), 4, signature_, n_, add(m_, 0x44), n_))
_isValid :=
and(
eq(mload(d_), f_),
staticcall(gas(), signer_, m_, add(returndatasize(), 0x44), d_, 0x20)
)
}
for { let n := mload(signature) } 1 {} {
if iszero(eq(mload(add(signature, n)), mul(0x6492, div(not(isValid), 0xffff)))) {
isValid := callIsValidSignature(signer, hash, signature)
break
}
let o := add(signature, 0x20)
let d := add(o, mload(add(o, 0x20)))
if iszero(extcodesize(signer)) {
if iszero(call(gas(), mload(o), 0, add(d, 0x20), mload(d), codesize(), 0x00)) {
break
}
}
let s := add(o, mload(add(o, 0x40)))
isValid := callIsValidSignature(signer, hash, s)
if iszero(isValid) {
if call(gas(), mload(o), 0, add(d, 0x20), mload(d), codesize(), 0x00) {
isValid := callIsValidSignature(signer, hash, s)
}
}
break
}
}
}
function isValidERC6492SignatureNow(address signer, bytes32 hash, bytes memory signature)
internal
returns (bool isValid)
{
assembly {
function callIsValidSignature(signer_, hash_, signature_) -> _isValid {
let m_ := mload(0x40)
let f_ := shl(224, 0x1626ba7e)
mstore(m_, f_)
mstore(add(m_, 0x04), hash_)
let d_ := add(m_, 0x24)
mstore(d_, 0x40)
let n_ := add(0x20, mload(signature_))
pop(staticcall(gas(), 4, signature_, n_, add(m_, 0x44), n_))
_isValid :=
and(
eq(mload(d_), f_),
staticcall(gas(), signer_, m_, add(returndatasize(), 0x44), d_, 0x20)
)
}
for { let n := mload(signature) } 1 {} {
if iszero(eq(mload(add(signature, n)), mul(0x6492, div(not(isValid), 0xffff)))) {
isValid := callIsValidSignature(signer, hash, signature)
break
}
if extcodesize(signer) {
let o := add(signature, 0x20)
isValid := callIsValidSignature(signer, hash, add(o, mload(add(o, 0x40))))
if isValid { break }
}
let m := mload(0x40)
mstore(m, signer)
mstore(add(m, 0x20), hash)
let willBeZeroIfRevertingVerifierExists :=
call(
gas(),
0x00007bd799e4A591FeA53f8A8a3E9f931626Ba7e,
0,
m,
add(returndatasize(), 0x40),
staticcall(gas(), 4, add(signature, 0x20), n, add(m, 0x40), n),
0x00
)
isValid := gt(returndatasize(), willBeZeroIfRevertingVerifierExists)
break
}
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 result) {
assembly {
mstore(0x20, hash)
mstore(0x00, "\x00\x00\x00\x00\x19Ethereum Signed Message:\n32")
result := keccak256(0x04, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32 result) {
assembly {
let sLength := mload(s)
let o := 0x20
mstore(o, "\x19Ethereum Signed Message:\n")
mstore(0x00, 0x00)
for { let temp := sLength } 1 {} {
o := sub(o, 1)
mstore8(o, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let n := sub(0x3a, o)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0x20))
mstore(s, or(mload(0x00), mload(n)))
result := keccak256(add(s, sub(0x20, n)), add(n, sLength))
mstore(s, sLength)
}
}
function emptySignature() internal pure returns (bytes calldata signature) {
assembly {
signature.length := 0
}
}
}
文件 44 的 45：SuperformTypes.sol
pragma solidity ^0.8.19;
enum TransactionType {
DEPOSIT,
WITHDRAW
}
enum CallbackType {
INIT,
RETURN,
FAIL
}
enum PayloadState {
STORED,
UPDATED,
PROCESSED
}
struct LiqRequest {
bytes txData;
address token;
address interimToken;
uint8 bridgeId;
uint64 liqDstChainId;
uint256 nativeAmount;
}
struct MultiVaultSFData {
uint256[] superformIds;
uint256[] amounts;
uint256[] outputAmounts;
uint256[] maxSlippages;
LiqRequest[] liqRequests;
bytes permit2data;
bool[] hasDstSwaps;
bool[] retain4626s;
address receiverAddress;
address receiverAddressSP;
bytes extraFormData;
}
struct SingleVaultSFData {
uint256 superformId;
uint256 amount;
uint256 outputAmount;
uint256 maxSlippage;
LiqRequest liqRequest;
bytes permit2data;
bool hasDstSwap;
bool retain4626;
address receiverAddress;
address receiverAddressSP;
bytes extraFormData;
}
struct MultiDstMultiVaultStateReq {
uint8[][] ambIds;
uint64[] dstChainIds;
MultiVaultSFData[] superformsData;
}
struct SingleXChainMultiVaultStateReq {
uint8[] ambIds;
uint64 dstChainId;
MultiVaultSFData superformsData;
}
struct MultiDstSingleVaultStateReq {
uint8[][] ambIds;
uint64[] dstChainIds;
SingleVaultSFData[] superformsData;
}
struct SingleXChainSingleVaultStateReq {
uint8[] ambIds;
uint64 dstChainId;
SingleVaultSFData superformData;
}
struct SingleDirectSingleVaultStateReq {
SingleVaultSFData superformData;
}
struct SingleDirectMultiVaultStateReq {
MultiVaultSFData superformData;
}
struct InitMultiVaultData {
uint256 payloadId;
uint256[] superformIds;
uint256[] amounts;
uint256[] outputAmounts;
uint256[] maxSlippages;
LiqRequest[] liqData;
bool[] hasDstSwaps;
bool[] retain4626s;
address receiverAddress;
bytes extraFormData;
}
struct InitSingleVaultData {
uint256 payloadId;
uint256 superformId;
uint256 amount;
uint256 outputAmount;
uint256 maxSlippage;
LiqRequest liqData;
bool hasDstSwap;
bool retain4626;
address receiverAddress;
bytes extraFormData;
}
struct QueuedWithdrawal {
address receiverAddress;
uint256 superformId;
uint256 amount;
uint256 srcPayloadId;
bool isProcessed;
}
enum TimelockStatus {
UNAVAILABLE,
PENDING,
PROCESSED
}
struct TimelockPayload {
uint8 isXChain;
uint64 srcChainId;
uint256 lockedTill;
InitSingleVaultData data;
TimelockStatus status;
}
struct AMBMessage {
uint256 txInfo;
bytes params;
}
struct BroadcastMessage {
bytes target;
bytes32 messageType;
bytes message;
}
struct ReturnMultiData {
uint256 payloadId;
uint256[] superformIds;
uint256[] amounts;
}
struct ReturnSingleData {
uint256 payloadId;
uint256 superformId;
uint256 amount;
}
struct AMBExtraData {
uint256[] gasPerAMB;
bytes[] extraDataPerAMB;
}
struct BroadCastAMBExtraData {
uint256[] gasPerDst;
bytes[] extraDataPerDst;
}
文件 45 的 45：VaultTypes.sol
pragma solidity ^0.8.19;
import { LiqRequest } from "./SuperformTypes.sol";
import { ISharePriceOracle, VaultReport } from "interfaces/ISharePriceOracle.sol";
import { ERC4626 } from "solady/tokens/ERC4626.sol";
import { IBaseRouter } from "src/interfaces/IBaseRouter.sol";
import { IHurdleRateOracle } from "src/interfaces/IHurdleRateOracle.sol";
import { ISuperPositions } from "src/interfaces/ISuperPositions.sol";
import { ISuperformFactory } from "src/interfaces/ISuperformFactory.sol";
import { ISuperformGateway } from "src/interfaces/ISuperformGateway.sol";
uint256 constant ORACLE_STALENESS_TOLERANCE = 1 days;
struct VaultData {
uint32 chainId;
uint256 superformId;
ISharePriceOracle oracle;
uint8 decimals;
uint128 totalDebt;
address vaultAddress;
}
struct VaultConfig {
address asset;
string name;
string symbol;
uint16 managementFee;
uint16 performanceFee;
uint16 oracleFee;
uint24 sharesLockTime;
IHurdleRateOracle hurdleRateOracle;
ISuperPositions superPositions;
address treasury;
address signerRelayer;
address owner;
}
library VaultLib {
error StaleSharePrice();
function convertToAssets(
VaultData memory self,
uint256 shares,
address metavaultAsset,
bool revertIfStale
)
internal
view
returns (uint256 assets)
{
(uint256 sharePrice_, uint64 lastUpdated) =
self.oracle.getLatestSharePrice(self.chainId, self.vaultAddress, metavaultAsset);
if (revertIfStale) {
if (lastUpdated + ORACLE_STALENESS_TOLERANCE < block.timestamp) revert StaleSharePrice();
}
return sharePrice_ * shares / 10 ** self.decimals;
}
function convertToShares(
VaultData memory self,
uint256 assets,
address metavaultAsset,
bool revertIfStale
)
internal
view
returns (uint256 shares)
{
(uint256 sharePrice_, uint64 lastUpdated) =
self.oracle.getLatestSharePrice(self.chainId, self.vaultAddress, metavaultAsset);
if (revertIfStale) {
if (lastUpdated + ORACLE_STALENESS_TOLERANCE < block.timestamp) revert();
}
return assets * 10 ** self.decimals / sharePrice_;
}
function sharePrice(VaultData memory self, address metavaultAsset) internal view returns (uint256) {
(uint256 sharePrice_,) = self.oracle.getLatestSharePrice(self.chainId, self.vaultAddress, metavaultAsset);
return sharePrice_;
}
function _chainId() internal view returns (uint64 chainId) {
return uint64(block.chainid);
}
}
struct SingleXChainSingleVaultWithdraw {
uint8[] ambIds;
uint256 outputAmount;
uint256 maxSlippage;
LiqRequest liqRequest;
bool hasDstSwap;
uint256 value;
}
struct SingleXChainMultiVaultWithdraw {
uint8[] ambIds;
uint256[] outputAmounts;
uint256[] maxSlippages;
LiqRequest[] liqRequests;
bool[] hasDstSwaps;
uint256 value;
}
struct MultiXChainSingleVaultWithdraw {
uint8[][] ambIds;
uint256[] outputAmounts;
uint256[] maxSlippages;
LiqRequest[] liqRequests;
bool[] hasDstSwaps;
uint256 value;
}
struct MultiXChainMultiVaultWithdraw {
uint8[][] ambIds;
uint256[][] outputAmounts;
uint256[][] maxSlippages;
LiqRequest[][] liqRequests;
bool[][] hasDstSwaps;
uint256 value;
}
struct ProcessRedeemRequestParams {
address controller;
uint256 shares;
SingleXChainSingleVaultWithdraw sXsV;
SingleXChainMultiVaultWithdraw sXmV;
MultiXChainSingleVaultWithdraw mXsV;
MultiXChainMultiVaultWithdraw mXmV;
}
{
"compilationTarget": {
"src/MetaVault.sol": "MetaVault"
},
"evmVersion": "shanghai",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@openzeppelin-contracts-5.1.0/=dependencies/@openzeppelin-contracts-5.1.0/",
":common/=src/common/",
":crosschain/=src/crosschain/",
":forge-std-1.9.2/=dependencies/forge-std-1.9.2/src/",
":forge-std/=dependencies/forge-std-1.9.2/src/",
":helpers/=src/helpers/",
":interfaces/=src/interfaces/",
":lib/=src/lib/",
":modules/=src/modules/",
":openzeppelin-contracts/=dependencies/@openzeppelin-contracts-5.1.0/",
":solady-0.0.236/=dependencies/solady-0.0.236/src/",
":solady/=dependencies/solady-0.0.236/src/",
":types/=src/types/"
],
"viaIR": true
}[{"inputs":[{"components":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint16","name":"managementFee","type":"uint16"},{"internalType":"uint16","name":"performanceFee","type":"uint16"},{"internalType":"uint16","name":"oracleFee","type":"uint16"},{"internalType":"uint24","name":"sharesLockTime","type":"uint24"},{"internalType":"contract IHurdleRateOracle","name":"hurdleRateOracle","type":"address"},{"internalType":"contract ISuperPositions","name":"superPositions","type":"address"},{"internalType":"address","name":"treasury","type":"address"},{"internalType":"address","name":"signerRelayer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"internalType":"struct VaultConfig","name":"config","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"DelegateCallNotAllowed","type":"error"},{"inputs":[],"name":"DepositMoreThanMax","type":"error"},{"inputs":[],"name":"DuplicateVaultInOrder","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientAvailableAssets","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidController","type":"error"},{"inputs":[],"name":"InvalidOperator","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"InvalidQueueType","type":"error"},{"inputs":[],"name":"InvalidSuperformId","type":"error"},{"inputs":[],"name":"InvalidVaultAddress","type":"error"},{"inputs":[],"name":"InvalidZeroAddress","type":"error"},{"inputs":[],"name":"InvalidZeroAssets","type":"error"},{"inputs":[],"name":"InvalidZeroShares","type":"error"},{"inputs":[],"name":"MaxQueueSizeExceeded","type":"error"},{"inputs":[],"name":"MintMoreThanMax","type":"error"},{"inputs":[],"name":"MissingVaultFromCurrentQueue","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NewVaultNotInCurrentQueue","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"RedeemMoreThanMax","type":"error"},{"inputs":[],"name":"RedeemNotProcessed","type":"error"},{"inputs":[],"name":"ReentrantCall","type":"error"},{"inputs":[],"name":"RequestNotSettled","type":"error"},{"inputs":[],"name":"SharesBalanceNotZero","type":"error"},{"inputs":[],"name":"SharesLocked","type":"error"},{"inputs":[],"name":"StaleSharePrice","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"VaultAlreadyListed","type":"error"},{"inputs":[],"name":"VaultCountMismatch","type":"error"},{"inputs":[],"name":"VaultShutdown","type":"error"},{"inputs":[],"name":"WithdrawMoreThanMax","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"chainId","type":"uint64"},{"indexed":false,"internalType":"address","name":"vault","type":"address"}],"name":"AddVault","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"uint256","name":"managementFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"performanceFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oracleFees","type":"uint256"}],"name":"AssessFees","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":true,"internalType":"address","name":"controller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"address","name":"source","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"}],"name":"DepositRequest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"EmergencyShutdown","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"FulfillDepositRequest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"}],"name":"FulfillRedeemRequest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"OperatorSet","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":true,"internalType":"address","name":"controller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"requestId","type":"uint256"},{"indexed":false,"internalType":"address","name":"source","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"RedeemRequest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"chainId","type":"uint64"},{"indexed":false,"internalType":"address","name":"vault","type":"address"}],"name":"RemoveVault","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":false,"internalType":"uint16","name":"fee","type":"uint16"}],"name":"SetManagementFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"fee","type":"uint16"}],"name":"SetOracleFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"fee","type":"uint16"}],"name":"SetPerformanceFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint24","name":"time","type":"uint24"}],"name":"SetSharesLockTime","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":true,"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"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"ADMIN_ROLE","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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"DST_CHAINS","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EMERGENCY_ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MANAGER_ROLE","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":"MAX_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"N_CHAINS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ORACLE_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RELAYER_ROLE","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":"THIS_CHAIN_ID","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWAL_QUEUE_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"address","name":"implementation","type":"address"},{"internalType":"bool","name":"forceOverride","type":"bool"}],"name":"addFunction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"},{"internalType":"address","name":"implementation","type":"address"},{"internalType":"bool","name":"forceOverride","type":"bool"}],"name":"addFunctions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"chainId","type":"uint32"},{"internalType":"uint256","name":"superformId","type":"uint256"},{"internalType":"address","name":"vault","type":"address"},{"internalType":"uint8","name":"vaultDecimals","type":"uint8"},{"internalType":"contract ISharePriceOracle","name":"oracle","type":"address"}],"name":"addVault","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":[{"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":[],"name":"chargeGlobalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"claimableDepositRequest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"claimableRedeemRequest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"uint256","name":"superformId","type":"uint256"},{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToSuperPositions","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":"to","type":"address"},{"internalType":"address","name":"controller","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"donate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dustThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyShutdown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gateway","outputs":[{"internalType":"contract ISuperformGateway","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"superformId","type":"uint256"}],"name":"getVault","outputs":[{"components":[{"internalType":"uint32","name":"chainId","type":"uint32"},{"internalType":"uint256","name":"superformId","type":"uint256"},{"internalType":"contract ISharePriceOracle","name":"oracle","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint128","name":"totalDebt","type":"uint128"},{"internalType":"address","name":"vaultAddress","type":"address"}],"internalType":"struct VaultData","name":"vault","type":"tuple"}],"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":"hurdleRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vaultAddress","type":"address"}],"name":"isVaultListed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"superformId","type":"uint256"}],"name":"isVaultListed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastFeesCharged","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"lastRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastReport","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"localWithdrawalQueue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managementFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"managementFeeExempt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"controller","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"superformIds","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"superformId","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oracleFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"oracleFeeExempt","outputs":[{"internalType":"uint256","name":"","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":[{"internalType":"address","name":"controller","type":"address"}],"name":"pendingDepositRequest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"pendingProcessedShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"pendingRedeemRequest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"performanceFeeExempt","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":"address","name":"","type":"address"}],"name":"positions","outputs":[{"internalType":"uint256","name":"averageEntryPrice","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint8","name":"queueType","type":"uint8"},{"internalType":"uint256[30]","name":"newOrder","type":"uint256[30]"}],"name":"rearrangeWithdrawalQueue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"controller","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"removeFunction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"}],"name":"removeFunctions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"superformId","type":"uint256"}],"name":"removeVault","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":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"controller","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"requestDeposit","outputs":[{"internalType":"uint256","name":"requestId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"controller","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"requestRedeem","outputs":[{"internalType":"uint256","name":"requestId","type":"uint256"}],"stateMutability":"nonpayable","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":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setOperator","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sharePriceWaterMark","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sharesLockTime","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"signerRelayer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"isSupported","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDebt","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDeposits","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalIdle","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLocalAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWithdrawableAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalXChainAssets","outputs":[{"internalType":"uint256","name":"assets","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":"uint256","name":"","type":"uint256"}],"name":"vaults","outputs":[{"internalType":"uint32","name":"chainId","type":"uint32"},{"internalType":"uint256","name":"superformId","type":"uint256"},{"internalType":"contract ISharePriceOracle","name":"oracle","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint128","name":"totalDebt","type":"uint128"},{"internalType":"address","name":"vaultAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"controller","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"xChainWithdrawalQueue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
