编译器
0.8.17+commit.8df45f5f
文件 1 的 33：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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 33：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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 3 的 33：AggregatorV3Interface.sol
pragma solidity ^0.8.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
文件 4 的 33：Authorized.sol
pragma solidity ^0.8.17;
import '@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol';
import './AuthorizedHelpers.sol';
import './interfaces/IAuthorized.sol';
import './interfaces/IAuthorizer.sol';
contract Authorized is IAuthorized, Initializable, AuthorizedHelpers {
address public override authorizer;
modifier auth() {
_authenticate(msg.sender, msg.sig);
_;
}
modifier authP(uint256[] memory params) {
_authenticate(msg.sender, msg.sig, params);
_;
}
constructor() {
_disableInitializers();
}
function __Authorized_init(address _authorizer) internal onlyInitializing {
__Authorized_init_unchained(_authorizer);
}
function __Authorized_init_unchained(address _authorizer) internal onlyInitializing {
authorizer = _authorizer;
}
function _authenticate(address who, bytes4 what) internal view {
_authenticate(who, what, new uint256[](0));
}
function _authenticate(address who, bytes4 what, uint256[] memory how) internal view {
if (!_isAuthorized(who, what, how)) revert AuthSenderNotAllowed(who, what, how);
}
function _hasPermissions(address who) internal view returns (bool) {
return IAuthorizer(authorizer).hasPermissions(who, address(this));
}
function _isAuthorized(address who, bytes4 what) internal view returns (bool) {
return _isAuthorized(who, what, new uint256[](0));
}
function _isAuthorized(address who, bytes4 what, uint256[] memory how) internal view returns (bool) {
return IAuthorizer(authorizer).isAuthorized(who, address(this), what, how);
}
}
文件 5 的 33：AuthorizedHelpers.sol
pragma solidity ^0.8.17;
contract AuthorizedHelpers {
function authParams(address p1) internal pure returns (uint256[] memory r) {
return authParams(uint256(uint160(p1)));
}
function authParams(bytes32 p1) internal pure returns (uint256[] memory r) {
return authParams(uint256(p1));
}
function authParams(uint256 p1) internal pure returns (uint256[] memory r) {
r = new uint256[](1);
r[0] = p1;
}
function authParams(address p1, bool p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = p2 ? 1 : 0;
}
function authParams(address p1, uint256 p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = p2;
}
function authParams(address p1, address p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
}
function authParams(bytes32 p1, bytes32 p2) internal pure returns (uint256[] memory r) {
r = new uint256[](2);
r[0] = uint256(p1);
r[1] = uint256(p2);
}
function authParams(address p1, address p2, uint256 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = p3;
}
function authParams(address p1, address p2, address p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = uint256(uint160(p3));
}
function authParams(address p1, address p2, bytes4 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = uint256(uint32(p3));
}
function authParams(address p1, uint256 p2, uint256 p3) internal pure returns (uint256[] memory r) {
r = new uint256[](3);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
}
function authParams(address p1, address p2, uint256 p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(uint160(p1));
r[1] = uint256(uint160(p2));
r[2] = p3;
r[3] = p4;
}
function authParams(address p1, uint256 p2, uint256 p3, uint256 p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
r[3] = p4;
}
function authParams(bytes32 p1, address p2, uint256 p3, bool p4) internal pure returns (uint256[] memory r) {
r = new uint256[](4);
r[0] = uint256(p1);
r[1] = uint256(uint160(p2));
r[2] = p3;
r[3] = p4 ? 1 : 0;
}
function authParams(address p1, uint256 p2, uint256 p3, uint256 p4, uint256 p5)
internal
pure
returns (uint256[] memory r)
{
r = new uint256[](5);
r[0] = uint256(uint160(p1));
r[1] = p2;
r[2] = p3;
r[3] = p4;
r[4] = p5;
}
}
文件 6 的 33：Authorizer.sol
pragma solidity ^0.8.17;
import '@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import './AuthorizedHelpers.sol';
import './interfaces/IAuthorizer.sol';
contract Authorizer is IAuthorizer, AuthorizedHelpers, Initializable, ReentrancyGuardUpgradeable {
address public constant ANYONE = address(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF);
address public constant ANYWHERE = address(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF);
enum Op {
NONE,
EQ,
NEQ,
GT,
LT,
GTE,
LTE
}
struct Permission {
bool authorized;
Param[] params;
}
struct PermissionsList {
uint256 count;
mapping (bytes4 => Permission) permissions;
}
mapping (address => mapping (address => PermissionsList)) private _permissionsLists;
constructor() {
_disableInitializers();
}
function initialize(address[] memory owners) external virtual initializer {
__ReentrancyGuard_init();
for (uint256 i = 0; i < owners.length; i++) {
_authorize(owners[i], address(this), IAuthorizer.authorize.selector, new Param[](0));
_authorize(owners[i], address(this), IAuthorizer.unauthorize.selector, new Param[](0));
}
}
function hasPermissions(address who, address where) external view override returns (bool) {
return _permissionsLists[who][where].count > 0;
}
function getPermissionsLength(address who, address where) external view override returns (uint256) {
return _permissionsLists[who][where].count;
}
function isAuthorized(address who, address where, bytes4 what, uint256[] memory how)
public
view
override
returns (bool)
{
if (_isAuthorized(who, where, what, how)) return true;
if (_isAuthorized(ANYONE, where, what, how)) return true;
if (_isAuthorized(who, ANYWHERE, what, how)) return true;
if (_isAuthorized(ANYONE, ANYWHERE, what, how)) return true;
return false;
}
function getPermissionParams(address who, address where, bytes4 what)
external
view
override
returns (Param[] memory)
{
return _permissionsLists[who][where].permissions[what].params;
}
function changePermissions(PermissionChange[] memory changes) external override {
for (uint256 i = 0; i < changes.length; i++) {
PermissionChange memory change = changes[i];
for (uint256 j = 0; j < change.grants.length; j++) {
GrantPermission memory grant = change.grants[j];
authorize(grant.who, change.where, grant.what, grant.params);
}
for (uint256 j = 0; j < change.revokes.length; j++) {
RevokePermission memory revoke = change.revokes[j];
unauthorize(revoke.who, change.where, revoke.what);
}
}
}
function authorize(address who, address where, bytes4 what, Param[] memory params) public override nonReentrant {
uint256[] memory how = authParams(who, where, what);
_authenticate(msg.sender, IAuthorizer.authorize.selector, how);
_authorize(who, where, what, params);
}
function unauthorize(address who, address where, bytes4 what) public override nonReentrant {
uint256[] memory how = authParams(who, where, what);
_authenticate(msg.sender, IAuthorizer.unauthorize.selector, how);
_unauthorize(who, where, what);
}
function _authenticate(address who, bytes4 what, uint256[] memory how) internal view {
bool allowed = isAuthorized(who, address(this), what, how);
if (!allowed) revert AuthorizerSenderNotAllowed(who, address(this), what, how);
}
function _isAuthorized(address who, address where, bytes4 what, uint256[] memory how) internal view returns (bool) {
Permission storage permission = _permissionsLists[who][where].permissions[what];
return permission.authorized && _evalParams(permission.params, how);
}
function _authorize(address who, address where, bytes4 what, Param[] memory params) internal {
PermissionsList storage list = _permissionsLists[who][where];
Permission storage permission = list.permissions[what];
if (!permission.authorized) list.count++;
permission.authorized = true;
delete permission.params;
for (uint256 i = 0; i < params.length; i++) permission.params.push(params[i]);
emit Authorized(who, where, what, params);
}
function _unauthorize(address who, address where, bytes4 what) internal {
PermissionsList storage list = _permissionsLists[who][where];
Permission storage permission = list.permissions[what];
if (permission.authorized) list.count--;
delete list.permissions[what];
emit Unauthorized(who, where, what);
}
function _evalParams(Param[] memory params, uint256[] memory how) private pure returns (bool) {
for (uint256 i = 0; i < params.length; i++) {
Param memory param = params[i];
if ((i < how.length && !_evalParam(param, how[i])) || (i >= how.length && Op(param.op) != Op.NONE)) {
return false;
}
}
return true;
}
function _evalParam(Param memory param, uint256 how) private pure returns (bool) {
if (Op(param.op) == Op.NONE) return true;
if (Op(param.op) == Op.EQ) return how == param.value;
if (Op(param.op) == Op.NEQ) return how != param.value;
if (Op(param.op) == Op.GT) return how > param.value;
if (Op(param.op) == Op.LT) return how < param.value;
if (Op(param.op) == Op.GTE) return how >= param.value;
if (Op(param.op) == Op.LTE) return how <= param.value;
revert AuthorizerInvalidParamOp(param.op);
}
}
文件 7 的 33：Bytes32AddressLib.sol
pragma solidity >=0.8.0;
library Bytes32AddressLib {
function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
return address(uint160(uint256(bytesValue)));
}
function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
return bytes32(bytes20(addressValue));
}
}
文件 8 的 33：BytesHelpers.sol
pragma solidity ^0.8.0;
library BytesHelpers {
error BytesOutOfBounds(uint256 start, uint256 length);
function concat(bytes memory self, address value) internal pure returns (bytes memory) {
return abi.encodePacked(self, value);
}
function concat(bytes memory self, uint24 value) internal pure returns (bytes memory) {
return abi.encodePacked(self, value);
}
function toUint256(bytes memory self) internal pure returns (uint256) {
return toUint256(self, 0);
}
function toUint256(bytes memory self, uint256 start) internal pure returns (uint256 result) {
if (self.length < start + 32) revert BytesOutOfBounds(start, self.length);
assembly {
result := mload(add(add(self, 0x20), start))
}
}
}
文件 9 的 33：CREATE3.sol
pragma solidity >=0.8.0;
import {Bytes32AddressLib} from "./Bytes32AddressLib.sol";
library CREATE3 {
using Bytes32AddressLib for bytes32;
bytes internal constant PROXY_BYTECODE = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";
bytes32 internal constant PROXY_BYTECODE_HASH = keccak256(PROXY_BYTECODE);
function deploy(
bytes32 salt,
bytes memory creationCode,
uint256 value
) internal returns (address deployed) {
bytes memory proxyChildBytecode = PROXY_BYTECODE;
address proxy;
assembly {
proxy := create2(0, add(proxyChildBytecode, 32), mload(proxyChildBytecode), salt)
}
require(proxy != address(0), "DEPLOYMENT_FAILED");
deployed = getDeployed(salt);
(bool success, ) = proxy.call{value: value}(creationCode);
require(success && deployed.code.length != 0, "INITIALIZATION_FAILED");
}
function getDeployed(bytes32 salt) internal view returns (address) {
address proxy = keccak256(
abi.encodePacked(
bytes1(0xFF),
address(this),
salt,
PROXY_BYTECODE_HASH
)
).fromLast20Bytes();
return
keccak256(
abi.encodePacked(
hex"d6_94",
proxy,
hex"01"
)
).fromLast20Bytes();
}
}
文件 10 的 33：Denominations.sol
pragma solidity ^0.8.0;
library Denominations {
address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address internal constant USD = address(840);
function isNativeToken(address token) internal pure returns (bool) {
return token == NATIVE_TOKEN;
}
}
文件 11 的 33：Deployer.sol
pragma solidity ^0.8.0;
import 'solmate/src/utils/CREATE3.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@mimic-fi/v3-authorizer/contracts/Authorizer.sol';
import '@mimic-fi/v3-price-oracle/contracts/PriceOracle.sol';
import '@mimic-fi/v3-smart-vault/contracts/SmartVault.sol';
import '@mimic-fi/v3-registry/contracts/interfaces/IRegistry.sol';
import './interfaces/IDeployer.sol';
contract Deployer is IDeployer {
using Address for address;
address public immutable override registry;
constructor(address _registry) {
registry = _registry;
}
function getAddress(address sender, string memory namespace, string memory name)
external
view
override
returns (address)
{
return CREATE3.getDeployed(getSalt(sender, namespace, name));
}
function getSalt(address sender, string memory namespace, string memory name)
public
pure
override
returns (bytes32)
{
return keccak256(abi.encodePacked(sender, namespace, name));
}
function deployAuthorizer(string memory namespace, string memory name, AuthorizerParams memory params)
external
override
{
_validateImplementation(params.impl);
address instance = _deployClone(namespace, name, params.impl);
Authorizer(instance).initialize(params.owners);
emit AuthorizerDeployed(namespace, name, instance, params.impl);
}
function deployPriceOracle(string memory namespace, string memory name, PriceOracleParams memory params)
external
override
{
_validateImplementation(params.impl);
address instance = _deployClone(namespace, name, params.impl);
PriceOracle(instance).initialize(params.authorizer, params.signer, params.pivot, _castFeedsData(params.feeds));
emit PriceOracleDeployed(namespace, name, instance, params.impl);
}
function deploySmartVault(string memory namespace, string memory name, SmartVaultParams memory params)
external
override
{
_validateImplementation(params.impl);
address payable instance = payable(_deployClone(namespace, name, params.impl));
SmartVault(instance).initialize(params.authorizer, params.priceOracle);
emit SmartVaultDeployed(namespace, name, instance, params.impl);
}
function deployTask(string memory namespace, string memory name, TaskParams memory params) external override {
if (!params.custom) _validateImplementation(params.impl);
address instance = _deployClone(namespace, name, params.impl);
if (params.initializeData.length > 0) instance.functionCall(params.initializeData, 'DEPLOYER_TASK_INIT_FAILED');
emit TaskDeployed(namespace, name, instance, params.impl);
}
function _validateImplementation(address implementation) internal view {
IRegistry reg = IRegistry(registry);
if (!reg.isRegistered(implementation)) revert DeployerImplementationNotRegistered(implementation);
if (reg.isStateless(implementation)) revert DeployerImplementationStateless(implementation);
if (reg.isDeprecated(implementation)) revert DeployerImplementationDeprecated(implementation);
}
function _deployClone(string memory namespace, string memory name, address implementation)
internal
returns (address)
{
if (bytes(namespace).length == 0) revert DeployerNamespaceEmpty();
if (bytes(name).length == 0) revert DeployerNameEmpty();
bytes memory bytecode = abi.encodePacked(
hex'3d602d80600a3d3981f3363d3d373d3d3d363d73',
implementation,
hex'5af43d82803e903d91602b57fd5bf3'
);
bytes32 salt = getSalt(msg.sender, namespace, name);
return CREATE3.deploy(salt, bytecode, 0);
}
function _castFeedsData(FeedData[] memory feeds) private pure returns (PriceOracle.FeedData[] memory result) {
assembly {
result := feeds
}
}
}
文件 12 的 33：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
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");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' 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 if (signature.length == 64) {
bytes32 r;
bytes32 vs;
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} 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);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
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", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 13 的 33：ERC20Helpers.sol
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import './Denominations.sol';
library ERC20Helpers {
function approve(address token, address to, uint256 amount) internal {
SafeERC20.safeApprove(IERC20(token), to, 0);
SafeERC20.safeApprove(IERC20(token), to, amount);
}
function transfer(address token, address to, uint256 amount) internal {
if (Denominations.isNativeToken(token)) Address.sendValue(payable(to), amount);
else SafeERC20.safeTransfer(IERC20(token), to, amount);
}
function balanceOf(address token, address account) internal view returns (uint256) {
if (Denominations.isNativeToken(token)) return address(account).balance;
else return IERC20(token).balanceOf(address(account));
}
}
文件 14 的 33：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 15 的 33：FixedPoint.sol
pragma solidity ^0.8.0;
library FixedPoint {
uint256 internal constant ONE = 1e18;
error FixedPointMulOverflow(uint256 a, uint256 b);
error FixedPointZeroDivision();
error FixedPointDivInternal(uint256 a, uint256 aInflated);
function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
uint256 product = a * b;
if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b);
return product / ONE;
}
}
function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
uint256 product = a * b;
if (a != 0 && product / a != b) revert FixedPointMulOverflow(a, b);
return product == 0 ? 0 : (((product - 1) / ONE) + 1);
}
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
if (b == 0) revert FixedPointZeroDivision();
if (a == 0) return 0;
uint256 aInflated = a * ONE;
if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated);
return aInflated / b;
}
}
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
if (b == 0) revert FixedPointZeroDivision();
if (a == 0) return 0;
uint256 aInflated = a * ONE;
if (aInflated / a != ONE) revert FixedPointDivInternal(a, aInflated);
return ((aInflated - 1) / b) + 1;
}
}
}
文件 16 的 33：IAuthorized.sol
pragma solidity >=0.8.0;
interface IAuthorized {
error AuthSenderNotAllowed(address who, bytes4 what, uint256[] how);
function authorizer() external view returns (address);
}
文件 17 的 33：IAuthorizer.sol
pragma solidity >=0.8.0;
interface IAuthorizer {
struct PermissionChange {
address where;
GrantPermission[] grants;
RevokePermission[] revokes;
}
struct GrantPermission {
address who;
bytes4 what;
Param[] params;
}
struct RevokePermission {
address who;
bytes4 what;
}
struct Param {
uint8 op;
uint248 value;
}
error AuthorizerSenderNotAllowed(address who, address where, bytes4 what, uint256[] how);
error AuthorizerInvalidParamOp(uint8 op);
event Authorized(address indexed who, address indexed where, bytes4 indexed what, Param[] params);
event Unauthorized(address indexed who, address indexed where, bytes4 indexed what);
function hasPermissions(address who, address where) external view returns (bool);
function getPermissionsLength(address who, address where) external view returns (uint256);
function isAuthorized(address who, address where, bytes4 what, uint256[] memory how) external view returns (bool);
function getPermissionParams(address who, address where, bytes4 what) external view returns (Param[] memory);
function changePermissions(PermissionChange[] memory changes) external;
function authorize(address who, address where, bytes4 what, Param[] memory params) external;
function unauthorize(address who, address where, bytes4 what) external;
}
文件 18 的 33：IDeployer.sol
pragma solidity >=0.8.0;
interface IDeployer {
error DeployerNamespaceEmpty();
error DeployerNameEmpty();
error DeployerImplementationNotRegistered(address implementation);
error DeployerImplementationStateless(address implementation);
error DeployerImplementationDeprecated(address implementation);
event AuthorizerDeployed(string namespace, string name, address instance, address implementation);
event PriceOracleDeployed(string namespace, string name, address instance, address implementation);
event SmartVaultDeployed(string namespace, string name, address instance, address implementation);
event TaskDeployed(string namespace, string name, address instance, address implementation);
function registry() external view returns (address);
struct AuthorizerParams {
address impl;
address[] owners;
}
struct PriceOracleParams {
address impl;
address authorizer;
address signer;
address pivot;
FeedData[] feeds;
}
struct FeedData {
address base;
address quote;
address feed;
}
struct SmartVaultParams {
address impl;
address authorizer;
address priceOracle;
}
struct TaskParams {
bool custom;
address impl;
bytes initializeData;
}
function getAddress(address sender, string memory namespace, string memory name) external view returns (address);
function getSalt(address sender, string memory namespace, string memory name) external pure returns (bytes32);
function deployAuthorizer(string memory namespace, string memory name, AuthorizerParams memory params) external;
function deployPriceOracle(string memory namespace, string memory name, PriceOracleParams memory params) external;
function deploySmartVault(string memory namespace, string memory name, SmartVaultParams memory params) external;
function deployTask(string memory namespace, string memory name, TaskParams memory params) external;
}
文件 19 的 33：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);
}
文件 20 的 33：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);
}
文件 21 的 33：IFeeController.sol
pragma solidity >=0.8.0;
interface IFeeController {
error FeeControllerCollectorZero();
error FeeControllerMaxPctZero();
error FeeControllerMaxPctAboveOne();
error FeeControllerMaxPctNotSet(address smartVault);
error FeeControllerPctAboveMax(address smartVault, uint256 pct, uint256 maxPct);
error FeeControllerMaxPctAbovePrevious(address smartVault, uint256 requestedMaxPct, uint256 previousMaxPct);
event DefaultFeeCollectorSet(address indexed collector);
event MaxFeePercentageSet(address indexed smartVault, uint256 maxPct);
event FeePercentageSet(address indexed smartVault, uint256 pct);
event FeeCollectorSet(address indexed smartVault, address indexed collector);
function defaultFeeCollector() external view returns (address);
function hasFee(address smartVault) external view returns (bool);
function getFee(address smartVault) external view returns (uint256 max, uint256 pct, address collector);
function setDefaultFeeCollector(address collector) external;
function setMaxFeePercentage(address smartVault, uint256 maxPct) external;
function setFeePercentage(address smartVault, uint256 pct) external;
function setFeeCollector(address smartVault, address collector) external;
}
文件 22 的 33：IPriceOracle.sol
pragma solidity >=0.8.0;
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorized.sol';
interface IPriceOracle is IAuthorized {
struct PriceData {
address base;
address quote;
uint256 rate;
uint256 deadline;
}
error PriceOracleInvalidSigner(address signer);
error PriceOracleMissingFeed(address base, address quote);
error PriceOracleOutdatedPrice(address base, address quote, uint256 deadline, uint256 currentTimestamp);
error PriceOracleBaseDecimalsTooBig(address base, uint256 baseDecimals, address quote, uint256 quoteDecimals);
error PriceOracleInverseFeedDecimalsTooBig(address inverseFeed, uint256 inverseFeedDecimals);
error PriceOracleQuoteFeedDecimalsTooBig(uint256 quoteFeedDecimals, uint256 baseFeedDecimals);
event SignerSet(address indexed signer, bool allowed);
event FeedSet(address indexed base, address indexed quote, address feed);
function isSignerAllowed(address signer) external view returns (bool);
function getAllowedSigners() external view returns (address[] memory);
function getPricesDigest(PriceData[] memory prices) external view returns (bytes32);
function getPrice(address base, address quote) external view returns (uint256);
function getPrice(address base, address quote, bytes memory data) external view returns (uint256);
function getFeed(address base, address quote) external view returns (address);
function setSigner(address signer, bool allowed) external;
function setFeed(address base, address quote, address feed) external;
}
文件 23 的 33：IRegistry.sol
pragma solidity ^0.8.0;
import './IRegistry.sol';
interface IRegistry {
error RegistryImplementationAddressZero();
error RegistryImplementationRegistered(address implementation);
error RegistryImplementationNotRegistered(address implementation);
error RegistryImplementationDeprecated(address implementation);
event Registered(address indexed implementation, string name, bool stateless);
event Deprecated(address indexed implementation);
function isRegistered(address implementation) external view returns (bool);
function isStateless(address implementation) external view returns (bool);
function isDeprecated(address implementation) external view returns (bool);
function create(string memory name, bytes memory code, bool stateless) external;
function register(string memory name, address implementation, bool stateless) external;
function deprecate(address implementation) external;
}
文件 24 的 33：ISmartVault.sol
pragma solidity >=0.8.0;
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorized.sol';
interface ISmartVault is IAuthorized {
error SmartVaultPaused();
error SmartVaultUnpaused();
error SmartVaultTokenZero();
error SmartVaultAmountZero();
error SmartVaultRecipientZero();
error SmartVaultConnectorDeprecated(address connector);
error SmartVaultConnectorNotRegistered(address connector);
error SmartVaultConnectorNotStateless(address connector);
error SmartVaultBalanceConnectorIdZero();
error SmartVaultBalanceConnectorInsufficientBalance(bytes32 id, address token, uint256 balance, uint256 amount);
error SmartVaultInsufficientNativeTokenBalance(uint256 balance, uint256 amount);
event Paused();
event Unpaused();
event PriceOracleSet(address indexed priceOracle);
event ConnectorCheckOverridden(address indexed connector, bool ignored);
event BalanceConnectorUpdated(bytes32 indexed id, address indexed token, uint256 amount, bool added);
event Executed(address indexed connector, bytes data, bytes result);
event Called(address indexed target, bytes data, uint256 value, bytes result);
event Wrapped(uint256 amount);
event Unwrapped(uint256 amount);
event Collected(address indexed token, address indexed from, uint256 amount);
event Withdrawn(address indexed token, address indexed recipient, uint256 amount, uint256 fee);
function isPaused() external view returns (bool);
function priceOracle() external view returns (address);
function registry() external view returns (address);
function feeController() external view returns (address);
function wrappedNativeToken() external view returns (address);
function isConnectorCheckIgnored(address connector) external view returns (bool);
function getBalanceConnector(bytes32 id, address token) external view returns (uint256);
function hasPermissions(address who) external view returns (bool);
function pause() external;
function unpause() external;
function setPriceOracle(address newPriceOracle) external;
function overrideConnectorCheck(address connector, bool ignored) external;
function updateBalanceConnector(bytes32 id, address token, uint256 amount, bool add) external;
function execute(address connector, bytes memory data) external returns (bytes memory result);
function call(address target, bytes memory data, uint256 value) external returns (bytes memory result);
function wrap(uint256 amount) external;
function unwrap(uint256 amount) external;
function collect(address token, address from, uint256 amount) external;
function withdraw(address token, address recipient, uint256 amount) external;
}
文件 25 的 33：IWrappedNativeToken.sol
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
interface IWrappedNativeToken is IERC20 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
文件 26 的 33：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);
}
}
}
文件 27 的 33：PriceOracle.sol
pragma solidity ^0.8.0;
import '@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/math/SafeCast.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-helpers/contracts/utils/BytesHelpers.sol';
import './interfaces/IPriceOracle.sol';
contract PriceOracle is IPriceOracle, Authorized, ReentrancyGuardUpgradeable {
using FixedPoint for uint256;
using BytesHelpers for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private constant FP_DECIMALS = 18;
uint256 private constant INVERSE_FEED_MAX_DECIMALS = 36;
address public pivot;
mapping (address => mapping (address => address)) public override getFeed;
EnumerableSet.AddressSet private _signers;
struct FeedData {
address base;
address quote;
address feed;
}
function initialize(address _authorizer, address _signer, address _pivot, FeedData[] memory _feeds)
external
initializer
{
__PriceOracle_init(_authorizer, _signer, _pivot, _feeds);
}
function __PriceOracle_init(address _authorizer, address _signer, address _pivot, FeedData[] memory _feeds)
internal
onlyInitializing
{
__ReentrancyGuard_init();
__Authorized_init(_authorizer);
__PriceOracle_init_unchained(_authorizer, _signer, _pivot, _feeds);
}
function __PriceOracle_init_unchained(address, address _signer, address _pivot, FeedData[] memory _feeds)
internal
onlyInitializing
{
_setSigner(_signer, true);
pivot = _pivot;
for (uint256 i = 0; i < _feeds.length; i++) _setFeed(_feeds[i].base, _feeds[i].quote, _feeds[i].feed);
}
function isSignerAllowed(address signer) public view override returns (bool) {
return _signers.contains(signer);
}
function getAllowedSigners() external view override returns (address[] memory) {
return _signers.values();
}
function getPricesDigest(PriceData[] memory prices) public pure override returns (bytes32) {
return ECDSA.toEthSignedMessageHash(keccak256(abi.encode(prices)));
}
function getPrice(address base, address quote) public view override returns (uint256) {
if (base == quote) return FixedPoint.ONE;
uint256 baseDecimals = IERC20Metadata(base).decimals();
uint256 quoteDecimals = IERC20Metadata(quote).decimals();
bool areBaseDecimalsTooBig = baseDecimals > quoteDecimals + FP_DECIMALS;
if (areBaseDecimalsTooBig) revert PriceOracleBaseDecimalsTooBig(base, baseDecimals, quote, quoteDecimals);
uint256 resultDecimals = quoteDecimals + FP_DECIMALS - baseDecimals;
(uint256 price, uint256 decimals) = _getPrice(base, quote);
return _scalePrice(price, decimals, resultDecimals);
}
function getPrice(address base, address quote, bytes memory data) external view override returns (uint256) {
if (base == quote) return FixedPoint.ONE;
PriceData[] memory prices = _decodePricesData(data);
for (uint256 i = 0; i < prices.length; i++) {
PriceData memory price = prices[i];
if (price.base == base && price.quote == quote) {
bool isPastDeadline = price.deadline < block.timestamp;
if (isPastDeadline) revert PriceOracleOutdatedPrice(base, quote, price.deadline, block.timestamp);
return price.rate;
}
}
return getPrice(base, quote);
}
function setSigner(address signer, bool allowed) external override nonReentrant authP(authParams(signer, allowed)) {
_setSigner(signer, allowed);
}
function setFeed(address base, address quote, address feed)
external
override
nonReentrant
authP(authParams(base, quote, feed))
{
_setFeed(base, quote, feed);
}
function _getPrice(address base, address quote) internal view returns (uint256 price, uint256 decimals) {
address feed = getFeed[base][quote];
if (feed != address(0)) return _getFeedData(feed);
address inverseFeed = getFeed[quote][base];
if (inverseFeed != address(0)) return _getInversePrice(inverseFeed);
address baseFeed = getFeed[base][pivot];
address quoteFeed = getFeed[quote][pivot];
if (baseFeed != address(0) && quoteFeed != address(0)) return _getPivotPrice(baseFeed, quoteFeed);
revert PriceOracleMissingFeed(base, quote);
}
function _getFeedData(address feed) internal view returns (uint256 price, uint256 decimals) {
decimals = AggregatorV3Interface(feed).decimals();
(, int256 priceInt, , , ) = AggregatorV3Interface(feed).latestRoundData();
price = SafeCast.toUint256(priceInt);
}
function _getInversePrice(address inverseFeed) internal view returns (uint256 price, uint256 decimals) {
(uint256 inversePrice, uint256 inverseFeedDecimals) = _getFeedData(inverseFeed);
bool areInverseFeedDecimalsTooBig = inverseFeedDecimals > INVERSE_FEED_MAX_DECIMALS;
if (areInverseFeedDecimalsTooBig) revert PriceOracleInverseFeedDecimalsTooBig(inverseFeed, inverseFeedDecimals);
price = FixedPoint.ONE.divDown(inversePrice);
decimals = INVERSE_FEED_MAX_DECIMALS - inverseFeedDecimals;
}
function _getPivotPrice(address baseFeed, address quoteFeed)
internal
view
returns (uint256 price, uint256 decimals)
{
(uint256 basePrice, uint256 baseFeedDecimals) = _getFeedData(baseFeed);
(uint256 quotePrice, uint256 quoteFeedDecimals) = _getFeedData(quoteFeed);
bool areQuoteFeedDecimalsTooBig = quoteFeedDecimals > baseFeedDecimals + FP_DECIMALS;
if (areQuoteFeedDecimalsTooBig) revert PriceOracleQuoteFeedDecimalsTooBig(quoteFeedDecimals, baseFeedDecimals);
price = basePrice.divDown(quotePrice);
decimals = baseFeedDecimals + FP_DECIMALS - quoteFeedDecimals;
}
function _scalePrice(uint256 price, uint256 priceDecimals, uint256 resultDecimals) internal pure returns (uint256) {
return
resultDecimals >= priceDecimals
? (price * 10**(resultDecimals - priceDecimals))
: (price / 10**(priceDecimals - resultDecimals));
}
function _decodePricesData(bytes memory data) internal view returns (PriceData[] memory) {
if (!_isOffChainDataEncodedProperly(data)) return new PriceData[](0);
(PriceData[] memory prices, bytes memory signature) = abi.decode(data, (PriceData[], bytes));
(address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(getPricesDigest(prices), signature);
bool isSignerValid = error == ECDSA.RecoverError.NoError && isSignerAllowed(recovered);
if (!isSignerValid) revert PriceOracleInvalidSigner(recovered);
return prices;
}
function _setSigner(address signer, bool allowed) internal {
allowed ? _signers.add(signer) : _signers.remove(signer);
emit SignerSet(signer, allowed);
}
function _setFeed(address base, address quote, address feed) internal {
getFeed[base][quote] = feed;
emit FeedSet(base, quote, feed);
}
function _isOffChainDataEncodedProperly(bytes memory data) private pure returns (bool) {
uint256 minimumLength = 32 + 32 + 32 + 32 + 96;
if (data.length < minimumLength) return false;
uint256 pricesOffset = data.toUint256(0);
if (data.length < pricesOffset) return false;
uint256 pricesLength = data.toUint256(pricesOffset);
if (data.length != minimumLength + (pricesLength * 128)) return false;
uint256 signatureOffset = data.toUint256(32);
if (signatureOffset != (32 * 3) + (pricesLength * 128)) return false;
uint256 signatureLength = data.toUint256(signatureOffset);
if (signatureLength != 64 && signatureLength != 65) return false;
for (uint256 i = 0; i < pricesLength; i++) {
uint256 offset = i * 128;
uint256 priceBase = data.toUint256(32 * 3 + offset);
if (priceBase > type(uint160).max) return false;
uint256 priceQuote = data.toUint256(32 * 4 + offset);
if (priceQuote > type(uint160).max) return false;
}
return true;
}
}
文件 28 的 33：ReentrancyGuardUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ReentrancyGuardUpgradeable is Initializable {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
uint256[49] private __gap;
}
文件 29 的 33：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248) {
require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits");
return int248(value);
}
function toInt240(int256 value) internal pure returns (int240) {
require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits");
return int240(value);
}
function toInt232(int256 value) internal pure returns (int232) {
require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits");
return int232(value);
}
function toInt224(int256 value) internal pure returns (int224) {
require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits");
return int224(value);
}
function toInt216(int256 value) internal pure returns (int216) {
require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits");
return int216(value);
}
function toInt208(int256 value) internal pure returns (int208) {
require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits");
return int208(value);
}
function toInt200(int256 value) internal pure returns (int200) {
require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits");
return int200(value);
}
function toInt192(int256 value) internal pure returns (int192) {
require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits");
return int192(value);
}
function toInt184(int256 value) internal pure returns (int184) {
require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits");
return int184(value);
}
function toInt176(int256 value) internal pure returns (int176) {
require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits");
return int176(value);
}
function toInt168(int256 value) internal pure returns (int168) {
require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits");
return int168(value);
}
function toInt160(int256 value) internal pure returns (int160) {
require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits");
return int160(value);
}
function toInt152(int256 value) internal pure returns (int152) {
require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits");
return int152(value);
}
function toInt144(int256 value) internal pure returns (int144) {
require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits");
return int144(value);
}
function toInt136(int256 value) internal pure returns (int136) {
require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits");
return int136(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
return int128(value);
}
function toInt120(int256 value) internal pure returns (int120) {
require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits");
return int120(value);
}
function toInt112(int256 value) internal pure returns (int112) {
require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits");
return int112(value);
}
function toInt104(int256 value) internal pure returns (int104) {
require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits");
return int104(value);
}
function toInt96(int256 value) internal pure returns (int96) {
require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits");
return int96(value);
}
function toInt88(int256 value) internal pure returns (int88) {
require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits");
return int88(value);
}
function toInt80(int256 value) internal pure returns (int80) {
require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits");
return int80(value);
}
function toInt72(int256 value) internal pure returns (int72) {
require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits");
return int72(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
return int64(value);
}
function toInt56(int256 value) internal pure returns (int56) {
require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits");
return int56(value);
}
function toInt48(int256 value) internal pure returns (int48) {
require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits");
return int48(value);
}
function toInt40(int256 value) internal pure returns (int40) {
require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits");
return int40(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
return int32(value);
}
function toInt24(int256 value) internal pure returns (int24) {
require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits");
return int24(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 30 的 33：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-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");
}
}
}
文件 31 的 33：SmartVault.sol
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@mimic-fi/v3-authorizer/contracts/Authorized.sol';
import '@mimic-fi/v3-authorizer/contracts/interfaces/IAuthorizer.sol';
import '@mimic-fi/v3-fee-controller/contracts/interfaces/IFeeController.sol';
import '@mimic-fi/v3-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v3-helpers/contracts/utils/ERC20Helpers.sol';
import '@mimic-fi/v3-helpers/contracts/utils/IWrappedNativeToken.sol';
import '@mimic-fi/v3-price-oracle/contracts/interfaces/IPriceOracle.sol';
import '@mimic-fi/v3-registry/contracts/interfaces/IRegistry.sol';
import './interfaces/ISmartVault.sol';
contract SmartVault is ISmartVault, Authorized, ReentrancyGuardUpgradeable {
using SafeERC20 for IERC20;
using FixedPoint for uint256;
bool public override isPaused;
address public override priceOracle;
address public immutable override registry;
address public immutable override feeController;
address public immutable override wrappedNativeToken;
mapping (address => bool) public override isConnectorCheckIgnored;
mapping (bytes32 => mapping (address => uint256)) public override getBalanceConnector;
modifier notPaused() {
if (isPaused) revert SmartVaultPaused();
_;
}
constructor(address _registry, address _feeController, address _wrappedNativeToken) {
registry = _registry;
feeController = _feeController;
wrappedNativeToken = _wrappedNativeToken;
}
function initialize(address _authorizer, address _priceOracle) external virtual initializer {
__SmartVault_init(_authorizer, _priceOracle);
}
function __SmartVault_init(address _authorizer, address _priceOracle) internal onlyInitializing {
__ReentrancyGuard_init();
__Authorized_init(_authorizer);
__SmartVault_init_unchained(_authorizer, _priceOracle);
}
function __SmartVault_init_unchained(address, address _priceOracle) internal onlyInitializing {
_setPriceOracle(_priceOracle);
}
receive() external payable {
}
function hasPermissions(address who) external view override returns (bool) {
return _hasPermissions(who);
}
function pause() external override auth {
if (isPaused) revert SmartVaultPaused();
isPaused = true;
emit Paused();
}
function unpause() external override auth {
if (!isPaused) revert SmartVaultUnpaused();
isPaused = false;
emit Unpaused();
}
function setPriceOracle(address newPriceOracle)
external
override
nonReentrant
notPaused
authP(authParams(newPriceOracle))
{
_setPriceOracle(newPriceOracle);
}
function overrideConnectorCheck(address connector, bool ignored)
external
override
nonReentrant
notPaused
authP(authParams(connector, ignored))
{
isConnectorCheckIgnored[connector] = ignored;
emit ConnectorCheckOverridden(connector, ignored);
}
function updateBalanceConnector(bytes32 id, address token, uint256 amount, bool add)
external
override
nonReentrant
notPaused
authP(authParams(id, token, amount, add))
{
if (id == bytes32(0)) revert SmartVaultBalanceConnectorIdZero();
if (token == address(0)) revert SmartVaultTokenZero();
(add ? _increaseBalanceConnector : _decreaseBalanceConnector)(id, token, amount);
}
function execute(address connector, bytes memory data)
external
override
nonReentrant
notPaused
authP(authParams(connector))
returns (bytes memory result)
{
_validateConnector(connector);
result = Address.functionDelegateCall(connector, data, 'SMART_VAULT_EXECUTE_FAILED');
emit Executed(connector, data, result);
}
function call(address target, bytes memory data, uint256 value)
external
override
nonReentrant
notPaused
authP(authParams(target))
returns (bytes memory result)
{
result = Address.functionCallWithValue(target, data, value, 'SMART_VAULT_CALL_FAILED');
emit Called(target, data, value, result);
}
function wrap(uint256 amount) external override nonReentrant notPaused authP(authParams(amount)) {
if (amount == 0) revert SmartVaultAmountZero();
uint256 balance = address(this).balance;
if (balance < amount) revert SmartVaultInsufficientNativeTokenBalance(balance, amount);
IWrappedNativeToken(wrappedNativeToken).deposit{ value: amount }();
emit Wrapped(amount);
}
function unwrap(uint256 amount) external override nonReentrant notPaused authP(authParams(amount)) {
if (amount == 0) revert SmartVaultAmountZero();
IWrappedNativeToken(wrappedNativeToken).withdraw(amount);
emit Unwrapped(amount);
}
function collect(address token, address from, uint256 amount)
external
override
nonReentrant
notPaused
authP(authParams(token, from, amount))
{
if (amount == 0) revert SmartVaultAmountZero();
IERC20(token).safeTransferFrom(from, address(this), amount);
emit Collected(token, from, amount);
}
function withdraw(address token, address recipient, uint256 amount)
external
override
nonReentrant
notPaused
authP(authParams(token, recipient, amount))
{
if (amount == 0) revert SmartVaultAmountZero();
if (recipient == address(0)) revert SmartVaultRecipientZero();
(, uint256 pct, address collector) = IFeeController(feeController).getFee(address(this));
uint256 feeAmount = amount.mulDown(pct);
_safeTransfer(token, collector, feeAmount);
uint256 withdrawn = amount - feeAmount;
_safeTransfer(token, recipient, withdrawn);
emit Withdrawn(token, recipient, withdrawn, feeAmount);
}
function _safeTransfer(address token, address to, uint256 amount) internal {
if (amount == 0) return;
ERC20Helpers.transfer(token, to, amount);
}
function _setPriceOracle(address newPriceOracle) internal {
priceOracle = newPriceOracle;
emit PriceOracleSet(newPriceOracle);
}
function _increaseBalanceConnector(bytes32 id, address token, uint256 amount) internal {
getBalanceConnector[id][token] += amount;
emit BalanceConnectorUpdated(id, token, amount, true);
}
function _decreaseBalanceConnector(bytes32 id, address token, uint256 amount) internal {
uint256 value = getBalanceConnector[id][token];
if (value < amount) revert SmartVaultBalanceConnectorInsufficientBalance(id, token, value, amount);
getBalanceConnector[id][token] = value - amount;
emit BalanceConnectorUpdated(id, token, amount, false);
}
function _validateConnector(address connector) private view {
if (isConnectorCheckIgnored[connector]) return;
if (!IRegistry(registry).isRegistered(connector)) revert SmartVaultConnectorNotRegistered(connector);
if (!IRegistry(registry).isStateless(connector)) revert SmartVaultConnectorNotStateless(connector);
if (IRegistry(registry).isDeprecated(connector)) revert SmartVaultConnectorDeprecated(connector);
}
}
文件 32 的 33：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
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] = _HEX_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);
}
}
文件 33 的 33：draft-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);
}
{
"compilationTarget": {
"contracts/Deployer.sol": "Deployer"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 10000
},
"remappings": []
}[{"inputs":[{"internalType":"address","name":"_registry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"DeployerImplementationDeprecated","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"DeployerImplementationNotRegistered","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"DeployerImplementationStateless","type":"error"},{"inputs":[],"name":"DeployerNameEmpty","type":"error"},{"inputs":[],"name":"DeployerNamespaceEmpty","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"namespace","type":"string"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"address","name":"instance","type":"address"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"AuthorizerDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"namespace","type":"string"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"address","name":"instance","type":"address"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"PriceOracleDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"namespace","type":"string"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"address","name":"instance","type":"address"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"SmartVaultDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"namespace","type":"string"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"address","name":"instance","type":"address"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"TaskDeployed","type":"event"},{"inputs":[{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"address","name":"impl","type":"address"},{"internalType":"address[]","name":"owners","type":"address[]"}],"internalType":"struct IDeployer.AuthorizerParams","name":"params","type":"tuple"}],"name":"deployAuthorizer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"address","name":"impl","type":"address"},{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"pivot","type":"address"},{"components":[{"internalType":"address","name":"base","type":"address"},{"internalType":"address","name":"quote","type":"address"},{"internalType":"address","name":"feed","type":"address"}],"internalType":"struct IDeployer.FeedData[]","name":"feeds","type":"tuple[]"}],"internalType":"struct IDeployer.PriceOracleParams","name":"params","type":"tuple"}],"name":"deployPriceOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"address","name":"impl","type":"address"},{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"address","name":"priceOracle","type":"address"}],"internalType":"struct IDeployer.SmartVaultParams","name":"params","type":"tuple"}],"name":"deploySmartVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"bool","name":"custom","type":"bool"},{"internalType":"address","name":"impl","type":"address"},{"internalType":"bytes","name":"initializeData","type":"bytes"}],"internalType":"struct IDeployer.TaskParams","name":"params","type":"tuple"}],"name":"deployTask","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"}],"name":"getAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"string","name":"namespace","type":"string"},{"internalType":"string","name":"name","type":"string"}],"name":"getSalt","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
