编译器
0.8.21+commit.d9974bed
文件 1 的 38：Address.sol
pragma solidity ^0.8.20;
library Address {
error AddressInsufficientBalance(address account);
error AddressEmptyCode(address target);
error FailedInnerCall();
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
function _revert(bytes memory returndata) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
文件 2 的 38：AsyncVault.sol
pragma solidity 0.8.21;
import {
IERC7540,
IERC165,
IERC7540Redeem,
IERC7540Deposit
} from "./interfaces/IERC7540.sol";
import { ERC7540Receiver } from "./interfaces/ERC7540Receiver.sol";
import { IERC20, SafeERC20, Math, PermitParams } from "./SyncVault.sol";
import { SyncVault } from "./SyncVault.sol";
uint256 constant BPS_DIVIDER = 10_000;
using Math for uint256;
using SafeERC20 for IERC20;
struct EpochData {
uint256 totalSupplySnapshot;
uint256 totalAssetsSnapshot;
mapping(address => uint256) depositRequestBalance;
mapping(address => uint256) redeemRequestBalance;
}
struct SettleValues {
uint256 lastSavedBalance;
uint256 fees;
uint256 pendingRedeem;
uint256 sharesToMint;
uint256 pendingDeposit;
uint256 assetsToWithdraw;
uint256 totalAssetsSnapshot;
uint256 totalSupplySnapshot;
}
contract Silo {
constructor(IERC20 underlying) {
underlying.forceApprove(msg.sender, type(uint256).max);
}
}
contract AsyncVault is IERC7540, SyncVault {
uint256 public epochId;
address public treasury;
Silo public pendingSilo;
Silo public claimableSilo;
mapping(uint256 epochId => EpochData epoch) public epochs;
mapping(address user => uint256 epochId) public lastDepositRequestId;
mapping(address user => uint256 epochId) public lastRedeemRequestId;
event DecreaseDepositRequest(
uint256 indexed requestId,
address indexed owner,
uint256 indexed previousRequestedAssets,
uint256 newRequestedAssets
);
event DecreaseRedeemRequest(
uint256 indexed requestId,
address indexed owner,
uint256 indexed previousRequestedShares,
uint256 newRequestedShares
);
event ClaimDeposit(
uint256 indexed requestId,
address indexed owner,
address indexed receiver,
uint256 assets,
uint256 shares
);
event ClaimRedeem(
uint256 indexed requestId,
address indexed owner,
address indexed receiver,
uint256 assets,
uint256 shares
);
error ExceededMaxRedeemRequest(
address receiver, uint256 shares, uint256 maxShares
);
error ExceededMaxDepositRequest(
address receiver, uint256 assets, uint256 maxDeposit
);
error ReceiverFailed();
error ERC7540CantRequestDepositOnBehalfOf();
error NoClaimAvailable(address owner);
error InvalidTreasury();
constructor() SyncVault() {
_disableInitializers();
}
function initialize(
uint16 fees,
address owner,
address _treasury,
IERC20 underlying,
uint256 bootstrapAmount,
string memory name,
string memory symbol
)
public
initializer
{
super.initialize(fees, owner, underlying, bootstrapAmount, name, symbol);
epochId = 1;
setTreasury(_treasury);
pendingSilo = new Silo(underlying);
claimableSilo = new Silo(underlying);
}
function decreaseDepositRequest(uint256 assets)
external
whenClosed
whenNotPaused
{
address owner = _msgSender();
uint256 oldBalance = epochs[epochId].depositRequestBalance[owner];
epochs[epochId].depositRequestBalance[owner] -= assets;
_asset.safeTransferFrom(address(pendingSilo), owner, assets);
emit DecreaseDepositRequest(
epochId,
owner,
oldBalance,
epochs[epochId].depositRequestBalance[owner]
);
}
function decreaseRedeemRequest(uint256 shares)
external
whenClosed
whenNotPaused
{
address owner = _msgSender();
uint256 oldBalance = epochs[epochId].redeemRequestBalance[owner];
epochs[epochId].redeemRequestBalance[owner] -= shares;
_update(address(pendingSilo), owner, shares);
emit DecreaseRedeemRequest(
epochId,
owner,
oldBalance,
epochs[epochId].redeemRequestBalance[owner]
);
}
function setTreasury(address _treasury) public onlyOwner {
if (_treasury == address(0)) revert InvalidTreasury();
treasury = _treasury;
}
function close() external override onlyOwner {
if (!vaultIsOpen) revert VaultIsClosed();
if (totalAssets() == 0) revert VaultIsEmpty();
lastSavedBalance = totalAssets();
vaultIsOpen = false;
_asset.safeTransfer(owner(), lastSavedBalance);
emit EpochStart(block.timestamp, lastSavedBalance, totalSupply());
}
function open(uint256 assetReturned)
external
override
onlyOwner
whenNotPaused
whenClosed
{
(uint256 newBalance,) = _settle(assetReturned);
vaultIsOpen = true;
_asset.safeTransferFrom(owner(), address(this), newBalance);
}
function settle(uint256 newSavedBalance)
external
onlyOwner
whenNotPaused
whenClosed
{
(uint256 _lastSavedBalance, uint256 totalSupply) =
_settle(newSavedBalance);
emit EpochStart(block.timestamp, _lastSavedBalance, totalSupply);
}
function pendingRedeemRequest(address owner)
external
view
returns (uint256)
{
return epochs[epochId].redeemRequestBalance[owner];
}
function claimableRedeemRequest(address owner)
external
view
returns (uint256)
{
uint256 lastRequestId = lastRedeemRequestId[owner];
return isCurrentEpoch(lastRequestId)
? 0
: epochs[lastRequestId].redeemRequestBalance[owner];
}
function pendingDepositRequest(address owner)
external
view
returns (uint256 assets)
{
return epochs[epochId].depositRequestBalance[owner];
}
function claimableDepositRequest(address owner)
external
view
returns (uint256 assets)
{
uint256 lastRequestId = lastDepositRequestId[owner];
return isCurrentEpoch(lastRequestId)
? 0
: epochs[lastRequestId].depositRequestBalance[owner];
}
function totalPendingDeposits() external view returns (uint256) {
return vaultIsOpen ? 0 : _asset.balanceOf(address(pendingSilo));
}
function totalPendingRedeems() external view returns (uint256) {
return vaultIsOpen ? 0 : balanceOf(address(pendingSilo));
}
function totalClaimableShares() external view returns (uint256) {
return balanceOf(address(claimableSilo));
}
function totalClaimableAssets() external view returns (uint256) {
return _asset.balanceOf(address(claimableSilo));
}
function requestDeposit(
uint256 assets,
address receiver,
address owner,
bytes memory data
)
public
whenNotPaused
whenClosed
{
if (_msgSender() != owner) {
revert ERC7540CantRequestDepositOnBehalfOf();
}
if (previewClaimDeposit(receiver) > 0) {
_claimDeposit(receiver, receiver);
}
if (assets > maxDepositRequest(owner)) {
revert ExceededMaxDepositRequest(
receiver, assets, maxDepositRequest(owner)
);
}
_asset.safeTransferFrom(owner, address(pendingSilo), assets);
_createDepositRequest(assets, receiver, owner, data);
}
function requestRedeem(
uint256 shares,
address receiver,
address owner,
bytes memory data
)
public
whenNotPaused
whenClosed
{
if (_msgSender() != owner) {
_spendAllowance(owner, _msgSender(), shares);
}
if (previewClaimRedeem(receiver) > 0) {
_claimRedeem(receiver, receiver);
}
if (shares > maxRedeemRequest(owner)) {
revert ExceededMaxRedeemRequest(
receiver, shares, maxRedeemRequest(owner)
);
}
_update(owner, address(pendingSilo), shares);
_createRedeemRequest(shares, receiver, owner, data);
}
function claimDeposit(address receiver)
public
whenNotPaused
returns (uint256 shares)
{
return _claimDeposit(_msgSender(), receiver);
}
function claimRedeem(address receiver)
public
whenNotPaused
returns (uint256 assets)
{
return _claimRedeem(_msgSender(), receiver);
}
function requestDepositWithPermit(
uint256 assets,
address receiver,
bytes memory data,
PermitParams calldata permitParams
)
public
{
address _msgSender = _msgSender();
if (_asset.allowance(_msgSender, address(this)) < assets) {
execPermit(_msgSender, address(this), permitParams);
}
return requestDeposit(assets, receiver, _msgSender, data);
}
function maxDepositRequest(address) public view returns (uint256) {
return vaultIsOpen || paused() ? 0 : type(uint256).max;
}
function maxRedeemRequest(address owner) public view returns (uint256) {
return vaultIsOpen || paused() ? 0 : balanceOf(owner);
}
function previewClaimDeposit(address owner) public view returns (uint256) {
uint256 lastRequestId = lastDepositRequestId[owner];
uint256 assets = epochs[lastRequestId].depositRequestBalance[owner];
return _convertToShares(assets, lastRequestId, Math.Rounding.Floor);
}
function previewClaimRedeem(address owner) public view returns (uint256) {
uint256 lastRequestId = lastRedeemRequestId[owner];
uint256 shares = epochs[lastRequestId].redeemRequestBalance[owner];
return _convertToAssets(shares, lastRequestId, Math.Rounding.Floor);
}
function convertToShares(
uint256 assets,
uint256 _epochId
)
public
view
returns (uint256)
{
return _convertToShares(assets, _epochId, Math.Rounding.Floor);
}
function convertToAssets(
uint256 shares,
uint256 _epochId
)
public
view
returns (uint256)
{
return _convertToAssets(shares, _epochId, Math.Rounding.Floor);
}
function claimableDepositBalanceInAsset(address owner)
public
view
returns (uint256)
{
uint256 shares = previewClaimDeposit(owner);
return convertToAssets(shares);
}
function previewSettle(uint256 newSavedBalance)
public
view
returns (
uint256 assetsToOwner,
uint256 assetsToVault,
uint256 expectedAssetFromOwner,
SettleValues memory settleValues
)
{
uint256 _lastSavedBalance = lastSavedBalance;
_checkMaxDrawdown(_lastSavedBalance, newSavedBalance);
uint256 fees = _computeFees(_lastSavedBalance, newSavedBalance);
uint256 totalSupply = totalSupply();
_lastSavedBalance = newSavedBalance - fees;
address pendingSiloAddr = address(pendingSilo);
uint256 pendingRedeem = balanceOf(pendingSiloAddr);
uint256 pendingDeposit = _asset.balanceOf(pendingSiloAddr);
uint256 sharesToMint = pendingDeposit.mulDiv(
totalSupply + 1, _lastSavedBalance + 1, Math.Rounding.Floor
);
uint256 totalAssetsSnapshot = _lastSavedBalance;
uint256 totalSupplySnapshot = totalSupply;
uint256 assetsToWithdraw = pendingRedeem.mulDiv(
_lastSavedBalance + pendingDeposit + 1,
totalSupply + sharesToMint + 1,
Math.Rounding.Floor
);
settleValues = SettleValues({
lastSavedBalance: _lastSavedBalance + fees,
fees: fees,
pendingRedeem: pendingRedeem,
sharesToMint: sharesToMint,
pendingDeposit: pendingDeposit,
assetsToWithdraw: assetsToWithdraw,
totalAssetsSnapshot: totalAssetsSnapshot,
totalSupplySnapshot: totalSupplySnapshot
});
if (pendingDeposit > assetsToWithdraw) {
assetsToOwner = pendingDeposit - assetsToWithdraw;
} else if (pendingDeposit < assetsToWithdraw) {
assetsToVault = assetsToWithdraw - pendingDeposit;
}
expectedAssetFromOwner = fees + assetsToVault;
}
function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
return interfaceId == type(IERC165).interfaceId
|| interfaceId == type(IERC7540Redeem).interfaceId
|| interfaceId == type(IERC7540Deposit).interfaceId;
}
function _createDepositRequest(
uint256 assets,
address receiver,
address owner,
bytes memory data
)
internal
{
epochs[epochId].depositRequestBalance[receiver] += assets;
if (lastDepositRequestId[receiver] != epochId) {
lastDepositRequestId[receiver] = epochId;
}
if (
data.length > 0
&& ERC7540Receiver(receiver).onERC7540DepositReceived(
_msgSender(), owner, epochId, assets, data
) != ERC7540Receiver.onERC7540DepositReceived.selector
) revert ReceiverFailed();
emit DepositRequest(receiver, owner, epochId, _msgSender(), assets);
}
function _createRedeemRequest(
uint256 shares,
address receiver,
address owner,
bytes memory data
)
internal
{
epochs[epochId].redeemRequestBalance[receiver] += shares;
if (lastRedeemRequestId[receiver] != epochId) {
lastRedeemRequestId[receiver] = epochId;
}
if (
data.length > 0
&& ERC7540Receiver(receiver).onERC7540RedeemReceived(
_msgSender(), owner, epochId, shares, data
) != ERC7540Receiver.onERC7540RedeemReceived.selector
) revert ReceiverFailed();
emit RedeemRequest(receiver, owner, epochId, _msgSender(), shares);
}
function _claimDeposit(
address owner,
address receiver
)
internal
returns (uint256 shares)
{
uint256 lastRequestId = lastDepositRequestId[owner];
if (lastRequestId == epochId) revert NoClaimAvailable(owner);
shares = previewClaimDeposit(owner);
uint256 assets = epochs[lastRequestId].depositRequestBalance[owner];
epochs[lastRequestId].depositRequestBalance[owner] = 0;
_update(address(claimableSilo), receiver, shares);
emit ClaimDeposit(lastRequestId, owner, receiver, assets, shares);
}
function _claimRedeem(
address owner,
address receiver
)
internal
whenNotPaused
returns (uint256 assets)
{
uint256 lastRequestId = lastRedeemRequestId[owner];
if (lastRequestId == epochId) revert NoClaimAvailable(owner);
assets = previewClaimRedeem(owner);
uint256 shares = epochs[lastRequestId].redeemRequestBalance[owner];
epochs[lastRequestId].redeemRequestBalance[owner] = 0;
_asset.safeTransferFrom(address(claimableSilo), receiver, assets);
emit ClaimRedeem(lastRequestId, owner, receiver, assets, shares);
}
function _settle(uint256 newSavedBalance)
internal
returns (uint256, uint256)
{
(
uint256 assetsToOwner,
uint256 assetsToVault,
,
SettleValues memory settleValues
) = previewSettle(newSavedBalance);
emit EpochEnd(
block.timestamp,
lastSavedBalance,
newSavedBalance,
settleValues.fees,
totalSupply()
);
_asset.safeTransferFrom(owner(), treasury, settleValues.fees);
_burn(address(pendingSilo), settleValues.pendingRedeem);
_mint(address(claimableSilo), settleValues.sharesToMint);
if (settleValues.pendingDeposit > settleValues.assetsToWithdraw) {
_asset.safeTransferFrom(
address(pendingSilo), owner(), assetsToOwner
);
if (settleValues.assetsToWithdraw > 0) {
_asset.safeTransferFrom(
address(pendingSilo),
address(claimableSilo),
settleValues.assetsToWithdraw
);
}
} else if (settleValues.pendingDeposit < settleValues.assetsToWithdraw)
{
_asset.safeTransferFrom(
owner(), address(claimableSilo), assetsToVault
);
if (settleValues.pendingDeposit > 0) {
_asset.safeTransferFrom(
address(pendingSilo),
address(claimableSilo),
settleValues.pendingDeposit
);
}
} else if (settleValues.pendingDeposit > 0) {
_asset.safeTransferFrom(
address(pendingSilo),
address(claimableSilo),
settleValues.assetsToWithdraw
);
}
emit Deposit(
address(pendingSilo),
address(claimableSilo),
settleValues.pendingDeposit,
settleValues.sharesToMint
);
emit Withdraw(
address(pendingSilo),
address(claimableSilo),
address(pendingSilo),
settleValues.assetsToWithdraw,
settleValues.pendingRedeem
);
settleValues.lastSavedBalance = settleValues.lastSavedBalance
- settleValues.fees + settleValues.pendingDeposit
- settleValues.assetsToWithdraw;
lastSavedBalance = settleValues.lastSavedBalance;
epochs[epochId].totalSupplySnapshot =
settleValues.totalSupplySnapshot;
epochs[epochId].totalAssetsSnapshot =
settleValues.totalAssetsSnapshot;
epochId++;
return (settleValues.lastSavedBalance, totalSupply());
}
function isCurrentEpoch(uint256 requestId) internal view returns (bool) {
return requestId == epochId;
}
function _convertToShares(
uint256 assets,
uint256 requestId,
Math.Rounding rounding
)
internal
view
returns (uint256)
{
if (isCurrentEpoch(requestId)) return 0;
uint256 totalAssets = epochs[requestId].totalAssetsSnapshot + 1;
uint256 totalSupply = epochs[requestId].totalSupplySnapshot + 1;
return assets.mulDiv(totalSupply, totalAssets, rounding);
}
function _convertToAssets(
uint256 shares,
uint256 requestId,
Math.Rounding rounding
)
internal
view
returns (uint256)
{
if (isCurrentEpoch(requestId)) return 0;
uint256 totalSupply = epochs[requestId].totalSupplySnapshot + 1;
uint256 totalAssets = epochs[requestId].totalAssetsSnapshot + 1;
return shares.mulDiv(totalAssets, totalSupply, rounding);
}
function _checkMaxDrawdown(
uint256 _lastSavedBalance,
uint256 newSavedBalance
)
internal
view
{
if (
newSavedBalance
< _lastSavedBalance.mulDiv(
BPS_DIVIDER - _maxDrawdown, BPS_DIVIDER, Math.Rounding.Ceil
)
) revert MaxDrawdownReached();
}
function _computeFees(
uint256 _lastSavedBalance,
uint256 newSavedBalance
)
internal
view
returns (uint256 fees)
{
if (newSavedBalance > _lastSavedBalance && feesInBps > 0) {
uint256 profits;
unchecked {
profits = newSavedBalance - _lastSavedBalance;
}
fees = (profits).mulDiv(feesInBps, BPS_DIVIDER, Math.Rounding.Floor);
}
}
}
文件 3 的 38：Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 4 的 38：ContextUpgradeable.sol
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 5 的 38：ECDSA.sol
pragma solidity ^0.8.20;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
error ECDSAInvalidSignature();
error ECDSAInvalidSignatureLength(uint256 length);
error ECDSAInvalidSignatureS(bytes32 s);
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
文件 6 的 38：EIP712.sol
pragma solidity ^0.8.20;
import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
文件 7 的 38：EIP712Upgradeable.sol
pragma solidity ^0.8.20;
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
struct EIP712Storage {
bytes32 _hashedName;
bytes32 _hashedVersion;
string _name;
string _version;
}
bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;
function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
assembly {
$.slot := EIP712StorageLocation
}
}
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
EIP712Storage storage $ = _getEIP712Storage();
$._name = name;
$._version = version;
$._hashedName = 0;
$._hashedVersion = 0;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator();
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
EIP712Storage storage $ = _getEIP712Storage();
require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._name;
}
function _EIP712Version() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._version;
}
function _EIP712NameHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory name = _EIP712Name();
if (bytes(name).length > 0) {
return keccak256(bytes(name));
} else {
bytes32 hashedName = $._hashedName;
if (hashedName != 0) {
return hashedName;
} else {
return keccak256("");
}
}
}
function _EIP712VersionHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory version = _EIP712Version();
if (bytes(version).length > 0) {
return keccak256(bytes(version));
} else {
bytes32 hashedVersion = $._hashedVersion;
if (hashedVersion != 0) {
return hashedVersion;
} else {
return keccak256("");
}
}
}
}
文件 8 的 38：ERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
_totalSupply -= value;
}
} else {
unchecked {
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
文件 9 的 38：ERC20PausableUpgradeable.sol
pragma solidity ^0.8.20;
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {PausableUpgradeable} from "../../../utils/PausableUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";
abstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {
function __ERC20Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __ERC20Pausable_init_unchained() internal onlyInitializing {
}
function _update(address from, address to, uint256 value) internal virtual override whenNotPaused {
super._update(from, to, value);
}
}
文件 10 的 38：ERC20Permit.sol
pragma solidity ^0.8.20;
import {IERC20Permit} from "./IERC20Permit.sol";
import {ERC20} from "../ERC20.sol";
import {ECDSA} from "../../../utils/cryptography/ECDSA.sol";
import {EIP712} from "../../../utils/cryptography/EIP712.sol";
import {Nonces} from "../../../utils/Nonces.sol";
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
bytes32 private constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
error ERC2612ExpiredSignature(uint256 deadline);
error ERC2612InvalidSigner(address signer, address owner);
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (block.timestamp > deadline) {
revert ERC2612ExpiredSignature(deadline);
}
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
if (signer != owner) {
revert ERC2612InvalidSigner(signer, owner);
}
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {
return super.nonces(owner);
}
function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
return _domainSeparatorV4();
}
}
文件 11 的 38：ERC20PermitUpgradeable.sol
pragma solidity ^0.8.20;
import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712Upgradeable} from "../../../utils/cryptography/EIP712Upgradeable.sol";
import {NoncesUpgradeable} from "../../../utils/NoncesUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20Permit, EIP712Upgradeable, NoncesUpgradeable {
bytes32 private constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
error ERC2612ExpiredSignature(uint256 deadline);
error ERC2612InvalidSigner(address signer, address owner);
function __ERC20Permit_init(string memory name) internal onlyInitializing {
__EIP712_init_unchained(name, "1");
}
function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (block.timestamp > deadline) {
revert ERC2612ExpiredSignature(deadline);
}
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
if (signer != owner) {
revert ERC2612InvalidSigner(signer, owner);
}
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override(IERC20Permit, NoncesUpgradeable) returns (uint256) {
return super.nonces(owner);
}
function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
return _domainSeparatorV4();
}
}
文件 12 的 38：ERC20Upgradeable.sol
pragma solidity ^0.8.20;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
struct ERC20Storage {
mapping(address account => uint256) _balances;
mapping(address account => mapping(address spender => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
}
bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;
function _getERC20Storage() private pure returns (ERC20Storage storage $) {
assembly {
$.slot := ERC20StorageLocation
}
}
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC20Storage storage $ = _getERC20Storage();
$._name = name_;
$._symbol = symbol_;
}
function name() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._name;
}
function symbol() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._balances[account];
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
function allowance(address owner, address spender) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._allowances[owner][spender];
}
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
function _update(address from, address to, uint256 value) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (from == address(0)) {
$._totalSupply += value;
} else {
uint256 fromBalance = $._balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
$._balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
$._totalSupply -= value;
}
} else {
unchecked {
$._balances[to] += value;
}
}
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
$._allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
文件 13 的 38：ERC7540Receiver.sol
pragma solidity 0.8.21;
interface ERC7540Receiver {
function onERC7540DepositReceived(
address operator,
address owner,
uint256 requestId,
uint256 assets,
bytes memory data
)
external
returns (bytes4);
function onERC7540RedeemReceived(
address operator,
address owner,
uint256 requestId,
uint256 shares,
bytes memory data
)
external
returns (bytes4);
}
文件 14 的 38：IERC20.sol
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
文件 15 的 38：IERC20Metadata.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 16 的 38：IERC20Permit.sol
pragma solidity ^0.8.20;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 17 的 38：IERC4626.sol
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/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);
}
文件 18 的 38：IERC5267.sol
pragma solidity ^0.8.20;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 19 的 38：IERC7540.sol
pragma solidity 0.8.21;
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
interface IERC7540Deposit {
event DepositRequest(
address indexed receiver,
address indexed owner,
uint256 indexed requestId,
address sender,
uint256 assets
);
function requestDeposit(
uint256 assets,
address receiver,
address owner,
bytes memory data
)
external;
function pendingDepositRequest(address owner)
external
view
returns (uint256 assets);
}
interface IERC7540Redeem {
event RedeemRequest(
address indexed receiver,
address indexed owner,
uint256 indexed requestId,
address sender,
uint256 shares
);
function requestRedeem(
uint256 shares,
address operator,
address owner,
bytes memory data
)
external;
function pendingRedeemRequest(address owner)
external
view
returns (uint256 shares);
}
interface IERC7540 is IERC7540Deposit, IERC7540Redeem, IERC4626, IERC165 { }
文件 20 的 38：Initializable.sol
pragma solidity ^0.8.20;
abstract contract Initializable {
struct InitializableStorage {
uint64 _initialized;
bool _initializing;
}
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
error InvalidInitialization();
error NotInitializing();
event Initialized(uint64 version);
modifier initializer() {
InitializableStorage storage $ = _getInitializableStorage();
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint64 version) {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
_checkInitializing();
_;
}
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
function _disableInitializers() internal virtual {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
文件 21 的 38：Math.sol
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
文件 22 的 38：MessageHashUtils.sol
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
library MessageHashUtils {
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
文件 23 的 38：Nonces.sol
pragma solidity ^0.8.20;
abstract contract Nonces {
error InvalidAccountNonce(address account, uint256 currentNonce);
mapping(address account => uint256) private _nonces;
function nonces(address owner) public view virtual returns (uint256) {
return _nonces[owner];
}
function _useNonce(address owner) internal virtual returns (uint256) {
unchecked {
return _nonces[owner]++;
}
}
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}
文件 24 的 38：NoncesUpgradeable.sol
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract NoncesUpgradeable is Initializable {
error InvalidAccountNonce(address account, uint256 currentNonce);
struct NoncesStorage {
mapping(address account => uint256) _nonces;
}
bytes32 private constant NoncesStorageLocation = 0x5ab42ced628888259c08ac98db1eb0cf702fc1501344311d8b100cd1bfe4bb00;
function _getNoncesStorage() private pure returns (NoncesStorage storage $) {
assembly {
$.slot := NoncesStorageLocation
}
}
function __Nonces_init() internal onlyInitializing {
}
function __Nonces_init_unchained() internal onlyInitializing {
}
function nonces(address owner) public view virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
return $._nonces[owner];
}
function _useNonce(address owner) internal virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
unchecked {
return $._nonces[owner]++;
}
}
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}
文件 25 的 38：Ownable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 26 的 38：Ownable2Step.sol
pragma solidity ^0.8.20;
import {Ownable} from "./Ownable.sol";
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
文件 27 的 38：Ownable2StepUpgradeable.sol
pragma solidity ^0.8.20;
import {OwnableUpgradeable} from "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
struct Ownable2StepStorage {
address _pendingOwner;
}
bytes32 private constant Ownable2StepStorageLocation = 0x237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00;
function _getOwnable2StepStorage() private pure returns (Ownable2StepStorage storage $) {
assembly {
$.slot := Ownable2StepStorageLocation
}
}
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function __Ownable2Step_init() internal onlyInitializing {
}
function __Ownable2Step_init_unchained() internal onlyInitializing {
}
function pendingOwner() public view virtual returns (address) {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
return $._pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
$._pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
delete $._pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
文件 28 的 38：OwnableUpgradeable.sol
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
struct OwnableStorage {
address _owner;
}
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 29 的 38：Pausable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Pausable is Context {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 30 的 38：PausableUpgradeable.sol
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
struct PausableStorage {
bool _paused;
}
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}
文件 31 的 38：SafeERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
error SafeERC20FailedOperation(address token);
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
文件 32 的 38：ShortStrings.sol
pragma solidity ^0.8.20;
import {StorageSlot} from "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 33 的 38：SignedMath.sol
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 34 的 38：StorageSlot.sol
pragma solidity ^0.8.20;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 35 的 38：Strings.sol
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 36 的 38：SyncVault.sol
pragma solidity 0.8.21;
import { Ownable2StepUpgradeable } from
"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import {
ERC20Upgradeable,
IERC20
} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import { IERC20Metadata } from
"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { ERC20PermitUpgradeable } from
"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol";
import { ERC20PausableUpgradeable } from
"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol";
import { SafeERC20 } from
"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Initializable } from
"@openzeppelin/contracts/proxy/utils/Initializable.sol";
import { ERC20Permit } from
"@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
using Math for uint256;
using SafeERC20 for IERC20;
struct PermitParams {
uint256 value;
uint256 deadline;
uint8 v;
bytes32 r;
bytes32 s;
}
uint16 constant MAX_FEES = 3000;
abstract contract SyncVault is
IERC4626,
Ownable2StepUpgradeable,
ERC20PermitUpgradeable,
ERC20PausableUpgradeable
{
uint16 public feesInBps;
uint16 internal _maxDrawdown;
uint8 private _underlyingDecimals;
IERC20 internal _asset;
bool public vaultIsOpen;
uint256 public lastSavedBalance;
event EpochStart(
uint256 indexed timestamp, uint256 lastSavedBalance, uint256 totalShares
);
event EpochEnd(
uint256 indexed timestamp,
uint256 lastSavedBalance,
uint256 returnedAssets,
uint256 fees,
uint256 totalShares
);
event FeesChanged(uint16 oldFees, uint16 newFees);
error VaultIsClosed();
error VaultIsOpen();
error FeesTooHigh();
error ERC4626ExceededMaxDeposit(
address receiver, uint256 assets, uint256 max
);
error ERC4626ExceededMaxMint(address receiver, uint256 shares, uint256 max);
error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max);
error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max);
error VaultIsEmpty();
error MaxDrawdownReached();
error PermitFailed();
modifier whenClosed() {
if (vaultIsOpen) revert VaultIsOpen();
_;
}
constructor() {
_disableInitializers();
}
function initialize(
uint16 fees,
address owner,
IERC20 underlying,
uint256 bootstrapAmount,
string memory name,
string memory symbol
)
public
virtual
onlyInitializing
{
if (fees > MAX_FEES) revert FeesTooHigh();
feesInBps = fees;
vaultIsOpen = true;
_maxDrawdown = 3000;
_asset = underlying;
_underlyingDecimals =
uint8(IERC20Metadata(address(underlying)).decimals());
__ERC20_init(name, symbol);
__Ownable_init(owner);
__ERC20Permit_init(name);
__ERC20Pausable_init();
deposit(bootstrapAmount, owner);
}
function withdraw(
uint256 assets,
address receiver,
address owner
)
external
whenNotPaused
returns (uint256)
{
uint256 maxAssets = maxWithdraw(owner);
if (assets > maxAssets) {
revert ERC4626ExceededMaxWithdraw(owner, assets, maxAssets);
}
uint256 sharesAmount = previewWithdraw(assets);
_withdraw(_msgSender(), receiver, owner, assets, sharesAmount);
return sharesAmount;
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function setFee(uint16 newFee) external onlyOwner {
if (!vaultIsOpen) revert VaultIsClosed();
if (newFee > MAX_FEES) revert FeesTooHigh();
feesInBps = newFee;
emit FeesChanged(feesInBps, newFee);
}
function setMaxDrawdown(uint16 newMaxDrawdown) external onlyOwner {
if (newMaxDrawdown > 10_000) revert MaxDrawdownReached();
_maxDrawdown = newMaxDrawdown;
}
function open(uint256 assetReturned) external virtual;
function close() external virtual;
function depositWithPermit(
uint256 assets,
address receiver,
PermitParams calldata permitParams
)
external
returns (uint256)
{
address _msgSender = _msgSender();
if (_asset.allowance(_msgSender, address(this)) < assets) {
execPermit(_msgSender, address(this), permitParams);
}
return deposit(assets, receiver);
}
function deposit(
uint256 assets,
address receiver
)
public
whenNotPaused
returns (uint256)
{
uint256 maxAssets = maxDeposit(receiver);
if (assets > maxAssets) {
revert ERC4626ExceededMaxDeposit(receiver, assets, maxAssets);
}
uint256 sharesAmount = previewDeposit(assets);
_deposit(_msgSender(), receiver, assets, sharesAmount);
return sharesAmount;
}
function mint(
uint256 shares,
address receiver
)
public
whenNotPaused
returns (uint256)
{
uint256 maxShares = maxMint(receiver);
if (shares > maxShares) {
revert ERC4626ExceededMaxMint(receiver, shares, maxShares);
}
uint256 assetsAmount = previewMint(shares);
_deposit(_msgSender(), receiver, assetsAmount, shares);
return assetsAmount;
}
function redeem(
uint256 shares,
address receiver,
address owner
)
public
whenNotPaused
returns (uint256)
{
uint256 maxShares = maxRedeem(owner);
if (shares > maxShares) {
revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);
}
uint256 assetsAmount = previewRedeem(shares);
_withdraw(_msgSender(), receiver, owner, assetsAmount, shares);
return assetsAmount;
}
function asset() public view returns (address) {
return address(_asset);
}
function convertToShares(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Floor);
}
function sharesBalanceInAsset(address owner)
public
view
returns (uint256)
{
return convertToAssets(balanceOf(owner));
}
function convertToAssets(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Floor);
}
function maxDeposit(address) public view returns (uint256) {
return vaultIsOpen && !paused() ? type(uint256).max : 0;
}
function maxMint(address) public view returns (uint256) {
return vaultIsOpen && !paused() ? type(uint256).max : 0;
}
function maxWithdraw(address owner) public view returns (uint256) {
return vaultIsOpen && !paused()
? _convertToAssets(balanceOf(owner), Math.Rounding.Floor)
: 0;
}
function maxRedeem(address owner) public view returns (uint256) {
return vaultIsOpen && !paused() ? balanceOf(owner) : 0;
}
function previewDeposit(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Floor);
}
function previewMint(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Ceil);
}
function previewWithdraw(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Ceil);
}
function previewRedeem(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Floor);
}
function totalAssets() public view returns (uint256) {
if (vaultIsOpen) return _asset.balanceOf(address(this));
else return _asset.balanceOf(address(this)) + lastSavedBalance;
}
function _deposit(
address caller,
address receiver,
uint256 assets,
uint256 shares
)
internal
{
_asset.safeTransferFrom(caller, address(this), assets);
_mint(receiver, shares);
emit Deposit(caller, receiver, assets, shares);
}
function _withdraw(
address caller,
address receiver,
address owner,
uint256 assets,
uint256 shares
)
internal
{
if (caller != owner) _spendAllowance(owner, caller, shares);
_burn(owner, shares);
_asset.safeTransfer(receiver, assets);
emit Withdraw(caller, receiver, owner, assets, shares);
}
function _update(
address from,
address to,
uint256 value
)
internal
virtual
override(ERC20Upgradeable, ERC20PausableUpgradeable)
{
ERC20PausableUpgradeable._update(from, to, value);
}
function execPermit(
address owner,
address spender,
PermitParams calldata permitParams
)
internal
{
ERC20Permit(address(_asset)).permit(
owner,
spender,
permitParams.value,
permitParams.deadline,
permitParams.v,
permitParams.r,
permitParams.s
);
if (_asset.allowance(owner, spender) != permitParams.value) {
revert PermitFailed();
}
}
function _convertToShares(
uint256 assets,
Math.Rounding rounding
)
internal
view
returns (uint256)
{
return assets.mulDiv(totalSupply() + 1, totalAssets() + 1, rounding);
}
function _convertToAssets(
uint256 shares,
Math.Rounding rounding
)
internal
view
returns (uint256)
{
return shares.mulDiv(totalAssets() + 1, totalSupply() + 1, rounding);
}
function decimals()
public
view
virtual
override(ERC20Upgradeable, IERC20Metadata)
returns (uint8)
{
return _underlyingDecimals;
}
}
文件 37 的 38：VaultZapper.sol
pragma solidity 0.8.21;
import {
Ownable2Step,
Ownable
} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import { Pausable } from "@openzeppelin/contracts/utils/Pausable.sol";
import { SafeERC20 } from
"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { IERC7540, IERC4626 } from "./interfaces/IERC7540.sol";
import { PermitParams, AsyncVault } from "./AsyncVault.sol";
import { ERC20Permit } from
"@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
contract VaultZapper is Ownable2Step, Pausable {
using SafeERC20 for IERC20;
using Address for address payable;
mapping(IERC4626 vault => bool isAuthorized) public authorizedVaults;
mapping(address routerAddress => bool isAuthorized) public authorizedRouters;
event ZapAndRequestDeposit(
IERC7540 indexed vault,
address indexed router,
IERC20 tokenIn,
uint256 amount
);
event ZapAndDeposit(
IERC4626 indexed vault,
address indexed router,
IERC20 tokenIn,
uint256 amount,
uint256 shares
);
event RouterApproved(address indexed router, IERC20 indexed token);
event RouterAuthorized(address indexed router, bool allowed);
event VaultAuthorized(IERC4626 indexed vault, bool allowed);
error NotRouter(address router);
error NotVault(IERC4626 vault);
error SwapFailed(string reason);
error InconsistantSwapData(
uint256 expectedTokenInBalance, uint256 actualTokenInBalance
);
error NotEnoughSharesMinted(uint256 sharesMinted, uint256 minSharesMinted);
error NotEnoughUnderlying(
uint256 previewedUnderlying, uint256 withdrawedUnderlying
);
error NullMinShares();
error PermitFailed();
modifier onlyAllowedRouter(address router) {
if (!authorizedRouters[router]) revert NotRouter(router);
_;
}
modifier onlyAllowedVault(IERC4626 vault) {
if (!authorizedVaults[vault]) revert NotVault(vault);
_;
}
constructor() Ownable(_msgSender()) { }
function withdrawToken(IERC20 token) external onlyOwner {
token.safeTransfer(_msgSender(), token.balanceOf(address(this)));
}
function withdrawNativeToken() external onlyOwner {
payable(_msgSender()).sendValue(address(this).balance);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function approveTokenForRouter(
IERC20 token,
address router
)
public
onlyOwner
onlyAllowedRouter(router)
{
token.forceApprove(router, type(uint256).max);
emit RouterApproved(router, token);
}
function toggleRouterAuthorization(address router) public onlyOwner {
bool authorized = !authorizedRouters[router];
authorizedRouters[router] = authorized;
emit RouterAuthorized(router, authorized);
}
function toggleVaultAuthorization(IERC7540 vault) public onlyOwner {
bool authorized = !authorizedVaults[vault];
IERC20(vault.asset()).forceApprove(
address(vault), authorized ? type(uint256).max : 0
);
authorizedVaults[vault] = authorized;
emit VaultAuthorized(vault, authorized);
}
function _zapIn(
IERC20 tokenIn,
address router,
uint256 amount,
bytes calldata data
)
internal
{
uint256 expectedBalance;
if (msg.value == 0) {
expectedBalance = tokenIn.balanceOf(address(this));
_transferTokenInAndApprove(router, tokenIn, amount);
} else {
expectedBalance = address(this).balance - msg.value;
}
_executeZap(router, data);
uint256 balanceAfterZap = msg.value == 0
? tokenIn.balanceOf(address(this))
: address(this).balance;
if (balanceAfterZap > expectedBalance) {
revert InconsistantSwapData({
expectedTokenInBalance: expectedBalance,
actualTokenInBalance: balanceAfterZap
});
}
}
function _transferTokenInAndApprove(
address router,
IERC20 tokenIn,
uint256 amount
)
internal
{
tokenIn.safeTransferFrom(_msgSender(), address(this), amount);
if (tokenIn.allowance(address(this), router) < amount) {
tokenIn.forceApprove(router, amount);
}
}
function zapAndDeposit(
IERC20 tokenIn,
IERC4626 vault,
address router,
uint256 amount,
bytes calldata data
)
public
payable
onlyAllowedRouter(router)
onlyAllowedVault(vault)
whenNotPaused
returns (uint256)
{
uint256 initialTokenOutBalance =
IERC20(vault.asset()).balanceOf(address(this));
_zapIn(tokenIn, router, amount, data);
uint256 shares = vault.deposit(
IERC20(vault.asset()).balanceOf(address(this))
- initialTokenOutBalance,
_msgSender()
);
emit ZapAndDeposit({
vault: vault,
router: router,
tokenIn: tokenIn,
amount: amount,
shares: shares
});
return shares;
}
function zapAndRequestDeposit(
IERC20 tokenIn,
IERC7540 vault,
address router,
uint256 amountIn,
bytes calldata swapData,
bytes calldata callback7540Data
)
public
payable
onlyAllowedRouter(router)
onlyAllowedVault(vault)
whenNotPaused
{
uint256 initialTokenOutBalance =
IERC20(vault.asset()).balanceOf(address(this));
_zapIn(tokenIn, router, amountIn, swapData);
vault.requestDeposit(
IERC20(vault.asset()).balanceOf(address(this))
- initialTokenOutBalance,
_msgSender(),
address(this),
callback7540Data
);
emit ZapAndRequestDeposit({
vault: vault,
router: router,
tokenIn: tokenIn,
amount: amountIn
});
}
function zapAndDepositWithPermit(
IERC20 tokenIn,
IERC4626 vault,
address router,
uint256 amount,
bytes calldata swapData,
PermitParams calldata permitParams
)
public
returns (uint256)
{
if (tokenIn.allowance(_msgSender(), address(this)) < amount) {
_execPermit(tokenIn, _msgSender(), address(this), permitParams);
}
return zapAndDeposit(tokenIn, vault, router, amount, swapData);
}
function zapAndRequestDepositWithPermit(
IERC20 tokenIn,
IERC7540 vault,
address router,
uint256 amount,
bytes calldata swapData,
PermitParams calldata permitParams,
bytes calldata callback7540Data
)
public
{
if (tokenIn.allowance(_msgSender(), address(this)) < amount) {
_execPermit(tokenIn, _msgSender(), address(this), permitParams);
}
zapAndRequestDeposit(
tokenIn, vault, router, amount, swapData, callback7540Data
);
}
function _executeZap(
address target,
bytes memory data
)
internal
returns (bytes memory response)
{
(bool success, bytes memory _data) =
target.call{ value: msg.value }(data);
if (!success) {
if (data.length > 0) revert SwapFailed(string(_data));
else revert SwapFailed("Unknown reason");
}
return _data;
}
function _execPermit(
IERC20 token,
address owner,
address spender,
PermitParams calldata permitParams
)
internal
{
ERC20Permit(address(token)).permit(
owner,
spender,
permitParams.value,
permitParams.deadline,
permitParams.v,
permitParams.r,
permitParams.s
);
if (token.allowance(owner, spender) != permitParams.value) {
revert PermitFailed();
}
}
}
文件 38 的 38：draft-IERC6093.sol
pragma solidity ^0.8.20;
interface IERC20Errors {
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
interface IERC721Errors {
error ERC721InvalidOwner(address owner);
error ERC721NonexistentToken(uint256 tokenId);
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
error ERC721InvalidSender(address sender);
error ERC721InvalidReceiver(address receiver);
error ERC721InsufficientApproval(address operator, uint256 tokenId);
error ERC721InvalidApprover(address approver);
error ERC721InvalidOperator(address operator);
}
interface IERC1155Errors {
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
error ERC1155InvalidSender(address sender);
error ERC1155InvalidReceiver(address receiver);
error ERC1155MissingApprovalForAll(address operator, address owner);
error ERC1155InvalidApprover(address approver);
error ERC1155InvalidOperator(address operator);
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
{
"compilationTarget": {
"src/VaultZapper.sol": "VaultZapper"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 10000
},
"remappings": [
":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
":@src/=src/",
":@test/=test/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
":permit2/=lib/permit2/",
":solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/",
":solmate/=lib/permit2/lib/solmate/"
]
}[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"expectedTokenInBalance","type":"uint256"},{"internalType":"uint256","name":"actualTokenInBalance","type":"uint256"}],"name":"InconsistantSwapData","type":"error"},{"inputs":[{"internalType":"uint256","name":"sharesMinted","type":"uint256"},{"internalType":"uint256","name":"minSharesMinted","type":"uint256"}],"name":"NotEnoughSharesMinted","type":"error"},{"inputs":[{"internalType":"uint256","name":"previewedUnderlying","type":"uint256"},{"internalType":"uint256","name":"withdrawedUnderlying","type":"uint256"}],"name":"NotEnoughUnderlying","type":"error"},{"inputs":[{"internalType":"address","name":"router","type":"address"}],"name":"NotRouter","type":"error"},{"inputs":[{"internalType":"contract IERC4626","name":"vault","type":"address"}],"name":"NotVault","type":"error"},{"inputs":[],"name":"NullMinShares","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"PermitFailed","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"string","name":"reason","type":"string"}],"name":"SwapFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"}],"name":"RouterApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"RouterAuthorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC4626","name":"vault","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"VaultAuthorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC4626","name":"vault","type":"address"},{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":false,"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"ZapAndDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC7540","name":"vault","type":"address"},{"indexed":true,"internalType":"address","name":"router","type":"address"},{"indexed":false,"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ZapAndRequestDeposit","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"router","type":"address"}],"name":"approveTokenForRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"routerAddress","type":"address"}],"name":"authorizedRouters","outputs":[{"internalType":"bool","name":"isAuthorized","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC4626","name":"vault","type":"address"}],"name":"authorizedVaults","outputs":[{"internalType":"bool","name":"isAuthorized","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"}],"name":"toggleRouterAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC7540","name":"vault","type":"address"}],"name":"toggleVaultAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawNativeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC4626","name":"vault","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"zapAndDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC4626","name":"vault","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"swapData","type":"bytes"},{"components":[{"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"}],"internalType":"struct PermitParams","name":"permitParams","type":"tuple"}],"name":"zapAndDepositWithPermit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC7540","name":"vault","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"bytes","name":"swapData","type":"bytes"},{"internalType":"bytes","name":"callback7540Data","type":"bytes"}],"name":"zapAndRequestDeposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC7540","name":"vault","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"swapData","type":"bytes"},{"components":[{"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"}],"internalType":"struct PermitParams","name":"permitParams","type":"tuple"},{"internalType":"bytes","name":"callback7540Data","type":"bytes"}],"name":"zapAndRequestDepositWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"}]
