// File: lib/openzeppelin-contracts/contracts/access/Ownable.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: lib/openzeppelin-contracts/contracts/utils/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: lib/solmate/src/tokens/ERC20.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

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

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

// File: lib/solmate/src/utils/FixedPointMathLib.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant MAX_UINT256 = 2**256 - 1;

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // Divide x * y by the denominator.
            z := div(mul(x, y), denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
            if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
                revert(0, 0)
            }

            // If x * y modulo the denominator is strictly greater than 0,
            // 1 is added to round up the division of x * y by the denominator.
            z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            let y := x // We start y at x, which will help us make our initial estimate.

            z := 181 // The "correct" value is 1, but this saves a multiplication later.

            // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
            // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.

            // We check y >= 2^(k + 8) but shift right by k bits
            // each branch to ensure that if x >= 256, then y >= 256.
            if iszero(lt(y, 0x10000000000000000000000000000000000)) {
                y := shr(128, y)
                z := shl(64, z)
            }
            if iszero(lt(y, 0x1000000000000000000)) {
                y := shr(64, y)
                z := shl(32, z)
            }
            if iszero(lt(y, 0x10000000000)) {
                y := shr(32, y)
                z := shl(16, z)
            }
            if iszero(lt(y, 0x1000000)) {
                y := shr(16, y)
                z := shl(8, z)
            }

            // Goal was to get z*z*y within a small factor of x. More iterations could
            // get y in a tighter range. Currently, we will have y in [256, 256*2^16).
            // We ensured y >= 256 so that the relative difference between y and y+1 is small.
            // That's not possible if x < 256 but we can just verify those cases exhaustively.

            // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
            // Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
            // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.

            // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
            // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.

            // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
            // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.

            // There is no overflow risk here since y < 2^136 after the first branch above.
            z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.

            // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // If x+1 is a perfect square, the Babylonian method cycles between
            // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
            // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
            // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
            // If you don't care whether the floor or ceil square root is returned, you can remove this statement.
            z := sub(z, lt(div(x, z), z))
        }
    }

    function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Mod x by y. Note this will return
            // 0 instead of reverting if y is zero.
            z := mod(x, y)
        }
    }

    function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Divide x by y. Note this will return
            // 0 instead of reverting if y is zero.
            r := div(x, y)
        }
    }

    function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            // Add 1 to x * y if x % y > 0. Note this will
            // return 0 instead of reverting if y is zero.
            z := add(gt(mod(x, y), 0), div(x, y))
        }
    }
}

// File: lib/solmate/src/utils/ReentrancyGuard.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
}

// File: lib/solmate/src/utils/SafeTransferLib.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

import {ERC20} from "../tokens/ERC20.sol";

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
    /*//////////////////////////////////////////////////////////////
                             ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and store if it succeeded or not.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(success, "ETH_TRANSFER_FAILED");
    }

    /*//////////////////////////////////////////////////////////////
                            ERC20 OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferFrom(
        ERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument.
            mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument.
            mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
            )
        }

        require(success, "TRANSFER_FROM_FAILED");
    }

    function safeTransfer(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "TRANSFER_FAILED");
    }

    function safeApprove(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "APPROVE_FAILED");
    }
}

// File: src/MeanFinanceDistributor.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.18;

import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {Ownable} from "oz/access/Ownable.sol";
import {OwnableERC4626Migrator} from "./OwnableERC4626Migrator.sol";
import {OwnableERC4626MigratorWithOSQTH} from "./OwnableERC4626MigratorWithOSQTH.sol";

/**
 * @title MeanFinanceDistributor
 * @notice Contract to be used to distribute and set up the Mean Finance ERC4626 migration contracts.
 */
contract MeanFinanceDistributor is Ownable, ReentrancyGuard {
    using SafeTransferLib for ERC20;

    ERC20 constant WETH = ERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
    ERC20 constant DAI = ERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
    ERC20 constant USDC = ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
    ERC20 constant OSQTH = ERC20(0xf1B99e3E573A1a9C5E6B2Ce818b617F0E664E86B);

    address public constant eulerMultisig = 0xcAD001c30E96765aC90307669d578219D4fb1DCe;

    address public constant weweth4626 = 0xd4dE9D2Fc1607d1DF63E1c95ecBfa8d7946f5457;
    address public constant weusdc4626 = 0xCd0E5871c97C663D43c62B5049C123Bb45BfE2cC;
    address public constant webtc4626 = 0x48E345cb84895EAb4db4C44ff9B619cA0bE671d9;
    address public constant weosqth4626 = 0x20706baA0F89e2dccF48eA549ea5A13B9b30462f;
    address public constant wedai4626 = 0xc4113b7605D691E073c162809060b6C5Ae402F1e;
    address public constant welusd4626 = 0xb95E6eee428902C234855990E18a632fA34407dc;

    address public weweth4626Migrator;
    address public weusdc4626Migrator;
    address public webtc4626Migrator;
    address public weosqth4626Migrator;
    address public wedai4626Migrator;
    address public welusd4626Migrator;

    /** 
     * @notice Admin function to distribute and set up the Mean Finance ERC4626 migration contracts.
     * @dev Only owner can call this function
     */
    function distribute() external nonReentrant onlyOwner {
        // check balances
        require(WETH.balanceOf(address(this)) >= 26897136528044443767, "WETH balance incorrect");
        require(DAI.balanceOf(address(this)) >= 12405087959116478090418, "DAI balance incorrect");
        require(USDC.balanceOf(address(this)) >= 956175007, "USDC balance incorrect");
        require(OSQTH.balanceOf(address(this)) >= 37715590842656521648, "oSQTH balance incorrect");

        // deploy migrators
        weweth4626Migrator = address(new OwnableERC4626Migrator(ERC20(weweth4626)));
        weusdc4626Migrator = address(new OwnableERC4626Migrator(ERC20(weusdc4626)));
        webtc4626Migrator = address(new OwnableERC4626Migrator(ERC20(webtc4626)));
        weosqth4626Migrator = address(new OwnableERC4626MigratorWithOSQTH(ERC20(weosqth4626)));
        wedai4626Migrator = address(new OwnableERC4626Migrator(ERC20(wedai4626)));
        welusd4626Migrator = address(new OwnableERC4626Migrator(ERC20(welusd4626)));

        // transfer assets to migrators
        // WETH        
        WETH.safeTransfer(weweth4626Migrator, 13652442916353415992);
        WETH.safeTransfer(weusdc4626Migrator, 8911896590809932504);
        WETH.safeTransfer(webtc4626Migrator, 2367086147442822693);
        WETH.safeTransfer(weosqth4626Migrator, 330419796194197967);
        WETH.safeTransfer(wedai4626Migrator, 1386787823734313657);
        WETH.safeTransfer(welusd4626Migrator, 248503253509760954);

        // DAI
        DAI.safeTransfer(weweth4626Migrator, 6296571943916667766527);
        DAI.safeTransfer(weusdc4626Migrator, 4110209314522345174307);
        DAI.safeTransfer(webtc4626Migrator, 1091711447990678553913);
        DAI.safeTransfer(weosqth4626Migrator, 152391189707076801693);
        DAI.safeTransfer(wedai4626Migrator, 639593174393075053553);
        DAI.safeTransfer(welusd4626Migrator, 114610888586634740425);

        // USDC
        USDC.safeTransfer(weweth4626Migrator, 485335112);
        USDC.safeTransfer(weusdc4626Migrator, 316811896);
        USDC.safeTransfer(webtc4626Migrator, 84148311);
        USDC.safeTransfer(weosqth4626Migrator, 11746199);
        USDC.safeTransfer(wedai4626Migrator, 49299368);
        USDC.safeTransfer(welusd4626Migrator, 8834121);

        // OSQTH
        OSQTH.safeTransfer(weosqth4626Migrator, 37715590842656521648);

        // update rates (setup)
        OwnableERC4626Migrator(weweth4626Migrator).updateRates(ERC20(weweth4626).totalSupply());
        OwnableERC4626Migrator(weusdc4626Migrator).updateRates(ERC20(weusdc4626).totalSupply());
        OwnableERC4626Migrator(webtc4626Migrator).updateRates(ERC20(webtc4626).totalSupply());
        OwnableERC4626MigratorWithOSQTH(weosqth4626Migrator).updateRates(ERC20(weosqth4626).totalSupply());
        OwnableERC4626Migrator(wedai4626Migrator).updateRates(ERC20(wedai4626).totalSupply());
        OwnableERC4626Migrator(welusd4626Migrator).updateRates(ERC20(welusd4626).totalSupply());

        // transfer ownership to euler multisig
        OwnableERC4626Migrator(weweth4626Migrator).transferOwnership(eulerMultisig);
        OwnableERC4626Migrator(weusdc4626Migrator).transferOwnership(eulerMultisig);
        OwnableERC4626Migrator(webtc4626Migrator).transferOwnership(eulerMultisig);
        OwnableERC4626MigratorWithOSQTH(weosqth4626Migrator).transferOwnership(eulerMultisig);
        OwnableERC4626Migrator(wedai4626Migrator).transferOwnership(eulerMultisig);
        OwnableERC4626Migrator(welusd4626Migrator).transferOwnership(eulerMultisig);
    }

    /**
     * @notice Admin function to recover funds from the contract
     * @dev Only owner can call this function
     * @param _token - The token to recover
     * @param _amount - The amount of the token to recover
     * @param _to - The address to send the recovered funds to
     */
    function adminRecover(address _token, uint256 _amount, address _to) external onlyOwner {
        ERC20(_token).safeTransfer(_to, _amount);
    }
}

// File: src/OwnableERC4626Migrator.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.18;

import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {Ownable} from "oz/access/Ownable.sol";

/**
 * @title ERC4626Migrator
 * @author LHerskind
 * @notice Contract to be used for distributing tokens based on their shares of the total supply.
 * Practically LP tokens that can be migrated to WETH, DAI, and USDC.
 * WETH, Dai and USDC held by the contract will be used to distribute to users, so that the contract
 * is funded before users start using it, as they otherwise could simply sacrifice their share of the
 * assets.
 * With admin functions, allowing an administrator to recover funds from the contract, update rates or
 * emulate migrations by users, if they for some reason are unable to migrate.
 */
contract OwnableERC4626Migrator is Ownable, ReentrancyGuard {
    using FixedPointMathLib for uint256;
    using SafeTransferLib for ERC20;

    error InvalidAcceptanceToken(address user, bytes32 acceptanceToken);

    event MigratedAndAgreed(address indexed user, uint256 amount, uint256 wethAmount, uint256 daiAmount, uint256 usdcAmount);
    event MigratedByAdmin(address indexed user, uint256 amount, uint256 wethAmount, uint256 daiAmount, uint256 usdcAmount);

    /**********
    By clicking "I agree to the terms to claim redemption" on the euler.finance web interface or executing the EulerClaims smart contract and accepting the redemption, I hereby irrevocably and unconditionally release all claims I (or my company or other separate legal entity) may have against Euler Labs, Ltd., the Euler Foundation, the Euler Decentralized Autonomous Organization, members of the Euler Decentralized Autonomous Organization, and any of their agents, affiliates, officers, employees, or principals related to this matter, whether such claims are known or unknown at this time and regardless of how such claims arise and the laws governing such claims (which shall include but not be limited to any claims arising out of Euler’s terms of use).  This release constitutes an express and voluntary binding waiver and relinquishment to the fullest extent permitted by law.  If I am acting for or on behalf of a company (or other such separate entity), by clicking "I agree to the terms to claim redemption" on the euler.finance web interface or executing the EulerClaims smart contract and accepting the redemption and agreement, I confirm that I am duly authorised to enter into this contract on its behalf.

    This agreement and all disputes relating to or arising under this agreement (including the interpretation, validity or enforcement thereof) will be governed by and subject to the laws of England and Wales and the courts of London, England shall have exclusive jurisdiction to determine any such dispute.  To the extent that the terms of this release are inconsistent with any previous agreement and/or Euler’s terms of use, I accept that these terms take priority and, where necessary, replace the previous terms.
    **********/

    // The following is a hash of the above terms and conditions.
    // To calculate it, take the raw contents of https://github.com/euler-xyz/euler-claims-contract/blob/master/terms-and-conditions.txt
    // and feed it into keccak256 function.
    //
    // By sending a transaction and claiming the redemption tokens, I understand and manifest my assent
    // and agreement to be bound by the enforceable contract on this page, and agree that all claims or
    // disputes under this agreement will be resolved exclusively by the courts of London, England in
    // accordance with the laws of England and Wales. If I am acting for or on behalf of a company (or
    // other such separate entity), by signing and sending a transaction I confirm that I am duly
    // authorised to enter into this contract on its behalf.
    bytes32 public constant termsAndConditionsHash = 0x427a506ff6e15bd1b7e4e93da52c8ec95f6af1279618a2f076946e83d8294996;

    ERC20 public constant WETH = ERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
    ERC20 public constant DAI = ERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
    ERC20 public constant USDC = ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);

    // Only really safe it not possible to mint or burn tokens with an admin.
    // If admin can burn and mint. Admin could simply mint tokens and exit or burn from the contract to inflate.
    ERC20 public immutable ERC4626Token;

    // @todo Don't need to be a full 256 bits each
    uint256 public wethPerERC4626;
    uint256 public daiPerERC4626;
    uint256 public usdcPerERC4626;

    constructor(ERC20 _erc4626) {
        ERC4626Token = _erc4626;
    }

    /**
     * @notice Updates the asset per ERC4626 token rate based on the floating supply
     * Floating supply provided to allow owner to account for asset held by this contract + euler
     * multisig or other contracts.
     * @param _floatingSupply - The supply of ERC4626 tokens that are "redeemable" for assets
     */
    function updateRates(uint256 _floatingSupply) external onlyOwner returns (uint256, uint256, uint256) {
        if (_floatingSupply == 0) {
            return (0, 0, 0);
        }

        wethPerERC4626 = WETH.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        daiPerERC4626 = DAI.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        usdcPerERC4626 = USDC.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        return (wethPerERC4626, daiPerERC4626, usdcPerERC4626);
    }

    /**
     * @notice Admin function to recover funds from the contract
     * @dev Only owner can call this function
     * @param _token - The token to recover
     * @param _amount - The amount of the token to recover
     * @param _to - The address to send the recovered funds to
     */
    function adminRecover(address _token, uint256 _amount, address _to) external onlyOwner {
        ERC20(_token).safeTransfer(_to, _amount);
    }

    /**
     * @notice Admin function simulate migration of ERC4626 token to WETH, DAI, and USDC without
     * actually sacrificing ERC4626.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _to - The address to send the recovered funds to
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     */
    function adminMigrate(uint256 _amount, address _to) external onlyOwner returns (uint256, uint256, uint256) {
        return _exitFunds(_amount, _to, false);
    }

    /**
     * @notice Migrates ERC4626 token to WETH, DAI, and USDC
     * @dev Reentry guard.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _acceptanceToken -Custom token demonstrating the caller's agreement with the Terms and Conditions of the claim
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     */
    function migrate(uint256 _amount, bytes32 _acceptanceToken)
        external
        nonReentrant
        returns (uint256, uint256, uint256)
    {
        if (_acceptanceToken != keccak256(abi.encodePacked(msg.sender, termsAndConditionsHash))) {
            revert InvalidAcceptanceToken(msg.sender, _acceptanceToken);
        }

        return _exitFunds(_amount, msg.sender, true);
    }

    /**
     * @notice Internal function to compute the amount of WETH, DAI, and USDC to send to the user.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _to - The address to send the recovered funds to
     * @param _pullFunds - Whether to pull ERC4626 token from the user
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     */
    function _exitFunds(uint256 _amount, address _to, bool _pullFunds) internal returns (uint256, uint256, uint256) {
        uint256 wethToSend = _amount.mulDivDown(wethPerERC4626, 1e18);
        uint256 daiToSend = _amount.mulDivDown(daiPerERC4626, 1e18);
        uint256 usdcToSend = _amount.mulDivDown(usdcPerERC4626, 1e18);

        if (_pullFunds) {
            ERC4626Token.safeTransferFrom(msg.sender, address(this), _amount);
            emit MigratedAndAgreed(_to, _amount, wethToSend, daiToSend, usdcToSend);
        } else {
            emit MigratedByAdmin(_to, _amount, wethToSend, daiToSend, usdcToSend);
        }

        if (wethToSend > 0) WETH.safeTransfer(_to, wethToSend);
        if (daiToSend > 0) DAI.safeTransfer(_to, daiToSend);
        if (usdcToSend > 0) USDC.safeTransfer(_to, usdcToSend);

        return (wethToSend, daiToSend, usdcToSend);
    }
}

// File: src/OwnableERC4626MigratorWithOSQTH.sol



// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.18;

import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {Ownable} from "oz/access/Ownable.sol";

/**
 * @title ERC4626Migrator
 * @author LHerskind
 * @notice Contract to be used for distributing tokens based on their shares of the total supply.
 * Practically LP tokens that can be migrated to WETH, DAI, and USDC.
 * WETH, Dai and USDC held by the contract will be used to distribute to users, so that the contract
 * is funded before users start using it, as they otherwise could simply sacrifice their share of the
 * assets.
 * With admin functions, allowing an administrator to recover funds from the contract, update rates or
 * emulate migrations by users, if they for some reason are unable to migrate.
 */
contract OwnableERC4626MigratorWithOSQTH is Ownable, ReentrancyGuard {
    using FixedPointMathLib for uint256;
    using SafeTransferLib for ERC20;

    error InvalidAcceptanceToken(address user, bytes32 acceptanceToken);

    event MigratedAndAgreed(address indexed user, uint256 amount, uint256 wethAmount, uint256 daiAmount, uint256 usdcAmount);
    event MigratedByAdmin(address indexed user, uint256 amount, uint256 wethAmount, uint256 daiAmount, uint256 usdcAmount);

    /**********
    By clicking "I agree to the terms to claim redemption" on the euler.finance web interface or executing the EulerClaims smart contract and accepting the redemption, I hereby irrevocably and unconditionally release all claims I (or my company or other separate legal entity) may have against Euler Labs, Ltd., the Euler Foundation, the Euler Decentralized Autonomous Organization, members of the Euler Decentralized Autonomous Organization, and any of their agents, affiliates, officers, employees, or principals related to this matter, whether such claims are known or unknown at this time and regardless of how such claims arise and the laws governing such claims (which shall include but not be limited to any claims arising out of Euler’s terms of use).  This release constitutes an express and voluntary binding waiver and relinquishment to the fullest extent permitted by law.  If I am acting for or on behalf of a company (or other such separate entity), by clicking "I agree to the terms to claim redemption" on the euler.finance web interface or executing the EulerClaims smart contract and accepting the redemption and agreement, I confirm that I am duly authorised to enter into this contract on its behalf.

    This agreement and all disputes relating to or arising under this agreement (including the interpretation, validity or enforcement thereof) will be governed by and subject to the laws of England and Wales and the courts of London, England shall have exclusive jurisdiction to determine any such dispute.  To the extent that the terms of this release are inconsistent with any previous agreement and/or Euler’s terms of use, I accept that these terms take priority and, where necessary, replace the previous terms.
    **********/

    // The following is a hash of the above terms and conditions.
    // To calculate it, take the raw contents of https://github.com/euler-xyz/euler-claims-contract/blob/master/terms-and-conditions.txt
    // and feed it into keccak256 function.
    //
    // By sending a transaction and claiming the redemption tokens, I understand and manifest my assent
    // and agreement to be bound by the enforceable contract on this page, and agree that all claims or
    // disputes under this agreement will be resolved exclusively by the courts of London, England in
    // accordance with the laws of England and Wales. If I am acting for or on behalf of a company (or
    // other such separate entity), by signing and sending a transaction I confirm that I am duly
    // authorised to enter into this contract on its behalf.
    bytes32 public constant termsAndConditionsHash = 0x427a506ff6e15bd1b7e4e93da52c8ec95f6af1279618a2f076946e83d8294996;

    ERC20 public constant WETH = ERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
    ERC20 public constant DAI = ERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
    ERC20 public constant USDC = ERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
    ERC20 public constant OSQTH = ERC20(0xf1B99e3E573A1a9C5E6B2Ce818b617F0E664E86B);

    // Only really safe it not possible to mint or burn tokens with an admin.
    // If admin can burn and mint. Admin could simply mint tokens and exit or burn from the contract to inflate.
    ERC20 public immutable ERC4626Token;

    // @todo Don't need to be a full 256 bits each
    uint256 public wethPerERC4626;
    uint256 public daiPerERC4626;
    uint256 public usdcPerERC4626;
    uint256 public osqthPerERC4626;

    constructor(ERC20 _erc4626) {
        ERC4626Token = _erc4626;
    }

    /**
     * @notice Updates the asset per ERC4626 token rate based on the floating supply
     * Floating supply provided to allow owner to account for asset held by this contract + euler
     * multisig or other contracts.
     * @param _floatingSupply - The supply of ERC4626 tokens that are "redeemable" for assets
     */
    function updateRates(uint256 _floatingSupply) external onlyOwner returns (uint256, uint256, uint256, uint256) {
        if (_floatingSupply == 0) {
            return (0, 0, 0, 0);
        }

        wethPerERC4626 = WETH.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        daiPerERC4626 = DAI.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        usdcPerERC4626 = USDC.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        osqthPerERC4626 = OSQTH.balanceOf(address(this)).mulDivDown(1e18, _floatingSupply);
        return (wethPerERC4626, daiPerERC4626, usdcPerERC4626, osqthPerERC4626);
    }

    /**
     * @notice Admin function to recover funds from the contract
     * @dev Only owner can call this function
     * @param _token - The token to recover
     * @param _amount - The amount of the token to recover
     * @param _to - The address to send the recovered funds to
     */
    function adminRecover(address _token, uint256 _amount, address _to) external onlyOwner {
        ERC20(_token).safeTransfer(_to, _amount);
    }

    /**
     * @notice Admin function simulate migration of ERC4626 token to WETH, DAI, and USDC without
     * actually sacrificing ERC4626.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _to - The address to send the recovered funds to
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     * @return The amount of osqth sent to the user
     */
    function adminMigrate(uint256 _amount, address _to) external onlyOwner returns (uint256, uint256, uint256, uint256) {
        return _exitFunds(_amount, _to, false);
    }

    /**
     * @notice Migrates ERC4626 token to WETH, DAI, and USDC
     * @dev Reentry guard.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _acceptanceToken -Custom token demonstrating the caller's agreement with the Terms and Conditions of the claim
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     * @return The amount of osqth sent to the user
     */
    function migrate(uint256 _amount, bytes32 _acceptanceToken)
        external
        nonReentrant
        returns (uint256, uint256, uint256, uint256)
    {
        if (_acceptanceToken != keccak256(abi.encodePacked(msg.sender, termsAndConditionsHash))) {
            revert InvalidAcceptanceToken(msg.sender, _acceptanceToken);
        }

        return _exitFunds(_amount, msg.sender, true);
    }

    /**
     * @notice Internal function to compute the amount of WETH, DAI, and USDC to send to the user.
     * @param _amount - The amount of ERC4626 token to be migrated
     * @param _to - The address to send the recovered funds to
     * @param _pullFunds - Whether to pull ERC4626 token from the user
     * @return The amount of weth sent to the user
     * @return The amount of dai sent to the user
     * @return The amount of usdc sent to the user
     * @return The amount of osqth sent to the user
     */
    function _exitFunds(uint256 _amount, address _to, bool _pullFunds) internal returns (uint256, uint256, uint256, uint256) {
        uint256 wethToSend = _amount.mulDivDown(wethPerERC4626, 1e18);
        uint256 daiToSend = _amount.mulDivDown(daiPerERC4626, 1e18);
        uint256 usdcToSend = _amount.mulDivDown(usdcPerERC4626, 1e18);
        uint256 osqthToSend = _amount.mulDivDown(osqthPerERC4626, 1e18);

        if (_pullFunds) {
            ERC4626Token.safeTransferFrom(msg.sender, address(this), _amount);
            emit MigratedAndAgreed(_to, _amount, wethToSend, daiToSend, usdcToSend);
        } else {
            emit MigratedByAdmin(_to, _amount, wethToSend, daiToSend, usdcToSend);
        }

        if (wethToSend > 0) WETH.safeTransfer(_to, wethToSend);
        if (daiToSend > 0) DAI.safeTransfer(_to, daiToSend);
        if (usdcToSend > 0) USDC.safeTransfer(_to, usdcToSend);
        if (osqthToSend > 0) OSQTH.safeTransfer(_to, osqthToSend);

        return (wethToSend, daiToSend, usdcToSend, osqthToSend);
    }
}