编译器
0.8.17+commit.8df45f5f
文件 1 的 60：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 60：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 3 的 60：ArrayMapping.sol
pragma solidity 0.8.17;
library ArrayMappingUint256 {
function toArray(mapping(uint256 => uint256) storage _self, uint256 length)
external
view
returns (uint256[] memory)
{
uint256[] memory arrayOut = new uint256[](length);
for (uint256 i; i < length; ++i) {
arrayOut[i] = _self[i];
}
return arrayOut;
}
function setValues(mapping(uint256 => uint256) storage _self, uint256[] calldata values) external {
for (uint256 i; i < values.length; ++i) {
_self[i] = values[i];
}
}
}
library ArrayMappingAddress {
function toArray(mapping(uint256 => address) storage _self, uint256 length)
external
view
returns (address[] memory)
{
address[] memory arrayOut = new address[](length);
for (uint256 i; i < length; ++i) {
arrayOut[i] = _self[i];
}
return arrayOut;
}
function setValues(mapping(uint256 => address) storage _self, address[] calldata values) external {
for (uint256 i; i < values.length; ++i) {
_self[i] = values[i];
}
}
}
文件 4 的 60：BeaconProxy.sol
pragma solidity ^0.8.0;
import "./IBeacon.sol";
import "../Proxy.sol";
import "../ERC1967/ERC1967Upgrade.sol";
contract BeaconProxy is Proxy, ERC1967Upgrade {
constructor(address beacon, bytes memory data) payable {
_upgradeBeaconToAndCall(beacon, data, false);
}
function _beacon() internal view virtual returns (address) {
return _getBeacon();
}
function _implementation() internal view virtual override returns (address) {
return IBeacon(_getBeacon()).implementation();
}
function _setBeacon(address beacon, bytes memory data) internal virtual {
_upgradeBeaconToAndCall(beacon, data, false);
}
}
文件 5 的 60：CommonErrors.sol
pragma solidity 0.8.17;
error InvalidArrayLength();
error NotSameAssetGroup();
error ConfigurationAddressZero();
error InvalidConfiguration();
error ExchangeRateOutOfSlippages();
error InvalidStrategy(address address_);
error AddressNotContract(address address_);
error OnlyViewExecution(address address_);
文件 6 的 60：Constants.sol
pragma solidity 0.8.17;
uint256 constant SECONDS_IN_YEAR = 31_556_926;
int256 constant SECONDS_IN_YEAR_INT = 31_556_926;
uint256 constant FULL_PERCENT = 100_00;
int256 constant FULL_PERCENT_INT = 100_00;
int256 constant YIELD_FULL_PERCENT_INT = 10 ** 12;
uint256 constant YIELD_FULL_PERCENT = uint256(YIELD_FULL_PERCENT_INT);
uint256 constant MANAGEMENT_FEE_MAX = 5_00;
uint256 constant DEPOSIT_FEE_MAX = 5_00;
uint256 constant SV_PERFORMANCE_FEE_MAX = 20_00;
uint256 constant ECOSYSTEM_FEE_MAX = 20_00;
uint256 constant TREASURY_FEE_MAX = 10_00;
uint8 constant MAX_RISK_SCORE = 10_0;
uint8 constant MIN_RISK_SCORE = 1;
int8 constant MAX_RISK_TOLERANCE = 10;
int8 constant MIN_RISK_TOLERANCE = -10;
address constant STATIC_RISK_PROVIDER = address(0xaaa);
uint8 constant STATIC_RISK_SCORE = 1;
uint256 constant MAXIMAL_DEPOSIT_ID = 2 ** 255;
uint256 constant MAXIMAL_WITHDRAWAL_ID = 2 ** 256 - 1;
uint256 constant NFT_MINTED_SHARES = 10 ** 6;
uint256 constant STRATEGY_COUNT_CAP = 16;
uint256 constant MAX_DHW_BASE_YIELD_LIMIT = 10_00;
uint256 constant INITIAL_SHARE_MULTIPLIER = 1000;
uint256 constant INITIAL_LOCKED_SHARES = 10 ** 12;
address constant INITIAL_LOCKED_SHARES_ADDRESS = address(0xdead);
uint256 constant MAX_GUARD_COUNT = 10;
uint256 constant MAX_ACTION_COUNT = 10;
uint256 constant NULL_ASSET_GROUP_ID = 0;
文件 7 的 60：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 8 的 60：ContextUpgradeable.sol
pragma solidity ^0.8.0;
import "../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;
}
uint256[50] private __gap;
}
文件 9 的 60：CountersUpgradeable.sol
pragma solidity ^0.8.0;
library CountersUpgradeable {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
文件 10 的 60：ECDSAUpgradeable.sol
pragma solidity ^0.8.0;
import "../StringsUpgradeable.sol";
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 11 的 60：EIP712Upgradeable.sol
pragma solidity ^0.8.0;
import "./ECDSAUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
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 {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
文件 12 的 60：ERC1155Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
using AddressUpgradeable for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
function __ERC1155_init(string memory uri_) internal onlyInitializing {
__ERC1155_init_unchained(uri_);
}
function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC1155Upgradeable).interfaceId ||
interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
uint256[47] private __gap;
}
文件 13 的 60：ERC165Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
文件 14 的 60：ERC1967Upgrade.sol
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
abstract contract ERC1967Upgrade {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
文件 15 的 60：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => 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 override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 16 的 60：ERC20Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
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 {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
uint256[45] private __gap;
}
文件 17 的 60：IAccessControlUpgradeable.sol
pragma solidity ^0.8.0;
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 18 的 60：IAction.sol
pragma solidity 0.8.17;
import "./RequestType.sol";
error InvalidAction(address address_);
error ActionStatusAlreadySet();
error ActionsAlreadyInitialized(address smartVault);
error TooManyActions();
error WrongActionRequestType(RequestType requestType);
struct ActionContext {
address smartVault;
address recipient;
address executor;
address owner;
RequestType requestType;
address[] tokens;
uint256[] amounts;
}
interface IAction {
function executeAction(ActionContext calldata actionCtx) external;
}
interface IActionManager {
function setActions(address smartVault, IAction[] calldata actions, RequestType[] calldata requestTypes) external;
function runActions(ActionContext calldata actionCtx) external;
function whitelistAction(address action, bool whitelist) external;
event ActionListed(address indexed action, bool whitelisted);
event ActionSet(address indexed smartVault, address indexed action, RequestType requestType);
}
文件 19 的 60：IAssetGroupRegistry.sol
pragma solidity 0.8.17;
import "@openzeppelin/token/ERC20/IERC20.sol";
error InvalidAssetGroup(uint256 assetGroupId);
error NoAssetsProvided();
error TokenNotAllowed(address token);
error AssetGroupAlreadyExists(uint256 assetGroupId);
error UnsortedArray();
interface IAssetGroupRegistry {
event TokenAllowed(address indexed token);
event AssetGroupRegistered(uint256 indexed assetGroupId);
function isTokenAllowed(address token) external view returns (bool isAllowed);
function numberOfAssetGroups() external view returns (uint256 count);
function listAssetGroup(uint256 assetGroupId) external view returns (address[] memory assets);
function assetGroupLength(uint256 assetGroupId) external view returns (uint256 length);
function validateAssetGroup(uint256 assetGroupId) external view;
function checkAssetGroupExists(address[] calldata assets) external view returns (uint256);
function allowToken(address token) external;
function allowTokenBatch(address[] calldata tokens) external;
function registerAssetGroup(address[] calldata assets) external returns (uint256 id);
}
文件 20 的 60：IBeacon.sol
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
}
文件 21 的 60：IDepositManager.sol
pragma solidity 0.8.17;
import "./ISmartVault.sol";
import "../libraries/uint16a16Lib.sol";
error InvalidAssetLengths();
error InvalidNftArrayLength();
error NoDepositsToRecover();
error NotGhostVault();
struct DepositBag {
address smartVault;
uint256[] assets;
address receiver;
address referral;
bool doFlush;
}
struct DepositExtras {
address depositor;
address[] tokens;
address[] strategies;
uint16a16 allocations;
uint256 flushIndex;
}
struct SmartVaultFeesCollected {
uint256 depositFees;
uint256 performanceFees;
uint256 managementFees;
}
struct DepositSyncResult {
uint256 mintedSVTs;
uint256 dhwTimestamp;
uint256 feeSVTs;
SmartVaultFeesCollected feesCollected;
uint256 initialLockedSVTs;
uint256[] sstShares;
}
struct SimulateDepositParams {
address smartVault;
uint256[2] bag;
address[] strategies;
address[] assetGroup;
uint16a16 dhwIndexes;
uint16a16 dhwIndexesOld;
SmartVaultFees fees;
}
interface IDepositManager {
event SmartVaultTokensClaimed(
address indexed smartVault,
address indexed claimer,
uint256 claimedVaultTokens,
uint256[] nftIds,
uint256[] nftAmounts
);
event DepositInitiated(
address indexed smartVault,
address indexed receiver,
uint256 indexed depositId,
uint256 flushIndex,
uint256[] assets,
address depositor,
address referral
);
event PendingDepositsRecovered(address indexed smartVault, uint256[] recoveredAssets);
event SmartVaultFeesMinted(address indexed smartVault, SmartVaultFeesCollected smartVaultFeesCollected);
function syncDepositsSimulate(SimulateDepositParams calldata parameters)
external
view
returns (DepositSyncResult memory syncResult);
function syncDeposits(
address smartVault,
uint256[2] calldata bag,
address[] calldata strategies,
uint16a16[2] calldata dhwIndexes,
address[] calldata assetGroup,
SmartVaultFees calldata fees
) external returns (DepositSyncResult memory syncResult);
function depositAssets(DepositBag calldata bag, DepositExtras calldata bag2) external returns (uint256 nftId);
function flushSmartVault(
address smartVault,
uint256 flushIndex,
address[] calldata strategies,
uint16a16 allocations,
address[] calldata tokens
) external returns (uint16a16 dhwIndexes);
function getClaimedVaultTokensPreview(
address smartVaultAddress,
DepositMetadata memory data,
uint256 nftShares,
uint256 mintedSVTs,
address[] calldata tokens
) external view returns (uint256);
function smartVaultDeposits(address smartVault, uint256 flushIdx, uint256 assetGroupLength)
external
view
returns (uint256[] memory);
function claimSmartVaultTokens(
address smartVault,
uint256[] calldata nftIds,
uint256[] calldata nftAmounts,
address[] calldata tokens,
address owner,
address executor,
uint256 flushIndexToSync
) external returns (uint256 claimedTokens);
function recoverPendingDeposits(
address smartVault,
uint256 flushIndex,
address[] calldata strategies,
address[] calldata tokens,
address emergencyWallet
) external;
function getDepositRatio(address[] memory tokens, uint16a16 allocations, address[] memory strategies)
external
view
returns (uint256[] memory ratio);
}
文件 22 的 60：IERC1155MetadataURIUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC1155Upgradeable.sol";
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
function uri(uint256 id) external view returns (string memory);
}
文件 23 的 60：IERC1155ReceiverUpgradeable.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 24 的 60：IERC1155Upgradeable.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
interface IERC1155Upgradeable is IERC165Upgradeable {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 25 的 60：IERC165Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 26 的 60：IERC20.sol
pragma solidity ^0.8.0;
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 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 27 的 60：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../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);
}
文件 28 的 60：IERC20MetadataUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 29 的 60：IERC20Permit.sol
pragma solidity ^0.8.0;
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);
}
文件 30 的 60：IERC20Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC20Upgradeable {
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 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
文件 31 的 60：IGuardManager.sol
pragma solidity 0.8.17;
import "./ISmartVault.sol";
import "./RequestType.sol";
error GuardsAlreadyInitialized();
error GuardsNotInitialized();
error GuardError();
error GuardFailed(uint256 guardNum);
error InvalidGuardParamType(uint256 paramType);
error TooManyGuards();
error IncompleteGuardDefinition();
enum GuardParamType {
VaultAddress,
Executor,
Receiver,
Owner,
Assets,
Tokens,
AssetGroup,
CustomValue,
DynamicCustomValue
}
struct GuardDefinition {
string methodSignature;
address contractAddress;
bytes2 operator;
uint256 expectedValue;
GuardParamType[] methodParamTypes;
bytes[] methodParamValues;
}
struct RequestContext {
address receiver;
address executor;
address owner;
RequestType requestType;
uint256[] assets;
address[] tokens;
}
interface IGuardManager {
function runGuards(address smartVault, RequestContext calldata context) external view;
function readGuards(address smartVault, RequestType requestType)
external
view
returns (GuardDefinition[] memory guards);
function setGuards(address smartVault, GuardDefinition[][] calldata guards, RequestType[] calldata requestTypes)
external;
event GuardsInitialized(address indexed smartVault, GuardDefinition[][] guards, RequestType[] requestTypes);
}
文件 32 的 60：IRiskManager.sol
pragma solidity 0.8.17;
import "../libraries/uint16a16Lib.sol";
error InvalidRiskInputLength();
error RiskScoreValueOutOfBounds(uint8 value);
error RiskToleranceValueOutOfBounds(int8 value);
error CannotSetRiskScoreForGhostStrategy(uint8 riskScore);
error InvalidAllocationSum(uint256 allocationsSum);
error InvalidRiskScores(address riskProvider, address strategy);
interface IRiskManager {
function calculateAllocation(address smartVault, address[] calldata strategies)
external
view
returns (uint16a16 allocation);
function getRiskScores(address riskProvider, address[] memory strategy)
external
view
returns (uint8[] memory riskScores);
function getRiskProvider(address smartVault) external view returns (address riskProvider);
function getAllocationProvider(address smartVault) external view returns (address allocationProvider);
function getRiskTolerance(address smartVault) external view returns (int8 riskTolerance);
function setRiskProvider(address smartVault, address riskProvider_) external;
function setAllocationProvider(address smartVault, address allocationProvider) external;
function setRiskScores(uint8[] calldata riskScores, address[] calldata strategies) external;
function setRiskTolerance(address smartVault, int8 riskTolerance) external;
event RiskScoresUpdated(address indexed riskProvider, address[] strategies, uint8[] riskScores);
event RiskProviderSet(address indexed smartVault, address indexed riskProvider);
event AllocationProviderSet(address indexed smartVault, address indexed allocationProvider);
event RiskToleranceSet(address indexed smartVault, int8 riskTolerance);
}
文件 33 的 60：ISmartVault.sol
pragma solidity 0.8.17;
import "@openzeppelin-upgradeable/token/ERC1155/IERC1155Upgradeable.sol";
import "@openzeppelin-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin-upgradeable/token/ERC1155/extensions/IERC1155MetadataURIUpgradeable.sol";
import "./Constants.sol";
import "./RequestType.sol";
error DepositIdOverflow();
error WithdrawalIdOverflow();
error InvalidDepositNftId(uint256 depositNftId);
error InvalidWithdrawalNftId(uint256 withdrawalNftId);
error InvalidNftBalance(uint256 balance);
error InvalidNftTransferAmount(uint256 transferAmount);
error SenderEqualsRecipient();
struct DepositMetadata {
uint256[] assets;
uint256 initiated;
uint256 flushIndex;
}
struct WithdrawalMetadata {
uint256 vaultShares;
uint256 flushIndex;
}
struct SmartVaultFees {
uint16 managementFeePct;
uint16 depositFeePct;
uint16 performanceFeePct;
}
interface ISmartVault is IERC20Upgradeable, IERC1155MetadataURIUpgradeable {
function balanceOfFractional(address account, uint256 id) external view returns (uint256 fractionalBalance);
function balanceOfFractionalBatch(address account, uint256[] calldata ids)
external
view
returns (uint256[] memory fractionalBalances);
function assetGroupId() external view returns (uint256 id);
function vaultName() external view returns (string memory name);
function getMetadata(uint256[] calldata nftIds) external view returns (bytes[] memory metadata);
function setBaseURI(string memory uri_) external;
function mintVaultShares(address receiver, uint256 vaultShares) external;
function burnVaultShares(
address owner,
uint256 vaultShares,
address[] calldata strategies,
uint256[] calldata shares
) external;
function mintWithdrawalNFT(address receiver, WithdrawalMetadata calldata metadata) external returns (uint256 id);
function mintDepositNFT(address receiver, DepositMetadata calldata metadata) external returns (uint256 id);
function burnNFTs(address owner, uint256[] calldata nftIds, uint256[] calldata nftAmounts)
external
returns (bytes[] memory metadata);
function transferFromSpender(address from, address to, uint256 amount) external returns (bool success);
function claimShares(address claimer, uint256 amount) external;
event BaseURIChanged(string baseUri);
}
文件 34 的 60：ISmartVaultManager.sol
pragma solidity 0.8.17;
import "./IDepositManager.sol";
import "./ISmartVault.sol";
import "./ISwapper.sol";
import "./IWithdrawalManager.sol";
error InsufficientBalance(uint256 available, uint256 required);
error NothingToFlush();
error SmartVaultAlreadyRegistered();
error SmartVaultNotRegisteredYet();
error ManagementFeeTooLarge(uint256 mgmtFeePct);
error PerformanceFeeTooLarge(uint256 performanceFeePct);
error StaticAllocationSmartVault();
error DepositFeeTooLarge(uint256 depositFeePct);
error RedeemForNotAllowed();
error VaultNotSynced();
error GhostVault();
error ReallocationParametersExpired();
struct SmartVaultRegistrationForm {
uint256 assetGroupId;
address[] strategies;
uint16a16 strategyAllocation;
uint16 managementFeePct;
uint16 depositFeePct;
uint16 performanceFeePct;
}
struct ReallocateParamBag {
address[] smartVaults;
address[] strategies;
SwapInfo[][] swapInfo;
uint256[][] depositSlippages;
uint256[][] withdrawalSlippages;
uint256[2][] exchangeRateSlippages;
uint256 validUntil;
}
struct FlushIndex {
uint128 current;
uint128 toSync;
}
interface ISmartVaultRegistry {
function registerSmartVault(address smartVault, SmartVaultRegistrationForm calldata registrationForm) external;
}
interface ISmartVaultManager is ISmartVaultRegistry {
function dhwIndexes(address smartVault, uint256 flushIndex) external view returns (uint16a16 dhwIndexes);
function getLatestFlushIndex(address smartVault) external view returns (uint256 flushIndex);
function allocations(address smartVault) external view returns (uint16a16 allocation);
function strategies(address smartVault) external view returns (address[] memory strategies);
function assetGroupId(address smartVault) external view returns (uint256 assetGroupId);
function depositRatio(address smartVault) external view returns (uint256[] memory ratio);
function flushSmartVault(address smartVault) external;
function reallocate(ReallocateParamBag calldata reallocateParams) external;
function removeStrategyFromVaults(address strategy, address[] calldata vaults, bool disableStrategy) external;
function syncSmartVault(address smartVault, bool revertIfError) external;
function simulateSync(address smartVault)
external
view
returns (uint256 oldTotalSVTs, uint256 mintedSVTs, uint256 feeSVTs, uint256[] calldata sstShares);
function simulateSyncWithBurn(address smartVault, address userAddress, uint256[] calldata nftIds)
external
view
returns (uint256 svts);
function redeemFast(RedeemBag calldata bag, uint256[][] calldata withdrawalSlippages)
external
returns (uint256[] memory withdrawnAssets);
function redeemFastView(RedeemBag calldata bag, uint256[][] calldata withdrawalSlippages, address redeemer)
external
returns (uint256[] memory withdrawnAssets);
function claimWithdrawal(
address smartVault,
uint256[] calldata nftIds,
uint256[] calldata nftAmounts,
address receiver
) external returns (uint256[] memory assetAmounts, uint256 assetGroupId);
function claimSmartVaultTokens(address smartVaultAddress, uint256[] calldata nftIds, uint256[] calldata nftAmounts)
external
returns (uint256 claimedAmount);
function redeem(RedeemBag calldata bag, address receiver, bool doFlush) external returns (uint256 receipt);
function redeemFor(RedeemBag calldata bag, address owner, bool doFlush) external returns (uint256 receipt);
function deposit(DepositBag calldata bag) external returns (uint256 receipt);
function recoverPendingDeposits(address smartVault) external;
event SmartVaultFlushed(address indexed smartVault, uint256 flushIndex);
event SmartVaultSynced(address indexed smartVault, uint256 flushIndex);
event SmartVaultRegistered(address indexed smartVault, SmartVaultRegistrationForm registrationForm);
event StrategyRemovedFromVault(address indexed strategy, address indexed vault);
event SmartVaultReallocated(address indexed smartVault, uint16a16 newAllocations);
}
文件 35 的 60：ISpoolAccessControl.sol
pragma solidity 0.8.17;
import "@openzeppelin-upgradeable/access/IAccessControlUpgradeable.sol";
error MissingRole(bytes32 role, address account);
error SystemPaused();
error SmartVaultOwnerAlreadySet(address smartVault);
error ReentrantCall();
error NoReentrantRole();
interface ISpoolAccessControl is IAccessControlUpgradeable {
function smartVaultOwner(address smartVault) external view returns (address owner);
function hasSmartVaultRole(address smartVault, bytes32 role, address account)
external
view
returns (bool hasRole);
function checkIsAdminOrVaultAdmin(address smartVault, address account) external view;
function paused() external view returns (bool isPaused);
function pause() external;
function unpause() external;
function grantSmartVaultRole(address smartVault, bytes32 role, address account) external;
function revokeSmartVaultRole(address smartVault, bytes32 role, address account) external;
function renounceSmartVaultRole(address smartVault, bytes32 role) external;
function grantSmartVaultOwnership(address smartVault, address owner) external;
function checkNonReentrant() external view;
function nonReentrantBefore() external;
function nonReentrantAfter() external;
event SmartVaultOwnershipGranted(address indexed smartVault, address indexed address_);
event SmartVaultRoleGranted(address indexed smartVault, bytes32 indexed role, address indexed account);
event SmartVaultRoleRevoked(address indexed smartVault, bytes32 indexed role, address indexed account);
event SmartVaultRoleRenounced(address indexed smartVault, bytes32 indexed role, address indexed account);
}
文件 36 的 60：IStrategy.sol
pragma solidity 0.8.17;
import "@openzeppelin/token/ERC20/IERC20.sol";
import "@openzeppelin-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {PlatformFees} from "./IStrategyRegistry.sol";
import "./ISwapper.sol";
import "./IUsdPriceFeedManager.sol";
struct SwapData {
uint256 slippage;
bytes path;
}
struct StrategyDhwParameterBag {
SwapInfo[] swapInfo;
SwapInfo[] compoundSwapInfo;
uint256[] slippages;
address[] assetGroup;
uint256[] exchangeRates;
uint256 withdrawnShares;
address masterWallet;
IUsdPriceFeedManager priceFeedManager;
int256 baseYield;
PlatformFees platformFees;
}
struct DhwInfo {
uint256 sharesMinted;
uint256[] assetsWithdrawn;
int256 yieldPercentage;
uint256 valueAtDhw;
uint256 totalSstsAtDhw;
}
error IsGhostStrategy();
error NotFastRedeemer(address user);
error InvalidAssetGroupIdInitialization();
interface IStrategy is IERC20Upgradeable {
event Deposited(
uint256 mintedShares, uint256 usdWorthDeposited, uint256[] assetsBeforeSwap, uint256[] assetsDeposited
);
event Withdrawn(uint256 withdrawnShares, uint256 usdWorthWithdrawn, uint256[] withdrawnAssets);
event PlatformFeesCollected(address indexed strategy, uint256 sharesMinted);
event Slippages(bool isDeposit, uint256 slippage, bytes data);
event BeforeDepositCheckSlippages(uint256[] amounts);
event BeforeRedeemalCheckSlippages(uint256 ssts);
function strategyName() external view returns (string memory name);
function assetRatio() external view returns (uint256[] memory ratio);
function assetGroupId() external view returns (uint256 id);
function assets() external view returns (address[] memory assets);
function getUnderlyingAssetAmounts() external view returns (uint256[] memory amounts);
function beforeDepositCheck(uint256[] memory amounts, uint256[] calldata slippages) external;
function beforeRedeemalCheck(uint256 ssts, uint256[] calldata slippages) external;
function doHardWork(StrategyDhwParameterBag calldata dhwParams) external returns (DhwInfo memory info);
function claimShares(address smartVault, uint256 amount) external;
function releaseShares(address smartVault, uint256 amount) external;
function redeemFast(
uint256 shares,
address masterWallet,
address[] calldata assetGroup,
uint256[] calldata slippages
) external returns (uint256[] memory assetsWithdrawn);
function redeemShares(uint256 shares, address redeemer, address[] calldata assetGroup, uint256[] calldata slippages)
external
returns (uint256[] memory assetsWithdrawn);
function depositFast(
address[] calldata assetGroup,
uint256[] calldata exchangeRates,
IUsdPriceFeedManager priceFeedManager,
uint256[] calldata slippages,
SwapInfo[] calldata swapInfo
) external returns (uint256 sstsMinted);
function emergencyWithdraw(uint256[] calldata slippages, address recipient) external;
function getUsdWorth(uint256[] memory exchangeRates, IUsdPriceFeedManager priceFeedManager)
external
returns (uint256 usdWorth);
function getProtocolRewards() external returns (address[] memory tokens, uint256[] memory amounts);
}
文件 37 的 60：IStrategyRegistry.sol
pragma solidity 0.8.17;
import "./ISwapper.sol";
import {DhwInfo} from "./IStrategy.sol";
import "../libraries/uint16a16Lib.sol";
error StrategyAlreadyRegistered(address address_);
error DhwNotRunYetForIndex(address strategy, uint256 strategyIndex);
error InvalidTokenList();
error GhostStrategyUsed();
error NothingToSync();
error EcosystemFeeTooLarge(uint256 ecosystemFeePct);
error TreasuryFeeTooLarge(uint256 treasuryFeePct);
error StrategyPreviouslyRemoved(address strategy);
struct StrategyAtIndex {
uint256[] exchangeRates;
uint256[] assetsDeposited;
uint256 sharesMinted;
uint256 totalSSTs;
uint256 totalStrategyValue;
int256 dhwYields;
}
struct DoHardWorkParameterBag {
address[][] strategies;
SwapInfo[][][] swapInfo;
SwapInfo[][][] compoundSwapInfo;
uint256[][][] strategySlippages;
int256[][] baseYields;
address[] tokens;
uint256[2][] exchangeRateSlippages;
uint256 validUntil;
}
struct RedeemFastParameterBag {
address[] strategies;
uint256[] strategyShares;
address[] assetGroup;
uint256[][] withdrawalSlippages;
}
struct PlatformFees {
address ecosystemFeeReceiver;
uint96 ecosystemFeePct;
address treasuryFeeReceiver;
uint96 treasuryFeePct;
}
interface IStrategyRegistry {
function emergencyWithdrawalWallet() external view returns (address emergencyWithdrawalWallet);
function currentIndex(address[] calldata strategies) external view returns (uint256[] memory dhwIndexes);
function strategyAPYs(address[] calldata strategies) external view returns (int256[] memory apys);
function depositedAssets(address strategy, uint256 dhwIndex) external view returns (uint256[] memory assets);
function sharesRedeemed(address strategy, uint256 dhwIndex) external view returns (uint256 shares);
function dhwTimestamps(address[] calldata strategies, uint16a16 dhwIndexes)
external
view
returns (uint256[] memory timestamps);
function getDhwYield(address[] calldata strategies, uint16a16 dhwIndexes)
external
view
returns (int256[] memory yields);
function strategyAtIndexBatch(address[] calldata strategies, uint16a16 dhwIndexes, uint256 assetGroupLength)
external
view
returns (StrategyAtIndex[] memory states);
function assetRatioAtLastDhw(address strategy) external view returns (uint256[] memory assetRatio);
function platformFees() external view returns (PlatformFees memory fees);
function registerStrategy(address strategy, int256 apy) external;
function removeStrategy(address strategy) external;
function setEcosystemFee(uint96 ecosystemFeePct) external;
function setEcosystemFeeReceiver(address ecosystemFeeReceiver) external;
function setTreasuryFee(uint96 treasuryFeePct) external;
function setTreasuryFeeReceiver(address treasuryFeeReceiver) external;
function doHardWork(DoHardWorkParameterBag calldata dhwParams) external;
function addDeposits(address[] calldata strategies, uint256[][] calldata amounts)
external
returns (uint16a16 strategyIndexes);
function addWithdrawals(address[] calldata strategies, uint256[] calldata strategyShares)
external
returns (uint16a16 strategyIndexes);
function redeemFast(RedeemFastParameterBag calldata redeemFastParams)
external
returns (uint256[] memory withdrawnAssets);
function claimWithdrawals(address[] calldata strategies, uint16a16 dhwIndexes, uint256[] calldata strategyShares)
external
returns (uint256[] memory assetsWithdrawn);
function redeemStrategyShares(
address[] calldata strategies,
uint256[] calldata shares,
uint256[][] calldata withdrawalSlippages
) external;
event StrategyRegistered(address indexed strategy);
event StrategyRemoved(address indexed strategy);
event StrategyDhw(address indexed strategy, uint256 dhwIndex, DhwInfo dhwInfo);
event EcosystemFeeSet(uint256 feePct);
event EcosystemFeeReceiverSet(address indexed ecosystemFeeReceiver);
event TreasuryFeeSet(uint256 feePct);
event TreasuryFeeReceiverSet(address indexed treasuryFeeReceiver);
event EmergencyWithdrawalWalletSet(address indexed wallet);
event StrategySharesRedeemed(
address indexed strategy,
address indexed owner,
address indexed recipient,
uint256 shares,
uint256[] assetsWithdrawn
);
event StrategySharesFastRedeemed(address indexed strategy, uint256 shares, uint256[] assetsWithdrawn);
event StrategyApyUpdated(address indexed strategy, int256 apy);
}
interface IEmergencyWithdrawal {
event StrategyEmergencyWithdrawn(address indexed strategy);
function setEmergencyWithdrawalWallet(address wallet) external;
function emergencyWithdraw(
address[] calldata strategies,
uint256[][] calldata withdrawalSlippages,
bool removeStrategies
) external;
}
文件 38 的 60：ISwapper.sol
pragma solidity 0.8.17;
struct SwapInfo {
address swapTarget;
address token;
bytes swapCallData;
}
error ExchangeNotAllowed(address exchange);
error NotSwapper(address caller);
interface ISwapper {
event ExchangeAllowlistUpdated(address indexed exchange, bool isAllowed);
event Swapped(
address indexed receiver, address[] tokensIn, address[] tokensOut, uint256[] amountsIn, uint256[] amountsOut
);
function swap(
address[] calldata tokensIn,
SwapInfo[] calldata swapInfo,
address[] calldata tokensOut,
address receiver
) external returns (uint256[] memory amountsOut);
function updateExchangeAllowlist(address[] calldata exchanges, bool[] calldata allowed) external;
function isExchangeAllowed(address exchange) external view returns (bool isAllowed);
}
文件 39 的 60：IUsdPriceFeedManager.sol
pragma solidity 0.8.17;
uint256 constant USD_DECIMALS = 18;
error InvalidAsset(address asset);
error NonPositivePrice(int256 price);
error StalePriceData();
interface IUsdPriceFeedManager {
function assetDecimals(address asset) external view returns (uint256 assetDecimals);
function usdDecimals() external view returns (uint256 usdDecimals);
function assetToUsd(address asset, uint256 assetAmount) external view returns (uint256 usdValue);
function usdToAsset(address asset, uint256 usdAmount) external view returns (uint256 assetValue);
function assetToUsdCustomPrice(address asset, uint256 assetAmount, uint256 price)
external
view
returns (uint256 usdValue);
function assetToUsdCustomPriceBulk(
address[] calldata assets,
uint256[] calldata assetAmounts,
uint256[] calldata prices
) external view returns (uint256 usdValue);
function usdToAssetCustomPrice(address asset, uint256 usdAmount, uint256 price)
external
view
returns (uint256 assetValue);
}
文件 40 的 60：IWithdrawalManager.sol
pragma solidity 0.8.17;
import "../libraries/uint16a16Lib.sol";
error WithdrawalNftNotSyncedYet(uint256 id);
struct RedeemBag {
address smartVault;
uint256 shares;
uint256[] nftIds;
uint256[] nftAmounts;
}
struct RedeemFastExtras {
address[] strategies;
address[] assetGroup;
uint256 assetGroupId;
address redeemer;
uint256[][] withdrawalSlippages;
}
struct RedeemExtras {
address receiver;
address owner;
address executor;
uint256 flushIndex;
}
struct WithdrawalClaimBag {
address smartVault;
uint256[] nftIds;
uint256[] nftAmounts;
address receiver;
address executor;
uint256 assetGroupId;
address[] assetGroup;
uint256 flushIndexToSync;
}
interface IWithdrawalManager {
event WithdrawalClaimed(
address indexed smartVault,
address indexed claimer,
uint256 assetGroupId,
uint256[] nftIds,
uint256[] nftAmounts,
uint256[] withdrawnAssets
);
event RedeemInitiated(
address indexed smartVault,
address indexed owner,
uint256 indexed redeemId,
uint256 flushIndex,
uint256 shares,
address receiver
);
event FastRedeemInitiated(
address indexed smartVault,
address indexed redeemer,
uint256 shares,
uint256[] nftIds,
uint256[] nftAmounts,
uint256[] assetsWithdrawn
);
function flushSmartVault(address smartVault, uint256 flushIndex, address[] calldata strategies)
external
returns (uint16a16 dhwIndexes);
function claimWithdrawal(WithdrawalClaimBag calldata bag)
external
returns (uint256[] memory withdrawnAssets, uint256 assetGroupId);
function syncWithdrawals(
address smartVault,
uint256 flushIndex,
address[] calldata strategies,
uint16a16 dhwIndexes_
) external;
function redeem(RedeemBag calldata bag, RedeemExtras calldata bag2) external returns (uint256 nftId);
function redeemFast(RedeemBag calldata bag, RedeemFastExtras memory bag2)
external
returns (uint256[] memory assets);
}
文件 41 的 60：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 42 的 60：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 43 的 60：MathUpgradeable.sol
pragma solidity ^0.8.0;
library MathUpgradeable {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 44 的 60：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 45 的 60：Proxy.sol
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
文件 46 的 60：RequestType.sol
pragma solidity 0.8.17;
enum RequestType {
Deposit,
Withdrawal,
TransferNFT,
BurnNFT,
TransferSVTs
}
文件 47 的 60：Roles.sol
pragma solidity 0.8.17;
bytes32 constant ROLE_SPOOL_ADMIN = 0x00;
bytes32 constant ROLE_SMART_VAULT_INTEGRATOR = keccak256("SMART_VAULT_INTEGRATOR");
bytes32 constant ROLE_SMART_VAULT_ADMIN = keccak256("SMART_VAULT_ADMIN");
bytes32 constant ROLE_GUARD_ALLOWLIST_MANAGER = keccak256("GUARD_ALLOWLIST_MANAGER");
bytes32 constant ROLE_MASTER_WALLET_MANAGER = keccak256("MASTER_WALLET_MANAGER");
bytes32 constant ROLE_SMART_VAULT_MANAGER = keccak256("SMART_VAULT_MANAGER");
bytes32 constant ROLE_STRATEGY_REGISTRY = keccak256("STRATEGY_REGISTRY");
bytes32 constant ROLE_RISK_PROVIDER = keccak256("RISK_PROVIDER");
bytes32 constant ROLE_ALLOCATION_PROVIDER = keccak256("ALLOCATION_PROVIDER");
bytes32 constant ROLE_PAUSER = keccak256("SYSTEM_PAUSER");
bytes32 constant ROLE_UNPAUSER = keccak256("SYSTEM_UNPAUSER");
bytes32 constant ROLE_REWARD_POOL_ADMIN = keccak256("REWARD_POOL_ADMIN");
bytes32 constant ROLE_REALLOCATOR = keccak256("REALLOCATOR");
bytes32 constant ROLE_STRATEGY = keccak256("STRATEGY");
bytes32 constant ROLE_STRATEGY_APY_SETTER = keccak256("STRATEGY_APY_SETTER");
bytes32 constant ADMIN_ROLE_STRATEGY = keccak256("ADMIN_STRATEGY");
bytes32 constant ROLE_SMART_VAULT_ALLOW_REDEEM = keccak256("SMART_VAULT_ALLOW_REDEEM");
bytes32 constant ADMIN_ROLE_SMART_VAULT_ALLOW_REDEEM = keccak256("ADMIN_SMART_VAULT_ALLOW_REDEEM");
bytes32 constant ROLE_DO_HARD_WORKER = keccak256("DO_HARD_WORKER");
bytes32 constant ROLE_EMERGENCY_WITHDRAWAL_EXECUTOR = keccak256("EMERGENCY_WITHDRAWAL_EXECUTOR");
bytes32 constant ROLE_SWAPPER = keccak256("SWAPPER");
文件 48 的 60：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
文件 49 的 60：SignedMath.sol
pragma solidity ^0.8.0;
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);
}
}
}
文件 50 的 60：SmartVault.sol
pragma solidity 0.8.17;
import "@openzeppelin/token/ERC20/ERC20.sol";
import "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/utils/Strings.sol";
import "@openzeppelin-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol";
import "./interfaces/IGuardManager.sol";
import "./interfaces/ISmartVault.sol";
import "./interfaces/CommonErrors.sol";
import "./interfaces/RequestType.sol";
import "./access/SpoolAccessControllable.sol";
import "./libraries/ArrayMapping.sol";
contract SmartVault is ERC20PermitUpgradeable, ERC1155Upgradeable, SpoolAccessControllable, ISmartVault {
using SafeERC20 for IERC20;
using ArrayMappingUint256 for mapping(uint256 => uint256);
IGuardManager internal immutable _guardManager;
uint256 public assetGroupId;
string internal _vaultName;
mapping(uint256 => DepositMetadata) private _depositMetadata;
mapping(uint256 => WithdrawalMetadata) private _withdrawalMetadata;
uint256 private _lastDepositId;
uint256 private _lastWithdrawalId;
constructor(ISpoolAccessControl accessControl_, IGuardManager guardManager_)
SpoolAccessControllable(accessControl_)
{
if (address(guardManager_) == address(0)) revert ConfigurationAddressZero();
_guardManager = guardManager_;
_disableInitializers();
}
function initialize(
string calldata vaultName_,
string calldata svtSymbol,
string calldata baseURI_,
uint256 assetGroupId_
) external initializer {
if (bytes(vaultName_).length == 0) revert InvalidConfiguration();
__ERC1155_init(baseURI_);
__ERC20_init(vaultName_, svtSymbol);
_vaultName = vaultName_;
assetGroupId = assetGroupId_;
_lastDepositId = 0;
_lastWithdrawalId = MAXIMAL_DEPOSIT_ID;
}
function uri(uint256 tokenId)
public
view
override(ERC1155Upgradeable, IERC1155MetadataURIUpgradeable)
returns (string memory)
{
return string(abi.encodePacked(super.uri(0), Strings.toString(tokenId), ".json"));
}
function balanceOf(address account, uint256 id)
public
view
override(ERC1155Upgradeable, IERC1155Upgradeable)
returns (uint256)
{
return super.balanceOf(account, id) >= 1 ? 1 : 0;
}
function balanceOfFractional(address account, uint256 id) public view returns (uint256) {
return super.balanceOf(account, id);
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
override(ERC1155Upgradeable, IERC1155Upgradeable)
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function balanceOfFractionalBatch(address account, uint256[] calldata ids) public view returns (uint256[] memory) {
uint256[] memory batchBalances = new uint256[](ids.length);
for (uint256 i; i < ids.length; ++i) {
batchBalances[i] = balanceOfFractional(account, ids[i]);
}
return batchBalances;
}
function vaultName() external view returns (string memory) {
return _vaultName;
}
function getMetadata(uint256[] calldata nftIds) public view returns (bytes[] memory) {
bytes[] memory metadata = new bytes[](nftIds.length);
for (uint256 i; i < nftIds.length; ++i) {
metadata[i] = nftIds[i] > MAXIMAL_DEPOSIT_ID
? abi.encode(_withdrawalMetadata[nftIds[i]])
: abi.encode(_depositMetadata[nftIds[i]]);
}
return metadata;
}
function setBaseURI(string memory uri_) external onlyAdminOrVaultAdmin(address(this), msg.sender) {
_setURI(uri_);
emit BaseURIChanged(uri_);
}
function mintVaultShares(address receiver, uint256 vaultShares)
external
onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender)
{
_mint(receiver, vaultShares);
}
function burnVaultShares(
address owner,
uint256 vaultShares,
address[] calldata strategies,
uint256[] calldata shares
) external onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender) {
_burn(owner, vaultShares);
for (uint256 i; i < strategies.length; ++i) {
if (shares[i] > 0) {
IERC20(strategies[i]).safeTransfer(strategies[i], shares[i]);
}
}
}
function burnNFTs(address owner, uint256[] calldata nftIds, uint256[] calldata nftAmounts)
external
onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender)
returns (bytes[] memory)
{
_burnBatch(owner, nftIds, nftAmounts);
return getMetadata(nftIds);
}
function claimShares(address claimer, uint256 amount) external onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender) {
_transfer(address(this), claimer, amount);
}
function mintDepositNFT(address receiver, DepositMetadata calldata metadata)
external
onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender)
returns (uint256)
{
if (_lastDepositId >= MAXIMAL_DEPOSIT_ID) {
revert DepositIdOverflow();
}
_lastDepositId++;
_depositMetadata[_lastDepositId] = metadata;
_mint(receiver, _lastDepositId, NFT_MINTED_SHARES, "");
return _lastDepositId;
}
function mintWithdrawalNFT(address receiver, WithdrawalMetadata memory metadata)
external
onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender)
returns (uint256 receipt)
{
if (_lastWithdrawalId >= MAXIMAL_WITHDRAWAL_ID) {
revert WithdrawalIdOverflow();
}
_lastWithdrawalId++;
_withdrawalMetadata[_lastWithdrawalId] = metadata;
_mint(receiver, _lastWithdrawalId, NFT_MINTED_SHARES, "");
return _lastWithdrawalId;
}
function transferFromSpender(address from, address to, uint256 amount)
external
onlyRole(ROLE_SMART_VAULT_MANAGER, msg.sender)
returns (bool)
{
_transfer(from, to, amount);
return true;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal view override {
_requireNotPaused();
if (from == address(0) || to == address(0) || to == address(this)) return;
if (from == to) revert SenderEqualsRecipient();
uint256[] memory assets = new uint256[](1);
assets[0] = amount;
RequestContext memory context = RequestContext({
receiver: to,
executor: msg.sender,
owner: from,
requestType: RequestType.TransferSVTs,
assets: assets,
tokens: new address[](0)
});
_guardManager.runGuards(address(this), context);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory
) internal view override {
_requireNotPaused();
if (from == address(0) || to == address(0)) return;
if (from == to) revert SenderEqualsRecipient();
for (uint256 i; i < ids.length; ++i) {
if (amounts[i] != NFT_MINTED_SHARES) {
revert InvalidNftTransferAmount(amounts[i]);
}
}
RequestContext memory context = RequestContext({
receiver: to,
executor: operator,
owner: from,
requestType: RequestType.TransferNFT,
assets: ids,
tokens: new address[](0)
});
_guardManager.runGuards(address(this), context);
}
}
文件 51 的 60：SmartVaultFactory.sol
pragma solidity 0.8.17;
import "@openzeppelin/proxy/beacon/BeaconProxy.sol";
import "@openzeppelin/proxy/beacon/UpgradeableBeacon.sol";
import "./interfaces/IAction.sol";
import "./interfaces/IAssetGroupRegistry.sol";
import "./interfaces/IGuardManager.sol";
import "./interfaces/IRiskManager.sol";
import "./interfaces/ISmartVault.sol";
import "./interfaces/ISmartVaultManager.sol";
import "./interfaces/ISpoolAccessControl.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/CommonErrors.sol";
import "./interfaces/Constants.sol";
import "./interfaces/RequestType.sol";
import "./access/Roles.sol";
import "./SmartVault.sol";
error SmartVaultRegistrationNoStrategies();
error StrategyCapExceeded();
error StrategiesNotUnique();
error InvalidStrategyAllocationsLength();
error InvalidStaticAllocation();
error StaticAllocationAndRiskProviderSet();
error StaticAllocationAndRiskToleranceSet();
error StaticAllocationAndAllocationProviderSet();
error SingleStrategyDynamicAllocation();
struct SmartVaultSpecification {
string smartVaultName;
string svtSymbol;
string baseURI;
uint256 assetGroupId;
address[] strategies;
uint16a16 strategyAllocation;
int8 riskTolerance;
address riskProvider;
address allocationProvider;
IAction[] actions;
RequestType[] actionRequestTypes;
GuardDefinition[][] guards;
RequestType[] guardRequestTypes;
uint16 managementFeePct;
uint16 depositFeePct;
uint16 performanceFeePct;
bool allowRedeemFor;
}
contract SmartVaultFactory is UpgradeableBeacon {
using uint16a16Lib for uint16a16;
event SmartVaultDeployed(address indexed smartVault, address indexed deployer);
ISpoolAccessControl immutable _accessControl;
IActionManager immutable _actionManager;
IGuardManager immutable _guardManager;
ISmartVaultRegistry immutable _smartVaultRegistry;
IAssetGroupRegistry immutable _assetGroupRegistry;
IRiskManager immutable _riskManager;
constructor(
address implementation,
ISpoolAccessControl accessControl_,
IActionManager actionManager_,
IGuardManager guardManager_,
ISmartVaultRegistry smartVaultRegistry_,
IAssetGroupRegistry assetGroupRegistry_,
IRiskManager riskManager_
) UpgradeableBeacon(implementation) {
if (address(accessControl_) == address(0)) revert ConfigurationAddressZero();
if (address(actionManager_) == address(0)) revert ConfigurationAddressZero();
if (address(guardManager_) == address(0)) revert ConfigurationAddressZero();
if (address(smartVaultRegistry_) == address(0)) revert ConfigurationAddressZero();
if (address(assetGroupRegistry_) == address(0)) revert ConfigurationAddressZero();
if (address(riskManager_) == address(0)) revert ConfigurationAddressZero();
_accessControl = accessControl_;
_actionManager = actionManager_;
_guardManager = guardManager_;
_smartVaultRegistry = smartVaultRegistry_;
_assetGroupRegistry = assetGroupRegistry_;
_riskManager = riskManager_;
}
function deploySmartVault(SmartVaultSpecification calldata specification) external returns (ISmartVault) {
_validateSpecification(specification);
address smartVaultAddress = address(
new BeaconProxy(
address(this),
_encodeInitializationCalldata(specification)
)
);
_integrateSmartVault(smartVaultAddress, specification);
emit SmartVaultDeployed(smartVaultAddress, msg.sender);
return ISmartVault(smartVaultAddress);
}
function deploySmartVaultDeterministically(SmartVaultSpecification calldata specification, bytes32 salt)
external
returns (ISmartVault)
{
_validateSpecification(specification);
address smartVaultAddress = address(
new BeaconProxy{salt: salt}(
address(this),
_encodeInitializationCalldata(specification)
)
);
_integrateSmartVault(smartVaultAddress, specification);
emit SmartVaultDeployed(smartVaultAddress, msg.sender);
return ISmartVault(smartVaultAddress);
}
function predictDeterministicAddress(SmartVaultSpecification calldata specification, bytes32 salt)
external
view
returns (address)
{
return address(
uint160(
uint256(
keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
keccak256(
abi.encodePacked(
type(BeaconProxy).creationCode,
abi.encode(address(this), _encodeInitializationCalldata(specification))
)
)
)
)
)
)
);
}
function _validateSpecification(SmartVaultSpecification calldata specification) private view {
_assetGroupRegistry.validateAssetGroup(specification.assetGroupId);
if (specification.strategies.length == 0) {
revert SmartVaultRegistrationNoStrategies();
}
if (specification.strategies.length > STRATEGY_COUNT_CAP) {
revert StrategyCapExceeded();
}
unchecked {
bool fixedAllocations = uint16a16.unwrap(specification.strategyAllocation) > 0;
uint256 fullAllocation;
if (specification.strategies.length == 1 && !fixedAllocations) {
revert SingleStrategyDynamicAllocation();
}
if (fixedAllocations) {
if (specification.riskProvider != address(0)) {
revert StaticAllocationAndRiskProviderSet();
}
if (specification.riskTolerance != 0) {
revert StaticAllocationAndRiskToleranceSet();
}
if (specification.allocationProvider != address(0)) {
revert StaticAllocationAndAllocationProviderSet();
}
}
for (uint256 i; i < specification.strategies.length; ++i) {
if (fixedAllocations) {
if (specification.strategyAllocation.get(i) == 0) {
revert InvalidStrategyAllocationsLength();
}
fullAllocation += specification.strategyAllocation.get(i);
}
if (!_accessControl.hasRole(ROLE_STRATEGY, specification.strategies[i])) {
revert InvalidStrategy(specification.strategies[i]);
}
if (IStrategy(specification.strategies[i]).assetGroupId() != specification.assetGroupId) {
revert NotSameAssetGroup();
}
for (uint256 j = i + 1; j < specification.strategies.length; ++j) {
if (specification.strategies[i] == specification.strategies[j]) {
revert StrategiesNotUnique();
}
}
}
if (fixedAllocations && fullAllocation != FULL_PERCENT) {
revert InvalidStaticAllocation();
}
}
if (specification.managementFeePct > MANAGEMENT_FEE_MAX) {
revert ManagementFeeTooLarge(specification.managementFeePct);
}
if (specification.depositFeePct > DEPOSIT_FEE_MAX) {
revert DepositFeeTooLarge(specification.depositFeePct);
}
if (specification.performanceFeePct > SV_PERFORMANCE_FEE_MAX) {
revert PerformanceFeeTooLarge(specification.performanceFeePct);
}
}
function _encodeInitializationCalldata(SmartVaultSpecification calldata specification)
private
pure
returns (bytes memory)
{
return abi.encodeWithSignature(
"initialize(string,string,string,uint256)",
specification.smartVaultName,
specification.svtSymbol,
specification.baseURI,
specification.assetGroupId
);
}
function _integrateSmartVault(address smartVaultAddress, SmartVaultSpecification calldata specification) private {
_accessControl.grantSmartVaultOwnership(smartVaultAddress, msg.sender);
_actionManager.setActions(smartVaultAddress, specification.actions, specification.actionRequestTypes);
_guardManager.setGuards(smartVaultAddress, specification.guards, specification.guardRequestTypes);
if (specification.allowRedeemFor) {
_accessControl.grantRole(ROLE_SMART_VAULT_ALLOW_REDEEM, smartVaultAddress);
}
uint16a16 allocations = specification.strategyAllocation;
if (uint16a16.unwrap(allocations) == 0) {
_riskManager.setRiskProvider(smartVaultAddress, specification.riskProvider);
_riskManager.setRiskTolerance(smartVaultAddress, specification.riskTolerance);
_riskManager.setAllocationProvider(smartVaultAddress, specification.allocationProvider);
allocations = _riskManager.calculateAllocation(smartVaultAddress, specification.strategies);
}
_smartVaultRegistry.registerSmartVault(
smartVaultAddress,
SmartVaultRegistrationForm({
assetGroupId: specification.assetGroupId,
strategies: specification.strategies,
strategyAllocation: allocations,
managementFeePct: specification.managementFeePct,
depositFeePct: specification.depositFeePct,
performanceFeePct: specification.performanceFeePct
})
);
}
}
文件 52 的 60：SpoolAccessControllable.sol
pragma solidity 0.8.17;
import "../interfaces/ISpoolAccessControl.sol";
import "../interfaces/CommonErrors.sol";
import "./Roles.sol";
abstract contract SpoolAccessControllable {
ISpoolAccessControl internal immutable _accessControl;
constructor(ISpoolAccessControl accessControl_) {
if (address(accessControl_) == address(0)) revert ConfigurationAddressZero();
_accessControl = accessControl_;
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!_accessControl.hasRole(role, account)) {
revert MissingRole(role, account);
}
}
function _checkSmartVaultRole(address smartVault, bytes32 role, address account) internal view {
if (!_accessControl.hasSmartVaultRole(smartVault, role, account)) {
revert MissingRole(role, account);
}
}
function _requireNotPaused() internal view virtual {
if (_accessControl.paused()) {
revert SystemPaused();
}
}
function _checkNonReentrant() internal view {
_accessControl.checkNonReentrant();
}
function _nonReentrantBefore() internal {
_accessControl.nonReentrantBefore();
}
function _nonReentrantAfter() internal {
_accessControl.nonReentrantAfter();
}
modifier onlyRole(bytes32 role, address account) {
_checkRole(role, account);
_;
}
modifier onlySmartVaultRole(address smartVault, bytes32 role, address account) {
_checkSmartVaultRole(smartVault, role, account);
_;
}
modifier onlyAdminOrVaultAdmin(address smartVault, address account) {
_accessControl.checkIsAdminOrVaultAdmin(smartVault, account);
_;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
modifier checkNonReentrant() {
_checkNonReentrant();
_;
}
uint256[49] private __gap;
}
文件 53 的 60：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
文件 54 的 60：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(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) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 55 的 60：StringsUpgradeable.sol
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
文件 56 的 60：UpgradeableBeacon.sol
pragma solidity ^0.8.0;
import "./IBeacon.sol";
import "../../access/Ownable.sol";
import "../../utils/Address.sol";
contract UpgradeableBeacon is IBeacon, Ownable {
address private _implementation;
event Upgraded(address indexed implementation);
constructor(address implementation_) {
_setImplementation(implementation_);
}
function implementation() public view virtual override returns (address) {
return _implementation;
}
function upgradeTo(address newImplementation) public virtual onlyOwner {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "UpgradeableBeacon: implementation is not a contract");
_implementation = newImplementation;
}
}
文件 57 的 60：draft-ERC20PermitUpgradeable.sol
pragma solidity ^0.8.0;
import "./draft-IERC20PermitUpgradeable.sol";
import "../ERC20Upgradeable.sol";
import "../../../utils/cryptography/ECDSAUpgradeable.sol";
import "../../../utils/cryptography/EIP712Upgradeable.sol";
import "../../../utils/CountersUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
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 override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
文件 58 的 60：draft-IERC1822.sol
pragma solidity ^0.8.0;
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
文件 59 的 60：draft-IERC20PermitUpgradeable.sol
pragma solidity ^0.8.0;
interface IERC20PermitUpgradeable {
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);
}
文件 60 的 60：uint16a16Lib.sol
pragma solidity 0.8.17;
type uint16a16 is uint256;
library uint16a16Lib {
uint256 constant bits = 16;
uint256 constant elements = 16;
uint256 constant range = 1 << bits;
uint256 constant max = range - 1;
function get(uint16a16 va, uint256 index) internal pure returns (uint256) {
require(index < elements);
return (uint16a16.unwrap(va) >> (bits * index)) & max;
}
function set(uint16a16 va, uint256 index, uint256 ev) internal pure returns (uint16a16) {
require(index < elements);
require(ev < range);
index *= bits;
return uint16a16.wrap((uint16a16.unwrap(va) & ~(max << index)) | (ev << index));
}
function set(uint16a16 va, uint256[] memory ev) internal pure returns (uint16a16) {
for (uint256 i; i < ev.length; ++i) {
va = set(va, i, ev[i]);
}
return va;
}
}
{
"compilationTarget": {
"src/SmartVaultFactory.sol": "SmartVaultFactory"
},
"evmVersion": "london",
"libraries": {
"script/helper/ArraysHelper.sol:ArraysHelper": "0x92076039b4b69576e99e338899f76dfc19f6b18c",
"src/libraries/ArrayMapping.sol:ArrayMappingUint256": "0x5589c1a93ad9c910eeb31496f514b0def2cc0b3d",
"src/libraries/SpoolUtils.sol:SpoolUtils": "0xee2748274586db8e4a227f39b1fd95f5ed35d81e"
},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 99999
},
"remappings": [
":@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
":@openzeppelin/=lib/openzeppelin-contracts/contracts/",
":@solmate/=lib/solmate/src/",
":create3/=lib/create3/contracts/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":solmate/=lib/solmate/src/",
":sstore2/=lib/sstore2/contracts/",
"lib/forge-std:ds-test/=lib/forge-std/lib/ds-test/src/",
"lib/openzeppelin-contracts-upgradeable:ds-test/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/lib/ds-test/src/",
"lib/openzeppelin-contracts-upgradeable:forge-std/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/src/",
"lib/openzeppelin-contracts:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
"lib/openzeppelin-contracts:erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
"lib/openzeppelin-contracts:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/",
"lib/solmate:ds-test/=lib/solmate/lib/ds-test/src/"
]
}[{"inputs":[{"internalType":"address","name":"implementation","type":"address"},{"internalType":"contract ISpoolAccessControl","name":"accessControl_","type":"address"},{"internalType":"contract IActionManager","name":"actionManager_","type":"address"},{"internalType":"contract IGuardManager","name":"guardManager_","type":"address"},{"internalType":"contract ISmartVaultRegistry","name":"smartVaultRegistry_","type":"address"},{"internalType":"contract IAssetGroupRegistry","name":"assetGroupRegistry_","type":"address"},{"internalType":"contract IRiskManager","name":"riskManager_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ConfigurationAddressZero","type":"error"},{"inputs":[{"internalType":"uint256","name":"depositFeePct","type":"uint256"}],"name":"DepositFeeTooLarge","type":"error"},{"inputs":[],"name":"InvalidStaticAllocation","type":"error"},{"inputs":[{"internalType":"address","name":"address_","type":"address"}],"name":"InvalidStrategy","type":"error"},{"inputs":[],"name":"InvalidStrategyAllocationsLength","type":"error"},{"inputs":[{"internalType":"uint256","name":"mgmtFeePct","type":"uint256"}],"name":"ManagementFeeTooLarge","type":"error"},{"inputs":[],"name":"NotSameAssetGroup","type":"error"},{"inputs":[{"internalType":"uint256","name":"performanceFeePct","type":"uint256"}],"name":"PerformanceFeeTooLarge","type":"error"},{"inputs":[],"name":"SingleStrategyDynamicAllocation","type":"error"},{"inputs":[],"name":"SmartVaultRegistrationNoStrategies","type":"error"},{"inputs":[],"name":"StaticAllocationAndAllocationProviderSet","type":"error"},{"inputs":[],"name":"StaticAllocationAndRiskProviderSet","type":"error"},{"inputs":[],"name":"StaticAllocationAndRiskToleranceSet","type":"error"},{"inputs":[],"name":"StrategiesNotUnique","type":"error"},{"inputs":[],"name":"StrategyCapExceeded","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"smartVault","type":"address"},{"indexed":true,"internalType":"address","name":"deployer","type":"address"}],"name":"SmartVaultDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[{"components":[{"internalType":"string","name":"smartVaultName","type":"string"},{"internalType":"string","name":"svtSymbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"uint256","name":"assetGroupId","type":"uint256"},{"internalType":"address[]","name":"strategies","type":"address[]"},{"internalType":"uint16a16","name":"strategyAllocation","type":"uint256"},{"internalType":"int8","name":"riskTolerance","type":"int8"},{"internalType":"address","name":"riskProvider","type":"address"},{"internalType":"address","name":"allocationProvider","type":"address"},{"internalType":"contract IAction[]","name":"actions","type":"address[]"},{"internalType":"enum RequestType[]","name":"actionRequestTypes","type":"uint8[]"},{"components":[{"internalType":"string","name":"methodSignature","type":"string"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"bytes2","name":"operator","type":"bytes2"},{"internalType":"uint256","name":"expectedValue","type":"uint256"},{"internalType":"enum GuardParamType[]","name":"methodParamTypes","type":"uint8[]"},{"internalType":"bytes[]","name":"methodParamValues","type":"bytes[]"}],"internalType":"struct GuardDefinition[][]","name":"guards","type":"tuple[][]"},{"internalType":"enum RequestType[]","name":"guardRequestTypes","type":"uint8[]"},{"internalType":"uint16","name":"managementFeePct","type":"uint16"},{"internalType":"uint16","name":"depositFeePct","type":"uint16"},{"internalType":"uint16","name":"performanceFeePct","type":"uint16"},{"internalType":"bool","name":"allowRedeemFor","type":"bool"}],"internalType":"struct SmartVaultSpecification","name":"specification","type":"tuple"}],"name":"deploySmartVault","outputs":[{"internalType":"contract ISmartVault","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"smartVaultName","type":"string"},{"internalType":"string","name":"svtSymbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"uint256","name":"assetGroupId","type":"uint256"},{"internalType":"address[]","name":"strategies","type":"address[]"},{"internalType":"uint16a16","name":"strategyAllocation","type":"uint256"},{"internalType":"int8","name":"riskTolerance","type":"int8"},{"internalType":"address","name":"riskProvider","type":"address"},{"internalType":"address","name":"allocationProvider","type":"address"},{"internalType":"contract IAction[]","name":"actions","type":"address[]"},{"internalType":"enum RequestType[]","name":"actionRequestTypes","type":"uint8[]"},{"components":[{"internalType":"string","name":"methodSignature","type":"string"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"bytes2","name":"operator","type":"bytes2"},{"internalType":"uint256","name":"expectedValue","type":"uint256"},{"internalType":"enum GuardParamType[]","name":"methodParamTypes","type":"uint8[]"},{"internalType":"bytes[]","name":"methodParamValues","type":"bytes[]"}],"internalType":"struct GuardDefinition[][]","name":"guards","type":"tuple[][]"},{"internalType":"enum RequestType[]","name":"guardRequestTypes","type":"uint8[]"},{"internalType":"uint16","name":"managementFeePct","type":"uint16"},{"internalType":"uint16","name":"depositFeePct","type":"uint16"},{"internalType":"uint16","name":"performanceFeePct","type":"uint16"},{"internalType":"bool","name":"allowRedeemFor","type":"bool"}],"internalType":"struct SmartVaultSpecification","name":"specification","type":"tuple"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"deploySmartVaultDeterministically","outputs":[{"internalType":"contract ISmartVault","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"smartVaultName","type":"string"},{"internalType":"string","name":"svtSymbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"uint256","name":"assetGroupId","type":"uint256"},{"internalType":"address[]","name":"strategies","type":"address[]"},{"internalType":"uint16a16","name":"strategyAllocation","type":"uint256"},{"internalType":"int8","name":"riskTolerance","type":"int8"},{"internalType":"address","name":"riskProvider","type":"address"},{"internalType":"address","name":"allocationProvider","type":"address"},{"internalType":"contract IAction[]","name":"actions","type":"address[]"},{"internalType":"enum RequestType[]","name":"actionRequestTypes","type":"uint8[]"},{"components":[{"internalType":"string","name":"methodSignature","type":"string"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"bytes2","name":"operator","type":"bytes2"},{"internalType":"uint256","name":"expectedValue","type":"uint256"},{"internalType":"enum GuardParamType[]","name":"methodParamTypes","type":"uint8[]"},{"internalType":"bytes[]","name":"methodParamValues","type":"bytes[]"}],"internalType":"struct GuardDefinition[][]","name":"guards","type":"tuple[][]"},{"internalType":"enum RequestType[]","name":"guardRequestTypes","type":"uint8[]"},{"internalType":"uint16","name":"managementFeePct","type":"uint16"},{"internalType":"uint16","name":"depositFeePct","type":"uint16"},{"internalType":"uint16","name":"performanceFeePct","type":"uint16"},{"internalType":"bool","name":"allowRedeemFor","type":"bool"}],"internalType":"struct SmartVaultSpecification","name":"specification","type":"tuple"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"predictDeterministicAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]
