ETH Price: $3,415.82 (+3.01%)

Contract

0xD5B927956057075377263aaB7f8AfC12F85100dB
 

Overview

ETH Balance

0.024279614134401612 ETH

Eth Value

$82.93 (@ $3,415.82/ETH)

Token Holdings

Transaction Hash
Method
Block
From
To
Transfer213290332024-12-04 12:07:4719 days ago1733314067IN
0xD5B92795...2F85100dB
1.5 ETH0.0005067921.37284806
Set Withdraw Fee201914982024-06-28 16:52:23178 days ago1719593543IN
0xD5B92795...2F85100dB
0 ETH0.000393587.97372262
Transfer201192042024-06-18 14:22:11188 days ago1718720531IN
0xD5B92795...2F85100dB
3.17647059 ETH0.0005468823.06380536
Transfer192914122024-02-23 16:14:35304 days ago1708704875IN
0xD5B92795...2F85100dB
0.975 ETH0.0016634770.15348362
Transfer185705312023-11-14 13:46:23405 days ago1699969583IN
0xD5B92795...2F85100dB
2.22 ETH0.0009427539.7586095
Withdraw182840312023-10-05 11:32:11445 days ago1696505531IN
0xD5B92795...2F85100dB
0 ETH0.000804726.28430128
Wrap182839912023-10-05 11:24:11445 days ago1696505051IN
0xD5B92795...2F85100dB
0 ETH0.0002975.90217056
Set Bridge Conne...182726042023-10-03 21:12:11447 days ago1696367531IN
0xD5B92795...2F85100dB
0 ETH0.0006566415.15587846
Set Bridge Conne...176207492023-07-04 13:06:11538 days ago1688475971IN
0xD5B92795...2F85100dB
0 ETH0.0009028420.83839315
Set Bridge Conne...176200082023-07-04 10:36:47538 days ago1688467007IN
0xD5B92795...2F85100dB
0 ETH0.0008855920.44024756
Set Bridge Conne...175883872023-06-30 0:00:23543 days ago1688083223IN
0xD5B92795...2F85100dB
0 ETH0.0009659422.29489655
Set Withdraw Fee175857412023-06-29 15:06:23543 days ago1688051183IN
0xD5B92795...2F85100dB
0 ETH0.0078260454.86145048
Set Swap Fee175857412023-06-29 15:06:23543 days ago1688051183IN
0xD5B92795...2F85100dB
0 ETH0.00270954.86145048
Authorize175856792023-06-29 14:53:59543 days ago1688050439IN
0xD5B92795...2F85100dB
0 ETH0.0018759135.3533266
Authorize175856792023-06-29 14:53:59543 days ago1688050439IN
0xD5B92795...2F85100dB
0 ETH0.0018759135.3533266
Transfer175655512023-06-26 19:04:35546 days ago1687806275IN
0xD5B92795...2F85100dB
2.7 ETH0.0003919316.52886982
Withdraw168783372023-03-21 20:19:35643 days ago1679429975IN
0xD5B92795...2F85100dB
0 ETH0.0009393418.78613195
Authorize168783332023-03-21 20:18:47643 days ago1679429927IN
0xD5B92795...2F85100dB
0 ETH0.0010722920.20372462
Transfer168757082023-03-21 11:26:47643 days ago1679398007IN
0xD5B92795...2F85100dB
2.1825 ETH0.0003048612.85696094
Transfer168401202023-03-16 11:29:59648 days ago1678966199IN
0xD5B92795...2F85100dB
1.95 ETH0.0005461623.03328075
Authorize168356232023-03-15 20:18:59649 days ago1678911539IN
0xD5B92795...2F85100dB
0 ETH0.0013084824.6540455

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block
From
To
214694142024-12-24 2:40:592 hrs ago1735008059
0xD5B92795...2F85100dB
0 ETH
214690642024-12-24 1:30:473 hrs ago1735003847
0xD5B92795...2F85100dB
0.00006519 ETH
214690622024-12-24 1:30:233 hrs ago1735003823
0xD5B92795...2F85100dB
0.0000003 ETH
214660102024-12-23 15:14:2314 hrs ago1734966863
0xD5B92795...2F85100dB
1 wei
214647882024-12-23 11:08:2318 hrs ago1734952103
0xD5B92795...2F85100dB
0.00002328 ETH
214602722024-12-22 19:58:1133 hrs ago1734897491
0xD5B92795...2F85100dB
0.01846101 ETH
214573652024-12-22 10:13:1143 hrs ago1734862391
0xD5B92795...2F85100dB
0.00013836 ETH
214529372024-12-21 19:21:352 days ago1734808895
0xD5B92795...2F85100dB
0.00526371 ETH
214528732024-12-21 19:08:352 days ago1734808115
0xD5B92795...2F85100dB
0.00032772 ETH
214511392024-12-21 13:19:472 days ago1734787187
0xD5B92795...2F85100dB
1 wei
214457462024-12-20 19:13:353 days ago1734722015
0xD5B92795...2F85100dB
0.15437574 ETH
214440342024-12-20 13:28:473 days ago1734701327
0xD5B92795...2F85100dB
1 wei
214434692024-12-20 11:35:113 days ago1734694511
0xD5B92795...2F85100dB
0.05218436 ETH
214434092024-12-20 11:23:113 days ago1734693791
0xD5B92795...2F85100dB
1 wei
214401112024-12-20 0:20:354 days ago1734654035
0xD5B92795...2F85100dB
0.00095482 ETH
214383232024-12-19 18:21:474 days ago1734632507
0xD5B92795...2F85100dB
0.02628785 ETH
214380542024-12-19 17:27:234 days ago1734629243
0xD5B92795...2F85100dB
0.00080038 ETH
214378032024-12-19 16:36:594 days ago1734626219
0xD5B92795...2F85100dB
0.00070933 ETH
214377532024-12-19 16:26:594 days ago1734625619
0xD5B92795...2F85100dB
0.00508392 ETH
214374162024-12-19 15:19:234 days ago1734621563
0xD5B92795...2F85100dB
0.0016677 ETH
214328552024-12-19 0:00:355 days ago1734566435
0xD5B92795...2F85100dB
0.00131273 ETH
214290262024-12-18 11:09:355 days ago1734520175
0xD5B92795...2F85100dB
0.00001928 ETH
214261742024-12-18 1:36:116 days ago1734485771
0xD5B92795...2F85100dB
0.00001987 ETH
214254062024-12-17 23:01:116 days ago1734476471
0xD5B92795...2F85100dB
0.00074211 ETH
214206652024-12-17 7:08:476 days ago1734419327
0xD5B92795...2F85100dB
1 wei
View All Internal Transactions
Loading...
Loading

Minimal Proxy Contract for 0x3e88c9b0e3be6817973a6e629211e702d12c577f

Contract Name:
SmartVault

Compiler Version
v0.8.3+commit.8d00100c

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 42 : SmartVault.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

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/utils/math/Math.sol';

import '@mimic-fi/v2-bridge-connector/contracts/IBridgeConnector.sol';
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v2-helpers/contracts/math/UncheckedMath.sol';
import '@mimic-fi/v2-helpers/contracts/utils/Denominations.sol';
import '@mimic-fi/v2-helpers/contracts/utils/IWrappedNativeToken.sol';
import '@mimic-fi/v2-price-oracle/contracts/oracle/IPriceOracle.sol';
import '@mimic-fi/v2-price-oracle/contracts/feeds/PriceFeedProvider.sol';
import '@mimic-fi/v2-strategies/contracts/IStrategy.sol';
import '@mimic-fi/v2-swap-connector/contracts/ISwapConnector.sol';
import '@mimic-fi/v2-registry/contracts/implementations/InitializableAuthorizedImplementation.sol';

import './ISmartVault.sol';
import './helpers/StrategyLib.sol';
import './helpers/SwapConnectorLib.sol';
import './helpers/BridgeConnectorLib.sol';

/**
 * @title Smart Vault
 * @dev Smart Vault contract where funds are being held offering a bunch of primitives to allow users model any
 * type of action to manage them, these are: collector, withdraw, swap, bridge, join, exit, bridge, wrap, and unwrap.
 *
 * It inherits from InitializableAuthorizedImplementation which means it's implementation can be cloned
 * from the Mimic Registry and should be initialized depending on each case.
 */
contract SmartVault is ISmartVault, PriceFeedProvider, InitializableAuthorizedImplementation {
    using SafeERC20 for IERC20;
    using FixedPoint for uint256;
    using UncheckedMath for uint256;
    using StrategyLib for address;
    using SwapConnectorLib for address;
    using BridgeConnectorLib for address;

    // Namespace under which the Smart Vault is registered in the Mimic Registry
    bytes32 public constant override NAMESPACE = keccak256('SMART_VAULT');

    /**
     * @dev Fee configuration parameters
     * @param pct Percentage expressed using 16 decimals (1e18 = 100%)
     * @param cap Maximum amount of fees to be charged per period
     * @param token Address of the token to express the cap amount
     * @param period Period length in seconds
     * @param totalCharged Total amount of fees charged in the current period
     * @param nextResetTime Current cap period end date
     */
    struct Fee {
        uint256 pct;
        uint256 cap;
        address token;
        uint256 period;
        uint256 totalCharged;
        uint256 nextResetTime;
    }

    // Price oracle reference
    address public override priceOracle;

    // Swap connector reference
    address public override swapConnector;

    // Bridge connector reference
    address public override bridgeConnector;

    // List of allowed strategies indexed by strategy address
    mapping (address => bool) public override isStrategyAllowed;

    // List of invested values indexed by strategy address
    mapping (address => uint256) public override investedValue;

    // Fee collector address where fees will be deposited
    address public override feeCollector;

    // Withdraw fee configuration
    Fee public override withdrawFee;

    // Performance fee configuration
    Fee public override performanceFee;

    // Swap fee configuration
    Fee public override swapFee;

    // Bridge fee configuration
    Fee public override bridgeFee;

    // Wrapped native token reference
    address public immutable override wrappedNativeToken;

    /**
     * @dev Creates a new Smart Vault implementation with references that should be shared among all implementations
     * @param _wrappedNativeToken Address of the wrapped native token to be used
     * @param _registry Address of the Mimic Registry to be referenced
     */
    constructor(address _wrappedNativeToken, address _registry) InitializableAuthorizedImplementation(_registry) {
        wrappedNativeToken = _wrappedNativeToken;
    }

    /**
     * @dev Initializes the Smart Vault instance
     * @param admin Address that will be granted with admin rights
     */
    function initialize(address admin) external initializer {
        _initialize(admin);
    }

    /**
     * @dev It allows receiving native token transfers
     */
    receive() external payable {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Sets a new strategy as allowed or not for a Smart Vault. Sender must be authorized.
     * @param strategy Address of the strategy to be set
     * @param allowed Whether the strategy is allowed or not
     */
    function setStrategy(address strategy, bool allowed) external override auth {
        _setStrategy(strategy, allowed);
    }

    /**
     * @dev Sets a new price oracle to a Smart Vault. Sender must be authorized.
     * @param newPriceOracle Address of the new price oracle to be set
     */
    function setPriceOracle(address newPriceOracle) external override auth {
        _setPriceOracle(newPriceOracle);
    }

    /**
     * @dev Sets a new swap connector to a Smart Vault. Sender must be authorized.
     * @param newSwapConnector Address of the new swap connector to be set
     */
    function setSwapConnector(address newSwapConnector) external override auth {
        _setSwapConnector(newSwapConnector);
    }

    /**
     * @dev Sets a new bridge connector to a Smart Vault. Sender must be authorized.
     * @param newBridgeConnector Address of the new bridge connector to be set
     */
    function setBridgeConnector(address newBridgeConnector) external override auth {
        _setBridgeConnector(newBridgeConnector);
    }

    /**
     * @dev Sets a new fee collector. Sender must be authorized.
     * @param newFeeCollector Address of the new fee collector to be set
     */
    function setFeeCollector(address newFeeCollector) external override auth {
        _setFeeCollector(newFeeCollector);
    }

    /**
     * @dev Sets a new withdraw fee. Sender must be authorized.
     * @param pct Withdraw fee percentage to be set
     * @param cap New maximum amount of withdraw fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the withdraw fee
     */
    function setWithdrawFee(uint256 pct, uint256 cap, address token, uint256 period) external override auth {
        _setFeeConfiguration(withdrawFee, pct, cap, token, period);
        emit WithdrawFeeSet(pct, cap, token, period);
    }

    /**
     * @dev Sets a new performance fee. Sender must be authorized.
     * @param pct Performance fee percentage to be set
     * @param cap New maximum amount of performance fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the performance fee
     */
    function setPerformanceFee(uint256 pct, uint256 cap, address token, uint256 period) external override auth {
        _setFeeConfiguration(performanceFee, pct, cap, token, period);
        emit PerformanceFeeSet(pct, cap, token, period);
    }

    /**
     * @dev Sets a new swap fee. Sender must be authorized.
     * @param pct New swap fee percentage to be set
     * @param cap New maximum amount of swap fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the swap fee
     */
    function setSwapFee(uint256 pct, uint256 cap, address token, uint256 period) external override auth {
        _setFeeConfiguration(swapFee, pct, cap, token, period);
        emit SwapFeeSet(pct, cap, token, period);
    }

    /**
     * @dev Sets a new bridge fee. Sender must be authorized.
     * @param pct New bridge fee percentage to be set
     * @param cap New maximum amount of bridge fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the bridge fee
     */
    function setBridgeFee(uint256 pct, uint256 cap, address token, uint256 period) external override auth {
        _setFeeConfiguration(bridgeFee, pct, cap, token, period);
        emit BridgeFeeSet(pct, cap, token, period);
    }

    /**
     * @dev Sets a of price feed
     * @param base Token base to be set
     * @param quote Token quote to be set
     * @param feed Price feed to be set
     */
    function setPriceFeed(address base, address quote, address feed)
        public
        override(IPriceFeedProvider, PriceFeedProvider)
        auth
    {
        super.setPriceFeed(base, quote, feed);
    }

    /**
     * @dev Tells the price of a token (base) in a given quote
     * @param base Token to rate
     * @param quote Token used for the price rate
     */
    function getPrice(address base, address quote) public view override returns (uint256) {
        return IPriceOracle(priceOracle).getPrice(address(this), base, quote);
    }

    /**
     * @dev Tells the last value accrued for a strategy. Note this value can be outdated.
     * @param strategy Address of the strategy querying the last value of
     */
    function lastValue(address strategy) public view override returns (uint256) {
        return IStrategy(strategy).lastValue(address(this));
    }

    /**
     * @dev Execute an arbitrary call from a Smart Vault. Sender must be authorized.
     * @param target Address where the call will be sent
     * @param data Calldata to be used for the call
     * @param value Value in wei that will be attached to the call
     * @return result Call response if it was successful, otherwise it reverts
     */
    function call(address target, bytes memory callData, uint256 value, bytes memory data)
        external
        override
        auth
        returns (bytes memory result)
    {
        result = Address.functionCallWithValue(target, callData, value, 'SMART_VAULT_ARBITRARY_CALL_FAIL');
        emit Call(target, callData, value, result, data);
    }

    /**
     * @dev Collect tokens from an external account to a Smart Vault. Sender must be authorized.
     * @param token Address of the token to be collected
     * @param from Address where the tokens will be transfer from
     * @param amount Amount of tokens to be transferred
     * @param data Extra data only logged
     * @return collected Amount of tokens collected
     */
    function collect(address token, address from, uint256 amount, bytes memory data)
        external
        override
        auth
        returns (uint256 collected)
    {
        require(amount > 0, 'COLLECT_AMOUNT_ZERO');

        uint256 previousBalance = IERC20(token).balanceOf(address(this));
        IERC20(token).safeTransferFrom(from, address(this), amount);
        uint256 currentBalance = IERC20(token).balanceOf(address(this));

        collected = currentBalance - previousBalance;
        emit Collect(token, from, collected, data);
    }

    /**
     * @dev Withdraw tokens to an external account. Sender must be authorized.
     * @param token Address of the token to be withdrawn
     * @param amount Amount of tokens to withdraw
     * @param recipient Address where the tokens will be transferred to
     * @param data Extra data only logged
     * @return withdrawn Amount of tokens transferred to the recipient address
     */
    function withdraw(address token, uint256 amount, address recipient, bytes memory data)
        external
        override
        auth
        returns (uint256 withdrawn)
    {
        require(amount > 0, 'WITHDRAW_AMOUNT_ZERO');
        require(recipient != address(0), 'RECIPIENT_ZERO');

        uint256 withdrawFeeAmount = recipient == feeCollector ? 0 : _payFee(token, amount, withdrawFee);
        withdrawn = amount - withdrawFeeAmount;
        _safeTransfer(token, recipient, withdrawn);
        emit Withdraw(token, recipient, withdrawn, withdrawFeeAmount, data);
    }

    /**
     * @dev Wrap an amount of native tokens to the wrapped ERC20 version of it. Sender must be authorized.
     * @param amount Amount of native tokens to be wrapped
     * @param data Extra data only logged
     * @return wrapped Amount of tokens wrapped
     */
    function wrap(uint256 amount, bytes memory data) external override auth returns (uint256 wrapped) {
        require(amount > 0, 'WRAP_AMOUNT_ZERO');
        require(address(this).balance >= amount, 'WRAP_INSUFFICIENT_AMOUNT');

        IWrappedNativeToken wrappedToken = IWrappedNativeToken(wrappedNativeToken);
        uint256 previousBalance = wrappedToken.balanceOf(address(this));
        wrappedToken.deposit{ value: amount }();
        uint256 currentBalance = wrappedToken.balanceOf(address(this));

        wrapped = currentBalance - previousBalance;
        emit Wrap(amount, wrapped, data);
    }

    /**
     * @dev Unwrap an amount of wrapped native tokens. Sender must be authorized.
     * @param amount Amount of wrapped native tokens to unwrapped
     * @param data Extra data only logged
     * @return unwrapped Amount of tokens unwrapped
     */
    function unwrap(uint256 amount, bytes memory data) external override auth returns (uint256 unwrapped) {
        require(amount > 0, 'UNWRAP_AMOUNT_ZERO');

        uint256 previousBalance = address(this).balance;
        IWrappedNativeToken(wrappedNativeToken).withdraw(amount);
        uint256 currentBalance = address(this).balance;

        unwrapped = currentBalance - previousBalance;
        emit Unwrap(amount, unwrapped, data);
    }

    /**
     * @dev Claim strategy rewards. Sender must be authorized.
     * @param strategy Address of the strategy to claim rewards
     * @param data Extra data passed to the strategy and logged
     * @return tokens Addresses of the tokens received as rewards
     * @return amounts Amounts of the tokens received as rewards
     */
    function claim(address strategy, bytes memory data)
        external
        override
        auth
        returns (address[] memory tokens, uint256[] memory amounts)
    {
        require(isStrategyAllowed[strategy], 'STRATEGY_NOT_ALLOWED');
        (tokens, amounts) = strategy.claim(data);
        emit Claim(strategy, tokens, amounts, data);
    }

    /**
     * @dev Join a strategy with an amount of tokens. Sender must be authorized.
     * @param strategy Address of the strategy to join
     * @param tokensIn List of token addresses to join with
     * @param amountsIn List of token amounts to join with
     * @param slippage Slippage that will be used to compute the join
     * @param data Extra data passed to the strategy and logged
     * @return tokensOut List of token addresses received after the join
     * @return amountsOut List of token amounts received after the join
     */
    function join(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) external override auth returns (address[] memory tokensOut, uint256[] memory amountsOut) {
        require(isStrategyAllowed[strategy], 'STRATEGY_NOT_ALLOWED');
        require(slippage <= FixedPoint.ONE, 'JOIN_SLIPPAGE_ABOVE_ONE');
        require(tokensIn.length == amountsIn.length, 'JOIN_INPUT_INVALID_LENGTH');

        uint256 value;
        (tokensOut, amountsOut, value) = strategy.join(tokensIn, amountsIn, slippage, data);
        require(tokensOut.length == amountsOut.length, 'JOIN_OUTPUT_INVALID_LENGTH');

        investedValue[strategy] = investedValue[strategy] + value;
        emit Join(strategy, tokensIn, amountsIn, tokensOut, amountsOut, value, slippage, data);
    }

    /**
     * @dev Exit a strategy. Sender must be authorized.
     * @param strategy Address of the strategy to exit
     * @param tokensIn List of token addresses to exit with
     * @param amountsIn List of token amounts to exit with
     * @param slippage Slippage that will be used to compute the exit
     * @param data Extra data passed to the strategy and logged
     * @return tokensOut List of token addresses received after the exit
     * @return amountsOut List of token amounts received after the exit
     */
    function exit(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) external override auth returns (address[] memory tokensOut, uint256[] memory amountsOut) {
        require(isStrategyAllowed[strategy], 'STRATEGY_NOT_ALLOWED');
        require(investedValue[strategy] > 0, 'EXIT_NO_INVESTED_VALUE');
        require(slippage <= FixedPoint.ONE, 'EXIT_SLIPPAGE_ABOVE_ONE');
        require(tokensIn.length == amountsIn.length, 'EXIT_INPUT_INVALID_LENGTH');

        uint256 value;
        (tokensOut, amountsOut, value) = strategy.exit(tokensIn, amountsIn, slippage, data);
        require(tokensOut.length == amountsOut.length, 'EXIT_OUTPUT_INVALID_LENGTH');
        uint256[] memory performanceFeeAmounts = new uint256[](amountsOut.length);

        // It can rely on the last updated value since we have just exited, no need to compute current value
        uint256 valueBeforeExit = lastValue(strategy) + value;
        if (valueBeforeExit <= investedValue[strategy]) {
            // There were losses, invested value is simply reduced using the exited ratio compared to the value
            // before exit. Invested value is round up to avoid interpreting losses due to rounding errors
            investedValue[strategy] -= investedValue[strategy].mulUp(value).divUp(valueBeforeExit);
        } else {
            // If value gains are greater than the exit value, it means only gains are being withdrawn. In that case
            // the taxable amount is the entire exited amount, otherwise it should be the equivalent gains ratio of it.
            uint256 valueGains = valueBeforeExit.uncheckedSub(investedValue[strategy]);
            bool onlyGains = valueGains >= value;

            // If the exit value is greater than the value gains, the invested value should be reduced by the portion
            // of the invested value being exited. Otherwise, it's still the same, only gains are being withdrawn.
            // No need for checked math as we are checking it manually beforehand
            uint256 decrement = onlyGains ? 0 : value.uncheckedSub(valueGains);
            investedValue[strategy] = investedValue[strategy] - decrement;

            // Compute performance fees per token out
            for (uint256 i = 0; i < tokensOut.length; i = i.uncheckedAdd(1)) {
                address token = tokensOut[i];
                uint256 amount = amountsOut[i];
                uint256 taxableAmount = onlyGains ? amount : ((amount * valueGains) / value);
                uint256 feeAmount = _payFee(token, taxableAmount, performanceFee);
                amountsOut[i] = amount - feeAmount;
                performanceFeeAmounts[i] = feeAmount;
            }
        }

        emit Exit(strategy, tokensIn, amountsIn, tokensOut, amountsOut, value, performanceFeeAmounts, slippage, data);
    }

    /**
     * @dev Swaps two tokens. Sender must be authorized.
     * @param source Source to request the swap: Uniswap V2, Uniswap V3, Balancer V2, or Paraswap V5.
     * @param tokenIn Token being sent
     * @param tokenOut Token being received
     * @param amountIn Amount of tokenIn being swapped
     * @param limitType Swap limit to be applied: slippage or min amount out
     * @param limitAmount Amount of the swap limit to be applied depending on limitType
     * @param data Encoded data to specify different swap parameters depending on the source picked
     * @return amountOut Received amount of tokens out
     */
    function swap(
        uint8 source,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        SwapLimit limitType,
        uint256 limitAmount,
        bytes memory data
    ) external override auth returns (uint256 amountOut) {
        require(tokenIn != tokenOut, 'SWAP_SAME_TOKEN');
        require(swapConnector != address(0), 'SWAP_CONNECTOR_NOT_SET');

        uint256 minAmountOut;
        if (limitType == SwapLimit.MinAmountOut) {
            minAmountOut = limitAmount;
        } else if (limitType == SwapLimit.Slippage) {
            require(limitAmount <= FixedPoint.ONE, 'SWAP_SLIPPAGE_ABOVE_ONE');
            uint256 price = getPrice(tokenIn, tokenOut);
            // No need for checked math as we are checking it manually beforehand
            // Always round up the expected min amount out. Limit amount is slippage.
            minAmountOut = amountIn.mulUp(price).mulUp(FixedPoint.ONE.uncheckedSub(limitAmount));
        } else {
            revert('SWAP_INVALID_LIMIT_TYPE');
        }

        uint256 preBalanceIn = IERC20(tokenIn).balanceOf(address(this));
        uint256 preBalanceOut = IERC20(tokenOut).balanceOf(address(this));
        swapConnector.swap(source, tokenIn, tokenOut, amountIn, minAmountOut, data);

        uint256 postBalanceIn = IERC20(tokenIn).balanceOf(address(this));
        require(postBalanceIn >= preBalanceIn - amountIn, 'SWAP_BAD_TOKEN_IN_BALANCE');

        uint256 amountOutBeforeFees = IERC20(tokenOut).balanceOf(address(this)) - preBalanceOut;
        require(amountOutBeforeFees >= minAmountOut, 'SWAP_MIN_AMOUNT');

        uint256 swapFeeAmount = _payFee(tokenOut, amountOutBeforeFees, swapFee);
        amountOut = amountOutBeforeFees - swapFeeAmount;
        emit Swap(source, tokenIn, tokenOut, amountIn, amountOut, minAmountOut, swapFeeAmount, data);
    }

    /**
     * @dev Bridge assets to another chain
     * @param source Source to request the bridge. It depends on the Bridge Connector attached to a Smart Vault.
     * @param chainId ID of the destination chain
     * @param token Address of the token to be bridged
     * @param amount Amount of tokens to be bridged
     * @param limitType Bridge limit to be applied: slippage or min amount out
     * @param limitAmount Amount of the swap limit to be applied depending on limitType
     * @param recipient Address that will receive the tokens on the destination chain
     * @param data Encoded data to specify different bridge parameters depending on the source picked
     * @return bridged Amount requested to be bridged after fees
     */
    function bridge(
        uint8 source,
        uint256 chainId,
        address token,
        uint256 amount,
        BridgeLimit limitType,
        uint256 limitAmount,
        address recipient,
        bytes memory data
    ) external override auth returns (uint256 bridged) {
        require(block.chainid != chainId, 'BRIDGE_SAME_CHAIN');
        require(recipient != address(0), 'BRIDGE_RECIPIENT_ZERO');
        require(bridgeConnector != address(0), 'BRIDGE_CONNECTOR_NOT_SET');

        uint256 bridgeFeeAmount = _payFee(token, amount, bridgeFee);
        bridged = amount - bridgeFeeAmount;

        uint256 minAmountOut;
        if (limitType == BridgeLimit.MinAmountOut) {
            minAmountOut = limitAmount;
        } else if (limitType == BridgeLimit.Slippage) {
            require(limitAmount <= FixedPoint.ONE, 'BRIDGE_SLIPPAGE_ABOVE_ONE');
            // No need for checked math as we are checking it manually beforehand
            // Always round up the expected min amount out. Limit amount is slippage.
            minAmountOut = bridged.mulUp(FixedPoint.ONE.uncheckedSub(limitAmount));
        } else {
            revert('BRIDGE_INVALID_LIMIT_TYPE');
        }

        uint256 preBalanceIn = IERC20(token).balanceOf(address(this));
        bridgeConnector.bridge(source, chainId, token, bridged, minAmountOut, recipient, data);
        uint256 postBalanceIn = IERC20(token).balanceOf(address(this));
        require(postBalanceIn >= preBalanceIn - bridged, 'BRIDGE_BAD_TOKEN_IN_BALANCE');

        emit Bridge(source, chainId, token, bridged, minAmountOut, bridgeFeeAmount, recipient, data);
    }

    /**
     * @dev Internal function to pay the amount of fees to be charged based on a fee configuration to the fee collector
     * @param token Token being charged
     * @param amount Token amount to be taxed with fees
     * @param fee Fee configuration to be applied
     * @return paidAmount Amount of fees paid to the fee collector
     */
    function _payFee(address token, uint256 amount, Fee storage fee) internal returns (uint256 paidAmount) {
        // Fee amounts are always rounded down
        uint256 feeAmount = amount.mulDown(fee.pct);

        // If cap amount or cap period are not set, charge the entire amount
        if (fee.token == address(0) || fee.cap == 0 || fee.period == 0) {
            _safeTransfer(token, feeCollector, feeAmount);
            return feeAmount;
        }

        // Reset cap totalizator if necessary
        if (block.timestamp >= fee.nextResetTime) {
            fee.totalCharged = 0;
            fee.nextResetTime = block.timestamp + fee.period;
        }

        // Calc fee amount in the fee token used for the cap
        uint256 feeTokenPrice = getPrice(token, fee.token);
        uint256 feeAmountInFeeToken = feeAmount.mulDown(feeTokenPrice);

        // Compute fee amount picking the minimum between the chargeable amount and the remaining part for the cap
        if (fee.totalCharged + feeAmountInFeeToken <= fee.cap) {
            paidAmount = feeAmount;
            fee.totalCharged += feeAmountInFeeToken;
        } else if (fee.totalCharged < fee.cap) {
            paidAmount = (fee.cap.uncheckedSub(fee.totalCharged) * feeAmount) / feeAmountInFeeToken;
            fee.totalCharged = fee.cap;
        } else {
            // This case is when the total charged amount is already greater than the cap amount. It could happen if
            // the cap amounts is decreased or if the cap token is changed. In this case the total charged amount is
            // not updated, and the amount to paid is zero.
            paidAmount = 0;
        }

        // Pay fee amount to the fee collector
        _safeTransfer(token, feeCollector, paidAmount);
    }

    /**
     * @dev Internal method to transfer ERC20 or native tokens from a Smart Vault
     * @param token Address of the ERC20 token to transfer
     * @param to Address transferring the tokens to
     * @param amount Amount of tokens to transfer
     */
    function _safeTransfer(address token, address to, uint256 amount) internal {
        if (amount == 0) return;
        if (Denominations.isNativeToken(token)) Address.sendValue(payable(to), amount);
        else IERC20(token).safeTransfer(to, amount);
    }

    /**
     * @dev Sets a new strategy as allowed or not
     * @param strategy Address of the strategy to be set
     * @param allowed Whether the strategy is allowed or not
     */
    function _setStrategy(address strategy, bool allowed) internal {
        if (allowed) _validateStatelessDependency(strategy);
        isStrategyAllowed[strategy] = allowed;
        emit StrategySet(strategy, allowed);
    }

    /**
     * @dev Sets a new price oracle
     * @param newPriceOracle New price oracle to be set
     */
    function _setPriceOracle(address newPriceOracle) internal {
        _validateStatelessDependency(newPriceOracle);
        priceOracle = newPriceOracle;
        emit PriceOracleSet(newPriceOracle);
    }

    /**
     * @dev Sets a new swap connector
     * @param newSwapConnector New swap connector to be set
     */
    function _setSwapConnector(address newSwapConnector) internal {
        _validateStatelessDependency(newSwapConnector);
        swapConnector = newSwapConnector;
        emit SwapConnectorSet(newSwapConnector);
    }

    /**
     * @dev Sets a new bridge connector
     * @param newBridgeConnector New bridge connector to be set
     */
    function _setBridgeConnector(address newBridgeConnector) internal {
        _validateStatelessDependency(newBridgeConnector);
        bridgeConnector = newBridgeConnector;
        emit BridgeConnectorSet(newBridgeConnector);
    }

    /**
     * @dev Internal method to set the fee collector
     * @param newFeeCollector New fee collector to be set
     */
    function _setFeeCollector(address newFeeCollector) internal {
        require(newFeeCollector != address(0), 'FEE_COLLECTOR_ZERO');
        feeCollector = newFeeCollector;
        emit FeeCollectorSet(newFeeCollector);
    }

    /**
     * @dev Internal method to set a new fee cap configuration
     * @param fee Fee configuration to be updated
     * @param pct Fee percentage to be set
     * @param cap New maximum amount of fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds
     */
    function _setFeeConfiguration(Fee storage fee, uint256 pct, uint256 cap, address token, uint256 period) internal {
        require(pct <= FixedPoint.ONE, 'FEE_PCT_ABOVE_ONE');

        // If there is no fee percentage, there must not be a fee cap
        bool isZeroCap = token == address(0) && cap == 0 && period == 0;
        require(pct != 0 || isZeroCap, 'INVALID_CAP_WITH_FEE_ZERO');

        // If there is a cap, all values must be non-zero
        bool isNonZeroCap = token != address(0) && cap != 0 && period != 0;
        require(isZeroCap || isNonZeroCap, 'INCONSISTENT_CAP_VALUES');

        // Changing the fee percentage does not affect the totalizator at all, it only affects future fee charges
        fee.pct = pct;

        // Changing the fee cap amount does not affect the totalizator, it only applies when changing the for the total
        // charged amount. Note that it can happen that the cap amount is lower than the total charged amount if the
        // cap amount is lowered. However, there shouldn't be any accounting issues with that.
        fee.cap = cap;

        // Changing the cap period only affects the end time of the next period, but not the end date of the current one
        fee.period = period;

        // Therefore, only clean the totalizators if the cap is being removed
        if (isZeroCap) {
            fee.totalCharged = 0;
            fee.nextResetTime = 0;
        } else {
            // If cap values are not zero, set the next reset time if it wasn't set already
            // Otherwise, if the cap token is being changed the total charged amount must be updated accordingly
            if (fee.nextResetTime == 0) {
                fee.nextResetTime = block.timestamp + period;
            } else if (fee.token != token) {
                uint256 newTokenPrice = getPrice(fee.token, token);
                fee.totalCharged = fee.totalCharged.mulDown(newTokenPrice);
            }
        }

        // Finally simply set the new requested token
        fee.token = token;
    }
}

File 2 of 42 : IBridgeConnector.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title IBridgeConnector
 * @dev Bridge Connector interface to bridge tokens between different chains. It must follow IImplementation interface.
 */
interface IBridgeConnector is IImplementation {
    /**
     * @dev Enum identifying the sources proposed: Hop only for now.
     */
    enum Source {
        Hop
    }

    /**
     * @dev Bridge assets to a different chain
     * @param source Source to execute the requested bridge op
     * @param chainId ID of the destination chain
     * @param token Address of the token to be bridged
     * @param amountIn Amount of tokens to be bridged
     * @param minAmountOut Minimum amount of tokens willing to receive on the destination chain
     * @param recipient Address that will receive the tokens on the destination chain
     * @param data ABI encoded data that will depend on the requested source
     */
    function bridge(
        uint8 source,
        uint256 chainId,
        address token,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        bytes memory data
    ) external;
}

File 3 of 42 : Authorizer.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import './IAuthorizer.sol';

/**
 * @title Authorizer
 * @dev Authorization module to be used by contracts that need to implement permissions for their methods.
 * It provides a permissions model to list who is allowed to call what function in a contract. And only accounts
 * authorized to manage those permissions are the ones that are allowed to authorize or unauthorize accounts.
 */
contract Authorizer is IAuthorizer {
    // Constant used to denote that a permission is open to anyone
    address public constant ANY_ADDRESS = address(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF);

    // Internal mapping to tell who is allowed to do what indexed by (account, function selector)
    mapping (address => mapping (bytes4 => bool)) private authorized;

    /**
     * @dev Modifier that should be used to tag protected functions
     */
    modifier auth() {
        _authenticate(msg.sender, msg.sig);
        _;
    }

    /**
     * @dev Tells whether someone is allowed to call a function or not. It returns true if it's allowed to anyone.
     * @param who Address asking permission for
     * @param what Function selector asking permission for
     */
    function isAuthorized(address who, bytes4 what) public view override returns (bool) {
        return authorized[ANY_ADDRESS][what] || authorized[who][what];
    }

    /**
     * @dev Authorizes someone to call a function. Sender must be authorize to do so.
     * @param who Address to be authorized
     * @param what Function selector to be granted
     */
    function authorize(address who, bytes4 what) external override auth {
        _authorize(who, what);
    }

    /**
     * @dev Unauthorizes someone to call a function. Sender must be authorize to do so.
     * @param who Address to be unauthorized
     * @param what Function selector to be revoked
     */
    function unauthorize(address who, bytes4 what) external override auth {
        _unauthorize(who, what);
    }

    /**
     * @dev Internal function to authenticate someone over a function.
     * It reverts if the given account is not authorized to call the requested function.
     * @param who Address to be authenticated
     * @param what Function selector to be authenticated
     */
    function _authenticate(address who, bytes4 what) internal view {
        require(isAuthorized(who, what), 'AUTH_SENDER_NOT_ALLOWED');
    }

    /**
     * @dev Internal function to authorize someone to call a function
     * @param who Address to be authorized
     * @param what Function selector to be granted
     */
    function _authorize(address who, bytes4 what) internal {
        authorized[who][what] = true;
        emit Authorized(who, what);
    }

    /**
     * @dev Internal function to unauthorize someone to call a function
     * @param who Address to be unauthorized
     * @param what Function selector to be revoked
     */
    function _unauthorize(address who, bytes4 what) internal {
        authorized[who][what] = false;
        emit Unauthorized(who, what);
    }
}

File 4 of 42 : IAuthorizer.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

/**
 * @title IAuthorizer
 */
interface IAuthorizer {
    /**
     * @dev Emitted when an account is authorized to call a function
     */
    event Authorized(address indexed who, bytes4 what);

    /**
     * @dev Emitted when an account is unauthorized to call a function
     */
    event Unauthorized(address indexed who, bytes4 what);

    /**
     * @dev Authorizes someone to call a function. Sender must be authorize to do so.
     * @param who Address to be authorized
     * @param what Function selector to be granted
     */
    function authorize(address who, bytes4 what) external;

    /**
     * @dev Unauthorizes someone to call a function. Sender must be authorize to do so.
     * @param who Address to be unauthorized
     * @param what Function selector to be revoked
     */
    function unauthorize(address who, bytes4 what) external;

    /**
     * @dev Tells whether someone is allowed to call a function or not. It returns true if it's allowed to anyone.
     * @param who Address asking permission for
     * @param what Function selector asking permission for
     */
    function isAuthorized(address who, bytes4 what) external view returns (bool);
}

File 5 of 42 : FixedPoint.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

/**
 * @title FixedPoint
 * @dev Math library to operate with fixed point values with 18 decimals
 */
library FixedPoint {
    // 1 in fixed point value: 18 decimal places
    uint256 internal constant ONE = 1e18;

    /**
     * @dev Multiplies two fixed point numbers rounding down
     */
    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            uint256 product = a * b;
            require(a == 0 || product / a == b, 'MUL_OVERFLOW');
            return product / ONE;
        }
    }

    /**
     * @dev Multiplies two fixed point numbers rounding up
     */
    function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            uint256 product = a * b;
            require(a == 0 || product / a == b, 'MUL_OVERFLOW');
            return product == 0 ? 0 : (((product - 1) / ONE) + 1);
        }
    }

    /**
     * @dev Divides two fixed point numbers rounding down
     */
    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            require(b != 0, 'ZERO_DIVISION');
            if (a == 0) return 0;
            uint256 aInflated = a * ONE;
            require(aInflated / a == ONE, 'DIV_INTERNAL');
            return aInflated / b;
        }
    }

    /**
     * @dev Divides two fixed point numbers rounding up
     */
    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            require(b != 0, 'ZERO_DIVISION');
            if (a == 0) return 0;
            uint256 aInflated = a * ONE;
            require(aInflated / a == ONE, 'DIV_INTERNAL');
            return ((aInflated - 1) / b) + 1;
        }
    }
}

File 6 of 42 : UncheckedMath.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

/**
 * @title UncheckedMath
 * @dev Math library to perform unchecked operations
 */
library UncheckedMath {
    /**
     * @dev Unsafely adds two unsigned integers
     */
    function uncheckedAdd(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a + b;
        }
    }

    /**
     * @dev Unsafely subtracts two unsigned integers
     */
    function uncheckedSub(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a - b;
        }
    }

    /**
     * @dev Unsafely multiplies two unsigned integers
     */
    function uncheckedMul(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a * b;
        }
    }

    /**
     * @dev Unsafely multiplies two signed integers
     */
    function uncheckedMul(int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            return a * b;
        }
    }

    /**
     * @dev Unsafely divides two unsigned integers
     */
    function uncheckedDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a / b;
        }
    }
}

File 7 of 42 : Denominations.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

/**
 * @title Denominations
 * @dev Provides a list of ground denominations for those tokens that cannot be represented by an ERC20.
 * For now, the only needed is the native token that could be ETH, MATIC, or other depending on the layer being operated.
 */
library Denominations {
    address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

    function isNativeToken(address token) internal pure returns (bool) {
        return token == NATIVE_TOKEN;
    }
}

File 8 of 42 : IWrappedNativeToken.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

/**
 * @title IWrappedNativeToken
 */
interface IWrappedNativeToken is IERC20 {
    /**
     * @dev Wraps msg.value into the wrapped-native token
     */
    function deposit() external payable;

    /**
     * @dev Unwraps requested amount to the native token
     */
    function withdraw(uint256 amount) external;
}

File 9 of 42 : IPriceFeedProvider.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

/**
 * @title IPriceFeedProvider
 * @dev Contract providing price feed references for (base, quote) token pairs
 */
interface IPriceFeedProvider {
    /**
     * @dev Emitted every time a price feed is set for (base, quote) pair
     */
    event PriceFeedSet(address indexed base, address indexed quote, address feed);

    /**
     * @dev Tells the price feed address for (base, quote) pair. It returns the zero address if there is no one set.
     * @param base Token to be rated
     * @param quote Token used for the price rate
     */
    function getPriceFeed(address base, address quote) external view returns (address);

    /**
     * @dev Sets a of price feed
     * @param base Token base to be set
     * @param quote Token quote to be set
     * @param feed Price feed to be set
     */
    function setPriceFeed(address base, address quote, address feed) external;

    /**
     * @dev Sets a list of price feeds
     * @param bases List of token bases to be set
     * @param quotes List of token quotes to be set
     * @param feeds List of price feeds to be set
     */
    function setPriceFeeds(address[] memory bases, address[] memory quotes, address[] memory feeds) external;
}

File 10 of 42 : PriceFeedProvider.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@mimic-fi/v2-helpers/contracts/math/UncheckedMath.sol';

import './IPriceFeedProvider.sol';

/**
 * @title IPriceFeedProvider
 * @dev Contract providing price feed references for (base, quote) token pairs
 */
contract PriceFeedProvider is IPriceFeedProvider {
    using UncheckedMath for uint256;

    // Mapping of price feeds from "token A" to "token B"
    mapping (address => mapping (address => address)) private _priceFeeds;

    /**
     * @dev Tells the price feed address for (base, quote) pair. It returns the zero address if there is no one set.
     * @param base Token to be rated
     * @param quote Token used for the price rate
     */
    function getPriceFeed(address base, address quote) external view override returns (address) {
        return _priceFeeds[base][quote];
    }

    /**
     * @dev Sets a of price feed
     * @param base Token base to be set
     * @param quote Token quote to be set
     * @param feed Price feed to be set
     */
    function setPriceFeed(address base, address quote, address feed) public virtual override {
        _priceFeeds[base][quote] = feed;
        emit PriceFeedSet(base, quote, feed);
    }

    /**
     * @dev Sets a list of price feeds. Sender must be authorized.
     * @param bases List of token bases to be set
     * @param quotes List of token quotes to be set
     * @param feeds List of price feeds to be set
     */
    function setPriceFeeds(address[] memory bases, address[] memory quotes, address[] memory feeds)
        public
        virtual
        override
    {
        require(bases.length == quotes.length, 'SET_FEEDS_INVALID_QUOTES_LENGTH');
        require(bases.length == feeds.length, 'SET_FEEDS_INVALID_FEEDS_LENGTH');
        for (uint256 i = 0; i < bases.length; i = i.uncheckedAdd(1)) setPriceFeed(bases[i], quotes[i], feeds[i]);
    }
}

File 11 of 42 : IPriceOracle.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title IPriceOracle
 * @dev Oracle that interfaces with external feeds to provide quotes for tokens based on any other token.
 * It must support also `IImplementation`.
 */
interface IPriceOracle is IImplementation {
    /**
     * @dev Tells the price of a token (base) in a given quote. The response is expressed using the corresponding
     * number of decimals so that when performing a fixed point product of it by a `base` amount it results in
     * a value expressed in `quote` decimals. For example, if `base` is ETH and `quote` is USDC, then the returned
     * value is expected to be expressed using 6 decimals:
     *
     * FixedPoint.mul(X[ETH], price[USDC/ETH]) = FixedPoint.mul(X[18], price[6]) = X * price [6]
     *
     * @param provider Contract providing the price feeds to use by the oracle
     * @param base Token to rate
     * @param quote Token used for the price rate
     */
    function getPrice(address provider, address base, address quote) external view returns (uint256);
}

File 12 of 42 : BaseImplementation.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/proxy/utils/Initializable.sol';

import './IImplementation.sol';
import '../registry/IRegistry.sol';

/**
 * @title BaseImplementation
 * @dev This implementation contract comes with an immutable reference to an implementations registry where it should
 * be registered as well (checked during initialization). It allows requesting new instances of other registered
 * implementations to as another safety check to make sure valid instances are referenced in case it's needed.
 */
abstract contract BaseImplementation is IImplementation {
    // Immutable implementations registry reference
    address public immutable override registry;

    /**
     * @dev Creates a new BaseImplementation
     * @param _registry Address of the Mimic Registry where dependencies will be validated against
     */
    constructor(address _registry) {
        registry = _registry;
    }

    /**
     * @dev Internal function to validate a new dependency that must be registered as stateless.
     * It checks the new dependency is registered, not deprecated, and stateless.
     * @param dependency New stateless dependency to be set
     */
    function _validateStatelessDependency(address dependency) internal view {
        require(_validateDependency(dependency), 'DEPENDENCY_NOT_STATELESS');
    }

    /**
     * @dev Internal function to validate a new dependency that cannot be registered as stateless.
     * It checks the new dependency is registered, not deprecated, and not stateful.
     * @param dependency New stateful dependency to be set
     */
    function _validateStatefulDependency(address dependency) internal view {
        require(!_validateDependency(dependency), 'DEPENDENCY_NOT_STATEFUL');
    }

    /**
     * @dev Internal function to validate a new dependency. It checks the dependency is registered and not deprecated.
     * @param dependency New dependency to be set
     * @return Whether the dependency is stateless or not
     */
    function _validateDependency(address dependency) private view returns (bool) {
        (bool stateless, bool deprecated, bytes32 namespace) = IRegistry(registry).implementationData(dependency);
        require(namespace != bytes32(0), 'DEPENDENCY_NOT_REGISTERED');
        require(!deprecated, 'DEPENDENCY_DEPRECATED');
        return stateless;
    }
}

File 13 of 42 : IImplementation.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

// solhint-disable func-name-mixedcase

/**
 * @title IImplementation
 * @dev Implementation interface that must be followed for implementations to be registered in the Mimic Registry
 */
interface IImplementation {
    /**
     * @dev Tells the namespace under which the implementation is registered in the Mimic Registry
     */
    function NAMESPACE() external view returns (bytes32);

    /**
     * @dev Tells the address of the Mimic Registry
     */
    function registry() external view returns (address);
}

File 14 of 42 : InitializableAuthorizedImplementation.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@mimic-fi/v2-helpers/contracts/auth/Authorizer.sol';

import './InitializableImplementation.sol';

/**
 * @title InitializableAuthorizedImplementation
 * @dev InitializableImplementation using the Authorizer mixin. Initializable implementations that want to use the
 * Authorizer permissions mechanism should inherit from this contract instead.
 */
abstract contract InitializableAuthorizedImplementation is InitializableImplementation, Authorizer {
    /**
     * @dev Creates a new InitializableAuthorizedImplementation
     * @param registry Address of the Mimic Registry
     */
    constructor(address registry) InitializableImplementation(registry) {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Initialization function that authorizes an admin account to authorize and unauthorize accounts.
     * Note this function can only be called from a function marked with the `initializer` modifier.
     * @param admin Address to be granted authorize and unauthorize permissions
     */
    function _initialize(address admin) internal onlyInitializing {
        _initialize();
        _authorize(admin, Authorizer.authorize.selector);
        _authorize(admin, Authorizer.unauthorize.selector);
    }
}

File 15 of 42 : InitializableImplementation.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/proxy/utils/Initializable.sol';

import './BaseImplementation.sol';

/**
 * @title InitializableImplementation
 * @dev Implementation contract to be used through proxies. Inheriting contracts are meant to be initialized through
 * initialization functions instead of constructor functions. It allows re-using the same logic contract while making
 * deployments cheaper.
 */
abstract contract InitializableImplementation is BaseImplementation, Initializable {
    /**
     * @dev Creates a new BaseImplementation. Note that initializers are disabled at creation time.
     */
    constructor(address registry) BaseImplementation(registry) {
        _disableInitializers();
    }

    /**
     * @dev Initialization function.
     * Note this function can only be called from a function marked with the `initializer` modifier.
     */
    function _initialize() internal view onlyInitializing {
        // solhint-disable-previous-line no-empty-blocks
    }
}

File 16 of 42 : IRegistry.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import '@mimic-fi/v2-helpers/contracts/auth/IAuthorizer.sol';

/**
 * @title IRegistry
 * @dev Registry interface, it must follow the IAuthorizer interface.
 */
interface IRegistry is IAuthorizer {
    /**
     * @dev Emitted every time a new implementation is registered
     */
    event Registered(bytes32 indexed namespace, address indexed implementation, bool stateless);

    /**
     * @dev Emitted every time an implementation is deprecated
     */
    event Deprecated(bytes32 indexed namespace, address indexed implementation);

    /**
     * @dev Tells the data of an implementation:
     * @param implementation Address of the implementation to request it's data
     */
    function implementationData(address implementation)
        external
        view
        returns (bool stateless, bool deprecated, bytes32 namespace);

    /**
     * @dev Tells if a specific implementation is registered under a certain namespace and it's not deprecated
     * @param namespace Namespace asking for
     * @param implementation Address of the implementation to be checked
     */
    function isActive(bytes32 namespace, address implementation) external view returns (bool);

    /**
     * @dev Registers a new implementation for a given namespace
     * @param namespace Namespace to be used for the implementation
     * @param implementation Address of the implementation to be registered
     * @param stateless Whether the implementation is stateless or not
     */
    function register(bytes32 namespace, address implementation, bool stateless) external;

    /**
     * @dev Deprecates a registered implementation
     * @param implementation Address of the implementation to be deprecated
     */
    function deprecate(address implementation) external;
}

File 17 of 42 : IStrategy.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title IStrategy
 * @dev Strategy interface required by Mimic Smart Vaults. It must follow the IImplementation interface.
 */
interface IStrategy is IImplementation {
    /**
     * @dev Tokens accepted to join the strategy
     */
    function joinTokens() external view returns (address[] memory);

    /**
     * @dev Tokens accepted to exit the strategy
     */
    function exitTokens() external view returns (address[] memory);

    /**
     * @dev Tells how much a value unit means expressed in the asset token.
     * For example, if a strategy has a value of 100 in T0, and then it has a value of 120 in T1,
     * and the value rate is 1.5, it means the strategy has earned 30 strategy tokens between T0 and T1.
     */
    function valueRate() external view returns (uint256);

    /**
     * @dev Tells the last value an account has over time. Note this value can be outdated: there could be rewards to
     * be claimed that will affect the accrued value. For example, if an account has a value of 100 in T0, and then it
     * has a value of 120 in T1, it means it gained a 20% between T0 and T1.
     * @param account Address of the account querying the last value of
     */
    function lastValue(address account) external view returns (uint256);

    /**
     * @dev Claim any existing rewards
     * @param data Arbitrary extra data
     * @return tokens Addresses of the tokens received as rewards
     * @return amounts Amounts of the tokens received as rewards
     */
    function claim(bytes memory data) external returns (address[] memory tokens, uint256[] memory amounts);

    /**
     * @dev Join the interfaced DeFi protocol
     * @param tokensIn List of token addresses to join with
     * @param amountsIn List of token amounts to join with
     * @param slippage Slippage value to join with
     * @param data Arbitrary extra data
     * @return tokensOut List of token addresses received after the join
     * @return amountsOut List of token amounts received after the join
     * @return value Value represented by the joined amount
     */
    function join(address[] memory tokensIn, uint256[] memory amountsIn, uint256 slippage, bytes memory data)
        external
        returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value);

    /**
     * @dev Exit the interfaced DeFi protocol
     * @param tokensIn List of token addresses to exit with
     * @param amountsIn List of token amounts to exit with
     * @param slippage Slippage value to exit with
     * @param data Arbitrary extra data
     * @return tokensOut List of token addresses received after the exit
     * @return amountsOut List of token amounts received after the exit
     * @return value Value represented by the exited amount
     */
    function exit(address[] memory tokensIn, uint256[] memory amountsIn, uint256 slippage, bytes memory data)
        external
        returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value);
}

File 18 of 42 : ISwapConnector.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title ISwapConnector
 * @dev Swap Connector interface to perform token swaps. It must follow the IImplementation interface.
 */
interface ISwapConnector is IImplementation {
    /**
     * @dev Enum identifying the sources proposed: Uniswap V2, Uniswap V3, Balancer V2, Paraswap V5, 1inch V5, and Hop.
     */
    enum Source {
        UniswapV2,
        UniswapV3,
        BalancerV2,
        ParaswapV5,
        OneInchV5,
        Hop
    }

    /**
     * @dev Swaps two tokens
     * @param source Source to execute the requested swap
     * @param tokenIn Token being sent
     * @param tokenOut Token being received
     * @param amountIn Amount of tokenIn being swapped
     * @param minAmountOut Minimum amount of tokenOut willing to receive
     * @param data Encoded data to specify different swap parameters depending on the source picked
     */
    function swap(
        uint8 source,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        bytes memory data
    ) external returns (uint256 amountOut);
}

File 19 of 42 : Clones.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/Clones.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create(0, ptr, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create2(0, ptr, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, deployer))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address implementation, bytes32 salt)
        internal
        view
        returns (address predicted)
    {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}

File 20 of 42 : Initializable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/Address.sol";

/**
 * @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) || (!Address.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 21 of 42 : ERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

File 22 of 42 : draft-IERC20Permit.sol
// SPDX-License-Identifier: MIT
// 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 23 of 42 : IERC20Metadata.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

File 24 of 42 : IERC20.sol
// SPDX-License-Identifier: MIT
// 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 25 of 42 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @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");
        }
    }
}

File 26 of 42 : Address.sol
// SPDX-License-Identifier: MIT
// 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 27 of 42 : Context.sol
// SPDX-License-Identifier: MIT
// 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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 28 of 42 : Math.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. It the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 1;
        }

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        uint256 result = sqrt(a);
        if (rounding == Rounding.Up && result * result < a) {
            result += 1;
        }
        return result;
    }
}

File 29 of 42 : BridgeConnectorLib.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/utils/Address.sol';

import '@mimic-fi/v2-bridge-connector/contracts/IBridgeConnector.sol';

/**
 * @title BridgeConnectorLib
 * @dev Library used to delegate-call bridge ops and decode return data correctly
 */
library BridgeConnectorLib {
    /**
     * @dev Delegate-calls a bridge to the bridge connector and decodes de expected data
     * IMPORTANT! This helper method does not check any of the given params, these should be checked beforehand.
     */
    function bridge(
        address connector,
        uint8 source,
        uint256 chainId,
        address token,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        bytes memory data
    ) internal {
        bytes memory bridgeData = abi.encodeWithSelector(
            IBridgeConnector.bridge.selector,
            source,
            chainId,
            token,
            amountIn,
            minAmountOut,
            recipient,
            data
        );

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = connector.delegatecall(bridgeData);
        Address.verifyCallResult(success, returndata, 'BRIDGE_CALL_REVERTED');
    }
}

File 30 of 42 : StrategyLib.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/utils/Address.sol';

import '@mimic-fi/v2-strategies/contracts/IStrategy.sol';

/**
 * @title StrategyLib
 * @dev Library used to delegate-call to strategy and decode return data correctly
 */
library StrategyLib {
    /**
     * @dev Delegate-calls a claim to a strategy and decodes de expected data
     * IMPORTANT! This helper method does not check any of the given params, these should be checked beforehand.
     */
    function claim(address strategy, bytes memory data) internal returns (address[] memory, uint256[] memory) {
        bytes memory claimData = abi.encodeWithSelector(IStrategy.claim.selector, data);

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = strategy.delegatecall(claimData);
        Address.verifyCallResult(success, returndata, 'CLAIM_CALL_REVERTED');
        return abi.decode(returndata, (address[], uint256[]));
    }

    /**
     * @dev Delegate-calls a join to a strategy and decodes de expected data
     * IMPORTANT! This helper method does not check any of the given params, these should be checked beforehand.
     */
    function join(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) internal returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value) {
        bytes memory joinData = abi.encodeWithSelector(IStrategy.join.selector, tokensIn, amountsIn, slippage, data);

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = strategy.delegatecall(joinData);
        Address.verifyCallResult(success, returndata, 'JOIN_CALL_REVERTED');
        return abi.decode(returndata, (address[], uint256[], uint256));
    }

    /**
     * @dev Delegate-calls a exit to a strategy and decodes de expected data
     * IMPORTANT! This helper method does not check any of the given params, these should be checked beforehand.
     */
    function exit(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) internal returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value) {
        bytes memory exitData = abi.encodeWithSelector(IStrategy.exit.selector, tokensIn, amountsIn, slippage, data);

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = strategy.delegatecall(exitData);
        Address.verifyCallResult(success, returndata, 'EXIT_CALL_REVERTED');
        return abi.decode(returndata, (address[], uint256[], uint256));
    }
}

File 31 of 42 : SwapConnectorLib.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/utils/Address.sol';

import '@mimic-fi/v2-swap-connector/contracts/ISwapConnector.sol';

/**
 * @title SwapConnectorLib
 * @dev Library used to delegate-call swaps and decode return data correctly
 */
library SwapConnectorLib {
    /**
     * @dev Delegate-calls a swap to the swap connector and decodes de expected data
     * IMPORTANT! This helper method does not check any of the given params, these should be checked beforehand.
     */
    function swap(
        address connector,
        uint8 source,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        bytes memory data
    ) internal returns (uint256 amountOut) {
        bytes memory swapData = abi.encodeWithSelector(
            ISwapConnector.swap.selector,
            source,
            tokenIn,
            tokenOut,
            amountIn,
            minAmountOut,
            data
        );

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = connector.delegatecall(swapData);
        Address.verifyCallResult(success, returndata, 'SWAP_CALL_REVERTED');
        return abi.decode(returndata, (uint256));
    }
}

File 32 of 42 : ISmartVault.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@mimic-fi/v2-helpers/contracts/auth/IAuthorizer.sol';
import '@mimic-fi/v2-price-oracle/contracts/feeds/IPriceFeedProvider.sol';
import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title ISmartVault
 * @dev Mimic Smart Vault interface to manage assets. It must support also `IImplementation` and `IAuthorizer`
 */
interface ISmartVault is IPriceFeedProvider, IImplementation, IAuthorizer {
    enum SwapLimit {
        Slippage,
        MinAmountOut
    }

    enum BridgeLimit {
        Slippage,
        MinAmountOut
    }

    /**
     * @dev Emitted every time a new strategy is set for the Smart Vault
     */
    event StrategySet(address indexed strategy, bool allowed);

    /**
     * @dev Emitted every time a new price oracle is set for the Smart Vault
     */
    event PriceOracleSet(address indexed priceOracle);

    /**
     * @dev Emitted every time a new swap connector is set for the Smart Vault
     */
    event SwapConnectorSet(address indexed swapConnector);

    /**
     * @dev Emitted every time a new bridge connector is set for the Smart Vault
     */
    event BridgeConnectorSet(address indexed bridgeConnector);

    /**
     * @dev Emitted every time a new fee collector is set
     */
    event FeeCollectorSet(address indexed feeCollector);

    /**
     * @dev Emitted every time the withdraw fee percentage is set
     */
    event WithdrawFeeSet(uint256 pct, uint256 cap, address token, uint256 period);

    /**
     * @dev Emitted every time the performance fee percentage is set
     */
    event PerformanceFeeSet(uint256 pct, uint256 cap, address token, uint256 period);

    /**
     * @dev Emitted every time the swap fee percentage is set
     */
    event SwapFeeSet(uint256 pct, uint256 cap, address token, uint256 period);

    /**
     * @dev Emitted every time the bridge fee percentage is set
     */
    event BridgeFeeSet(uint256 pct, uint256 cap, address token, uint256 period);

    /**
     * @dev Emitted every time `call` is called
     */
    event Call(address indexed target, bytes callData, uint256 value, bytes result, bytes data);

    /**
     * @dev Emitted every time `collect` is called
     */
    event Collect(address indexed token, address indexed from, uint256 collected, bytes data);

    /**
     * @dev Emitted every time `withdraw` is called
     */
    event Withdraw(address indexed token, address indexed recipient, uint256 withdrawn, uint256 fee, bytes data);

    /**
     * @dev Emitted every time `wrap` is called
     */
    event Wrap(uint256 amount, uint256 wrapped, bytes data);

    /**
     * @dev Emitted every time `unwrap` is called
     */
    event Unwrap(uint256 amount, uint256 unwrapped, bytes data);

    /**
     * @dev Emitted every time `claim` is called
     */
    event Claim(address indexed strategy, address[] tokens, uint256[] amounts, bytes data);

    /**
     * @dev Emitted every time `join` is called
     */
    event Join(
        address indexed strategy,
        address[] tokensIn,
        uint256[] amountsIn,
        address[] tokensOut,
        uint256[] amountsOut,
        uint256 value,
        uint256 slippage,
        bytes data
    );

    /**
     * @dev Emitted every time `exit` is called
     */
    event Exit(
        address indexed strategy,
        address[] tokensIn,
        uint256[] amountsIn,
        address[] tokensOut,
        uint256[] amountsOut,
        uint256 value,
        uint256[] fees,
        uint256 slippage,
        bytes data
    );

    /**
     * @dev Emitted every time `swap` is called
     */
    event Swap(
        uint8 indexed source,
        address indexed tokenIn,
        address indexed tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        uint256 minAmountOut,
        uint256 fee,
        bytes data
    );

    /**
     * @dev Emitted every time `bridge` is called
     */
    event Bridge(
        uint8 indexed source,
        uint256 indexed chainId,
        address indexed token,
        uint256 amountIn,
        uint256 minAmountOut,
        uint256 fee,
        address recipient,
        bytes data
    );

    /**
     * @dev Tells a strategy is allowed or not
     * @param strategy Address of the strategy being queried
     */
    function isStrategyAllowed(address strategy) external view returns (bool);

    /**
     * @dev Tells the invested value for a strategy
     * @param strategy Address of the strategy querying the invested value of
     */
    function investedValue(address strategy) external view returns (uint256);

    /**
     * @dev Tells the last value accrued for a strategy. Note this value can be outdated.
     * @param strategy Address of the strategy querying the last value of
     */
    function lastValue(address strategy) external view returns (uint256);

    /**
     * @dev Tells the price oracle associated to a Smart Vault
     */
    function priceOracle() external view returns (address);

    /**
     * @dev Tells the swap connector associated to a Smart Vault
     */
    function swapConnector() external view returns (address);

    /**
     * @dev Tells the bridge connector associated to a Smart Vault
     */
    function bridgeConnector() external view returns (address);

    /**
     * @dev Tells the address where fees will be deposited
     */
    function feeCollector() external view returns (address);

    /**
     * @dev Tells the withdraw fee configuration
     */
    function withdrawFee()
        external
        view
        returns (uint256 pct, uint256 cap, address token, uint256 period, uint256 totalCharged, uint256 nextResetTime);

    /**
     * @dev Tells the performance fee configuration
     */
    function performanceFee()
        external
        view
        returns (uint256 pct, uint256 cap, address token, uint256 period, uint256 totalCharged, uint256 nextResetTime);

    /**
     * @dev Tells the swap fee configuration
     */
    function swapFee()
        external
        view
        returns (uint256 pct, uint256 cap, address token, uint256 period, uint256 totalCharged, uint256 nextResetTime);

    /**
     * @dev Tells the bridge fee configuration
     */
    function bridgeFee()
        external
        view
        returns (uint256 pct, uint256 cap, address token, uint256 period, uint256 totalCharged, uint256 nextResetTime);

    /**
     * @dev Tells the address of the wrapped native token
     */
    function wrappedNativeToken() external view returns (address);

    /**
     * @dev Sets a new strategy as allowed or not for a Smart Vault
     * @param strategy Address of the strategy to be set
     * @param allowed Whether the strategy is allowed or not
     */
    function setStrategy(address strategy, bool allowed) external;

    /**
     * @dev Sets a new price oracle to a Smart Vault
     * @param newPriceOracle Address of the new price oracle to be set
     */
    function setPriceOracle(address newPriceOracle) external;

    /**
     * @dev Sets a new swap connector to a Smart Vault
     * @param newSwapConnector Address of the new swap connector to be set
     */
    function setSwapConnector(address newSwapConnector) external;

    /**
     * @dev Sets a new bridge connector to a Smart Vault
     * @param newBridgeConnector Address of the new bridge connector to be set
     */
    function setBridgeConnector(address newBridgeConnector) external;

    /**
     * @dev Sets a new fee collector
     * @param newFeeCollector Address of the new fee collector to be set
     */
    function setFeeCollector(address newFeeCollector) external;

    /**
     * @dev Sets a new withdraw fee configuration
     * @param pct Withdraw fee percentage to be set
     * @param cap New maximum amount of withdraw fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the withdraw fee
     */
    function setWithdrawFee(uint256 pct, uint256 cap, address token, uint256 period) external;

    /**
     * @dev Sets a new performance fee configuration
     * @param pct Performance fee percentage to be set
     * @param cap New maximum amount of performance fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the performance fee
     */
    function setPerformanceFee(uint256 pct, uint256 cap, address token, uint256 period) external;

    /**
     * @dev Sets a new swap fee configuration
     * @param pct Swap fee percentage to be set
     * @param cap New maximum amount of swap fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the swap fee
     */
    function setSwapFee(uint256 pct, uint256 cap, address token, uint256 period) external;

    /**
     * @dev Sets a new bridge fee configuration
     * @param pct Bridge fee percentage to be set
     * @param cap New maximum amount of bridge fees to be charged per period
     * @param token Address of the token cap to be set
     * @param period New cap period length in seconds for the bridge fee
     */
    function setBridgeFee(uint256 pct, uint256 cap, address token, uint256 period) external;

    /**
     * @dev Tells the price of a token (base) in a given quote
     * @param base Token to rate
     * @param quote Token used for the price rate
     */
    function getPrice(address base, address quote) external view returns (uint256);

    /**
     * @dev Execute an arbitrary call from a Smart Vault
     * @param target Address where the call will be sent
     * @param callData Calldata to be used for the call
     * @param value Value in wei that will be attached to the call
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return result Call response if it was successful, otherwise it reverts
     */
    function call(address target, bytes memory callData, uint256 value, bytes memory data)
        external
        returns (bytes memory result);

    /**
     * @dev Collect tokens from a sender to a Smart Vault
     * @param token Address of the token to be collected
     * @param from Address where the tokens will be transfer from
     * @param amount Amount of tokens to be transferred
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return collected Amount of tokens assigned to the Smart Vault
     */
    function collect(address token, address from, uint256 amount, bytes memory data)
        external
        returns (uint256 collected);

    /**
     * @dev Withdraw tokens to an external account
     * @param token Address of the token to be withdrawn
     * @param amount Amount of tokens to withdraw
     * @param recipient Address where the tokens will be transferred to
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return withdrawn Amount of tokens transferred to the recipient address
     */
    function withdraw(address token, uint256 amount, address recipient, bytes memory data)
        external
        returns (uint256 withdrawn);

    /**
     * @dev Wrap an amount of native tokens to the wrapped ERC20 version of it
     * @param amount Amount of native tokens to be wrapped
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return wrapped Amount of tokens wrapped
     */
    function wrap(uint256 amount, bytes memory data) external returns (uint256 wrapped);

    /**
     * @dev Unwrap an amount of wrapped native tokens
     * @param amount Amount of wrapped native tokens to unwrapped
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return unwrapped Amount of tokens unwrapped
     */
    function unwrap(uint256 amount, bytes memory data) external returns (uint256 unwrapped);

    /**
     * @dev Claim strategy rewards
     * @param strategy Address of the strategy to claim rewards
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return tokens Addresses of the tokens received as rewards
     * @return amounts Amounts of the tokens received as rewards
     */
    function claim(address strategy, bytes memory data)
        external
        returns (address[] memory tokens, uint256[] memory amounts);

    /**
     * @dev Join a strategy with an amount of tokens
     * @param strategy Address of the strategy to join
     * @param tokensIn List of token addresses to join with
     * @param amountsIn List of token amounts to join with
     * @param slippage Slippage that will be used to compute the join
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return tokensOut List of token addresses received after the join
     * @return amountsOut List of token amounts received after the join
     */
    function join(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) external returns (address[] memory tokensOut, uint256[] memory amountsOut);

    /**
     * @dev Exit a strategy
     * @param strategy Address of the strategy to exit
     * @param tokensIn List of token addresses to exit with
     * @param amountsIn List of token amounts to exit with
     * @param slippage Slippage that will be used to compute the exit
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return tokensOut List of token addresses received after the exit
     * @return amountsOut List of token amounts received after the exit
     */
    function exit(
        address strategy,
        address[] memory tokensIn,
        uint256[] memory amountsIn,
        uint256 slippage,
        bytes memory data
    ) external returns (address[] memory tokensOut, uint256[] memory amountsOut);

    /**
     * @dev Swaps two tokens
     * @param source Source to request the swap. It depends on the Swap Connector attached to a Smart Vault.
     * @param tokenIn Token being sent
     * @param tokenOut Token being received
     * @param amountIn Amount of tokenIn being swapped
     * @param limitType Swap limit to be applied: slippage or min amount out
     * @param limitAmount Amount of the swap limit to be applied depending on limitType
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return amountOut Received amount of tokens out
     */
    function swap(
        uint8 source,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        SwapLimit limitType,
        uint256 limitAmount,
        bytes memory data
    ) external returns (uint256 amountOut);

    /**
     * @dev Bridge assets to another chain
     * @param source Source to request the bridge. It depends on the Bridge Connector attached to a Smart Vault.
     * @param chainId ID of the destination chain
     * @param token Address of the token to be bridged
     * @param amount Amount of tokens to be bridged
     * @param limitType Swap limit to be applied: slippage or min amount out
     * @param limitAmount Amount of the swap limit to be applied depending on limitType
     * @param recipient Address that will receive the tokens on the destination chain
     * @param data Extra data that may enable or not different behaviors depending on the implementation
     * @return bridged Amount requested to be bridged after fees
     */
    function bridge(
        uint8 source,
        uint256 chainId,
        address token,
        uint256 amount,
        BridgeLimit limitType,
        uint256 limitAmount,
        address recipient,
        bytes memory data
    ) external returns (uint256 bridged);
}

File 33 of 42 : ISmartVaultsFactory.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity >=0.8.0;

import '@mimic-fi/v2-registry/contracts/implementations/IImplementation.sol';

/**
 * @title ISmartVaultsFactory
 * @dev Smart Vaults Factory interface, it must follow the IImplementation interface.
 */
interface ISmartVaultsFactory is IImplementation {
    /**
     * @dev Emitted every time a new Smart Vault instance is created
     */
    event Created(address indexed implementation, address indexed instance, bytes initializeResult);

    /**
     * @dev Tells the implementation associated to a contract instance
     * @param instance Address of the instance to request it's implementation
     */
    function implementationOf(address instance) external view returns (address);

    /**
     * @dev Creates a new Smart Vault pointing to a registered implementation
     * @param salt Salt bytes to derivate the address of the new instance
     * @param implementation Address of the implementation to be instanced
     * @param initializeData Arbitrary data to be sent after deployment
     * @return instance Address of the new instance created
     */
    function create(bytes32 salt, address implementation, bytes memory initializeData) external returns (address);
}

File 34 of 42 : SmartVaultsFactory.sol
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/proxy/Clones.sol';
import '@openzeppelin/contracts/utils/Address.sol';

import '@mimic-fi/v2-helpers/contracts/auth/Authorizer.sol';
import '@mimic-fi/v2-registry/contracts/registry/IRegistry.sol';
import '@mimic-fi/v2-registry/contracts/implementations/BaseImplementation.sol';

import './ISmartVaultsFactory.sol';

/**
 * @title SmartVaultsFactory
 * @dev
 */
contract SmartVaultsFactory is ISmartVaultsFactory, BaseImplementation {
    using Address for address;

    // Smart Vaults Factory namespace
    bytes32 public constant override NAMESPACE = keccak256('SMART_VAULTS_FACTORY');

    // Namespace to use by this deployer to fetch ISmartVault implementations from the Mimic Registry
    bytes32 private constant SMART_VAULT_NAMESPACE = keccak256('SMART_VAULT');

    // List of instances' implementations indexed by instance address
    mapping (address => address) public override implementationOf;

    /**
     * @dev Creates a new Smart Vaults Factory implementation
     * @param registry Address of the Mimic Registry to be referenced
     */
    constructor(address registry) BaseImplementation(registry) {
        // solhint-disable-previous-line no-empty-blocks
    }

    /**
     * @dev Creates a new Smart Vault pointing to a registered implementation using CREATE2
     * @param salt Salt bytes to derivate the address of the new instance
     * @param implementation Address of the implementation to be instanced. It must be registered and not deprecated.
     * @param initializeData Arbitrary data to be sent after deployment. It can be used to initialize the new instance.
     * @return instance Address of the new instance created
     */
    function create(bytes32 salt, address implementation, bytes memory initializeData)
        external
        override
        returns (address instance)
    {
        require(implementation != address(0), 'IMPLEMENTATION_ADDRESS_ZERO');
        require(IImplementation(implementation).NAMESPACE() == SMART_VAULT_NAMESPACE, 'BAD_IMPLEMENTATION_NAMESPACE');
        require(IRegistry(registry).isActive(SMART_VAULT_NAMESPACE, implementation), 'BAD_SMART_VAULT_IMPLEMENTATION');

        bytes32 senderSalt = keccak256(abi.encodePacked(msg.sender, salt));
        instance = Clones.cloneDeterministic(address(implementation), senderSalt);

        implementationOf[instance] = implementation;
        bytes memory result = initializeData.length == 0
            ? new bytes(0)
            : instance.functionCall(initializeData, 'SMART_VAULT_INIT_FAILED');

        emit Created(implementation, instance, result);
    }
}

File 35 of 42 : BridgeConnectorMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '@mimic-fi/v2-bridge-connector/contracts/IBridgeConnector.sol';
import '@mimic-fi/v2-registry/contracts/implementations/BaseImplementation.sol';

import '../samples/BridgeMock.sol';

contract BridgeConnectorMock is IBridgeConnector, BaseImplementation {
    bytes32 public constant override NAMESPACE = keccak256('BRIDGE_CONNECTOR');

    BridgeMock public immutable bridgeMock;

    constructor(address registry) BaseImplementation(registry) {
        bridgeMock = new BridgeMock();
    }

    function bridge(
        uint8, /* source */
        uint256, /* chainId */
        address token,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient,
        bytes memory data
    ) external override {
        IERC20(token).approve(address(bridgeMock), amountIn);
        return bridgeMock.bridge(token, amountIn, minAmountOut, recipient, data);
    }
}

File 36 of 42 : PriceOracleMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v2-price-oracle/contracts/oracle/IPriceOracle.sol';
import '@mimic-fi/v2-registry/contracts/implementations/BaseImplementation.sol';

contract PriceOracleMock is IPriceOracle, BaseImplementation {
    bytes32 public constant override NAMESPACE = keccak256('PRICE_ORACLE');

    struct Feed {
        bool set;
        uint256 rate;
    }

    mapping (address => mapping (address => Feed)) public mockedFeeds;

    constructor(address registry) BaseImplementation(registry) {
        // solhint-disable-previous-line no-empty-blocks
    }

    function mockRate(address base, address quote, uint256 newMockedRate) external {
        Feed storage feed = mockedFeeds[base][quote];
        feed.set = true;
        feed.rate = newMockedRate;
    }

    function getPrice(address, address base, address quote) external view override returns (uint256) {
        if (base == quote) return FixedPoint.ONE;
        Feed storage feed = mockedFeeds[base][quote];
        require(feed.set, 'PRICE_ORACLE_FEED_NOT_SET');
        return feed.rate;
    }
}

File 37 of 42 : StrategyMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import '@mimic-fi/v2-strategies/contracts/IStrategy.sol';
import '@mimic-fi/v2-registry/contracts/implementations/BaseImplementation.sol';

import '../samples/TokenMock.sol';

contract StrategyMock is IStrategy, BaseImplementation {
    using FixedPoint for uint256;

    bytes32 public constant override NAMESPACE = keccak256('STRATEGY');

    address public immutable lpt;
    address public immutable token;
    address public immutable rewardToken;

    event Claimed(bytes data);
    event Joined(address[] tokensIn, uint256[] amountsIn, uint256 slippage, bytes data);
    event Exited(address[] tokensIn, uint256[] amountsIn, uint256 slippage, bytes data);

    constructor(address registry) BaseImplementation(registry) {
        lpt = address(new TokenMock('LPT'));
        token = address(new TokenMock('TKN'));
        rewardToken = address(new TokenMock('REW'));
    }

    function mockGains(address account, uint256 multiplier) external {
        uint256 balance = IERC20(lpt).balanceOf(account);
        TokenMock(lpt).mint(account, balance * (multiplier - 1));
    }

    function mockLosses(address account, uint256 divisor) external {
        uint256 balance = IERC20(lpt).balanceOf(account);
        TokenMock(lpt).burn(account, balance / divisor);
    }

    function joinTokens() public view override returns (address[] memory tokens) {
        tokens = new address[](1);
        tokens[0] = token;
    }

    function exitTokens() public view override returns (address[] memory tokens) {
        tokens = new address[](1);
        tokens[0] = lpt;
    }

    function valueRate() public pure override returns (uint256) {
        return FixedPoint.ONE;
    }

    function lastValue(address account) public view override returns (uint256) {
        return IERC20(lpt).balanceOf(account);
    }

    function claim(bytes memory data) external override returns (address[] memory tokens, uint256[] memory amounts) {
        uint256 amount = abi.decode(data, (uint256));
        TokenMock(rewardToken).mint(address(this), amount);
        tokens = new address[](1);
        tokens[0] = rewardToken;
        amounts = new uint256[](1);
        amounts[0] = amount;
        emit Claimed(data);
    }

    function join(address[] memory tokensIn, uint256[] memory amountsIn, uint256 slippage, bytes memory data)
        external
        override
        returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value)
    {
        require(tokensIn.length == 1, 'STRATEGY_INVALID_TOKENS_IN_LEN');
        require(amountsIn.length == 1, 'STRATEGY_INVALID_AMOUNTS_IN_LEN');
        require(tokensIn[0] == token, 'STRATEGY_INVALID_JOIN_TOKEN');

        tokensOut = exitTokens();
        amountsOut = new uint256[](1);
        amountsOut[0] = amountsIn[0];

        TokenMock(token).burn(address(this), amountsIn[0]);
        TokenMock(lpt).mint(address(this), amountsOut[0]);
        value = amountsOut[0].mulDown(valueRate());
        emit Joined(tokensIn, amountsIn, slippage, data);
    }

    function exit(address[] memory tokensIn, uint256[] memory amountsIn, uint256 slippage, bytes memory data)
        external
        override
        returns (address[] memory tokensOut, uint256[] memory amountsOut, uint256 value)
    {
        require(tokensIn.length == 1, 'STRATEGY_INVALID_TOKENS_IN_LEN');
        require(amountsIn.length == 1, 'STRATEGY_INVALID_AMOUNTS_IN_LEN');
        require(tokensIn[0] == lpt, 'STRATEGY_INVALID_EXIT_TOKEN');

        tokensOut = joinTokens();
        amountsOut = new uint256[](1);
        amountsOut[0] = amountsIn[0];

        TokenMock(lpt).burn(address(this), amountsIn[0]);
        TokenMock(token).mint(address(this), amountsOut[0]);
        value = amountsIn[0].divUp(valueRate());
        emit Exited(tokensIn, amountsIn, slippage, data);
    }
}

File 38 of 42 : SwapConnectorMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '@mimic-fi/v2-swap-connector/contracts/ISwapConnector.sol';
import '@mimic-fi/v2-registry/contracts/implementations/BaseImplementation.sol';

import '../samples/DexMock.sol';

contract SwapConnectorMock is ISwapConnector, BaseImplementation {
    bytes32 public constant override NAMESPACE = keccak256('SWAP_CONNECTOR');

    DexMock public immutable dex;

    constructor(address registry) BaseImplementation(registry) {
        dex = new DexMock();
    }

    function mockRate(uint256 newRate) external {
        dex.mockRate(newRate);
    }

    function swap(
        uint8, /* source */
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        bytes memory data
    ) external override returns (uint256 amountOut) {
        IERC20(tokenIn).approve(address(dex), amountIn);
        return dex.swap(tokenIn, tokenOut, amountIn, minAmountOut, data);
    }
}

File 39 of 42 : BridgeMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

contract BridgeMock {
    function bridge(address token, uint256 amount, uint256, address, bytes memory) external {
        IERC20(token).transferFrom(msg.sender, address(this), amount);
    }
}

File 40 of 42 : DexMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';

contract DexMock {
    using FixedPoint for uint256;

    uint256 public mockedRate;

    constructor() {
        mockedRate = FixedPoint.ONE;
    }

    function mockRate(uint256 newRate) external {
        mockedRate = newRate;
    }

    function swap(address tokenIn, address tokenOut, uint256 amountIn, uint256, bytes memory)
        external
        returns (uint256 amountOut)
    {
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        amountOut = amountIn.mulDown(mockedRate);
        IERC20(tokenOut).transfer(msg.sender, amountOut);
    }
}

File 41 of 42 : TokenMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';

contract TokenMock is ERC20 {
    constructor(string memory symbol) ERC20(symbol, symbol) {
        // solhint-disable-previous-line no-empty-blocks
    }

    function mint(address account, uint256 amount) external {
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) external {
        _burn(account, amount);
    }
}

File 42 of 42 : WrappedNativeTokenMock.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@mimic-fi/v2-helpers/contracts/utils/IWrappedNativeToken.sol';

contract WrappedNativeTokenMock is IWrappedNativeToken {
    uint8 public decimals = 18;
    string public name = 'Wrapped Native Token';
    string public symbol = 'WNT';

    event Deposit(address indexed to, uint256 amount);
    event Withdrawal(address indexed from, uint256 amount);

    mapping (address => uint256) public override balanceOf;
    mapping (address => mapping (address => uint256)) public override allowance;

    receive() external payable {
        deposit();
    }

    function deposit() public payable override {
        balanceOf[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }

    function withdraw(uint256 amount) public override {
        require(balanceOf[msg.sender] >= amount, 'WNT_NOT_ENOUGH_BALANCE');
        balanceOf[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
        emit Withdrawal(msg.sender, amount);
    }

    function totalSupply() public view override returns (uint256) {
        return address(this).balance;
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) public override returns (bool) {
        return transferFrom(msg.sender, to, amount);
    }

    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
        require(balanceOf[from] >= amount, 'NOT_ENOUGH_BALANCE');

        if (from != msg.sender && allowance[from][msg.sender] != type(uint256).max) {
            require(allowance[from][msg.sender] >= amount, 'NOT_ENOUGH_ALLOWANCE');
            allowance[from][msg.sender] -= amount;
        }

        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"_wrappedNativeToken","type":"address"},{"internalType":"address","name":"_registry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"who","type":"address"},{"indexed":false,"internalType":"bytes4","name":"what","type":"bytes4"}],"name":"Authorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint8","name":"source","type":"uint8"},{"indexed":true,"internalType":"uint256","name":"chainId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Bridge","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"bridgeConnector","type":"address"}],"name":"BridgeConnectorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pct","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"period","type":"uint256"}],"name":"BridgeFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bytes","name":"callData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"result","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Call","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"address[]","name":"tokens","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"collected","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Collect","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"address[]","name":"tokensIn","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"indexed":false,"internalType":"address[]","name":"tokensOut","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"fees","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"slippage","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Exit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"feeCollector","type":"address"}],"name":"FeeCollectorSet","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":"strategy","type":"address"},{"indexed":false,"internalType":"address[]","name":"tokensIn","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"indexed":false,"internalType":"address[]","name":"tokensOut","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"slippage","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Join","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pct","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"period","type":"uint256"}],"name":"PerformanceFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"base","type":"address"},{"indexed":true,"internalType":"address","name":"quote","type":"address"},{"indexed":false,"internalType":"address","name":"feed","type":"address"}],"name":"PriceFeedSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"priceOracle","type":"address"}],"name":"PriceOracleSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"strategy","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"StrategySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint8","name":"source","type":"uint8"},{"indexed":true,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":true,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"swapConnector","type":"address"}],"name":"SwapConnectorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pct","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"period","type":"uint256"}],"name":"SwapFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"who","type":"address"},{"indexed":false,"internalType":"bytes4","name":"what","type":"bytes4"}],"name":"Unauthorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"unwrapped","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Unwrap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"withdrawn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pct","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"period","type":"uint256"}],"name":"WithdrawFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"wrapped","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Wrap","type":"event"},{"inputs":[],"name":"ANY_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAMESPACE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"},{"internalType":"bytes4","name":"what","type":"bytes4"}],"name":"authorize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"source","type":"uint8"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum ISmartVault.BridgeLimit","name":"limitType","type":"uint8"},{"internalType":"uint256","name":"limitAmount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"bridge","outputs":[{"internalType":"uint256","name":"bridged","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bridgeConnector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridgeFee","outputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"totalCharged","type":"uint256"},{"internalType":"uint256","name":"nextResetTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"call","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"claim","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"collect","outputs":[{"internalType":"uint256","name":"collected","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"},{"internalType":"address[]","name":"tokensIn","type":"address[]"},{"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"internalType":"uint256","name":"slippage","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"exit","outputs":[{"internalType":"address[]","name":"tokensOut","type":"address[]"},{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"base","type":"address"},{"internalType":"address","name":"quote","type":"address"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"base","type":"address"},{"internalType":"address","name":"quote","type":"address"}],"name":"getPriceFeed","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"investedValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"},{"internalType":"bytes4","name":"what","type":"bytes4"}],"name":"isAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isStrategyAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"},{"internalType":"address[]","name":"tokensIn","type":"address[]"},{"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"internalType":"uint256","name":"slippage","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"join","outputs":[{"internalType":"address[]","name":"tokensOut","type":"address[]"},{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"lastValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"totalCharged","type":"uint256"},{"internalType":"uint256","name":"nextResetTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceOracle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newBridgeConnector","type":"address"}],"name":"setBridgeConnector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"}],"name":"setBridgeFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newFeeCollector","type":"address"}],"name":"setFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"base","type":"address"},{"internalType":"address","name":"quote","type":"address"},{"internalType":"address","name":"feed","type":"address"}],"name":"setPriceFeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"bases","type":"address[]"},{"internalType":"address[]","name":"quotes","type":"address[]"},{"internalType":"address[]","name":"feeds","type":"address[]"}],"name":"setPriceFeeds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newPriceOracle","type":"address"}],"name":"setPriceOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"name":"setStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSwapConnector","type":"address"}],"name":"setSwapConnector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"}],"name":"setSwapFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"}],"name":"setWithdrawFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"source","type":"uint8"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"enum ISmartVault.SwapLimit","name":"limitType","type":"uint8"},{"internalType":"uint256","name":"limitAmount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swap","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapConnector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapFee","outputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"totalCharged","type":"uint256"},{"internalType":"uint256","name":"nextResetTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"},{"internalType":"bytes4","name":"what","type":"bytes4"}],"name":"unauthorize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"unwrap","outputs":[{"internalType":"uint256","name":"unwrapped","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"withdrawn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFee","outputs":[{"internalType":"uint256","name":"pct","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"period","type":"uint256"},{"internalType":"uint256","name":"totalCharged","type":"uint256"},{"internalType":"uint256","name":"nextResetTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"wrap","outputs":[{"internalType":"uint256","name":"wrapped","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wrappedNativeToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Chain Token Portfolio % Price Amount Value
POL69.18%$0.012084,643,429.7513$56,090.96
POL0.10%$14.965.5227$82.62
POL0.10%$361.30.219$79.11
POL0.08%$0.0572521,163.8607$66.63
POL0.08%$1.8436.0171$66.27
POL0.08%<$0.0000014,829,669,690.2141$62.3
POL0.08%$0.212718289.1662$61.51
POL0.08%$0.020472,973.1824$60.86
POL0.07%$155.9861$56.04
POL0.07%$24.22.2393$54.19
POL0.07%$0.215607245.3783$52.91
POL0.06%$0.0440881,065.8943$46.99
POL0.06%$0.94611747.4792$44.92
POL0.05%$0.000295130,961.8622$38.58
POL0.05%$136.9563$36.96
POL0.04%$0.50249971.0932$35.72
POL0.04%$0.052039633.7395$32.98
POL0.04%$3,409.140.00949828$32.38
POL0.04%$0.0000047,875,136.6767$32.37
POL0.04%$0.99915329.241$29.22
POL0.04%$0.0030569,405.2006$28.75
POL0.03%$0.113743248.3048$28.24
POL0.03%$379.350.0712$26.99
POL0.03%$0.0104862,150.1747$22.55
POL0.03%$0.00137715,635.8338$21.52
POL0.03%$0.0149031,375.8306$20.5
POL0.02%$0.000032625,695.4582$19.99
POL0.02%$1.0718.1556$19.48
POL0.02%$0.079837220.6377$17.62
POL0.02%$3.814.4527$16.96
POL0.02%$0.19137384.8494$16.24
POL0.02%$0.00139711,281.5912$15.75
POL0.02%$0.020717755.9516$15.66
POL0.02%$0.015464954.1977$14.76
POL0.02%$0.0006821,102.8385$14.34
POL0.02%$0.44989530.5104$13.73
POL0.02%$0.84920915.7277$13.36
POL0.02%<$0.00000159,322,340.9566$13.16
POL0.02%$4,040.870.00324712$13.12
POL0.02%$0.0017287,498.9725$12.96
POL0.02%$0.000022542,131.4803$12.17
POL0.01%$0.0039782,910.1046$11.58
POL0.01%$0.0021935,149.7902$11.3
POL0.01%$111.1461$11.16
POL0.01%$0.0050222,167.2046$10.88
POL0.01%$0.35506430.432$10.81
POL0.01%$0.00075314,173.3033$10.67
POL0.01%$0.0000019,265,933.6397$10.3
POL0.01%$0.63681816.0479$10.22
POL0.01%$0.5862217.177$10.07
POL0.01%$7.81.2503$9.75
POL0.01%$2.673.5427$9.46
POL0.01%$2.14.3959$9.23
POL0.01%$1.048.625$8.94
POL0.01%$0.028466313.0519$8.91
POL0.01%$0.09928588.2212$8.76
POL0.01%$0.0026053,345.6007$8.71
POL0.01%$3,408.160.00250261$8.53
POL0.01%$0.000011756,002.3592$8.13
POL0.01%$1.047.81$8.13
POL<0.01%$0.50355615.8573$7.99
POL<0.01%$0.00023733,393.1676$7.9
POL<0.01%$0.0011246,877.9078$7.73
POL<0.01%$0.08915681.2301$7.24
POL<0.01%$0.040895173.7906$7.11
POL<0.01%$0.9982546.751$6.74
POL<0.01%$0.007147933.9686$6.68
POL<0.01%$0.022687280.5626$6.37
POL<0.01%$0.21856829.0432$6.35
POL<0.01%$1.913.2894$6.28
POL<0.01%$0.011134556.8421$6.2
POL<0.01%$0.000022275,370.8901$6.11
POL<0.01%$0.9999586.0202$6.02
POL<0.01%$0.13421741.9267$5.63
POL<0.01%$0.014356378.0525$5.43
POL<0.01%$0.0042651,248.0214$5.32
POL<0.01%$0.051933100.575$5.22
POL<0.01%$0.9994415.1853$5.18
POL<0.01%$0.033411150.6022$5.03
POL<0.01%$84.390.0588$4.96
POL<0.01%$0.027405176.861$4.85
POL<0.01%<$0.00000120,167,045.9115$4.76
POL<0.01%$0.005048906.0911$4.57
POL<0.01%$14.5411$4.54
POL<0.01%$0.04894190.917$4.45
POL<0.01%$0.752285.9093$4.45
POL<0.01%$38.890.1114$4.33
POL<0.01%$0.0021351,984.8418$4.24
POL<0.01%$0.0037471,118.8146$4.19
POL<0.01%$2.481.684$4.17
POL<0.01%$0.0008994,522.3112$4.06
POL<0.01%$1.522.6274$3.99
POL<0.01%$382.920.0103$3.93
POL<0.01%$0.9998613.8982$3.9
POL<0.01%$155.340.0248$3.85
POL<0.01%$0.004796799.9257$3.84
POL<0.01%$0.00035510,741.6056$3.81
POL<0.01%$383.190.00993161$3.81
POL<0.01%$0.025993141.7832$3.69
POL<0.01%$0.007833459.2901$3.6
POL<0.01%$3.511.0113$3.55
POL<0.01%$0.9612913.6059$3.47
POL<0.01%$0.011819290.8379$3.44
POL<0.01%$0.009353365.3352$3.42
POL<0.01%$0.16235720.8765$3.39
POL<0.01%$0.000007478,128.2236$3.23
POL<0.01%$0.00003493,386.0252$3.19
POL<0.01%$0.006559481.5821$3.16
POL<0.01%$0.562845.5938$3.15
POL<0.01%$0.00347901.6082$3.13
POL<0.01%$0.013335232.4738$3.1
POL<0.01%$0.004401673.4763$2.96
POL<0.01%$0.006357465.9209$2.96
POL<0.01%$0.003746782.4658$2.93
POL<0.01%$0.1202123.8677$2.87
POL<0.01%$0.0010922,492.7597$2.72
POL<0.01%$275.590.00974153$2.68
POL<0.01%$0.02395109.6139$2.63
POL<0.01%$0.23487711$2.58
POL<0.01%<$0.000001273,534,094.2042$2.52
POL<0.01%$0.9963822.4897$2.48
POL<0.01%<$0.000001163,994,521.2472$2.48
POL<0.01%$0.09772425.2495$2.47
POL<0.01%<$0.00000165,766,670.6724$2.43
POL<0.01%$0.002846812.6642$2.31
POL<0.01%$0.11155919.9598$2.23
POL<0.01%$0.0004684,730.5038$2.22
POL<0.01%$0.003068715.4341$2.19
POL<0.01%$1.042.0596$2.15
POL<0.01%$3.170.661$2.1
POL<0.01%$0.04759642.8751$2.04
POL<0.01%$0.005693353.76$2.01
POL<0.01%$0.9562032.0623$1.97
POL<0.01%$0.012527156.6308$1.96
POL<0.01%$0.5471353.522$1.93
POL<0.01%$1,609.980.00119354$1.92
POL<0.01%$0.000912,066.0786$1.88
POL<0.01%$0.00015512,082.1707$1.87
POL<0.01%$1.061.7583$1.87
POL<0.01%$0.5013593.6067$1.81
POL<0.01%$0.0010241,743.5437$1.79
POL<0.01%$0.03736745.8087$1.71
POL<0.01%$3.330.5068$1.69
POL<0.01%$0.11689214.0547$1.64
POL<0.01%$0.0013581,206.0476$1.64
POL<0.01%$0.3111455.1957$1.62
POL<0.01%$0.001708921.2607$1.57
POL<0.01%$0.005966258.4928$1.54
POL<0.01%$0.000007217,011.3081$1.47
POL<0.01%$0.001497973.4075$1.46
POL<0.01%$0.3813733.6462$1.39
POL<0.01%$0.002233611.8003$1.37
POL<0.01%$0.1689847.9652$1.35
POL<0.01%$0.004571293.3072$1.34
POL<0.01%$0.01453691.8709$1.34
POL<0.01%$0.0002225,981.4202$1.33
POL<0.01%$0.0011821,107.7168$1.31
POL<0.01%$0.002093610.0298$1.28
POL<0.01%$1.241$1.24
POL<0.01%$0.00002842,875.209$1.2
POL<0.01%$0.0001916,246.2664$1.19
POL<0.01%$0.000284,214.3094$1.18
POL<0.01%$0.8480481.3847$1.17
POL<0.01%$0.0009881,184.2083$1.17
POL<0.01%$0.005821197.0706$1.15
POL<0.01%$0.03948726.5068$1.05
POL<0.01%$0.3701892.7948$1.03
POL<0.01%$0.2077144.9767$1.03
POL<0.01%$0.07537713.5595$1.02
POL<0.01%$2,631.620.00038785$1.02
POL<0.01%$2.10.4837$1.02
POL<0.01%$0.01315877.1352$1.01
POL<0.01%$0.4402122.2715$0.9999
POL<0.01%$0.04872420.4887$0.9982
POL<0.01%$0.001172817.727$0.9584
POL<0.01%$0.001171817.0754$0.9566
POL<0.01%$0.2678743.5636$0.9545
POL<0.01%$0.9754450.9555$0.932
POL<0.01%$0.1786985.0166$0.8964
POL<0.01%$0.007587117.8237$0.8939
POL<0.01%$0.1928234.6309$0.8929
POL<0.01%$0.02013943.6524$0.8791
POL<0.01%$0.0002134,041.5662$0.8616
POL<0.01%$0.03711822.844$0.8479
POL<0.01%$0.02897128.4026$0.8228
POL<0.01%$0.5973751.3512$0.8071
POL<0.01%$0.0154952.0252$0.8058
POL<0.01%$0.004355183.8442$0.8005
POL<0.01%$0.4023861.9509$0.785
POL<0.01%$1.030.7603$0.7838
POL<0.01%$0.3052672.5656$0.7831
POL<0.01%$0.000002447,416.4778$0.7561
POL<0.01%$0.504411.4288$0.7207
POL<0.01%$10.7187$0.7194
POL<0.01%$1.150.6186$0.7113
POL<0.01%$0.000736965.9502$0.7106
POL<0.01%$0.1168925.8905$0.6885
POL<0.01%$3.190.2106$0.6718
POL<0.01%$0.221313.0315$0.6708
POL<0.01%$0.01999732.1574$0.643
POL<0.01%$53.450.0116$0.619
POL<0.01%$94,2000.00000657$0.6188
POL<0.01%$94,1710.00000647$0.6092
POL<0.01%$0.0074680.9639$0.6039
POL<0.01%$7.30.0817$0.5964
POL<0.01%$0.005371110.3154$0.5925
POL<0.01%$0.000608941.8123$0.573
POL<0.01%$0.04603412.2984$0.5661
POL<0.01%$0.001289433.8534$0.5593
POL<0.01%$0.0000414,049.1519$0.5563
POL<0.01%$0.3156861.7556$0.5542
POL<0.01%$0.1173264.5747$0.5367
POL<0.01%$0.00636784.1307$0.5356
POL<0.01%$0.01067249.7591$0.531
POL<0.01%$0.00082644.5618$0.5287
POL<0.01%$14.060.0356$0.50
POL<0.01%$0.0237121.0087$0.4981
POL<0.01%$0.999170.4981$0.4977
POL<0.01%$0.01711329.0628$0.4973
POL<0.01%$0.0001752,819.062$0.4929
POL<0.01%$0.0003511,356.7986$0.4768
POL<0.01%$0.000001426,260.0307$0.4688
POL<0.01%$0.001942232.4154$0.4512
POL<0.01%$0.00568578.6328$0.4469
POL<0.01%$0.03933111.096$0.4364
POL<0.01%$0.000677630.0976$0.4263
POL<0.01%$191.130.00222073$0.4244
POL<0.01%$30.1394$0.4182
POL<0.01%$1.140.3624$0.4131
POL<0.01%$0.03026713.3451$0.4039
POL<0.01%$0.0000884,441.9971$0.3889
POL<0.01%$0.003726102.4982$0.3819
POL<0.01%$0.5747590.664$0.3816
POL<0.01%$1.140.3254$0.3724
POL<0.01%$0.0856644.2538$0.3643
POL<0.01%$3,821.60.00009329$0.3565
POL<0.01%$1.580.2237$0.3534
POL<0.01%$0.000409853.3732$0.3488
POL<0.01%$0.00619154.9599$0.3402
POL<0.01%$0.1458442.2774$0.3321
POL<0.01%$0.1754561.8727$0.3285
POL<0.01%$0.01949816.4803$0.3213
POL<0.01%$1.360.2283$0.3104
POL<0.01%$0.01172826.1243$0.3063
POL<0.01%$2.270.1317$0.2989
POL<0.01%$0.01728317.0732$0.295
POL<0.01%$93,6840.00000302$0.2829
POL<0.01%$0.00510154.9515$0.2802
POL<0.01%$0.9953430.2793$0.278
POL<0.01%$0.01087625.2854$0.275
POL<0.01%$24.170.0112$0.2703
POL<0.01%$0.01196522.5646$0.2699
POL<0.01%$0.0475125.6389$0.2679
POL<0.01%$1.050.2526$0.2644
POL<0.01%$0.0094527.8643$0.2633
POL<0.01%$8,972.820.00002923$0.2622
POL<0.01%$0.001939132.6878$0.2573
POL<0.01%$0.0000962,657.4111$0.256
POL<0.01%$0.0927822.6553$0.2463
POL<0.01%$0.002292101.5407$0.2327
POL<0.01%$0.0618333.7296$0.2306
POL<0.01%$0.2024241.1236$0.2274
POL<0.01%$0.2555980.8812$0.2252
POL<0.01%$1.230.182$0.2238
POL<0.01%$3,380.010.00006574$0.2221
POL<0.01%$0.00181121.7583$0.2204
POL<0.01%$0.000342632.6163$0.2162
POL<0.01%$0.6390420.3377$0.2158
POL<0.01%$0.001955108.6022$0.2123
POL<0.01%$7.220.0281$0.2026
POL<0.01%$0.0001621,243.7738$0.2018
POL<0.01%$1.360.1479$0.2011
POL<0.01%$0.01663612.0442$0.2003
POL<0.01%$0.000464431.5939$0.2001
POL<0.01%$0.3285230.5727$0.1881
POL<0.01%$0.00451739.9393$0.1803
POL<0.01%$0.9935850.18$0.1788
POL<0.01%$1.060.1617$0.1715
POL<0.01%$0.7372690.2272$0.1675
POL<0.01%$6.690.0243$0.1622
POL<0.01%$0.7320710.2208$0.1616
POL<0.01%$0.000306527.6255$0.1612
POL<0.01%<$0.00000119,754,412.462$0.158
POL<0.01%$0.000162959.0637$0.1556
POL<0.01%$37.080.00408616$0.1515
POL<0.01%$67.190.00217328$0.146
POL<0.01%$0.00356239.441$0.1405
POL<0.01%$3,696.760.00003767$0.1392
POL<0.01%$0.00076180.0792$0.1368
POL<0.01%$0.2310220.5629$0.13
POL<0.01%$0.3147620.3959$0.1246
POL<0.01%$0.00512323.8359$0.1221
POL<0.01%$0.9998920.1194$0.1194
POL<0.01%$0.000879132.2431$0.1162
POL<0.01%$0.01084410.7203$0.1162
POL<0.01%$0.1810990.6384$0.1156
POL<0.01%$0.5712030.188$0.1074
POL<0.01%$0.00364428.8296$0.105
POL<0.01%$0.5067640.000000000000000002<$0.000001
ETH0.77%<$0.0000015,401,179,268.262$620.42
ETH0.61%$1496.2174$496.22
ETH0.54%$0.000001442,539,935.3562$435.45
ETH0.46%$0.001971187,205.5926$368.94
ETH0.37%$3,411.120.0875$298.42
ETH0.35%$378.920.7527$285.2
ETH0.35%$0.1607241,765.156$283.7
ETH0.35%$0.00001815,519,533.2841$283.7
ETH0.35%$94,2520.00299597$282.38
ETH0.27%$0.0000239,665,033.9626$222.48
ETH0.26%$0.710556299.0936$212.52
ETH0.26%<$0.0000013,536,660,490.0411$210.5
ETH0.25%$1.49135.1918$201.44
ETH0.24%$1.77110.6782$195.61
ETH0.21%$0.00546530,722.7863$167.91
ETH0.20%$0.00337749,002.0269$165.49
ETH0.20%$3,415.820.0478$163.44
ETH0.20%$487.020.3347$163
ETH0.20%$1.21134.6123$162.71
ETH0.20%$0.00000724,020,732.0823$161.46
ETH0.19%$1.12140.9572$157.87
ETH0.18%$0.568235255.567$145.22
ETH0.18%$0.416162343.3396$142.88
ETH0.17%$1140.4071$140.55
ETH0.17%$6.1722.0018$135.76
ETH0.16%$0.591427224.6639$132.87
ETH0.16%$190.880.6785$129.52
ETH0.16%$0.00869914,656.8155$127.5
ETH0.15%$0.1139951,080.1709$123.13
ETH0.15%$0.0000691,738,141.6803$120.49
ETH0.14%$0.94554123.958$117.21
ETH0.14%$0.01126210,341.1336$116.46
ETH0.14%$0.490768237.2447$116.43
ETH0.14%$0.998941110.7608$110.64
ETH0.14%$3,406.620.0322$109.56
ETH0.13%$0.0000224,866,340.8143$109.25
ETH0.13%$3,823.160.0282$107.71
ETH0.13%$0.0283543,773.5066$107
ETH0.13%<$0.0000012,879,487,451.5181$106.49
ETH0.13%$0.00000429,306,460.6854$106.39
ETH0.13%$0.000025,344,004.4626$106.03
ETH0.13%$1.3676.8454$104.2
ETH0.12%$0.0118118,341.7567$98.52
ETH0.12%$84.391.1614$98.01
ETH0.12%$0.785088122.4345$96.12
ETH0.12%$0.99902293.9221$93.83
ETH0.11%$0.00896610,363.2673$92.92
ETH0.11%$1.6157.4087$92.43
ETH0.11%$0.9993592.1824$92.12
ETH0.11%$0.0403952,280.219$92.11
ETH0.11%$0.208119442.0826$92.01
ETH0.11%$0.0109638,265.9776$90.62
ETH0.11%$0.450876196.932$88.79
ETH0.11%$0.0357462,479.836$88.64
ETH0.11%$1.0384.3327$86.69
ETH0.11%<$0.000001438,744,246.2683$85.68
ETH0.11%$0.0268243,187.5113$85.5
ETH
Ether (ETH)
0.10%$3,415.820.0243$82.93
ETH0.10%$0.160723507.9249$81.64
ETH0.10%$0.00611212,880.0331$78.72
ETH0.10%$118.760.6603$78.42
ETH0.10%$0.0443031,769.3778$78.39
ETH0.09%$0.97461677.7112$75.74
ETH0.09%$0.00640611,783.0435$75.48
ETH0.09%$0.223113338.1564$75.45
ETH0.09%$0.000115650,137.5599$74.97
ETH0.09%$27.952.6339$73.62
ETH0.09%$1.0967.6068$73.45
ETH0.09%$0.00496314,796.7893$73.43
ETH0.09%$0.0118276,119.2603$72.37
ETH0.09%$8.568.146$69.71
ETH0.09%$0.0597081,157.3465$69.1
ETH0.08%$4.9513.8244$68.43
ETH0.08%$1.0266.6557$67.73
ETH0.08%$0.0643681,038.4996$66.85
ETH0.08%$0.202537326.3558$66.1
ETH0.07%$0.266859225.505$60.18
ETH0.07%$0.0438861,340.3953$58.82
ETH0.07%$158.74$58.8
ETH0.07%$0.0239522,435.0544$58.33
ETH0.07%$0.0442431,316.8854$58.26
ETH0.07%$0.99909658.2101$58.16
ETH0.07%<$0.000001256,832,563.5524$57.04
ETH0.07%$0.00000413,877,137.063$56.9
ETH0.07%$0.000521107,149.9606$55.81
ETH0.07%$5.679.8382$55.78
ETH0.07%$94,1500.0005899$55.54
ETH0.07%$94,4610.00056903$53.75
ETH0.07%$0.59119889.4954$52.91
ETH0.07%$0.256522206.0137$52.85
ETH0.06%$1.4436.2415$52.19
ETH0.06%$1.5233.5746$51.03
ETH0.06%$0.124574403.2867$50.24
ETH0.06%$3.1915.6425$49.9
ETH0.06%$1.5831.2229$49.33
ETH0.06%$0.50244398.0749$49.28
ETH0.06%$0.000266182,259.2382$48.55
ETH0.06%$0.000284170,548.0878$48.38
ETH0.06%$0.0206252,303.6241$47.51
ETH0.06%$0.0000281,702,868.9229$47.36
ETH0.06%$0.0064937,218.1056$46.87
ETH0.06%$41.471.1119$46.11
ETH0.06%$1.6427.7726$45.55
ETH0.06%$6.886.586$45.34
ETH0.06%$1.6627.011$44.84
ETH0.06%$0.000177252,053.0886$44.68
ETH0.05%$0.073426604.6911$44.4
ETH0.05%$5.278.185$43.13
ETH0.05%$0.99635141.4824$41.33
ETH0.05%$1.2333.1109$40.73
ETH0.05%$0.000176227,927.9022$40.03
ETH0.05%$0.0276581,439.866$39.82
ETH0.05%$0.0164382,394.0619$39.35
ETH0.05%$0.000226173,923.2628$39.31
ETH0.05%$0.311536124.9454$38.93
ETH0.05%$0.211735181.9726$38.53
ETH0.05%$260.890.147$38.34
ETH0.05%$0.99725238.3653$38.26
ETH0.05%$0.159394238.9692$38.09
ETH0.05%$0.0183772,066.4998$37.98
ETH0.05%<$0.00000129,365,053,379.4436$37.55
ETH0.05%$5.626.6633$37.45
ETH0.05%$0.0000123,122,679.2337$37.44
ETH0.05%$45.820.8146$37.33
ETH0.05%$0.182414203.8134$37.18
ETH0.05%$0.217779169.6832$36.95
ETH0.05%$0.177177206.4084$36.57
ETH0.05%$0.0060696,023.1541$36.55
ETH0.04%$0.061596583.6904$35.95
ETH0.04%$0.152514233.3116$35.58
ETH0.04%$0.0249841,421.8115$35.52
ETH0.04%$0.99473735.3958$35.21
ETH0.04%$0.037394939.9219$35.15
ETH0.04%$0.0089323,925.0084$35.06
ETH0.04%$0.221129157.8742$34.91
ETH0.04%$0.00037992,124.8907$34.88
ETH0.04%$20.841.6683$34.77
ETH0.04%$0.80010343.4287$34.75
ETH0.04%$0.107538317.8185$34.18
ETH0.04%$0.80699242.0492$33.93
ETH0.04%$24.741.3692$33.87
ETH0.04%$0.45032675.2149$33.87
ETH0.04%$23.091.4614$33.74
ETH0.04%$1.5321.9021$33.51
ETH0.04%$0.00068448,361.8016$33.08
ETH0.04%$0.0036818,938.0824$32.9
ETH0.04%$0.77296542.077$32.52
ETH0.04%$0.60480652.4851$31.74
ETH0.04%$4.916.3783$31.34
ETH0.04%$3.0410.2536$31.17
ETH0.04%$115.940.2671$30.97
ETH0.04%<$0.00000119,788,278,948,680.582$30.65
ETH0.04%$2.6710.9232$29.16
ETH0.04%<$0.000001191,621,136.4947$28.66
ETH0.04%$0.047178606$28.59
ETH0.03%$0.51794253.795$27.86
ETH0.03%<$0.00000176,630,570.7736$27.64
ETH0.03%$127.5503$27.55
ETH0.03%$0.0120762,275.2061$27.48
ETH0.03%$19.331.4174$27.4
ETH0.03%$0.47627957.5085$27.39
ETH0.03%$93,3580.00029133$27.2
ETH0.03%$275.830.0983$27.11
ETH0.03%$1.3619.2738$26.21
ETH0.03%$0.058669446.5265$26.2
ETH0.03%$0.9883826.1214$25.82
ETH0.03%$0.58520543.5864$25.51
ETH0.03%$71.750.3538$25.39
ETH0.03%$0.39411763.7898$25.14
ETH0.03%$0.82578330.3726$25.08
ETH0.03%$0.075715324.5082$24.57
ETH0.03%$0.0144471,698.0249$24.53
ETH0.03%$20.291.2031$24.41
ETH0.03%$0.48080850.6178$24.34
ETH0.03%$1.0423.2988$24.23
ETH0.03%$2.519.5938$24.08
ETH0.03%$0.40425557.8357$23.38
ETH0.03%$0.053602420.7588$22.55
ETH0.03%$0.26630684.4759$22.5
ETH0.03%$0.039074574.1337$22.43
ETH0.03%$49.390.4499$22.22
ETH0.03%$270.340.0822$22.21
ETH0.03%$0.63160434.9457$22.07
ETH0.03%$5.414.0095$21.69
ETH0.03%$3,513.620.00617285$21.69
ETH0.03%$0.29775170.0659$20.86
ETH0.03%$1.1817.6511$20.83
ETH0.03%$4.774.3538$20.77
ETH0.03%$3.545.8415$20.68
ETH0.03%$120.3584$20.4
ETH0.02%$0.002069,782.5052$20.15
ETH0.02%$293.620.068$19.97
ETH0.02%$0.50473139.5177$19.95
ETH0.02%$0.22214689.0164$19.77
ETH0.02%$36.4631$19.39
ETH0.02%$0.00091220,960.4826$19.13
ETH0.02%$1.215.5086$18.61
ETH0.02%$0.54717833.8636$18.53
ETH0.02%$0.0158881,131.0471$17.97
ETH0.02%$0.00000133,150,718.4543$17.93
ETH0.02%$0.120509148.0447$17.84
ETH0.02%$3,566.710.0049837$17.78
ETH0.02%$14.091.2128$17.09
ETH0.02%$2.287.4616$17.01
ETH0.02%<$0.00000146,763,040.8487$16.74
ETH0.02%$0.0108091,441.9835$15.59
ETH0.02%<$0.000001675,539,864,954,565.88$15.58
ETH0.02%$0.0024916,100.6002$15.2
ETH0.02%$1.878.1137$15.15
ETH0.02%$1.1313.2661$14.99
ETH0.02%$17.620.848$14.94
ETH0.02%$0.00102314,416.023$14.75
ETH0.02%$17.370.8334$14.48
ETH0.02%<$0.0000012,225,081,330.5233$14.39
ETH0.02%$0.047323302.7808$14.33
ETH0.02%$0.00060122,923.757$13.77
ETH0.02%$0.20217268.0482$13.76
ETH0.02%$0.0111591,232.7902$13.76
ETH0.02%$0.042874316.2181$13.56
ETH0.02%$0.53067225.1323$13.34
ETH0.02%$154.020.0866$13.34
ETH0.02%$0.21862660.2828$13.18
ETH0.02%$0.00056522,784.7371$12.87
ETH0.02%$1.2610.111$12.74
ETH0.02%$0.46159327.532$12.71
ETH0.02%$155.490.0817$12.7
ETH0.02%$5.432.3134$12.56
ETH0.02%$0.054587228.7108$12.48
ETH0.02%$0.0043822,788.8931$12.22
ETH0.02%$0.0001964,279.4919$12.2
ETH0.02%$0.00114210,649.3344$12.17
ETH0.01%$0.13392390.0651$12.06
ETH0.01%$0.00022353,876.3684$12.04
ETH0.01%$0.036545327.4796$11.97
ETH0.01%$0.13535688.0906$11.92
ETH0.01%$0.21095856.1438$11.84
ETH0.01%$0.24080749.1818$11.84
ETH0.01%$0.00000112,446,274.5121$11.83
ETH0.01%$0.99391211.7804$11.71
ETH0.01%$5,592.040.0020767$11.61
ETH0.01%$22.740.5083$11.56
ETH0.01%$0.20321256.4798$11.48
ETH0.01%$0.0063641,788.0681$11.38
ETH0.01%$0.0055392,039.0074$11.29
ETH0.01%$0.0000024,890,772.1631$11.22
ETH0.01%$1.139.6881$10.95
ETH0.01%$21.170.5138$10.88
ETH0.01%$0.00081813,070.1068$10.7
ETH0.01%$0.018377580.1064$10.66
ETH0.01%$3,427.590.00307632$10.54
ETH0.01%$2.084.9918$10.38
ETH0.01%$0.000028366,808.3237$10.25
ETH0.01%<$0.0000011,746,453,593.8417$10.2
ETH0.01%<$0.0000013,059,713,101,797.9541$10.16
ETH0.01%$0.11603286.8103$10.07
ETH0.01%$0.0010649,455.2348$10.06
ETH0.01%$0.0056831,750.23$9.95
ETH0.01%$0.058809169.06$9.94
ETH0.01%$0.069776142.3491$9.93
ETH0.01%$3,603.260.00274623$9.9
ETH0.01%$0.00095910,304.3884$9.88
ETH0.01%$0.015885618.2866$9.82
ETH0.01%<$0.000001590,349,532.8158$9.78
ETH0.01%$0.46804620.6588$9.67
ETH0.01%$0.075828127.0834$9.64
ETH0.01%$0.02892332.8391$9.63
ETH0.01%$0.00014764,898.1727$9.57
ETH0.01%$0.038597243.2772$9.39
ETH0.01%$1.227.6901$9.38
ETH0.01%$0.033492277.3175$9.29
ETH0.01%$0.14805861.4303$9.1
ETH0.01%$12.610.709$8.94
ETH0.01%$3.342.6547$8.86
ETH0.01%$0.04507190.4067$8.58
ETH0.01%$0.014838577.3614$8.57
ETH0.01%$7.021.2166$8.54
ETH0.01%$0.44024319.3197$8.51
ETH<0.01%$1.844.3944$8.09
ETH<0.01%$0.13920157.649$8.02
ETH<0.01%$0.0028842,759.0578$7.96
ETH<0.01%$0.50312415.5721$7.83
ETH<0.01%$0.59844813.087$7.83
ETH<0.01%$1.36.0017$7.8
ETH<0.01%$0.029399263.0568$7.73
ETH<0.01%$0.75097610.277$7.72
ETH<0.01%$1.196.4825$7.71
ETH<0.01%$7.261.0621$7.71
ETH<0.01%$0.033296230.5309$7.68
ETH<0.01%$0.49201615.1914$7.47
ETH<0.01%$0.012808581.7548$7.45
ETH<0.01%$0.005081,437.8784$7.3
ETH<0.01%$0.37678719.0108$7.16
ETH<0.01%$0.00056412,263.4565$6.92
ETH<0.01%$0.029708232.0914$6.89
ETH<0.01%$0.13267651.528$6.84
ETH<0.01%$0.001554,389.3822$6.8
ETH<0.01%$2.173.1096$6.75
ETH<0.01%$0.20027733.6261$6.73
ETH<0.01%$3,501.030.0019078$6.68
ETH<0.01%$3,403.540.00196207$6.68
ETH<0.01%$4.311.5452$6.66
ETH<0.01%$0.15316242.7643$6.55
ETH<0.01%$0.26785824.4408$6.55
ETH<0.01%$0.00006797,547.7043$6.54
ETH<0.01%$0.00020331,955.3806$6.5
ETH<0.01%$0.12620251.3821$6.48
ETH<0.01%$0.09241969.6736$6.44
ETH<0.01%$0.54799911.6755$6.4
ETH<0.01%$0.0000014,653,994.2576$6.38
ETH<0.01%$0.00043614,567.2271$6.36
ETH<0.01%$0.7361168.6216$6.35
ETH<0.01%$0.0012445,095.3493$6.34
ETH<0.01%$3,586.530.00176357$6.33
ETH<0.01%$0.0008987,022.3688$6.31
ETH<0.01%$1.075.911$6.3
ETH<0.01%$0.9993536.2871$6.28
ETH<0.01%$0.09943763.1026$6.27
ETH<0.01%$1.524.1011$6.23
ETH<0.01%$0.027422227.0062$6.22
ETH<0.01%$12.050.5107$6.15
ETH<0.01%$0.833227.2429$6.03
ETH<0.01%<$0.00000172,344,183.5156$6.01
ETH<0.01%$2.442.431$5.92
ETH<0.01%$7.30.8102$5.91
ETH<0.01%$0.0006738,752.758$5.89
ETH<0.01%$0.000045131,425.2082$5.85
ETH<0.01%$0.05087112.9708$5.75
ETH<0.01%$0.000006925,087.9153$5.74
ETH<0.01%$0.32290217.7357$5.73
ETH<0.01%$0.1635.654$5.7
ETH<0.01%$0.7924157.1709$5.68
ETH<0.01%<$0.000001114,919,665.7427$5.66
ETH<0.01%$2.322.4327$5.64
ETH<0.01%$2.322.4136$5.6
ETH<0.01%$0.00026121,374.9262$5.58
ETH<0.01%$0.022816239.8889$5.47
ETH<0.01%$2.092.5612$5.35
ETH<0.01%$0.000041128,251.9601$5.26
ETH<0.01%$0.012351418.2783$5.17
ETH<0.01%$47.170.1092$5.15
ETH<0.01%$0.003231,547.3848$5
ETH<0.01%$0.08017761.5855$4.94
ETH<0.01%$0.11150842.1687$4.7
ETH<0.01%<$0.0000011,782,477,115.5742$4.63
ETH<0.01%$0.0039581,154.7475$4.57
ETH<0.01%$0.004581996.4952$4.56
ETH<0.01%$0.8692175.1972$4.52
ETH<0.01%$0.002721,657.5239$4.51
ETH<0.01%$0.0971246.0524$4.47
ETH<0.01%$1.14.0414$4.43
ETH<0.01%$0.029237150.6853$4.41
ETH<0.01%<$0.000001306,453,755.5695$4.36
ETH<0.01%$0.0000015,555,368.1287$4.36
ETH<0.01%$0.0000021,803,208.1748$4.32
ETH<0.01%$0.001323,227.0841$4.26
ETH<0.01%$0.99964.2344$4.23
ETH<0.01%$0.11108837.9945$4.22
ETH<0.01%$1.253.367$4.21
ETH<0.01%$535.230.00779326$4.17
ETH<0.01%$0.9705144.2802$4.15
ETH<0.01%$1.422.926$4.14
ETH<0.01%$0.0000022,304,139.2201$4.08
ETH<0.01%$0.6029066.755$4.07
ETH<0.01%$0.29699313.7128$4.07
ETH<0.01%$0.40056910.0243$4.02
ETH<0.01%$8,957.960.0004446$3.98
ETH<0.01%$0.0011793,350.2236$3.95
ETH<0.01%$7.970.4945$3.94
ETH<0.01%$0.16740223.5028$3.93
ETH<0.01%$0.024468156.2529$3.82
ETH<0.01%$3.781$3.78
ETH<0.01%$0.1235630.4945$3.77
ETH<0.01%$1.033.6481$3.76
ETH<0.01%$0.0000031,119,665.2925$3.71
ETH<0.01%$0.017895206.2938$3.69
ETH<0.01%$0.0016912,180.9871$3.69
ETH<0.01%$0.21351417.1313$3.66
ETH<0.01%$0.004142879.6705$3.64
ETH<0.01%<$0.00000139,392,908.1072$3.54
ETH<0.01%$0.030639114.4681$3.51
ETH<0.01%$0.9987733.5065$3.5
ETH<0.01%$6.650.5195$3.45
ETH<0.01%$0.0000015,894,503.4739$3.39
ETH<0.01%$9.580.3527$3.38
ETH<0.01%$0.0795542.3414$3.37
ETH<0.01%$107.110.0311$3.33
ETH<0.01%$0.001272,622.1585$3.33
ETH<0.01%$1,611.80.0020611$3.32
ETH<0.01%$2.871.1521$3.31
ETH<0.01%$0.4835936.8314$3.3
ETH<0.01%$0.13504524.4173$3.3
ETH<0.01%$1.562.0962$3.27
ETH<0.01%$0.20868315.6119$3.26
ETH<0.01%$0.27662111.7029$3.24
ETH<0.01%$0.00021115,069.5764$3.18
ETH<0.01%$0.030291104.6883$3.17
ETH<0.01%$0.07088344.5841$3.16
ETH<0.01%$148.320.0212$3.15
ETH<0.01%$36.810.0849$3.13
ETH<0.01%$0.022361139.7867$3.13
ETH<0.01%$23.80.1288$3.06
ETH<0.01%$1.032.9668$3.04
ETH<0.01%$0.000006528,821.8145$3.03
ETH<0.01%$0.26846911.1383$2.99
ETH<0.01%$2.811.0635$2.99
ETH<0.01%$0.0016431,818.364$2.99
ETH<0.01%$0.0004037,133.8405$2.88
ETH<0.01%$0.9054623.1677$2.87
ETH<0.01%<$0.00000114,689,022.1812$2.85
ETH<0.01%$0.23137512.3145$2.85
ETH<0.01%$0.02849898.8376$2.82
ETH<0.01%$0.03413582.1292$2.8
ETH<0.01%$0.007062380.7096$2.69
ETH<0.01%$0.012726210.7614$2.68
ETH<0.01%$3.150.8299$2.61
ETH<0.01%$0.11131523.3004$2.59
ETH<0.01%$0.7273363.5245$2.56
ETH<0.01%$2.610.975$2.54
ETH<0.01%$0.0505250.3554$2.54
ETH<0.01%$0.012595199.9183$2.52
ETH<0.01%$0.5059794.9172$2.49
ETH<0.01%$0.019815125.1437$2.48
ETH<0.01%<$0.000001947,013,641.782$2.44
ETH<0.01%$3,411.150.0007088$2.42
ETH<0.01%$0.13299418.0828$2.4
ETH<0.01%$1.451.6425$2.38
ETH<0.01%$204.610.0115$2.36
ETH<0.01%$0.03950459.3493$2.34
ETH<0.01%$0.03273171.0523$2.33
ETH<0.01%$2.221.0462$2.32
ETH<0.01%$0.08183527.2134$2.23
ETH<0.01%$0.3109717.152$2.22
ETH<0.01%$71.920.0309$2.22
ETH<0.01%$0.0014291,549.1979$2.21
ETH<0.01%$2.760.7985$2.2
ETH<0.01%$0.02613484.1199$2.2
ETH<0.01%$0.2419699.0031$2.18
ETH<0.01%<$0.000001177,451,924.9151$2.16
ETH<0.01%$0.9399642.2575$2.12
ETH<0.01%$0.002236930.7315$2.08
ETH<0.01%$0.00275752.4574$2.07
ETH<0.01%$0.002159953.0372$2.06
ETH<0.01%$0.0000021,057,625.2466$1.97
ETH<0.01%$0.0006962,825.2881$1.97
ETH<0.01%$0.0232983.902$1.95
ETH<0.01%$0.997491.9249$1.92
ETH<0.01%$0.03303658.0477$1.92
ETH<0.01%<$0.000001493,700,282.3523$1.87
ETH<0.01%$0.012972143.1141$1.86
ETH<0.01%$0.02481773.7551$1.83
ETH<0.01%$0.0000013,357,331.5281$1.8
ETH<0.01%$0.08829320.3649$1.8
ETH<0.01%$0.16253610.5205$1.71
ETH<0.01%$0.03713945.0859$1.67
ETH<0.01%$0.9993731.6463$1.65
ETH<0.01%$0.4021554.0719$1.64
ETH<0.01%$0.010979143.3157$1.57
ETH<0.01%$0.006305246.8209$1.56
ETH<0.01%$0.002059748.7586$1.54
ETH<0.01%$0.000005312,515.6691$1.53
ETH<0.01%$0.0013021,178.3495$1.53
ETH<0.01%$0.001836829.7789$1.52
ETH<0.01%$0.2349986.4649$1.52
ETH<0.01%$0.6310132.3559$1.49
ETH<0.01%$246,313.860.00000592$1.46
ETH<0.01%$0.03895337.2695$1.45
ETH<0.01%$0.009286155.9393$1.45
ETH<0.01%$0.02649652.4182$1.39
ETH<0.01%$0.01748979.1776$1.38
ETH<0.01%$0.0006442,121.0789$1.37
ETH<0.01%<$0.000001111,199,657.6965$1.36
ETH<0.01%$0.00010512,913.2105$1.35
ETH<0.01%$0.001659809.0455$1.34
ETH<0.01%$4,042.670.00033135$1.34
ETH<0.01%$0.01600583.2263$1.33
ETH<0.01%$0.0000012,489,040.6081$1.33
ETH<0.01%<$0.00000112,012,150.5612$1.33
ETH<0.01%$378.920.00347967$1.32
ETH<0.01%$0.04854726.9223$1.31
ETH<0.01%$719.330.00179845$1.29
ETH<0.01%$0.01817771.1252$1.29
ETH<0.01%$0.0160380.5711$1.29
ETH<0.01%$24.150.053$1.28
ETH<0.01%$0.4389912.8441$1.25
ETH<0.01%$0.008517145.1235$1.24
ETH<0.01%$0.01368189.4805$1.22
ETH<0.01%$0.001298936.8754$1.22
ETH<0.01%$0.010795109.8951$1.19
ETH<0.01%$0.002039580.8548$1.18
ETH<0.01%$1.950.6041$1.18
ETH<0.01%$0.544682.1378$1.16
ETH<0.01%$0.00337336.0024$1.13
ETH<0.01%$0.008595130.4348$1.12
ETH<0.01%$0.0001318,560.5412$1.12
ETH<0.01%$0.0618117.9021$1.11
ETH<0.01%$0.2328484.7279$1.1
ETH<0.01%$0.1147229.5736$1.1
ETH<0.01%$0.9922111.0898$1.08
ETH<0.01%$0.0943111.3964$1.07
ETH<0.01%$0.02150949.2892$1.06
ETH<0.01%$0.3090753.3794$1.04
ETH<0.01%$1.650.6048$0.9979
ETH<0.01%$1.830.5434$0.9968
ETH<0.01%$0.3414292.8766$0.9821
ETH<0.01%$0.3798032.5712$0.9765
ETH<0.01%$46.10.0212$0.9764
ETH<0.01%$0.000004248,548.1658$0.976
ETH<0.01%$0.00003230,540.6396$0.9757
ETH<0.01%$0.02051747.4563$0.9736
ETH<0.01%$3,816.910.00025321$0.9664
ETH<0.01%$0.9938720.9616$0.9556
ETH<0.01%$0.4555822.0966$0.9551
ETH<0.01%$1.950.4734$0.9231
ETH<0.01%$24.040.0382$0.9181
ETH<0.01%$0.003066298.5846$0.9153
ETH<0.01%$0.00114798.0104$0.9095
ETH<0.01%$0.06901513.1371$0.9066
ETH<0.01%<$0.000001248,054,921.4784$0.9063
ETH<0.01%$0.02517935.518$0.8943
ETH<0.01%$0.05357616.685$0.8939
ETH<0.01%$0.0007571,171.0259$0.8866
ETH<0.01%$6.520.1355$0.8841
ETH<0.01%$0.7011411.2396$0.8691
ETH<0.01%$3,514.490.00024721$0.8688
ETH<0.01%$0.1100027.7678$0.8544
ETH<0.01%$0.0902499.3243$0.8415
ETH<0.01%$0.002122394.194$0.8365
ETH<0.01%$10.8268$0.8268
ETH<0.01%$0.02143137.8005$0.8101
ETH<0.01%$0.05853713.8089$0.8083
ETH<0.01%<$0.000001630,588,898.4603$0.8027
ETH<0.01%$0.005004156.9403$0.7853
ETH<0.01%$0.03610221.7258$0.7843
ETH<0.01%$0.06391212.1023$0.7734
ETH<0.01%$0.02758227.9033$0.7696
ETH<0.01%$0.000003227,031.4197$0.7696
ETH<0.01%$0.3928361.9358$0.7604
ETH<0.01%$0.0002053,637.7349$0.7446
ETH<0.01%$0.3982961.8651$0.7428
ETH<0.01%$10.170.0729$0.7414
ETH<0.01%$0.1410445.1736$0.7297
ETH<0.01%$0.7544130.949$0.7159
ETH<0.01%<$0.0000014,497,547.3425$0.71
ETH<0.01%$0.0006781,037.8208$0.7031
ETH<0.01%$0.06584410.6682$0.7024
ETH<0.01%$0.003993175.6487$0.7013
ETH<0.01%$37.460.0186$0.6981
ETH<0.01%$0.0000011,163,578.0656$0.6946
ETH<0.01%$0.1178235.6287$0.6631
ETH<0.01%$0.5828931.1257$0.6561
ETH<0.01%$0.8439150.7625$0.6435
ETH<0.01%$0.04082715.6657$0.6395
ETH<0.01%$0.001041611.9285$0.6373
ETH<0.01%<$0.0000011,649,246.3181$0.6367
ETH<0.01%$0.6114371.0368$0.6339
ETH<0.01%$0.0001145,440.8298$0.6207
ETH<0.01%$0.1163865.2482$0.6108
ETH<0.01%$0.1392934.313$0.6007
ETH<0.01%$0.0189731.6195$0.5998
ETH<0.01%$0.000001518,713.0576$0.5993
ETH<0.01%$1.510.3948$0.5961
ETH<0.01%$0.001703348.137$0.5928
ETH<0.01%$0.05081511.5802$0.5884
ETH<0.01%$1.180.4931$0.5819
ETH<0.01%$0.0606929.5842$0.5816
ETH<0.01%$0.1158734.8478$0.5617
ETH<0.01%$3,491.930.00015877$0.5544
ETH<0.01%$0.0002222,484.0098$0.5509
ETH<0.01%$15.870.0346$0.549
ETH<0.01%<$0.0000016,988,107.9282$0.5472
ETH<0.01%$0.00194278.3165$0.5399
ETH<0.01%$0.1253634.2928$0.5381
ETH<0.01%$1.280.4181$0.535
ETH<0.01%$2.180.2364$0.5149
ETH<0.01%$0.060378.4419$0.5096
ETH<0.01%$0.00078653.6556$0.5095
ETH<0.01%$0.000699725.1489$0.5068
ETH<0.01%$0.00891756.4226$0.5031
ETH<0.01%$0.1173894.2679$0.501
ETH<0.01%$0.003193156.8888$0.501
ETH<0.01%$0.001285382.8287$0.4921
ETH<0.01%$0.001231395.6269$0.4868
ETH<0.01%$0.002451197.8658$0.485
ETH<0.01%$0.539790.8963$0.4838
ETH<0.01%$0.04065511.8375$0.4812
ETH<0.01%$0.03691613.0155$0.4804
ETH<0.01%$0.0002032,349.1793$0.4778
ETH<0.01%$1.490.3133$0.4668
ETH<0.01%$0.01244936.5416$0.4549
ETH<0.01%$0.2617911.7032$0.4458
ETH<0.01%$0.004023110.7005$0.4453
ETH<0.01%$0.0003041,452.1221$0.4418
ETH<0.01%$0.001506291.885$0.4395
ETH<0.01%$0.2145592.0293$0.4354
ETH<0.01%$0.000629688.6696$0.4329
ETH<0.01%$3,342.520.00012932$0.4322
ETH<0.01%$0.0150628.6321$0.4311
ETH<0.01%$93,888.730.00000458$0.4303
ETH<0.01%$0.00517182.4229$0.4261
ETH<0.01%$19.880.0214$0.4257
ETH<0.01%$0.00002218,903.1579$0.4188
ETH<0.01%$0.00614566.8132$0.4105
ETH<0.01%$0.2886241.4084$0.4064
ETH<0.01%$0.0639086.275$0.401
ETH<0.01%$0.01623924.6495$0.4002
ETH<0.01%$1.010.3889$0.392
ETH<0.01%$0.00404496.1255$0.3887
ETH<0.01%$0.9325080.4117$0.3838
ETH<0.01%$0.02748813.9546$0.3835
ETH<0.01%$0.1239523.0476$0.3777
ETH<0.01%$0.0000784,684.2922$0.3632
ETH<0.01%$0.5399450.6676$0.3604
ETH<0.01%$0.001519236.0177$0.3584
ETH<0.01%$0.000001673,254.1366$0.3574
ETH<0.01%$0.9894040.3524$0.3486
ETH<0.01%$0.000001524,481.3652$0.3393
ETH<0.01%$0.000002194,553.6858$0.3336
ETH<0.01%$0.1449832.2767$0.33
ETH<0.01%$0.0401098.2099$0.3292
ETH<0.01%$0.1173212.7876$0.327
ETH<0.01%$0.1649541.9746$0.3257
ETH<0.01%<$0.0000011,326,837,119.0208$0.3257
ETH<0.01%$0.0876293.7041$0.3245
ETH<0.01%$0.1858791.7422$0.3238
ETH<0.01%$0.00002115,598.844$0.3208
ETH<0.01%$0.9542540.3348$0.3194
ETH<0.01%$0.002128149.2719$0.3176
ETH<0.01%$0.001182264.718$0.3129
ETH<0.01%$0.1606281.9368$0.311
ETH<0.01%$0.00653147.453$0.3099
ETH<0.01%$0.01663618.3278$0.3048
ETH<0.01%$0.000315966.4404$0.3042
ETH<0.01%$0.7327810.4125$0.3022
ETH<0.01%$7.860.0375$0.2947
ETH<0.01%$0.001066274.5169$0.2925
ETH<0.01%$3,609.130.00008102$0.2924
ETH<0.01%$4,005.320.00007224$0.2893
ETH<0.01%$0.000595480.6754$0.2862
ETH<0.01%$0.0973152.91$0.2831
ETH<0.01%$0.00818133.9776$0.2779
ETH<0.01%$0.0593254.6494$0.2758
ETH<0.01%<$0.0000012,406,167.7918$0.2703
ETH<0.01%$15.850.017$0.2698
ETH<0.01%$0.000815328.607$0.2677
ETH<0.01%$0.00279395.6469$0.2671
ETH<0.01%$14.990.0177$0.266
ETH<0.01%$0.3059360.8524$0.2607
ETH<0.01%$7.80.0333$0.2594
ETH<0.01%$0.033197.7907$0.2585
ETH<0.01%$0.01118122.8356$0.2553
ETH<0.01%$0.1695521.5042$0.255
ETH<0.01%$0.01730814.6247$0.2531
ETH<0.01%$0.0053746.7992$0.2512
ETH<0.01%$0.7728880.3208$0.2479
ETH<0.01%$0.000328754.4583$0.2475
ETH<0.01%$67.190.00367144$0.2466
ETH<0.01%$0.000461528.4427$0.2435
ETH<0.01%$0.3199950.7556$0.2417
ETH<0.01%$1.050.2248$0.2369
ETH<0.01%$0.5590760.4184$0.2339
ETH<0.01%$24.360.0095518$0.2326
ETH<0.01%$0.0580313.9855$0.2312
ETH<0.01%$0.001754126.8915$0.2226
ETH<0.01%$0.0001821,212.5275$0.221
ETH<0.01%$2.140.1027$0.2201
ETH<0.01%$0.01709612.8731$0.22
ETH<0.01%$0.0001541,424.982$0.2195
ETH<0.01%$0.00294674.2626$0.2187
ETH<0.01%$0.253560.8609$0.2182
ETH<0.01%$0.0475364.5411$0.2158
ETH<0.01%$0.094392.2831$0.2155
ETH<0.01%$1.280.1677$0.2146
ETH<0.01%$0.0231539.269$0.2146
ETH<0.01%$0.000001184,188.0867$0.2116
ETH<0.01%<$0.0000015,302,145.127$0.2064
ETH<0.01%$0.0000120,198.923$0.202
ETH<0.01%$0.0408974.9054$0.2006
ETH<0.01%$0.000974203.58$0.1982
ETH<0.01%$0.9722280.2035$0.1978
ETH<0.01%$0.2110180.9056$0.1911
ETH<0.01%$14,716.480.00001298$0.191
ETH<0.01%<$0.000001511,871.437$0.1907
ETH<0.01%$0.7112620.2673$0.1901
ETH<0.01%$0.00439343.2609$0.19
ETH<0.01%$0.1248911.493$0.1864
ETH<0.01%$0.00000443,733.0041$0.1819
ETH<0.01%$0.00705825.3828$0.1791
ETH<0.01%$0.0745332.3849$0.1777
ETH<0.01%$0.00203986.095$0.1755
ETH<0.01%$0.00330252.3997$0.173
ETH<0.01%$0.44340.387$0.1715
ETH<0.01%$0.00125137.0452$0.1712
ETH<0.01%$10.1685$0.169
ETH<0.01%$0.0694862.3922$0.1662
ETH<0.01%$0.000622260.7143$0.1621
ETH<0.01%<$0.0000011,480,336.7126$0.1621
ETH<0.01%$0.00719122.53$0.162
ETH<0.01%$0.000001161,734.1466$0.1612
ETH<0.01%$0.051143.1474$0.1609
ETH<0.01%$0.000548292.4141$0.1601
ETH<0.01%<$0.0000012,135,234.1959$0.1584
ETH<0.01%<$0.000001424,662.3349$0.1584
ETH<0.01%$0.075192.0901$0.1571
ETH<0.01%$0.000001137,474.4491$0.1527
ETH<0.01%$0.00166390.9417$0.1512
ETH<0.01%$0.00289651.6526$0.1495
ETH<0.01%$27.990.00533573$0.1493
ETH<0.01%$0.0231646.4426$0.1492
ETH<0.01%<$0.000001341,200.4421$0.1486
ETH<0.01%$0.000027,298.6229$0.145
ETH<0.01%$0.3640050.3925$0.1428
ETH<0.01%$0.000001119,080.4694$0.1417
ETH<0.01%$0.000299470.6699$0.1405
ETH<0.01%$0.2154370.6347$0.1367
ETH<0.01%$0.6983720.1907$0.1331
ETH<0.01%$0.00648220.5145$0.1329
ETH<0.01%$1.10.1193$0.1311
ETH<0.01%$0.000542240.2742$0.1301
ETH<0.01%$0.00186469.3411$0.1292
ETH<0.01%$0.0145278.8997$0.1292
ETH<0.01%$0.0433762.923$0.1267
ETH<0.01%$15.120.00813314$0.1229
ETH<0.01%$0.2320080.5227$0.1212
ETH<0.01%$0.0000751,598.464$0.1194
ETH<0.01%$0.5033290.2365$0.119
ETH<0.01%$0.1285710.903$0.1161
ETH<0.01%$0.1009631.1372$0.1148
ETH<0.01%$1.040.1102$0.1145
ETH<0.01%$624.260.00018235$0.1138
ETH<0.01%$0.000284399.7959$0.1135
ETH<0.01%$0.00094119.133$0.1119
ETH<0.01%$0.0213725.1913$0.1109
ETH<0.01%$0.000001164,285.3717$0.1103
ETH<0.01%$0.01063110.3727$0.1102
ETH<0.01%$0.0182925.967$0.1091
ETH<0.01%$0.7328950.1481$0.1085
ETH<0.01%$0.0146227.3801$0.1079
ETH<0.01%$0.0260134.1381$0.1076
ETH<0.01%$0.2347560.4566$0.1071
ETH<0.01%<$0.00000110,799,484.6419$0.1069
ETH<0.01%$0.000559191.0963$0.1068
ETH<0.01%$0.0909391.1724$0.1066
ETH<0.01%<$0.00000122,822,349.1178$0.1047
ETH<0.01%$0.00987110.5559$0.1041
ETH<0.01%$0.3207150.3244$0.104
ETH<0.01%$0.0061316.6495$0.102
ETH<0.01%$0.00652215.473$0.1009
ETH<0.01%$0.3404050.2952$0.1004
FTM2.04%<$0.00000110,474,850,417.7579$1,653.98
FTM0.07%$1.0355.0481$56.53
FTM0.07%$155.0679$55.23
FTM0.04%$94,2210.00035204$33.17
FTM0.04%$1.0329.5978$30.46
FTM0.04%$129.1319$29.16
FTM0.02%$1.1910.2533$12.2
FTM0.01%$0.0040962,813.0074$11.52
FTM0.01%$0.33898828.8042$9.76
FTM0.01%$0.037391251.6311$9.41
FTM0.01%$24.160.3793$9.16
FTM0.01%$0.01897454.276$8.62
FTM<0.01%$0.034982227.3608$7.95
FTM<0.01%$0.26607724.4807$6.51
FTM<0.01%$0.9775095.063$4.95
FTM<0.01%$0.31155714.5559$4.53
FTM<0.01%$378.320.0107$4.07
FTM<0.01%$28.580.1396$3.99
FTM<0.01%$1.033.5843$3.68
FTM<0.01%$0.07354548.4729$3.56
FTM<0.01%$3,414.380.00092549$3.16
FTM<0.01%$0.9932283.145$3.12
FTM<0.01%$0.00003292,881.6078$2.96
FTM<0.01%$94,2210.00002943$2.77
FTM<0.01%$3,414.380.00071624$2.45
FTM<0.01%$0.9963062.3555$2.35
FTM<0.01%$0.0012871,495.3248$1.93
FTM<0.01%$0.9122281.9293$1.76
FTM<0.01%$1.031.6683$1.71
FTM<0.01%$8,957.740.000188$1.68
FTM<0.01%<$0.0000018,293,531,740.583$1.66
FTM<0.01%$11.6244$1.63
FTM<0.01%$38.870.0418$1.62
FTM<0.01%$361.320.0044954$1.62
FTM<0.01%$0.000012103,306.9923$1.24
FTM<0.01%$0.0006961,743.4158$1.21
FTM<0.01%$0.5036052.2999$1.16
FTM<0.01%$1.520.7516$1.14
FTM<0.01%$0.0203653.9097$1.1
FTM<0.01%$0.0182449.8677$0.9095
FTM<0.01%$0.9995050.7149$0.7145
FTM<0.01%$0.05191213.2478$0.6877
FTM<0.01%$0.6080291.0802$0.6567
FTM<0.01%$0.000311,884.03$0.5843
FTM<0.01%<$0.0000012,235,089.0467$0.3862
FTM<0.01%$0.9959370.3505$0.349
FTM<0.01%$0.00372983.193$0.3101
FTM<0.01%$0.0002881,050.3667$0.3024
FTM<0.01%$24.690.00969902$0.2394
FTM<0.01%$0.000777283.4851$0.2201
FTM<0.01%$0.00357256.5254$0.2019
FTM<0.01%$0.00345556.1993$0.1941
FTM<0.01%$88,9390.000002$0.1778
FTM<0.01%$0.0262346.1166$0.1604
FTM<0.01%<$0.000001794,121,452.2312$0.1588
FTM<0.01%$0.00829516.0832$0.1334
FTM<0.01%$0.0118899.394$0.1116
FTM<0.01%$0.5477420.1924$0.1053
BSC0.49%$0.00905344,067.2239$398.92
BSC0.12%$691.230.1418$98.05
BSC0.10%$3,409.140.0248$84.6
BSC0.07%$0.011874,491.5426$53.31
BSC0.05%$0.066038661.9905$43.72
BSC0.05%$1.4526.5637$38.52
BSC0.04%$692.030.0516$35.71
BSC0.04%$0.99915332.395$32.37
BSC0.04%$0.00151220,728.5038$31.34
BSC0.04%$0.0000221,397,141.4777$31.3
BSC0.04%$0.110098265.3247$29.21
BSC0.03%$128.0846$28.15
BSC0.03%$0.27676889.5201$24.78
BSC0.03%$0.035557599.4531$21.31
BSC0.02%$0.49465940.3483$19.96
BSC0.02%$0.0000161,230,011.008$19.3
BSC0.02%$1.1216.2866$18.24
BSC0.02%$3.814.3915$16.73
BSC0.02%$3.364.8751$16.38
BSC0.02%$0.0061112,659.0812$16.25
BSC0.02%$0.030013538.867$16.17
BSC0.02%<$0.000001434,731,140.8547$16.07
BSC0.02%$0.000018813,190.5995$14.88
BSC0.02%$114.6658$14.67
BSC0.02%$0.37405738.488$14.4
BSC0.02%$0.14619795.5603$13.97
BSC0.02%$84.230.1634$13.76
BSC0.02%$0.0000121,094,600.8881$13.1
BSC0.02%$0.00020364,285.0785$13.07
BSC0.01%$7.321.6279$11.91
BSC0.01%$0.21545547.8238$10.3
BSC0.01%$0.06823148.8652$10.16
BSC0.01%$0.097095102.5601$9.96
BSC0.01%$0.13942769.6762$9.71
BSC0.01%$0.77386512.3696$9.57
BSC0.01%$94,192.710.00009592$9.04
BSC0.01%$0.15469957.7347$8.93
BSC0.01%<$0.00000154,992,252.8852$8.69
BSC0.01%$0.00000115,901,774.8828$8.5
BSC0.01%$7.861.0722$8.43
BSC0.01%$0.0012256,854.1421$8.39
BSC0.01%$0.009409878.2988$8.26
BSC0.01%$40.880.2001$8.18
BSC<0.01%$0.008537927.4963$7.92
BSC<0.01%$0.048339161.5591$7.81
BSC<0.01%$1.17.0883$7.8
BSC<0.01%$14.050.5482$7.7
BSC<0.01%$0.00041518,469.0408$7.66
BSC<0.01%$0.020793360.0658$7.49
BSC<0.01%$0.17573241.9419$7.37
BSC<0.01%$0.040354181.1296$7.31
BSC<0.01%$0.048618147.8895$7.19
BSC<0.01%$1.35.4717$7.13
BSC<0.01%$0.014427482.4427$6.96
BSC<0.01%$0.027587244.2679$6.74
BSC<0.01%$0.10332265.0212$6.72
BSC<0.01%$0.14605645.8268$6.69
BSC<0.01%$5.261.2647$6.65
BSC<0.01%$0.00036617,510.5534$6.42
BSC<0.01%$0.26844323.7108$6.37
BSC<0.01%$22.760.2758$6.28
BSC<0.01%$0.8470867.1055$6.02
BSC<0.01%$0.03808156.5093$5.96
BSC<0.01%$0.26823921.4174$5.74
BSC<0.01%$0.32208917.8067$5.74
BSC<0.01%$2.931.932$5.66
BSC<0.01%$0.012811441.4493$5.66
BSC<0.01%$0.008201673.033$5.52
BSC<0.01%$0.0040491,246.8231$5.05
BSC<0.01%$0.46835610.7319$5.03
BSC<0.01%$2.262.174$4.91
BSC<0.01%$0.05368887.2766$4.69
BSC<0.01%$0.000005989,358.6989$4.63
BSC<0.01%$5.690.8045$4.58
BSC<0.01%$0.13865932.9668$4.57
BSC<0.01%$0.23124819.3669$4.48
BSC<0.01%$0.21856820.4276$4.46
BSC<0.01%$0.43984910.1448$4.46
BSC<0.01%$0.41066410.7084$4.4
BSC<0.01%$0.0501484.5798$4.24
BSC<0.01%$0.0005986,969.7612$4.17
BSC<0.01%$1.193.4538$4.11
BSC<0.01%$0.037313109.9229$4.1
BSC<0.01%$0.004326923.7303$4
BSC<0.01%<$0.000001161,680,462.3099$3.96
BSC<0.01%$0.011485343.8399$3.95
BSC<0.01%$0.01283302.5945$3.88
BSC<0.01%$0.31802912.0994$3.85
BSC<0.01%$0.0010623,621.9437$3.85
BSC<0.01%$0.09168241.3751$3.79
BSC<0.01%$0.004394850.8718$3.74
BSC<0.01%$0.012721283.4655$3.61
BSC<0.01%$0.5834486.1692$3.6
BSC<0.01%$0.005957591.6283$3.52
BSC<0.01%$0.03986387.8753$3.5
BSC<0.01%$0.09046938.0367$3.44
BSC<0.01%$0.20808216.3056$3.39
BSC<0.01%$0.9126433.6811$3.36
BSC<0.01%$0.06997547.0427$3.29
BSC<0.01%$0.06520550.1328$3.27
BSC<0.01%$1.52.1738$3.27
BSC<0.01%$0.009439340.2567$3.21
BSC<0.01%$3.041.044$3.17
BSC<0.01%$0.023902131.7892$3.15
BSC<0.01%$0.03457490.0171$3.11
BSC<0.01%$0.0008173,664.5214$3
BSC<0.01%$0.023006124.3561$2.86
BSC<0.01%$1.262.2664$2.85
BSC<0.01%$0.0003987,102.2994$2.83
BSC<0.01%$0.0023631,186.5287$2.8
BSC<0.01%$0.5474145.1084$2.8
BSC<0.01%$0.0017071,634.8449$2.79
BSC<0.01%$0.20176913.7436$2.77
BSC<0.01%$0.009225296.709$2.74
BSC<0.01%$1.61.6529$2.64
BSC<0.01%$0.4023866.514$2.62
BSC<0.01%$0.0007643,353.6713$2.56
BSC<0.01%$0.10062625.3263$2.55
BSC<0.01%$0.0944226.7234$2.52
BSC<0.01%$0.022152113.1585$2.51
BSC<0.01%$361.30.00667891$2.41
BSC<0.01%$0.0006693,545.728$2.37
BSC<0.01%$0.012681186.8123$2.37
BSC<0.01%$0.3395056.9184$2.35
BSC<0.01%$0.08958625.9781$2.33
BSC<0.01%$5.620.4073$2.29
BSC<0.01%$0.3226637.049$2.27
BSC<0.01%$1.951.154$2.25
BSC<0.01%$0.14459115.5472$2.25
BSC<0.01%$0.00015114,828.2826$2.23
BSC<0.01%$0.004571487.844$2.23
BSC<0.01%$20.240.1102$2.23
BSC<0.01%$0.04751246.8269$2.22
BSC<0.01%$0.9997932.1856$2.19
BSC<0.01%$0.3417616.3579$2.17
BSC<0.01%$0.752282.8207$2.12
BSC<0.01%$0.10563819.835$2.1
BSC<0.01%$1.151.7976$2.07
BSC<0.01%$0.02631378.1556$2.06
BSC<0.01%$0.4214.8466$2.04
BSC<0.01%$0.08183624.8021$2.03
BSC<0.01%$0.15970212.4498$1.99
BSC<0.01%$0.15359612.834$1.97
BSC<0.01%$0.03890350.6211$1.97
BSC<0.01%$2.440.7886$1.92
BSC<0.01%<$0.0000019,823,340.0521$1.92
BSC<0.01%$0.9423382.029$1.91
BSC<0.01%$0.009448200.6904$1.9
BSC<0.01%$0.03222258.4857$1.88
BSC<0.01%$9.750.1924$1.88
BSC<0.01%$0.05839731.746$1.85
BSC<0.01%$5.180.3498$1.81
BSC<0.01%$0.011965150.0018$1.79
BSC<0.01%$1.571.1304$1.77
BSC<0.01%$3,511.410.00050184$1.76
BSC<0.01%$0.0003914,434.9616$1.73
BSC<0.01%$0.002798610.8382$1.71
BSC<0.01%$0.00001895,599.0453$1.68
BSC<0.01%$2.50.6703$1.68
BSC<0.01%$0.002329704.6853$1.64
BSC<0.01%$0.0000011,398,458.4223$1.62
BSC<0.01%$0.3052675.2748$1.61
BSC<0.01%$0.00013811,452.9482$1.58
BSC<0.01%$0.006568238.7345$1.57
BSC<0.01%$0.02235669.8358$1.56
BSC<0.01%$0.4869373.1643$1.54
BSC<0.01%$0.3201764.7727$1.53
BSC<0.01%$68.40.0222$1.52
BSC<0.01%$0.000002680,260.2644$1.5
BSC<0.01%$0.0006012,454.3137$1.47
BSC<0.01%$0.438063.2979$1.44
BSC<0.01%$15.940.0871$1.39
BSC<0.01%$0.0006112,269.2699$1.39
BSC<0.01%$0.0006552,117.3603$1.39
BSC<0.01%$0.002622524.1848$1.37
BSC<0.01%$0.007805170.3057$1.33
BSC<0.01%$0.02013965.9441$1.33
BSC<0.01%$11.3018$1.3
BSC<0.01%$0.0008611,492.561$1.28
BSC<0.01%$0.06037820.6111$1.24
BSC<0.01%$0.004371284.4883$1.24
BSC<0.01%<$0.000001338,943,128.0693$1.24
BSC<0.01%$0.09214413.3956$1.23
BSC<0.01%$0.01244597.9438$1.22
BSC<0.01%<$0.000001399,321,685.4515$1.21
BSC<0.01%$0.00003236,658.2442$1.17
BSC<0.01%$0.01713967.3872$1.15
BSC<0.01%$0.4369272.6115$1.14
BSC<0.01%$0.0373930.364$1.14
BSC<0.01%$0.07099515.5752$1.11
BSC<0.01%$0.01955953.0985$1.04
BSC<0.01%$0.3110723.2871$1.02
BSC<0.01%$0.5848611.6853$0.9856
BSC<0.01%$0.03663226.868$0.9842
BSC<0.01%$0.0008851,100.3392$0.9737
BSC<0.01%$0.01986547.9683$0.9529
BSC<0.01%$0.002929318.5083$0.9328
BSC<0.01%$0.13057.1$0.9265
BSC<0.01%$0.0000011,711,912.9288$0.9154
BSC<0.01%$1.680.5362$0.9007
BSC<0.01%$0.0008081,107.6995$0.8951
BSC<0.01%$0.0004142,150.7965$0.89
BSC<0.01%$0.9979160.8765$0.8746
BSC<0.01%$0.0003972,187.7352$0.8678
BSC<0.01%<$0.000001590,690,076.6692$0.8588
BSC<0.01%$0.01028582.2162$0.8455
BSC<0.01%$0.00166503.023$0.8349
BSC<0.01%$106.660.0075146$0.8014
BSC<0.01%$0.0001266,311.0808$0.7954
BSC<0.01%<$0.0000011,434,428,361.0648$0.795
BSC<0.01%$0.04262418.4902$0.7881
BSC<0.01%$1.370.576$0.7873
BSC<0.01%$0.0002283,400.5492$0.7737
BSC<0.01%<$0.0000013,252,971,182.1604$0.7508
BSC<0.01%<$0.0000013,349,368.0182$0.7444
BSC<0.01%$0.2372593.0378$0.7207
BSC<0.01%$0.006239113.6079$0.7088
BSC<0.01%$0.0003252,160.6277$0.7012
BSC<0.01%$0.004731145.7341$0.6895
BSC<0.01%$0.0002612,622.7541$0.6857
BSC<0.01%$0.01033765.613$0.6782
BSC<0.01%$0.0399416.3039$0.6511
BSC<0.01%$0.990520.6572$0.6509
BSC<0.01%$0.4531541.3806$0.6256
BSC<0.01%$0.02245627.3239$0.6135
BSC<0.01%$0.004014151.083$0.6064
BSC<0.01%$0.00000966,288.193$0.5906
BSC<0.01%$0.0663518.8535$0.5874
BSC<0.01%$0.0763897.5311$0.5752
BSC<0.01%$0.0694468.1948$0.569
BSC<0.01%$0.04198613.4741$0.5657
BSC<0.01%$0.001037543.6825$0.5635
BSC<0.01%$0.4918611.1333$0.5574
BSC<0.01%$0.00594892.4272$0.5497
BSC<0.01%$0.003143174.3877$0.5481
BSC<0.01%$0.00003914,147.6055$0.5459
BSC<0.01%$1.450.3761$0.5453
BSC<0.01%$0.00757371.493$0.5414
BSC<0.01%$0.0002961,823.6534$0.54
BSC<0.01%$0.02365221.4176$0.5065
BSC<0.01%$0.0003891,294.025$0.5032
BSC<0.01%$0.255491.9432$0.4964
BSC<0.01%$0.1130684.307$0.4869
BSC<0.01%$0.0805725.6691$0.4567
BSC<0.01%$0.0708886.3943$0.4532
BSC<0.01%$6.880.0657$0.4521
BSC<0.01%$0.003066146.1425$0.448
BSC<0.01%$0.02183820.4684$0.4469
BSC<0.01%$0.04373210.2173$0.4468
BSC<0.01%$0.003112135.6516$0.4221
BSC<0.01%$0.0591797.1094$0.4207
BSC<0.01%$0.000612684.0889$0.4185
BSC<0.01%$5.960.0699$0.4166
BSC<0.01%$0.000666616.5617$0.4106
BSC<0.01%$0.0000934,242.3221$0.3958
BSC<0.01%$0.7110370.5463$0.3884
BSC<0.01%$460.10.00084283$0.3877
BSC<0.01%$0.7171530.528$0.3786
BSC<0.01%$4,004.480.0000945$0.3784
BSC<0.01%$0.01941919.3922$0.3765
BSC<0.01%$0.00530669.7348$0.37
BSC<0.01%$0.1405422.473$0.3475
BSC<0.01%$0.00536864.3954$0.3456
BSC<0.01%$0.0609895.6613$0.3452
BSC<0.01%$0.0840734.0742$0.3425
BSC<0.01%$0.5036520.6699$0.3373
BSC<0.01%$1.030.3233$0.332
BSC<0.01%$0.00890437.1837$0.331
BSC<0.01%$0.02295814.4019$0.3306
BSC<0.01%$1.040.3147$0.3282
BSC<0.01%$0.03189810.2635$0.3273
BSC<0.01%$0.0000883,702.4607$0.3267
BSC<0.01%$0.4613530.6999$0.3229
BSC<0.01%$0.5988870.5369$0.3215
BSC<0.01%$0.9963820.3166$0.3154
BSC<0.01%$0.001485211.3153$0.3138
BSC<0.01%$0.02846610.7737$0.3066
BSC<0.01%$0.9923310.2867$0.2844
BSC<0.01%<$0.00000119,723,052.704$0.278
BSC<0.01%$3.410.0792$0.2697
BSC<0.01%$0.1950991.3825$0.2697
BSC<0.01%$0.0353667.4458$0.2633
BSC<0.01%$0.0000663,988.7538$0.2627
BSC<0.01%$0.000602418.6933$0.2518
BSC<0.01%$0.2349851.069$0.2511
BSC<0.01%$0.7660450.3277$0.251
BSC<0.01%$0.0610714.053$0.2475
BSC<0.01%$0.001887128.7988$0.243
BSC<0.01%$190.320.00127648$0.2429
BSC<0.01%$0.937070.2574$0.2412
BSC<0.01%$0.00802229.8019$0.239
BSC<0.01%$104,7220.00000228$0.2386
BSC<0.01%$0.2055171.148$0.2359
BSC<0.01%$0.0001042,257.7467$0.2354
BSC<0.01%$0.00458550.7824$0.2328
BSC<0.01%$0.2070521.1112$0.23
BSC<0.01%$0.2919950.7778$0.2271
BSC<0.01%$0.01248518.078$0.2257
BSC<0.01%$0.0000268,546.6303$0.2247
BSC<0.01%$0.001534145.3838$0.223
BSC<0.01%$0.0034264.9338$0.222
BSC<0.01%$0.0038756.2983$0.2178
BSC<0.01%$0.00240288.9399$0.2136
BSC<0.01%$0.00900923.0019$0.2072
BSC<0.01%$0.0390315.2804$0.2061
BSC<0.01%$0.00440346.7425$0.2057
BSC<0.01%$2.870.0707$0.2029
BSC<0.01%$0.001023197.6168$0.202
BSC<0.01%$0.0631693.1834$0.201
BSC<0.01%$0.0000375,442.9281$0.201
BSC<0.01%$0.0099820.1075$0.2006
BSC<0.01%$0.00495640.1007$0.1987
BSC<0.01%$0.01285614.9408$0.192
BSC<0.01%$0.5035560.3794$0.191
BSC<0.01%$0.000689270.3588$0.1861
BSC<0.01%$0.0609223.0508$0.1858
BSC<0.01%$0.000275674.3925$0.1857
BSC<0.01%$0.1359811.364$0.1854
BSC<0.01%$24.180.00754421$0.1824
BSC<0.01%$0.0032455.0678$0.1784
BSC<0.01%$0.000444386.6579$0.1716
BSC<0.01%$0.0337375.0288$0.1696
BSC<0.01%$1.390.1214$0.1688
BSC<0.01%$0.1737730.9201$0.1598
BSC<0.01%$0.0001031,546.5851$0.1586
BSC<0.01%$0.00880317.5075$0.1541
BSC<0.01%$0.000465329.2012$0.1531
BSC<0.01%$0.00000345,986.8994$0.1522
BSC<0.01%$0.1264311.1861$0.1499
BSC<0.01%$0.0000285,225.5124$0.1464
BSC<0.01%$0.00107133.9971$0.1433
BSC<0.01%$0.0159558.8997$0.1419
BSC<0.01%$0.00215965.1206$0.1405
BSC<0.01%$0.000862154.5892$0.1332
BSC<0.01%$0.1614280.8035$0.1297
BSC<0.01%<$0.0000019,577,419,279.9253$0.1282
BSC<0.01%$0.0234265.363$0.1256
BSC<0.01%<$0.000001755,101.3177$0.1253
BSC<0.01%$0.0441172.7904$0.1231
BSC<0.01%$0.00188664.882$0.1223
BSC<0.01%$0.0785631.5541$0.122
BSC<0.01%$0.000331368.009$0.1217
BSC<0.01%$0.00377130.5049$0.115
BSC<0.01%$0.000137835.9768$0.1144
BSC<0.01%$0.2682390.4205$0.1128
BSC<0.01%$0.0195035.6919$0.111
BSC<0.01%$0.0132128.2239$0.1086
BSC<0.01%$0.00444723.9993$0.1067
BSC<0.01%$0.2163410.4727$0.1022
BSC<0.01%$0.00349728.9309$0.1011
BSC<0.01%$0.0617321.6308$0.1006
ARB0.09%$0.99139269.6818$69.08
ARB0.08%$0.9996761.853$61.83
ARB0.07%$0.0325071,760.5799$57.23
ARB0.07%$47.171.1877$56.02
ARB0.07%$155.5791$55.58
ARB0.04%$0.41081587.1517$35.8
ARB0.04%$0.80009237.7166$30.18
ARB0.03%$29.480.8291$24.44
ARB0.03%$94,0860.00025343$23.84
ARB0.03%$0.999120.598$20.58
ARB0.02%$4,681.410.00361735$16.93
ARB0.02%$3,415.830.00479889$16.39
ARB0.02%$0.21523675.2618$16.2
ARB0.02%$0.042799356.4046$15.25
ARB0.02%$3,408.050.00437959$14.93
ARB0.02%$14.090.9929$13.99
ARB0.01%$24.160.486$11.74
ARB0.01%$0.065969169.9029$11.21
ARB0.01%$3,412.550.00305765$10.43
ARB0.01%$18.010.5462$9.84
ARB0.01%$4,042.010.00224474$9.07
ARB0.01%$3,514.380.00254379$8.94
ARB0.01%$1.028.6977$8.84
ARB0.01%$0.9968278.6925$8.66
ARB0.01%$2.084.0886$8.5
ARB0.01%$1.844.4414$8.17
ARB0.01%$0.000012678,399.0295$8.13
ARB<0.01%$0.000018428,663.3798$7.84
ARB<0.01%$1,120.970.00667988$7.49
ARB<0.01%$5.271.4039$7.4
ARB<0.01%$3,823.140.00192149$7.35
ARB<0.01%$0.059207119.7293$7.09
ARB<0.01%$0.999177.0943$7.09
ARB<0.01%$0.9939376.7893$6.75
ARB<0.01%$0.21872230.7521$6.73
ARB<0.01%$24.270.262$6.36
ARB<0.01%$1.913.276$6.26
ARB<0.01%$0.08176476.0711$6.22
ARB<0.01%$379.110.0162$6.13
ARB<0.01%$2.432.4037$5.84
ARB<0.01%$0.9105016.1256$5.58
ARB<0.01%$0.025288207.3663$5.24
ARB<0.01%<$0.00000126,755,515.5651$5.23
ARB<0.01%$0.013784373.7065$5.15
ARB<0.01%$94,1520.00005288$4.98
ARB<0.01%$0.008626567.062$4.89
ARB<0.01%$0.08094858.2758$4.72
ARB<0.01%$0.9703794.772$4.63
ARB<0.01%$0.08376652.4549$4.39
ARB<0.01%$2.172.024$4.39
ARB<0.01%$0.0036761,187.684$4.37
ARB<0.01%$0.1541528.0474$4.32
ARB<0.01%$0.40442610.6642$4.31
ARB<0.01%$0.29433714.3212$4.22
ARB<0.01%$1.772.381$4.21
ARB<0.01%$0.09929342.1918$4.19
ARB<0.01%$0.06039369.332$4.19
ARB<0.01%$0.31206413.4107$4.19
ARB<0.01%$0.04201297.0157$4.08
ARB<0.01%$0.589896.6278$3.91
ARB<0.01%$3,449.020.00112373$3.88
ARB<0.01%$13.7353$3.74
ARB<0.01%$5,591.450.00057195$3.2
ARB<0.01%$0.28438511.1392$3.17
ARB<0.01%$0.9990343.1536$3.15
ARB<0.01%$0.03151794.2833$2.97
ARB<0.01%$0.03949972.9497$2.88
ARB<0.01%$0.10088426.1239$2.64
ARB<0.01%$2.321.1322$2.63
ARB<0.01%$0.800743.1455$2.52
ARB<0.01%$4,004.110.00058881$2.36
ARB<0.01%$3,771.340.00061645$2.32
ARB<0.01%$0.0003985,824.7517$2.32
ARB<0.01%$0.0007762,932.559$2.27
ARB<0.01%$0.9624462.3589$2.27
ARB<0.01%$0.002477902.1233$2.23
ARB<0.01%$0.07878428.2522$2.23
ARB<0.01%$0.009285238.2128$2.21
ARB<0.01%$0.15240613.9895$2.13
ARB<0.01%$0.9996022.0473$2.05
ARB<0.01%$0.2469538.1852$2.02
ARB<0.01%$0.05788934.3267$1.99
ARB<0.01%$0.000017113,099.9845$1.95
ARB<0.01%$0.002503763.4662$1.91
ARB<0.01%$0.9990331.8718$1.87
ARB<0.01%$0.03881548.086$1.87
ARB<0.01%$94,2950.00001963$1.85
ARB<0.01%$0.02298978.586$1.81
ARB<0.01%$0.1983228.6218$1.71
ARB<0.01%$2.660.5589$1.49
ARB<0.01%$0.00003245,377.8212$1.45
ARB<0.01%$0.02654452.8962$1.4
ARB<0.01%$94,2100.00001418$1.34
ARB<0.01%$0.7325071.735$1.27
ARB<0.01%$0.01582779.3367$1.26
ARB<0.01%$94,2000.00001314$1.24
ARB<0.01%$1.450.8499$1.23
ARB<0.01%$3.20.3774$1.21
ARB<0.01%$0.07616615.7803$1.2
ARB<0.01%$3,665.960.0003237$1.19
ARB<0.01%$0.5696072.0119$1.15
ARB<0.01%$165.080.00688365$1.14
ARB<0.01%$0.01730362.9316$1.09
ARB<0.01%$18.020.0604$1.09
ARB<0.01%$1.520.6422$0.9761
ARB<0.01%$20.830.0467$0.9728
ARB<0.01%$3.530.2546$0.8986
ARB<0.01%$0.018348.8877$0.8946
ARB<0.01%$37.130.0238$0.8827
ARB<0.01%$0.9996130.8718$0.8714
ARB<0.01%$0.0805499.588$0.7723
ARB<0.01%$2.50.3029$0.7572
ARB<0.01%$0.003582209.1647$0.7491
ARB<0.01%$0.02778126.4558$0.7349
ARB<0.01%$0.2023393.5572$0.7197
ARB<0.01%$24.20.0283$0.685
ARB<0.01%$10.6623$0.6623
ARB<0.01%$0.1436684.1079$0.5901
ARB<0.01%$0.9962250.5831$0.5809
ARB<0.01%$0.0607029.3854$0.5697
ARB<0.01%$0.0239923.67$0.5678
ARB<0.01%$0.9999580.5457$0.5456
ARB<0.01%$0.03351315.9558$0.5347
ARB<0.01%$0.01174743.2692$0.5082
ARB<0.01%$0.7206640.6627$0.4775
ARB<0.01%$0.2212192.1569$0.4771
ARB<0.01%$0.01215432.6079$0.3963
ARB<0.01%$0.00650360.1545$0.3911
ARB<0.01%$0.441120.879$0.3877
ARB<0.01%$0.002842131.5378$0.3738
ARB<0.01%$0.0000993,473.2745$0.3445
ARB<0.01%$3,697.510.00008975$0.3318
ARB<0.01%$0.0527076.2857$0.3313
ARB<0.01%$0.000779419.3624$0.3267
ARB<0.01%$0.0302289.6025$0.2902
ARB<0.01%$10.2894$0.2893
ARB<0.01%$0.9488590.2687$0.2549
ARB<0.01%$275.730.00088111$0.2429
ARB<0.01%$2.510.0954$0.2393
ARB<0.01%$2.760.0825$0.2277
ARB<0.01%$94,5010.00000238$0.2249
ARB<0.01%$1.040.2158$0.2248
ARB<0.01%$5.670.039$0.2212
ARB<0.01%$0.000397500$0.1987
ARB<0.01%<$0.00000136,012,969.763$0.198
ARB<0.01%$0.333830.5699$0.1902
ARB<0.01%$0.0350965.3185$0.1866
ARB<0.01%$0.000445413.1556$0.1838
ARB<0.01%$2.590.0683$0.1768
ARB<0.01%$0.1829010.929$0.1699
ARB<0.01%$0.010814.6304$0.158
ARB<0.01%$0.2884750.5376$0.155
ARB<0.01%$0.8333550.1855$0.1545
ARB<0.01%$0.0529912.8452$0.1507
ARB<0.01%$0.0171157.6252$0.1305
ARB<0.01%$1.040.1251$0.1303
ARB<0.01%$0.8452430.1528$0.1291
ARB<0.01%$0.7731190.1661$0.1284
ARB<0.01%$0.0268954.7199$0.1269
ARB<0.01%$0.0591511.9887$0.1176
ARB<0.01%$0.00313936.6938$0.1151
ARB<0.01%$0.5481750.2086$0.1143
ARB<0.01%$10.1092$0.1094
ARB<0.01%$1.010.1078$0.1084
ARB<0.01%$0.3870450.2777$0.1074
ARB<0.01%$0.0000283,772.5658$0.1055
ARB<0.01%$270.730.00037003$0.1001
AVAX0.12%$0.99982699.4759$99.46
AVAX0.12%$0.99856595.9622$95.82
AVAX0.10%$38.822.1229$82.42
AVAX0.09%$45.761.5251$69.79
AVAX0.06%$0.00000228,564,746.9985$47.42
AVAX0.02%$114.2487$14.25
AVAX0.02%$94,0820.00014472$13.62
AVAX0.02%$94,3020.0001388$13.09
AVAX0.01%$38.850.2918$11.34
AVAX0.01%<$0.000001616,665,940.1582$11.1
AVAX0.01%$3,412.630.00284583$9.71
AVAX<0.01%$0.062643120.6717$7.56
AVAX<0.01%$3,408.050.00220463$7.51
AVAX<0.01%$0.58984412.2612$7.23
AVAX<0.01%$1.046.8153$7.07
AVAX<0.01%$188.680.0367$6.92
AVAX<0.01%$0.9881696.4699$6.39
AVAX<0.01%$5,591.450.00101099$5.65
AVAX<0.01%$0.9985654.5683$4.56
AVAX<0.01%$44.310.0978$4.34
AVAX<0.01%$0.007566540.3281$4.09
AVAX<0.01%$14.0435$4.04
AVAX<0.01%$0.0000031,228,558.9962$4.02
AVAX<0.01%$0.002971,270.2484$3.77
AVAX<0.01%$0.000005780,231.4463$3.63
AVAX<0.01%$24.170.1498$3.62
AVAX<0.01%$0.9978293.485$3.48
AVAX<0.01%$1.043.036$3.16
AVAX<0.01%$0.330279.3164$3.08
AVAX<0.01%$0.0026161,116.8428$2.92
AVAX<0.01%$0.017437149.7367$2.61
AVAX<0.01%$0.009434264.2341$2.49
AVAX<0.01%$0.4106685.6658$2.33
AVAX<0.01%$0.5468084.029$2.2
AVAX<0.01%$0.000012176,797.4326$2.13
AVAX<0.01%$0.0004354,439.9534$1.93
AVAX<0.01%$0.11247216.3399$1.84
AVAX<0.01%$0.00796218.0983$1.74
AVAX<0.01%$0.00091,926.9609$1.73
AVAX<0.01%$29.480.0523$1.54
AVAX<0.01%$0.008042173.9785$1.4
AVAX<0.01%$0.02008469.5074$1.4
AVAX<0.01%$0.9999581.3321$1.33
AVAX<0.01%$473.530.00265868$1.26
AVAX<0.01%$5.670.2027$1.15
AVAX<0.01%$1.10.9684$1.07
AVAX<0.01%$0.9955691.022$1.02
AVAX<0.01%$379.110.00200865$0.7614
AVAX<0.01%$360.990.00174391$0.6295
AVAX<0.01%$0.000282,180.2321$0.6097
AVAX<0.01%$0.999170.5314$0.5309
AVAX<0.01%$5.260.0912$0.4797
AVAX<0.01%$1.510.292$0.442
AVAX<0.01%$0.3121341.3861$0.4326
AVAX<0.01%$0.000398818.1876$0.3259
AVAX<0.01%$0.001395206.0025$0.2874
AVAX<0.01%$377.620.00072822$0.2749
AVAX<0.01%$0.0381867.1975$0.2748
AVAX<0.01%$0.0125221.8656$0.2737
AVAX<0.01%$0.000742314.3358$0.2332
AVAX<0.01%$0.1241041.7489$0.217
AVAX<0.01%<$0.0000016,415,801.1458$0.1546
AVAX<0.01%$0.0000542,860.002$0.154
AVAX<0.01%$0.00203172.7052$0.1476
AVAX<0.01%$0.0001211,151.8436$0.1397
AVAX<0.01%$0.00042295.2815$0.124
AVAX<0.01%$0.0374153.0613$0.1145
AVAX<0.01%$0.01123210.0723$0.1131
AVAX<0.01%$14.090.00772156$0.1087
OP0.09%$174.2571$74.26
OP0.09%$3,412.630.0203$69.24
OP0.06%$0.99142149.9611$49.53
OP0.06%$94,0820.00051644$48.59
OP0.05%$1.9222.4626$43.07
OP0.04%$3,416.930.0102$34.84
OP0.03%$0.182727121.6897$22.24
OP0.02%$377.620.0519$19.61
OP0.02%$2.328.1982$19.02
OP0.02%$4,041.770.00352994$14.27
OP0.02%$362.540.0347$12.59
OP0.02%$0.99908312.3224$12.31
OP0.01%$27.050.4418$11.95
OP0.01%$0.20233957.9649$11.73
OP0.01%$110.5815$10.58
OP<0.01%$0.8342539.0018$7.51
OP<0.01%$94,2000.00006703$6.31
OP<0.01%$3,386.390.0018507$6.27
OP<0.01%$5.671.0924$6.19
OP<0.01%$0.9923815.864$5.82
OP<0.01%$0.9991075.0118$5.01
OP<0.01%$0.9925883.4823$3.46
OP<0.01%$1.841.8778$3.46
OP<0.01%$3,364.940.0010074$3.39
OP<0.01%$0.22989514.6856$3.38
OP<0.01%$0.9999783.0795$3.08
OP<0.01%$0.09507230.9478$2.94
OP<0.01%$0.9999582.8826$2.88
OP<0.01%$0.9969082.8145$2.81
OP<0.01%$0.999681.8735$1.87
OP<0.01%$1.031.661$1.71
OP<0.01%$14.090.1065$1.5
OP<0.01%$3,329.930.00043642$1.45
OP<0.01%$0.08555216.6406$1.42
OP<0.01%$0.9483521.1773$1.12
OP<0.01%$0.1827275.3336$0.9745
OP<0.01%$0.0005361,816.3023$0.9735
OP<0.01%$0.9989650.9566$0.9556
OP<0.01%$1.010.6881$0.6928
OP<0.01%$0.0727779.3375$0.6795
OP<0.01%$0.3121342.1608$0.6744
OP<0.01%$0.01730338.8352$0.6719
OP<0.01%$0.9914650.5397$0.535
OP<0.01%$0.001943264.4842$0.5139
OP<0.01%$0.04501311.3826$0.5123
OP<0.01%$0.02394818.0951$0.4333
OP<0.01%$0.8212110.4876$0.4003
OP<0.01%$2.10.188$0.3948
OP<0.01%$379.110.00100204$0.3798
OP<0.01%$3,408.050.00007803$0.2659
OP<0.01%$0.0115820.8603$0.2415
OP<0.01%$0.01711613.7127$0.2347
OP<0.01%$0.9995220.2036$0.2035
OP<0.01%$0.00975718.3371$0.1789
OP<0.01%$0.0314425.4764$0.1721
OP<0.01%$2.660.0622$0.1653
OP<0.01%$0.00217675.4378$0.1641
OP<0.01%$0.1008761.6159$0.163
OP<0.01%$0.00001211,080.262$0.1336
BASE0.06%$0.0036513,324.6182$48.64
BASE0.03%$0.00109420,305.55$22.2
BASE0.01%<$0.000001306,886,535$11.57
BASE<0.01%$0.030286124.0777$3.76
BASE<0.01%$0.07209633.689$2.43
BASE<0.01%$0.000009200,004.2069$1.77
BASE<0.01%$0.007042169$1.19
BASE<0.01%$0.03476411$0.3824
BASE<0.01%$0.000946274$0.2592
BASE<0.01%<$0.00000127,531,552$0.2285
Loading...
Loading
[ Download: CSV Export  ]
[ 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.