Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
import "@layerzerolabs/solidity-examples/contracts/token/oft/IOFTCore.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SwapAndBridgeUniswapV3 {
    uint24 public constant poolFee = 3000; // 0.3%

    IUniversalRouter public immutable universalRouter;
    address public immutable weth;
	IOFTCore public immutable oft;

    constructor(address _weth, address _oft, address _universalRouter) {
        require(_weth != address(0), "SwappableBridge: invalid WETH address");
        require(_oft != address(0), "SwappableBridge: invalid OFT address");
        require(_universalRouter != address(0), "SwappableBridge: invalid Universal Router address");

        weth = _weth;
        oft = IOFTCore(_oft);
        universalRouter = IUniversalRouter(_universalRouter);
    }

    function swapAndBridge(uint amountIn, uint amountOutMin, uint16 dstChainId, address to, address payable refundAddress, address zroPaymentAddress, bytes calldata adapterParams) external payable {
        require(to != address(0), "SwappableBridge: invalid to address");
        require(msg.value >= amountIn, "SwappableBridge: not enough value sent");

        // 1) commands
        // 0x0b == WRAP_ETH ... https://docs.uniswap.org/contracts/universal-router/technical-reference#wrap_eth
        // 0x00 == V3_SWAP_EXACT_IN... https://docs.uniswap.org/contracts/universal-router/technical-reference#v3_swap_exact_in
        bytes memory commands = hex"0b00";

        // 2) inputs
        bytes[] memory inputs = new bytes[](2);
        // For weth deposit
        inputs[0] = abi.encode(
            address(universalRouter), // recipient
            amountIn // amount
        );
        // For token swap
        inputs[1] = abi.encode(
            address(this), // recipient
            amountIn, // amount input
            amountOutMin, // min amount output
            // pathway(inputToken, poolFee, outputToken)
            abi.encodePacked(weth, poolFee, address(oft)),
            false
        );

        // 3) deadline
        uint256 deadline = block.timestamp;

        // Call execute on the universal Router
        universalRouter.execute{value: amountIn}(commands, inputs, deadline);

        // check balance after to see how many tokens we received
        uint256 amountReceived = IERC20(address(oft)).balanceOf(address(this));
        // redundant check to ensure we received enough tokens
        require(amountReceived >= amountOutMin, "SwappableBridge: insufficient amount received");

        oft.sendFrom{value: msg.value - amountIn}(
            address(this),
            dstChainId,
            abi.encodePacked(to),
            amountReceived,
            refundAddress,
            zroPaymentAddress,
            adapterParams
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.15;

import {ERC20} from 'solmate/src/tokens/ERC20.sol';

/// @title LooksRare Rewards Collector
/// @notice Implements a permissionless call to fetch LooksRare rewards earned by Universal Router users
/// and transfers them to an external rewards distributor contract
interface IRewardsCollector {
    /// @notice Fetches users' LooksRare rewards and sends them to the distributor contract
    /// @param looksRareClaim The data required by LooksRare to claim reward tokens
    function collectRewards(bytes calldata looksRareClaim) external;
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.17;

import {IERC721Receiver} from '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import {IERC1155Receiver} from '@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol';
import {IRewardsCollector} from './IRewardsCollector.sol';

interface IUniversalRouter is IRewardsCollector, IERC721Receiver, IERC1155Receiver {
    /// @notice Thrown when a required command has failed
    error ExecutionFailed(uint256 commandIndex, bytes message);

    /// @notice Thrown when attempting to send ETH directly to the contract
    error ETHNotAccepted();

    /// @notice Thrown when executing commands with an expired deadline
    error TransactionDeadlinePassed();

    /// @notice Thrown when attempting to execute commands and an incorrect number of inputs are provided
    error LengthMismatch();

    /// @notice Executes encoded commands along with provided inputs. Reverts if deadline has expired.
    /// @param commands A set of concatenated commands, each 1 byte in length
    /// @param inputs An array of byte strings containing abi encoded inputs for each command
    /// @param deadline The deadline by which the transaction must be executed
    function execute(bytes calldata commands, bytes[] calldata inputs, uint256 deadline) external payable;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.5.0;

import "@openzeppelin/contracts/utils/introspection/IERC165.sol";

/**
 * @dev Interface of the IOFT core standard
 */
interface IOFTCore is IERC165 {
    /**
     * @dev estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`)
     * _dstChainId - L0 defined chain id to send tokens too
     * _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain
     * _amount - amount of the tokens to transfer
     * _useZro - indicates to use zro to pay L0 fees
     * _adapterParam - flexible bytes array to indicate messaging adapter services in L0
     */
    function estimateSendFee(uint16 _dstChainId, bytes calldata _toAddress, uint _amount, bool _useZro, bytes calldata _adapterParams) external view returns (uint nativeFee, uint zroFee);

    /**
     * @dev send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from`
     * `_from` the owner of token
     * `_dstChainId` the destination chain identifier
     * `_toAddress` can be any size depending on the `dstChainId`.
     * `_amount` the quantity of tokens in wei
     * `_refundAddress` the address LayerZero refunds if too much message fee is sent
     * `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token)
     * `_adapterParams` is a flexible bytes array to indicate messaging adapter services
     */
    function sendFrom(address _from, uint16 _dstChainId, bytes calldata _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;

    /**
     * @dev returns the circulating amount of tokens on current chain
     */
    function circulatingSupply() external view returns (uint);

    /**
     * @dev returns the address of the ERC20 token
     */
    function token() external view returns (address);

    /**
     * @dev Emitted when `_amount` tokens are moved from the `_sender` to (`_dstChainId`, `_toAddress`)
     * `_nonce` is the outbound nonce
     */
    event SendToChain(uint16 indexed _dstChainId, address indexed _from, bytes _toAddress, uint _amount);

    /**
     * @dev Emitted when `_amount` tokens are received from `_srcChainId` into the `_toAddress` on the local chain.
     * `_nonce` is the inbound nonce.
     */
    event ReceiveFromChain(uint16 indexed _srcChainId, address indexed _to, uint _amount);

    event SetUseCustomAdapterParams(bool _useCustomAdapterParams);
}

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

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_weth","type":"address"},{"internalType":"address","name":"_oft","type":"address"},{"internalType":"address","name":"_universalRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"oft","outputs":[{"internalType":"contract IOFTCore","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolFee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"uint16","name":"dstChainId","type":"uint16"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address payable","name":"refundAddress","type":"address"},{"internalType":"address","name":"zroPaymentAddress","type":"address"},{"internalType":"bytes","name":"adapterParams","type":"bytes"}],"name":"swapAndBridge","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"universalRouter","outputs":[{"internalType":"contract IUniversalRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x60806040526004361061004a5760003560e01c8063089fe6aa1461004f57806335a9e4df1461007e5780633fc8cef3146100ca5780639b5215f6146100fe578063ae30f6ee14610132575b600080fd5b34801561005b57600080fd5b50610065610bb881565b60405162ffffff90911681526020015b60405180910390f35b34801561008a57600080fd5b506100b27f0000000000000000000000003fc91a3afd70395cd496c647d5a6cc9d4b2b7fad81565b6040516001600160a01b039091168152602001610075565b3480156100d657600080fd5b506100b27f00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab181565b34801561010a57600080fd5b506100b27f000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d481565b610145610140366004610600565b610147565b005b6001600160a01b0385166101ae5760405162461bcd60e51b815260206004820152602360248201527f537761707061626c654272696467653a20696e76616c696420746f206164647260448201526265737360e81b60648201526084015b60405180910390fd5b8734101561020d5760405162461bcd60e51b815260206004820152602660248201527f537761707061626c654272696467653a206e6f7420656e6f7567682076616c7560448201526519481cd95b9d60d21b60648201526084016101a5565b6040805180820182526002808252600b60f81b60208301528251818152606081019093529091600091816020015b606081526020019060019003908161023b57905050604080516001600160a01b037f0000000000000000000000003fc91a3afd70395cd496c647d5a6cc9d4b2b7fad1660208201529081018c9052909150606001604051602081830303815290604052816000815181106102b1576102b16106d7565b6020026020010181905250308a8a7f00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1610bb87f000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d460405160200161034c93929190606093841b6bffffffffffffffffffffffff19908116825260e89390931b6001600160e81b0319166014820152921b166017820152602b0190565b60408051601f198184030181529082905261036f94939291600090602001610733565b60405160208183030381529060405281600181518110610391576103916106d7565b6020908102919091010152604051630d64d59360e21b815242906001600160a01b037f0000000000000000000000003fc91a3afd70395cd496c647d5a6cc9d4b2b7fad1690633593564c908d906103f090879087908790600401610774565b6000604051808303818588803b15801561040957600080fd5b505af115801561041d573d6000803e3d6000fd5b50506040516370a0823160e01b8152306004820152600093507f000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d46001600160a01b031692506370a082319150602401602060405180830381865afa158015610489573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104ad91906107ef565b90508a8110156105155760405162461bcd60e51b815260206004820152602d60248201527f537761707061626c654272696467653a20696e73756666696369656e7420616d60448201526c1bdd5b9d081c9958d95a5d9959609a1b60648201526084016101a5565b6001600160a01b037f000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d416635190563661054e8e34610808565b6040516bffffffffffffffffffffffff1960608e901b16602082015230908e90603401604051602081830303815290604052868e8e8e8e6040518a63ffffffff1660e01b81526004016105a898979695949392919061082f565b6000604051808303818588803b1580156105c157600080fd5b505af11580156105d5573d6000803e3d6000fd5b5050505050505050505050505050505050565b6001600160a01b03811681146105fd57600080fd5b50565b60008060008060008060008060e0898b03121561061c57600080fd5b8835975060208901359650604089013561ffff8116811461063c57600080fd5b9550606089013561064c816105e8565b9450608089013561065c816105e8565b935060a089013561066c816105e8565b925060c089013567ffffffffffffffff8082111561068957600080fd5b818b0191508b601f83011261069d57600080fd5b8135818111156106ac57600080fd5b8c60208285010111156106be57600080fd5b6020830194508093505050509295985092959890939650565b634e487b7160e01b600052603260045260246000fd5b6000815180845260005b81811015610713576020818501810151868301820152016106f7565b506000602082860101526020601f19601f83011685010191505092915050565b60018060a01b038616815284602082015283604082015260a06060820152600061076060a08301856106ed565b905082151560808301529695505050505050565b60608152600061078760608301866106ed565b6020838203818501528186518084528284019150828160051b85010183890160005b838110156107d757601f198784030185526107c58383516106ed565b948601949250908501906001016107a9565b50508095505050505050826040830152949350505050565b60006020828403121561080157600080fd5b5051919050565b8181038181111561082957634e487b7160e01b600052601160045260246000fd5b92915050565b600060018060a01b03808b16835261ffff8a16602084015260e0604084015261085b60e084018a6106ed565b886060850152818816608085015281871660a085015283810360c0850152848152848660208301376000602086830101526020601f19601f87011682010192505050999850505050505050505056fea2646970667358221220f91508e23345baa7a2ef4eb13a8b534ff980f461442b2a15b46061c9fae50d1764736f6c63430008110033

00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d40000000000000000000000003fc91a3afd70395cd496c647d5a6cc9d4b2b7fad

-----Decoded View---------------
Arg [0] : _weth (address): 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1
Arg [1] : _oft (address): 0xE71bDfE1Df69284f00EE185cf0d95d0c7680c0d4
Arg [2] : _universalRouter (address): 0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1
Arg [1] : 000000000000000000000000e71bdfe1df69284f00ee185cf0d95d0c7680c0d4
Arg [2] : 0000000000000000000000003fc91a3afd70395cd496c647d5a6cc9d4b2b7fad

269:2646:7:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;307:37;;;;;;;;;;;;340:4;307:37;;;;;188:8:9;176:21;;;158:40;;146:2;131:18;307:37:7;;;;;;;;359:49;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;397:32:9;;;379:51;;367:2;352:18;359:49:7;209:227:9;414:29:7;;;;;;;;;;;;;;;446;;;;;;;;;;;;;;;935:1978;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1146:16:7;;1138:64;;;;-1:-1:-1;;;1138:64:7;;2537:2:9;1138:64:7;;;2519:21:9;2576:2;2556:18;;;2549:30;2615:34;2595:18;;;2588:62;-1:-1:-1;;;2666:18:9;;;2659:33;2709:19;;1138:64:7;;;;;;;;;1233:8;1220:9;:21;;1212:72;;;;-1:-1:-1;;;1212:72:7;;2941:2:9;1212:72:7;;;2923:21:9;2980:2;2960:18;;;2953:30;3019:34;2999:18;;;2992:62;-1:-1:-1;;;3070:18:9;;;3063:36;3116:19;;1212:72:7;2739:402:9;1212:72:7;1559:33;;;;;;;;;;;;-1:-1:-1;;;1559:33:7;;;;1648:14;;;;;;;;;;;1559:33;;-1:-1:-1;;1648:14:7;;;;;;;;;;;;;;;;;;;-1:-1:-1;1712:103:7;;;-1:-1:-1;;;;;1744:15:7;3470:32:9;1712:103:7;;;3452:51:9;3519:18;;;3512:34;;;1624:38:7;;-1:-1:-1;3425:18:9;;1712:103:7;;;;;;;;;;;;1700:6;1707:1;1700:9;;;;;;;;:::i;:::-;;;;;;:115;;;;1895:4;1927:8;1965:12;2086:4;340;2109:3;2069:45;;;;;;;;;3942:2:9;3938:15;;;-1:-1:-1;;3934:24:9;;;3922:37;;4015:3;3993:16;;;;-1:-1:-1;;;;;;3989:41:9;3984:2;3975:12;;3968:63;4065:15;;4061:24;4056:2;4047:12;;4040:46;4111:2;4102:12;;3689:431;2069:45:7;;;;-1:-1:-1;;2069:45:7;;;;;;;;;;1863:280;;;;;2128:5;;2069:45;1863:280;;:::i;:::-;;;;;;;;;;;;;1851:6;1858:1;1851:9;;;;;;;;:::i;:::-;;;;;;;;;;:292;2270:68;;-1:-1:-1;;;2270:68:7;;2196:15;;-1:-1:-1;;;;;2270:15:7;:23;;;;2301:8;;2270:68;;2311:8;;2321:6;;2196:15;;2270:68;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2440:45:7;;-1:-1:-1;;;2440:45:7;;2479:4;2440:45;;;379:51:9;2415:22:7;;-1:-1:-1;2455:3:7;-1:-1:-1;;;;;2440:30:7;;-1:-1:-1;2440:30:7;;-1:-1:-1;352:18:9;;2440:45:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2415:70;;2584:12;2566:14;:30;;2558:88;;;;-1:-1:-1;;;2558:88:7;;6486:2:9;2558:88:7;;;6468:21:9;6525:2;6505:18;;;6498:30;6564:34;6544:18;;;6537:62;-1:-1:-1;;;6615:18:9;;;6608:43;6668:19;;2558:88:7;6284:409:9;2558:88:7;-1:-1:-1;;;;;2657:3:7;:12;;2677:20;2689:8;2677:9;:20;:::i;:::-;2763;;-1:-1:-1;;7077:2:9;7073:15;;;7069:53;2763:20:7;;;7057:66:9;2720:4:7;;2739:10;;7139:12:9;;2763:20:7;;;;;;;;;;;;2797:14;2825:13;2852:17;2883:13;;2657:249;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1128:1785;;;;935:1978;;;;;;;;:::o;872:131:9:-;-1:-1:-1;;;;;947:31:9;;937:42;;927:70;;993:1;990;983:12;927:70;872:131;:::o;1008:1322::-;1139:6;1147;1155;1163;1171;1179;1187;1195;1248:3;1236:9;1227:7;1223:23;1219:33;1216:53;;;1265:1;1262;1255:12;1216:53;1301:9;1288:23;1278:33;;1358:2;1347:9;1343:18;1330:32;1320:42;;1412:2;1401:9;1397:18;1384:32;1456:6;1449:5;1445:18;1438:5;1435:29;1425:57;;1478:1;1475;1468:12;1425:57;1501:5;-1:-1:-1;1558:2:9;1543:18;;1530:32;1571:33;1530:32;1571:33;:::i;:::-;1623:7;-1:-1:-1;1682:3:9;1667:19;;1654:33;1696;1654;1696;:::i;:::-;1748:7;-1:-1:-1;1807:3:9;1792:19;;1779:33;1821;1779;1821;:::i;:::-;1873:7;-1:-1:-1;1931:3:9;1916:19;;1903:33;1955:18;1985:14;;;1982:34;;;2012:1;2009;2002:12;1982:34;2050:6;2039:9;2035:22;2025:32;;2095:7;2088:4;2084:2;2080:13;2076:27;2066:55;;2117:1;2114;2107:12;2066:55;2157:2;2144:16;2183:2;2175:6;2172:14;2169:34;;;2199:1;2196;2189:12;2169:34;2244:7;2239:2;2230:6;2226:2;2222:15;2218:24;2215:37;2212:57;;;2265:1;2262;2255:12;2212:57;2296:2;2292;2288:11;2278:21;;2318:6;2308:16;;;;;1008:1322;;;;;;;;;;;:::o;3557:127::-;3618:10;3613:3;3609:20;3606:1;3599:31;3649:4;3646:1;3639:15;3673:4;3670:1;3663:15;4125:422;4166:3;4204:5;4198:12;4231:6;4226:3;4219:19;4256:1;4266:162;4280:6;4277:1;4274:13;4266:162;;;4342:4;4398:13;;;4394:22;;4388:29;4370:11;;;4366:20;;4359:59;4295:12;4266:162;;;4270:3;4473:1;4466:4;4457:6;4452:3;4448:16;4444:27;4437:38;4536:4;4529:2;4525:7;4520:2;4512:6;4508:15;4504:29;4499:3;4495:39;4491:50;4484:57;;;4125:422;;;;:::o;4552:540::-;4834:1;4830;4825:3;4821:11;4817:19;4809:6;4805:32;4794:9;4787:51;4874:6;4869:2;4858:9;4854:18;4847:34;4917:6;4912:2;4901:9;4897:18;4890:34;4960:3;4955:2;4944:9;4940:18;4933:31;4768:4;4981:45;5021:3;5010:9;5006:19;4998:6;4981:45;:::i;:::-;4973:53;;5077:6;5070:14;5063:22;5057:3;5046:9;5042:19;5035:51;4552:540;;;;;;;;:::o;5097:993::-;5368:2;5357:9;5350:21;5331:4;5394:44;5434:2;5423:9;5419:18;5411:6;5394:44;:::i;:::-;5457:2;5507:9;5499:6;5495:22;5490:2;5479:9;5475:18;5468:50;5538:6;5573;5567:13;5604:6;5596;5589:22;5639:2;5631:6;5627:15;5620:22;;5698:2;5688:6;5685:1;5681:14;5673:6;5669:27;5665:36;5736:2;5728:6;5724:15;5757:1;5767:251;5781:6;5778:1;5775:13;5767:251;;;5871:2;5867:7;5858:6;5850;5846:19;5842:33;5837:3;5830:46;5899:39;5931:6;5922;5916:13;5899:39;:::i;:::-;5996:12;;;;5889:49;-1:-1:-1;5961:15:9;;;;5803:1;5796:9;5767:251;;;5771:3;;6035:6;6027:14;;;;;;;6077:6;6072:2;6061:9;6057:18;6050:34;5097:993;;;;;;:::o;6095:184::-;6165:6;6218:2;6206:9;6197:7;6193:23;6189:32;6186:52;;;6234:1;6231;6224:12;6186:52;-1:-1:-1;6257:16:9;;6095:184;-1:-1:-1;6095:184:9:o;6698:225::-;6765:9;;;6786:11;;;6783:134;;;6839:10;6834:3;6830:20;6827:1;6820:31;6874:4;6871:1;6864:15;6902:4;6899:1;6892:15;6783:134;6698:225;;;;:::o;7162:991::-;7482:4;7528:1;7524;7519:3;7515:11;7511:19;7569:2;7561:6;7557:15;7546:9;7539:34;7621:6;7613;7609:19;7604:2;7593:9;7589:18;7582:47;7665:3;7660:2;7649:9;7645:18;7638:31;7692:45;7732:3;7721:9;7717:19;7709:6;7692:45;:::i;:::-;7773:6;7768:2;7757:9;7753:18;7746:34;7829:2;7821:6;7817:15;7811:3;7800:9;7796:19;7789:44;7882:2;7874:6;7870:15;7864:3;7853:9;7849:19;7842:44;7935:9;7927:6;7923:22;7917:3;7906:9;7902:19;7895:51;7970:6;7962;7955:22;8024:6;8016;8011:2;8003:6;7999:15;7986:45;8077:1;8072:2;8063:6;8055;8051:19;8047:28;8040:39;8144:2;8137;8133:7;8128:2;8120:6;8116:15;8112:29;8104:6;8100:42;8096:51;8088:59;;;;7162:991;;;;;;;;;;;:::o

ipfs://f91508e23345baa7a2ef4eb13a8b534ff980f461442b2a15b46061c9fae50d17