Overview
S Balance
0 S
S Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 6 from a total of 6 transactions
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xfE28234A...df5F1c0bc The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
StrategyNSLP
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity Standard Json-Input format)
pragma solidity ^0.8.0; interface INAVITracker { function claim(address receiver) external; function claimable(address user) external view returns (uint256); function depositBalances(address user, address token) external view returns (uint256); function stakedAmounts(address user) external view returns (uint256); } pragma solidity ^0.8.0; interface INSLPManager { function vault() external view returns (address); function getAumInUsdn(bool _maximise) external view returns (uint256); function lastAddedAt(address _user) external view returns (uint256); function cooldownDuration() external view returns (uint256); } pragma solidity ^0.8.0; interface INAVIVault { function getFeeBasisPoints( address _token, uint256 _usdnDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment ) external view returns (uint256); function mintBurnFeeBasisPoints() external view returns (uint256); function taxBasisPoints() external view returns (uint256); function getMaxPrice(address _token) external view returns (uint256); function PRICE_PRECISION() external view returns (uint256); function getRedemptionAmount(address _token, uint256 _usdnAmount) external view returns (uint256); function adjustForDecimals( uint256 _amount, address _tokenDiv, address _tokenMul ) external view returns (uint256); function usdn() external view returns (address); } pragma solidity ^0.8.0; interface INAVIRouter { function stakeNavi(uint256 amount) external; function unstakeNavi(uint256 amount) external; function compound() external; function claimFees() external; function mintAndStakeNslp( address _token, uint256 _amount, uint256 _minUsdn, uint256 _minNslp ) external returns (uint256); function unstakeAndRedeemNslp( address _tokenOut, uint256 _nslpAmount, uint256 _minOut, address _receiver ) external returns (uint256); function feeNslpTracker() external view returns (address); function feeNaviTracker() external view returns (address); function stakedNaviTracker() external view returns (address); function nslpManager() external view returns (address); function nslp() external view returns (address); function signalTransfer(address _receiver) external; function acceptTransfer(address _sender) external; } pragma solidity ^0.8.0; interface INAVIStrategy { function acceptTransfer() external; } pragma solidity ^0.8.0; interface IMicroVault { struct StratCandidate { address implementation; uint proposedTime; } function strategy() external view returns (address); function stratCandidate() external view returns (StratCandidate memory); } pragma solidity ^0.8.0; interface IFeeConfig { struct FeeCategory { uint256 total; uint256 micro; uint256 call; uint256 strategist; string label; bool active; } struct AllFees { FeeCategory performance; uint256 deposit; uint256 withdraw; } function getFees(address strategy) external view returns (FeeCategory memory); function stratFeeId(address strategy) external view returns (uint256); function setStratFeeId(uint256 feeId) external; } // File @openzeppelin/contracts-upgradeable/utils/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ 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"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ 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); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ 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); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts-upgradeable/proxy/utils/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`. */ 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); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original * initialization step. This is essential to configure modules that are added through upgrades and that require * initialization. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } } // File @openzeppelin/contracts-upgradeable/utils/[email protected] // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ 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; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File @openzeppelin/contracts-upgradeable/access/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File @openzeppelin/contracts-upgradeable/security/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract PausableUpgradeable is Initializable, ContextUpgradeable { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ function __Pausable_init() internal onlyInitializing { __Pausable_init_unchained(); } function __Pausable_init_unchained() internal onlyInitializing { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } pragma solidity ^0.8.0; contract StratFeeManagerInitializable is OwnableUpgradeable, PausableUpgradeable { struct CommonAddresses { address vault; address unirouter; address keeper; address strategist; address microFeeRecipient; address microFeeConfig; } // common addresses for the strategy address public vault; address public unirouter; address public keeper; address public strategist; address public microFeeRecipient; IFeeConfig public microFeeConfig; uint256 constant DIVISOR = 1 ether; uint256 constant public WITHDRAWAL_FEE_CAP = 50; uint256 constant public WITHDRAWAL_MAX = 10000; uint256 internal withdrawalFee; event SetStratFeeId(uint256 feeId); event SetWithdrawalFee(uint256 withdrawalFee); event SetVault(address vault); event SetUnirouter(address unirouter); event SetKeeper(address keeper); event SetStrategist(address strategist); event SetMicroFeeRecipient(address microFeeRecipient); event SetMicroFeeConfig(address microFeeConfig); function __StratFeeManager_init(CommonAddresses calldata _commonAddresses) internal onlyInitializing { __Ownable_init(); __Pausable_init(); vault = _commonAddresses.vault; unirouter = _commonAddresses.unirouter; keeper = _commonAddresses.keeper; strategist = _commonAddresses.strategist; microFeeRecipient = _commonAddresses.microFeeRecipient; microFeeConfig = IFeeConfig(_commonAddresses.microFeeConfig); withdrawalFee = 10; } // checks that caller is either owner or keeper. modifier onlyManager() { require(msg.sender == owner() || msg.sender == keeper, "!manager"); _; } // fetch fees from config contract function getFees() internal view returns (IFeeConfig.FeeCategory memory) { return microFeeConfig.getFees(address(this)); } // fetch fees from config contract and dynamic deposit/withdraw fees function getAllFees() external view returns (IFeeConfig.AllFees memory) { return IFeeConfig.AllFees(getFees(), depositFee(), withdrawFee()); } function getStratFeeId() external view returns (uint256) { return microFeeConfig.stratFeeId(address(this)); } function setStratFeeId(uint256 _feeId) external onlyManager { microFeeConfig.setStratFeeId(_feeId); emit SetStratFeeId(_feeId); } // adjust withdrawal fee function setWithdrawalFee(uint256 _fee) public onlyManager { require(_fee <= WITHDRAWAL_FEE_CAP, "!cap"); withdrawalFee = _fee; emit SetWithdrawalFee(_fee); } // set new vault (only for strategy upgrades) function setVault(address _vault) external onlyOwner { vault = _vault; emit SetVault(_vault); } // set new unirouter function setUnirouter(address _unirouter) external onlyOwner { unirouter = _unirouter; emit SetUnirouter(_unirouter); } // set new keeper to manage strat function setKeeper(address _keeper) external onlyManager { keeper = _keeper; emit SetKeeper(_keeper); } // set new strategist address to receive strat fees function setStrategist(address _strategist) external { require(msg.sender == strategist, "!strategist"); strategist = _strategist; emit SetStrategist(_strategist); } // set new micro fee address to receive micro fees function setMicroFeeRecipient(address _microFeeRecipient) external onlyOwner { microFeeRecipient = _microFeeRecipient; emit SetMicroFeeRecipient(_microFeeRecipient); } // set new fee config address to fetch fees function setMicroFeeConfig(address _microFeeConfig) external onlyOwner { microFeeConfig = IFeeConfig(_microFeeConfig); emit SetMicroFeeConfig(_microFeeConfig); } function depositFee() public virtual view returns (uint256) { return 0; } function withdrawFee() public virtual view returns (uint256) { return paused() ? 0 : withdrawalFee; } function beforeDeposit() external virtual {} } // File @openzeppelin-4/contracts/token/ERC20/[email protected] // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); } // File @openzeppelin-4/contracts/utils/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ 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"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ 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); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ 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); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ 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); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin-4/contracts/token/ERC20/extensions/[email protected] // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File @openzeppelin-4/contracts/token/ERC20/utils/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ 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)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' 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"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } /* * @title Solidity Bytes Arrays Utils * @author Gonçalo Sá <[email protected]> * * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity. * The library lets you concatenate, slice and type cast bytes arrays both in memory and storage. */ pragma solidity >=0.8.0 <0.9.0; library BytesLib { function concat( bytes memory _preBytes, bytes memory _postBytes ) internal pure returns (bytes memory) { bytes memory tempBytes; assembly { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // Store the length of the first bytes array at the beginning of // the memory for tempBytes. let length := mload(_preBytes) mstore(tempBytes, length) // Maintain a memory counter for the current write location in the // temp bytes array by adding the 32 bytes for the array length to // the starting location. let mc := add(tempBytes, 0x20) // Stop copying when the memory counter reaches the length of the // first bytes array. let end := add(mc, length) for { // Initialize a copy counter to the start of the _preBytes data, // 32 bytes into its memory. let cc := add(_preBytes, 0x20) } lt(mc, end) { // Increase both counters by 32 bytes each iteration. mc := add(mc, 0x20) cc := add(cc, 0x20) } { // Write the _preBytes data into the tempBytes memory 32 bytes // at a time. mstore(mc, mload(cc)) } // Add the length of _postBytes to the current length of tempBytes // and store it as the new length in the first 32 bytes of the // tempBytes memory. length := mload(_postBytes) mstore(tempBytes, add(length, mload(tempBytes))) // Move the memory counter back from a multiple of 0x20 to the // actual end of the _preBytes data. mc := end // Stop copying when the memory counter reaches the new combined // length of the arrays. end := add(mc, length) for { let cc := add(_postBytes, 0x20) } lt(mc, end) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { mstore(mc, mload(cc)) } // Update the free-memory pointer by padding our last write location // to 32 bytes: add 31 bytes to the end of tempBytes to move to the // next 32 byte block, then round down to the nearest multiple of // 32. If the sum of the length of the two arrays is zero then add // one before rounding down to leave a blank 32 bytes (the length block with 0). mstore(0x40, and( add(add(end, iszero(add(length, mload(_preBytes)))), 31), not(31) // Round down to the nearest 32 bytes. )) } return tempBytes; } function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal { assembly { // Read the first 32 bytes of _preBytes storage, which is the length // of the array. (We don't need to use the offset into the slot // because arrays use the entire slot.) let fslot := sload(_preBytes.slot) // Arrays of 31 bytes or less have an even value in their slot, // while longer arrays have an odd value. The actual length is // the slot divided by two for odd values, and the lowest order // byte divided by two for even values. // If the slot is even, bitwise and the slot with 255 and divide by // two to get the length. If the slot is odd, bitwise and the slot // with -1 and divide by two. let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2) let mlength := mload(_postBytes) let newlength := add(slength, mlength) // slength can contain both the length and contents of the array // if length < 32 bytes so let's prepare for that // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage switch add(lt(slength, 32), lt(newlength, 32)) case 2 { // Since the new array still fits in the slot, we just need to // update the contents of the slot. // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length sstore( _preBytes.slot, // all the modifications to the slot are inside this // next block add( // we can just add to the slot contents because the // bytes we want to change are the LSBs fslot, add( mul( div( // load the bytes from memory mload(add(_postBytes, 0x20)), // zero all bytes to the right exp(0x100, sub(32, mlength)) ), // and now shift left the number of bytes to // leave space for the length in the slot exp(0x100, sub(32, newlength)) ), // increase length by the double of the memory // bytes length mul(mlength, 2) ) ) ) } case 1 { // The stored value fits in the slot, but the combined value // will exceed it. // get the keccak hash to get the contents of the array mstore(0x0, _preBytes.slot) let sc := add(keccak256(0x0, 0x20), div(slength, 32)) // save new length sstore(_preBytes.slot, add(mul(newlength, 2), 1)) // The contents of the _postBytes array start 32 bytes into // the structure. Our first read should obtain the `submod` // bytes that can fit into the unused space in the last word // of the stored array. To get this, we read 32 bytes starting // from `submod`, so the data we read overlaps with the array // contents by `submod` bytes. Masking the lowest-order // `submod` bytes allows us to add that value directly to the // stored value. let submod := sub(32, slength) let mc := add(_postBytes, submod) let end := add(_postBytes, mlength) let mask := sub(exp(0x100, submod), 1) sstore( sc, add( and( fslot, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 ), and(mload(mc), mask) ) ) for { mc := add(mc, 0x20) sc := add(sc, 1) } lt(mc, end) { sc := add(sc, 1) mc := add(mc, 0x20) } { sstore(sc, mload(mc)) } mask := exp(0x100, sub(mc, end)) sstore(sc, mul(div(mload(mc), mask), mask)) } default { // get the keccak hash to get the contents of the array mstore(0x0, _preBytes.slot) // Start copying to the last used word of the stored array. let sc := add(keccak256(0x0, 0x20), div(slength, 32)) // save new length sstore(_preBytes.slot, add(mul(newlength, 2), 1)) // Copy over the first `submod` bytes of the new data as in // case 1 above. let slengthmod := mod(slength, 32) let mlengthmod := mod(mlength, 32) let submod := sub(32, slengthmod) let mc := add(_postBytes, submod) let end := add(_postBytes, mlength) let mask := sub(exp(0x100, submod), 1) sstore(sc, add(sload(sc), and(mload(mc), mask))) for { sc := add(sc, 1) mc := add(mc, 0x20) } lt(mc, end) { sc := add(sc, 1) mc := add(mc, 0x20) } { sstore(sc, mload(mc)) } mask := exp(0x100, sub(mc, end)) sstore(sc, mul(div(mload(mc), mask), mask)) } } } function slice( bytes memory _bytes, uint256 _start, uint256 _length ) internal pure returns (bytes memory) { require(_length + 31 >= _length, "slice_overflow"); require(_bytes.length >= _start + _length, "slice_outOfBounds"); bytes memory tempBytes; assembly { switch iszero(_length) case 0 { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // The first word of the slice result is potentially a partial // word read from the original array. To read it, we calculate // the length of that partial word and start copying that many // bytes into the array. The first word we copy will start with // data we don't care about, but the last `lengthmod` bytes will // land at the beginning of the contents of the new array. When // we're done copying, we overwrite the full first word with // the actual length of the slice. let lengthmod := and(_length, 31) // The multiplication in the next line is necessary // because when slicing multiples of 32 bytes (lengthmod == 0) // the following copy loop was copying the origin's length // and then ending prematurely not copying everything it should. let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod))) let end := add(mc, _length) for { // The multiplication in the next line has the same exact purpose // as the one above. let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start) } lt(mc, end) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { mstore(mc, mload(cc)) } mstore(tempBytes, _length) //update free-memory pointer //allocating the array padded to 32 bytes like the compiler does now mstore(0x40, and(add(mc, 31), not(31))) } //if we want a zero-length slice let's just return a zero-length array default { tempBytes := mload(0x40) //zero out the 32 bytes slice we are about to return //we need to do it because Solidity does not garbage collect mstore(tempBytes, 0) mstore(0x40, add(tempBytes, 0x20)) } } return tempBytes; } function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) { require(_bytes.length >= _start + 20, "toAddress_outOfBounds"); address tempAddress; assembly { tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000) } return tempAddress; } function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) { require(_bytes.length >= _start + 1 , "toUint8_outOfBounds"); uint8 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x1), _start)) } return tempUint; } function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) { require(_bytes.length >= _start + 2, "toUint16_outOfBounds"); uint16 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x2), _start)) } return tempUint; } function toUint24(bytes memory _bytes, uint256 _start) internal pure returns (uint24) { require(_start + 3 >= _start, 'toUint24_overflow'); require(_bytes.length >= _start + 3, 'toUint24_outOfBounds'); uint24 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x3), _start)) } return tempUint; } function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) { require(_bytes.length >= _start + 4, "toUint32_outOfBounds"); uint32 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x4), _start)) } return tempUint; } function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) { require(_bytes.length >= _start + 8, "toUint64_outOfBounds"); uint64 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x8), _start)) } return tempUint; } function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) { require(_bytes.length >= _start + 12, "toUint96_outOfBounds"); uint96 tempUint; assembly { tempUint := mload(add(add(_bytes, 0xc), _start)) } return tempUint; } function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) { require(_bytes.length >= _start + 16, "toUint128_outOfBounds"); uint128 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x10), _start)) } return tempUint; } function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) { require(_bytes.length >= _start + 32, "toUint256_outOfBounds"); uint256 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x20), _start)) } return tempUint; } function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) { require(_bytes.length >= _start + 32, "toBytes32_outOfBounds"); bytes32 tempBytes32; assembly { tempBytes32 := mload(add(add(_bytes, 0x20), _start)) } return tempBytes32; } function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) { bool success = true; assembly { let length := mload(_preBytes) // if lengths don't match the arrays are not equal switch eq(length, mload(_postBytes)) case 1 { // cb is a circuit breaker in the for loop since there's // no said feature for inline assembly loops // cb = 1 - don't breaker // cb = 0 - break let cb := 1 let mc := add(_preBytes, 0x20) let end := add(mc, length) for { let cc := add(_postBytes, 0x20) // the next line is the loop condition: // while(uint256(mc < end) + cb == 2) } eq(add(lt(mc, end), cb), 2) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { // if any of these checks fails then arrays are not equal if iszero(eq(mload(mc), mload(cc))) { // unsuccess: success := 0 cb := 0 } } } default { // unsuccess: success := 0 } } return success; } function equalStorage( bytes storage _preBytes, bytes memory _postBytes ) internal view returns (bool) { bool success = true; assembly { // we know _preBytes_offset is 0 let fslot := sload(_preBytes.slot) // Decode the length of the stored array like in concatStorage(). let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2) let mlength := mload(_postBytes) // if lengths don't match the arrays are not equal switch eq(slength, mlength) case 1 { // slength can contain both the length and contents of the array // if length < 32 bytes so let's prepare for that // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage if iszero(iszero(slength)) { switch lt(slength, 32) case 1 { // blank the last byte which is the length fslot := mul(div(fslot, 0x100), 0x100) if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) { // unsuccess: success := 0 } } default { // cb is a circuit breaker in the for loop since there's // no said feature for inline assembly loops // cb = 1 - don't breaker // cb = 0 - break let cb := 1 // get the keccak hash to get the contents of the array mstore(0x0, _preBytes.slot) let sc := keccak256(0x0, 0x20) let mc := add(_postBytes, 0x20) let end := add(mc, mlength) // the next line is the loop condition: // while(uint256(mc < end) + cb == 2) for {} eq(add(lt(mc, end), cb), 2) { sc := add(sc, 1) mc := add(mc, 0x20) } { if iszero(eq(sload(sc), mload(mc))) { // unsuccess: success := 0 cb := 0 } } } } } default { // unsuccess: success := 0 } } return success; } } pragma solidity ^0.8.0; pragma solidity >=0.6.0; /// @title Functions for manipulating path data for multihop swaps library Path { using BytesLib for bytes; /// @dev The length of the bytes encoded address uint256 private constant ADDR_SIZE = 20; /// @dev The length of the bytes encoded fee uint256 private constant FEE_SIZE = 3; /// @dev The offset of a single token address and pool fee uint256 private constant NEXT_OFFSET = ADDR_SIZE + FEE_SIZE; /// @dev The offset of an encoded pool key uint256 private constant POP_OFFSET = NEXT_OFFSET + ADDR_SIZE; /// @dev The minimum length of an encoding that contains 2 or more pools uint256 private constant MULTIPLE_POOLS_MIN_LENGTH = POP_OFFSET + NEXT_OFFSET; /// @notice Returns true iff the path contains two or more pools /// @param path The encoded swap path /// @return True if path contains two or more pools, otherwise false function hasMultiplePools(bytes memory path) internal pure returns (bool) { return path.length >= MULTIPLE_POOLS_MIN_LENGTH; } /// @notice Returns the number of pools in the path /// @param path The encoded swap path /// @return The number of pools in the path function numPools(bytes memory path) internal pure returns (uint256) { // Ignore the first token address. From then on every fee and token offset indicates a pool. return ((path.length - ADDR_SIZE) / NEXT_OFFSET); } /// @notice Decodes the first pool in path /// @param path The bytes encoded swap path /// @return tokenA The first token of the given pool /// @return tokenB The second token of the given pool /// @return fee The fee level of the pool function decodeFirstPool(bytes memory path) internal pure returns ( address tokenA, address tokenB, uint24 fee ) { tokenA = path.toAddress(0); fee = path.toUint24(ADDR_SIZE); tokenB = path.toAddress(NEXT_OFFSET); } /// @notice Gets the segment corresponding to the first pool in the path /// @param path The bytes encoded swap path /// @return The segment containing all data necessary to target the first pool in the path function getFirstPool(bytes memory path) internal pure returns (bytes memory) { return path.slice(0, POP_OFFSET); } /// @notice Skips a token + fee element from the buffer and returns the remainder /// @param path The swap path /// @return The remaining token + fee elements in the path function skipToken(bytes memory path) internal pure returns (bytes memory) { return path.slice(NEXT_OFFSET, path.length - NEXT_OFFSET); } } pragma solidity >=0.6.0; pragma experimental ABIEncoderV2; interface IUniswapRouterV3WithDeadline { struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; } /// @notice Swaps `amountIn` of one token for as much as possible of another token /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata /// @return amountOut The amount of the received token function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); struct ExactInputParams { bytes path; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; } /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata /// @return amountOut The amount of the received token function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut); struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; } /// @notice Swaps as little as possible of one token for `amountOut` of another token /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata /// @return amountIn The amount of the input token function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn); struct ExactOutputParams { bytes path; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; } /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed) /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata /// @return amountIn The amount of the input token function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn); } library UniswapV3Utils { using Path for bytes; // Swap along an encoded path using known amountIn function swap( address _router, bytes memory _path, uint256 _amountIn ) internal returns (uint256 amountOut) { IUniswapRouterV3WithDeadline.ExactInputParams memory params = IUniswapRouterV3WithDeadline.ExactInputParams({ path: _path, recipient: address(this), deadline: block.timestamp, amountIn: _amountIn, amountOutMinimum: 0 }); return IUniswapRouterV3WithDeadline(_router).exactInput(params); } // Swap along a token route using known fees and amountIn function swap( address _router, address[] memory _route, uint24[] memory _fee, uint256 _amountIn ) internal returns (uint256 amountOut) { return swap(_router, routeToPath(_route, _fee), _amountIn); } // Convert encoded path to token route function pathToRoute(bytes memory _path) internal pure returns (address[] memory) { uint256 numPools = _path.numPools(); address[] memory route = new address[](numPools + 1); for (uint256 i; i < numPools; i++) { (address tokenA, address tokenB,) = _path.decodeFirstPool(); route[i] = tokenA; route[i + 1] = tokenB; _path = _path.skipToken(); } return route; } // Convert token route to encoded path // uint24 type for fees so path is packed tightly function routeToPath( address[] memory _route, uint24[] memory _fee ) internal pure returns (bytes memory path) { path = abi.encodePacked(_route[0]); uint256 feeLength = _fee.length; for (uint256 i = 0; i < feeLength; i++) { path = abi.encodePacked(path, _fee[i], _route[i+1]); } } } pragma solidity ^0.8.0; contract StrategyNSLP is StratFeeManagerInitializable { using SafeERC20 for IERC20; // Route bytes public nativeToWantPath; // Tokens used address public want; address public native; // Third party contracts address public minter; address public chef; address public nslpRewardStorage; address public naviRewardStorage; address public nslpManager; bool public harvestOnDeposit; uint256 public lastHarvest; bool public cooldown; uint256 public extraCooldownDuration = 1; event StratHarvest(address indexed harvester, uint256 wantHarvested, uint256 tvl); event Deposit(uint256 tvl); event Withdraw(uint256 tvl); event ChargedFees(uint256 callFees, uint256 microFees, uint256 strategistFees); function initialize( address _want, address _native, address _minter, address _chef, address[] calldata _nativeToWantRoute, uint24[] calldata _nativeToWantFees, CommonAddresses calldata _commonAddresses ) public initializer { __StratFeeManager_init(_commonAddresses); want = _want; native = _native; minter = _minter; chef = _chef; nativeToWantPath = UniswapV3Utils.routeToPath(_nativeToWantRoute, _nativeToWantFees); nslpRewardStorage = INAVIRouter(chef).feeNslpTracker(); naviRewardStorage = INAVIRouter(chef).feeNaviTracker(); nslpManager = INAVIRouter(minter).nslpManager(); _giveAllowances(); } // prevent griefing by preventing deposits for longer than the cooldown period modifier whenNotCooling { if (cooldown) { require(block.timestamp >= withdrawOpen() + extraCooldownDuration, "cooldown"); } _; } // puts the funds to work function deposit() public whenNotPaused whenNotCooling { emit Deposit(balanceOf()); } function withdraw(uint256 _amount) external { require(msg.sender == vault, "!vault"); uint256 wantBal = balanceOfWant(); if (wantBal > _amount) { wantBal = _amount; } if (tx.origin != owner() && !paused()) { uint256 withdrawalFeeAmount = wantBal * withdrawalFee / WITHDRAWAL_MAX; wantBal = wantBal - withdrawalFeeAmount; } IERC20(want).safeTransfer(vault, wantBal); emit Withdraw(balanceOf()); } function beforeDeposit() external virtual override { if (harvestOnDeposit) { require(msg.sender == vault, "!vault"); _harvest(tx.origin); } } function harvest() external virtual { _harvest(tx.origin); } function harvest(address callFeeRecipient) external virtual { _harvest(callFeeRecipient); } function managerHarvest() external onlyManager { _harvest(tx.origin); } // compounds earnings and charges performance fee function _harvest(address callFeeRecipient) internal whenNotPaused { INAVIRouter(chef).compound(); // Claim and restake esNAVI and multiplier points INAVIRouter(chef).claimFees(); uint256 nativeBal = IERC20(native).balanceOf(address(this)); if (nativeBal > 0) { chargeFees(callFeeRecipient); uint256 before = balanceOfWant(); swapRewards(); mintNslp(); uint256 wantHarvested = balanceOfWant() - before; lastHarvest = block.timestamp; emit StratHarvest(msg.sender, wantHarvested, balanceOf()); } } function swapRewards() internal { uint256 nativeBal = IERC20(native).balanceOf(address(this)); require(nativeBal > 0, "No native balance to swap"); UniswapV3Utils.swap(unirouter, nativeToWantPath, nativeBal); } // performance fees function chargeFees(address callFeeRecipient) internal { IFeeConfig.FeeCategory memory fees = getFees(); uint256 feeBal = IERC20(native).balanceOf(address(this)) * fees.total / DIVISOR; uint256 callFeeAmount = feeBal * fees.call / DIVISOR; IERC20(native).safeTransfer(callFeeRecipient, callFeeAmount); uint256 microFeeAmount = feeBal * fees.micro / DIVISOR; IERC20(native).safeTransfer(microFeeRecipient, microFeeAmount); uint256 strategistFeeAmount = feeBal * fees.strategist / DIVISOR; IERC20(native).safeTransfer(strategist, strategistFeeAmount); emit ChargedFees(callFeeAmount, microFeeAmount, strategistFeeAmount); } // mint more NSLP with the converted USDC.e function mintNslp() internal whenNotCooling { uint256 wantBal = IERC20(want).balanceOf(address(this)); require(wantBal > 0, "No want balance to mint NSLP"); // Mint and stake NSLP using the converted USDC.e INAVIRouter(minter).mintAndStakeNslp(want, wantBal, 0, 0); } function nativeToWant() external view returns (address[] memory) { return UniswapV3Utils.pathToRoute(nativeToWantPath); } // calculate the total underlaying 'want' held by the strat. function balanceOf() public view returns (uint256) { return balanceOfWant() + balanceOfPool(); } // it calculates how much 'want' this contract holds. function balanceOfWant() public view returns (uint256) { return IERC20(want).balanceOf(address(this)); } // it calculates how much 'want' the strategy has working in the farm. function balanceOfPool() public pure returns (uint256) { return 0; } // returns rewards unharvested function rewardsAvailable() public view returns (uint256) { uint256 rewardNSLP = INAVITracker(nslpRewardStorage).claimable(address(this)); uint256 rewardNAVI = INAVITracker(naviRewardStorage).claimable(address(this)); return rewardNSLP + rewardNAVI; } // native reward amount for calling harvest function callReward() public view returns (uint256) { IFeeConfig.FeeCategory memory fees = getFees(); uint256 nativeBal = rewardsAvailable(); return nativeBal * fees.total / DIVISOR * fees.call / DIVISOR; } function setHarvestOnDeposit(bool _harvestOnDeposit) external onlyManager { harvestOnDeposit = _harvestOnDeposit; if (harvestOnDeposit) { setWithdrawalFee(0); } else { setWithdrawalFee(10); } } // called as part of strat migration. Transfers all want, NSLP, esNAVI and MP to new strat. function retireStrat() external { require(msg.sender == vault, "!vault"); IMicroVault.StratCandidate memory candidate = IMicroVault(vault).stratCandidate(); address stratAddress = candidate.implementation; INAVIRouter(chef).signalTransfer(stratAddress); INAVIStrategy(stratAddress).acceptTransfer(); uint256 wantBal = IERC20(want).balanceOf(address(this)); IERC20(want).transfer(vault, wantBal); } // pauses deposits and withdraws all funds from third party systems. function panic() public onlyManager { pause(); } function pause() public onlyManager { _pause(); _removeAllowances(); } function unpause() external onlyManager { _unpause(); _giveAllowances(); } function _giveAllowances() internal { IERC20(native).safeApprove(nslpManager, type(uint).max); } function _removeAllowances() internal { IERC20(native).safeApprove(nslpManager, 0); } // timestamp at which withdrawals open again function withdrawOpen() public view returns (uint256) { return INSLPManager(nslpManager).lastAddedAt(address(this)) + INSLPManager(nslpManager).cooldownDuration(); } // turn on extra cooldown time to allow users to withdraw function setCooldown(bool _cooldown) external onlyManager { cooldown = _cooldown; } // set the length of cooldown time for withdrawals function setExtraCooldownDuration(uint256 _extraCooldownDuration) external onlyManager { extraCooldownDuration = _extraCooldownDuration; } function acceptTransfer() external { address prevStrat = IMicroVault(vault).strategy(); require(msg.sender == prevStrat, "!prevStrat"); INAVIRouter(chef).acceptTransfer(prevStrat); // send back 1 wei to complete upgrade IERC20(want).safeTransfer(prevStrat, 1); } }
{ "evmVersion": "shanghai", "libraries": {}, "metadata": { "bytecodeHash": "ipfs", "useLiteralContent": true }, "optimizer": { "enabled": true, "runs": 200 }, "remappings": [], "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"callFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"microFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"strategistFees","type":"uint256"}],"name":"ChargedFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"keeper","type":"address"}],"name":"SetKeeper","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"microFeeConfig","type":"address"}],"name":"SetMicroFeeConfig","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"microFeeRecipient","type":"address"}],"name":"SetMicroFeeRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"feeId","type":"uint256"}],"name":"SetStratFeeId","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"strategist","type":"address"}],"name":"SetStrategist","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"unirouter","type":"address"}],"name":"SetUnirouter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"vault","type":"address"}],"name":"SetVault","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"withdrawalFee","type":"uint256"}],"name":"SetWithdrawalFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"harvester","type":"address"},{"indexed":false,"internalType":"uint256","name":"wantHarvested","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"StratHarvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"WITHDRAWAL_FEE_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWAL_MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beforeDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"callReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chef","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cooldown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extraCooldownDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllFees","outputs":[{"components":[{"components":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"micro","type":"uint256"},{"internalType":"uint256","name":"call","type":"uint256"},{"internalType":"uint256","name":"strategist","type":"uint256"},{"internalType":"string","name":"label","type":"string"},{"internalType":"bool","name":"active","type":"bool"}],"internalType":"struct IFeeConfig.FeeCategory","name":"performance","type":"tuple"},{"internalType":"uint256","name":"deposit","type":"uint256"},{"internalType":"uint256","name":"withdraw","type":"uint256"}],"internalType":"struct IFeeConfig.AllFees","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStratFeeId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"callFeeRecipient","type":"address"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestOnDeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_want","type":"address"},{"internalType":"address","name":"_native","type":"address"},{"internalType":"address","name":"_minter","type":"address"},{"internalType":"address","name":"_chef","type":"address"},{"internalType":"address[]","name":"_nativeToWantRoute","type":"address[]"},{"internalType":"uint24[]","name":"_nativeToWantFees","type":"uint24[]"},{"components":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"unirouter","type":"address"},{"internalType":"address","name":"keeper","type":"address"},{"internalType":"address","name":"strategist","type":"address"},{"internalType":"address","name":"microFeeRecipient","type":"address"},{"internalType":"address","name":"microFeeConfig","type":"address"}],"internalType":"struct StratFeeManagerInitializable.CommonAddresses","name":"_commonAddresses","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHarvest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managerHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"microFeeConfig","outputs":[{"internalType":"contract IFeeConfig","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"microFeeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"native","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nativeToWant","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nativeToWantPath","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"naviRewardStorage","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nslpManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nslpRewardStorage","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"panic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"retireStrat","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsAvailable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_cooldown","type":"bool"}],"name":"setCooldown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_extraCooldownDuration","type":"uint256"}],"name":"setExtraCooldownDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_harvestOnDeposit","type":"bool"}],"name":"setHarvestOnDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_keeper","type":"address"}],"name":"setKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_microFeeConfig","type":"address"}],"name":"setMicroFeeConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_microFeeRecipient","type":"address"}],"name":"setMicroFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feeId","type":"uint256"}],"name":"setStratFeeId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_unirouter","type":"address"}],"name":"setUnirouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setWithdrawalFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unirouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawOpen","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.