Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at monadscan.com on 2025-11-26
*/

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

// lib/openzeppelin-contracts/contracts/utils/Context.sol

// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// src/interfaces/IRouter.sol

interface IRouter {
    error Router__DeadlineExceeded();
    error Router__InsufficientOutputAmount(uint256 outputAmount, uint256 minOutputAmount);
    error Router__InsufficientAmountReceived(uint256 balanceBefore, uint256 balanceAfter, uint256 amountOutMin);
    error Router__InvalidTo();
    error Router__ZeroAmount();
    error Router__OnlyWnative();
    error Router__InvalidWnative();
    error Router__IdenticalTokens();
    error Router__LogicAlreadyAdded(address routerLogic);
    error Router__LogicNotFound(address routerLogic);
    error Router__UntrustedLogic(address routerLogic);
    error Router__Simulations(uint256[] amounts);
    error Router__SimulateSingle(uint256 amount);

    event SwapExactIn(
        address indexed sender, address to, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut
    );
    event SwapExactOut(
        address indexed sender, address to, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut
    );
    event RouterLogicUpdated(address indexed routerLogic, bool added);

    function WNATIVE() external view returns (address);
    function getTrustedLogicAt(uint256 index) external view returns (address);
    function getTrustedLogicLength() external view returns (uint256);
    function updateRouterLogic(address routerLogic, bool added) external;
    function swapExactIn(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address to,
        uint256 deadline,
        bytes memory route
    ) external payable returns (uint256, uint256);
    function swapExactOut(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountOut,
        uint256 amountInMax,
        address to,
        uint256 deadline,
        bytes memory route
    ) external payable returns (uint256, uint256);
    function simulate(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address to,
        bool exactIn,
        bytes[] calldata route
    ) external payable;
    function simulateSingle(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address to,
        bool exactIn,
        bytes calldata route
    ) external payable;
}

// lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// src/libraries/TokenLib.sol

/**
 * @title TokenLib
 * @dev Helper library for token operations, such as balanceOf, transfer, transferFrom, wrap, and unwrap.
 */
library TokenLib {
    error TokenLib__BalanceOfFailed();
    error TokenLib__WrapFailed();
    error TokenLib__UnwrapFailed();
    error TokenLib__NativeTransferFailed();
    error TokenLib__TransferFromFailed();
    error TokenLib__TransferFailed();

    /**
     * @dev Returns the balance of a token for an account.
     *
     * Requirements:
     * - The call must succeed.
     * - The target contract must return at least 32 bytes.
     */
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        uint256 success;
        uint256 returnDataSize;

        assembly ("memory-safe") {
            mstore(0, 0x70a08231) // balanceOf(address)
            mstore(32, account)

            success := staticcall(gas(), token, 28, 36, 0, 32)

            returnDataSize := returndatasize()

            amount := mload(0)
        }

        if (success == 0) _tryRevertWithReason();

        // If call failed, and it didn't already bubble up the revert reason, then the return data size must be 0,
        // which will revert here with a generic error message
        if (returnDataSize < 32) revert TokenLib__BalanceOfFailed();
    }

    /**
     * @dev Returns the balance of a token for an account, or the native balance of the account if the token is the native token.
     *
     * Requirements:
     * - The call must succeed (if the token is not the native token).
     * - The target contract must return at least 32 bytes (if the token is not the native token).
     */
    function universalBalanceOf(address token, address account) internal view returns (uint256 amount) {
        return token == address(0) ? account.balance : balanceOf(token, account);
    }

    /**
     * @dev Transfers native tokens to an account.
     *
     * Requirements:
     * - The call must succeed.
     */
    function transferNative(address to, uint256 amount) internal {
        uint256 success;

        assembly ("memory-safe") {
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        if (success == 0) {
            _tryRevertWithReason();
            revert TokenLib__NativeTransferFailed();
        }
    }

    /**
     * @dev Transfers tokens from an account to another account.
     * This function does not check if the target contract has code, this should be done before calling this function
     *
     * Requirements:
     * - The call must succeed.
     */
    function wrap(address wnative, uint256 amount) internal {
        uint256 success;

        assembly ("memory-safe") {
            mstore(0, 0xd0e30db0) // deposit()

            success := call(gas(), wnative, amount, 28, 4, 0, 0)
        }

        if (success == 0) {
            _tryRevertWithReason();
            revert TokenLib__WrapFailed();
        }
    }

    /**
     * @dev Transfers tokens from an account to another account.
     * This function does not check if the target contract has code, this should be done before calling this function
     *
     * Requirements:
     * - The call must succeed.
     */
    function unwrap(address wnative, uint256 amount) internal {
        uint256 success;

        assembly ("memory-safe") {
            mstore(0, 0x2e1a7d4d) // withdraw(uint256)
            mstore(32, amount)

            success := call(gas(), wnative, 0, 28, 36, 0, 0)
        }

        if (success == 0) {
            _tryRevertWithReason();
            revert TokenLib__UnwrapFailed();
        }
    }

    /**
     * @dev Transfers tokens from an account to another account.
     *
     * Requirements:
     * - The call must succeed
     * - The target contract must either return true or no value.
     * - The target contract must have code.
     */
    function transfer(address token, address to, uint256 amount) internal {
        uint256 success;
        uint256 returnSize;
        uint256 returnValue;

        assembly ("memory-safe") {
            let m0x40 := mload(0x40)

            mstore(0, 0xa9059cbb) // transfer(address,uint256)
            mstore(32, to)
            mstore(64, amount)

            success := call(gas(), token, 0, 28, 68, 0, 32)

            returnSize := returndatasize()
            returnValue := mload(0)

            mstore(0x40, m0x40)
        }

        if (success == 0) {
            _tryRevertWithReason();
            revert TokenLib__TransferFailed();
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) revert TokenLib__TransferFailed();
    }

    /**
     * @dev Transfers tokens from an account to another account.
     *
     * Requirements:
     * - The call must succeed.
     * - The target contract must either return true or no value.
     * - The target contract must have code.
     */
    function transferFrom(address token, address from, address to, uint256 amount) internal {
        uint256 success;
        uint256 returnSize;
        uint256 returnValue;

        assembly ("memory-safe") {
            let m0x40 := mload(0x40)
            let m0x60 := mload(0x60)

            mstore(0, 0x23b872dd) // transferFrom(address,address,uint256)
            mstore(32, from)
            mstore(64, to)
            mstore(96, amount)

            success := call(gas(), token, 0, 28, 100, 0, 32)

            returnSize := returndatasize()
            returnValue := mload(0)

            mstore(0x40, m0x40)
            mstore(0x60, m0x60)
        }

        if (success == 0) {
            _tryRevertWithReason();
            revert TokenLib__TransferFromFailed();
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) revert TokenLib__TransferFromFailed();
    }

    /**
     * @dev Tries to bubble up the revert reason.
     * This function needs to be called only if the call has failed, and will revert if there is a revert reason.
     * This function might no revert if there is no revert reason, always use it in conjunction with a revert.
     */
    function _tryRevertWithReason() private pure {
        assembly ("memory-safe") {
            if returndatasize() {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }
        }
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

// src/libraries/RouterLib.sol

/**
 * @title RouterLib
 * @dev Helper library for router operations, such as validateAndTransfer, transfer, and swap.
 * The router must implement a fallback function that uses `validateAndTransfer` to validate the allowance
 * and transfer the tokens and functions that uses `swap` to call the router logic to swap tokens.
 * The router logic must implement the `swapExactIn` and `swapExactOut` functions to swap tokens and
 * use the `transfer` function to transfer tokens from the router according to the route selected.
 */
library RouterLib {
    error RouterLib__ZeroAmount();
    error RouterLib__InsufficientAllowance(uint256 allowance, uint256 amount);

    /**
     * @dev Returns the slot for the allowance of a token for a sender from an address.
     */
    function getAllowanceSlot(
        mapping(bytes32 key => uint256) storage allowances,
        address token,
        address sender,
        address from
    ) internal pure returns (bytes32 s) {
        assembly ("memory-safe") {
            mstore(0, shl(96, token))
            mstore(20, shl(96, sender))

            // Overwrite the last 8 bytes of the free memory pointer with zero,
            //which should always be zeros
            mstore(40, shl(96, from))

            let key := keccak256(0, 60)

            mstore(0, key)
            mstore(32, allowances.slot)

            s := keccak256(0, 64)
        }
    }

    /**
     * @dev Validates the allowance of a token for a sender from an address, and transfers the token.
     *
     * Requirements:
     * - The allowance must be greater than or equal to the amount.
     * - The amount must be greater than zero.
     * - If from is not the router, the token must have been approved for the router.
     */
    function validateAndTransfer(mapping(bytes32 key => uint256) storage allowances) internal {
        address token;
        address from;
        address to;
        uint256 amount;
        uint256 allowance;

        uint256 success;
        assembly ("memory-safe") {
            token := shr(96, calldataload(4))
            from := shr(96, calldataload(24))
            to := shr(96, calldataload(44))
            amount := calldataload(64)
        }

        bytes32 allowanceSlot = getAllowanceSlot(allowances, token, msg.sender, from);

        assembly ("memory-safe") {
            allowance := sload(allowanceSlot)

            if iszero(lt(allowance, amount)) {
                success := 1

                sstore(allowanceSlot, sub(allowance, amount))
            }
        }

        if (amount == 0) revert RouterLib__ZeroAmount(); // Also prevent calldata <= 64
        if (success == 0) revert RouterLib__InsufficientAllowance(allowance, amount);

        from == address(this) ? TokenLib.transfer(token, to, amount) : TokenLib.transferFrom(token, from, to, amount);
    }

    /**
     * @dev Calls the router to transfer tokens from an account to another account.
     *
     * Requirements:
     * - The call must succeed.
     * - The target contract must use `validateAndTransfer` inside its fallback function to validate the allowance
     *   and transfer the tokens accordingly.
     */
    function transfer(address router, address token, address from, address to, uint256 amount) internal {
        assembly ("memory-safe") {
            let m0x40 := mload(0x40)

            mstore(0, shr(32, shl(96, token)))
            mstore(24, shl(96, from))
            mstore(44, shl(96, to))
            mstore(64, amount)

            if iszero(call(gas(), router, 0, 0, 96, 0, 0)) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }

            mstore(0x40, m0x40)
        }
    }

    /**
     * @dev Swaps tokens using the router logic.
     * It will also set the allowance for the logic contract to spend the token from the sender and reset it
     * after the swap is done.
     *
     * Requirements:
     * - The logic contract must not be the zero address.
     * - The call must succeed.
     * - The logic contract must call this contract's fallback function to validate the allowance and transfer the tokens.
     */
    function swap(
        mapping(bytes32 key => uint256) storage allowances,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address from,
        address to,
        bytes calldata route,
        bool exactIn,
        address logic
    ) internal returns (uint256 totalIn, uint256 totalOut) {
        bytes32 allowanceSlot = getAllowanceSlot(allowances, tokenIn, logic, from);

        uint256 length = 256 + route.length; // 32 * 6 + 32 + 32 + route.length
        bytes memory data = new bytes(length);

        assembly ("memory-safe") {
            sstore(allowanceSlot, amountIn)

            switch exactIn
            // swapExactIn(tokenIn, tokenOut, amountIn, amountOut, from, to, route)
            // swapExactOut(tokenIn, tokenOut, amountOut, amountIn, from, to, route)
            case 1 { mstore(data, 0xbd084435) }
            default { mstore(data, 0xcb7e0007) }

            mstore(add(data, 32), tokenIn)
            mstore(add(data, 64), tokenOut)
            mstore(add(data, 96), amountIn)
            mstore(add(data, 128), amountOut)
            mstore(add(data, 160), from)
            mstore(add(data, 192), to)
            mstore(add(data, 224), 224) // 32 * 6 + 32
            mstore(add(data, 256), route.length)
            calldatacopy(add(data, 288), route.offset, route.length)

            if iszero(call(gas(), logic, 0, add(data, 28), add(length, 4), 0, 64)) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }

            totalIn := mload(0)
            totalOut := mload(32)

            sstore(allowanceSlot, 0)
        }
    }
}

// lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is specified at deployment time in the constructor for `Ownable`. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

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

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        if (pendingOwner() != sender) {
            revert OwnableUnauthorizedAccount(sender);
        }
        _transferOwnership(sender);
    }
}

// src/Router.sol

/**
 * @title Router
 * @dev Router contract for swapping tokens using a predefined route.
 * The route must follow the PackedRoute format.
 */
contract Router is Ownable2Step, ReentrancyGuard, IRouter {
    using EnumerableSet for EnumerableSet.AddressSet;

    address public immutable WNATIVE;

    EnumerableSet.AddressSet private _trustedLogics;

    /**
     * @dev The allowances represent the maximum amount of tokens that the logic contract can spend on behalf of the sender.
     * It is always reseted at the end of the swap.
     * The key is calculated as keccak256(abi.encodePacked(token, sender, user)).
     */
    mapping(bytes32 key => uint256 allowance) private _allowances;

    /**
     * @dev Constructor for the Router contract.
     *
     * Requirements:
     * - The wnative address must be a contract with code.
     */
    constructor(address wnative, address initialOwner) Ownable(initialOwner) {
        if (address(wnative).code.length == 0) revert Router__InvalidWnative();

        WNATIVE = wnative;
    }

    /**
     * @dev Only allows native token to be received from unwrapping wnative.
     */
    receive() external payable {
        if (msg.sender != WNATIVE) revert Router__OnlyWnative();
    }

    /**
     * @dev Fallback function to validate and transfer tokens.
     */
    fallback() external {
        RouterLib.validateAndTransfer(_allowances);
    }

    /**
     * @dev Returns the logic contract address at the specified index.
     */
    function getTrustedLogicAt(uint256 index) external view override returns (address) {
        return _trustedLogics.at(index);
    }

    /**
     * @dev Returns the number of trusted logic contracts.
     */
    function getTrustedLogicLength() external view override returns (uint256) {
        return _trustedLogics.length();
    }

    /**
     * @dev Swaps tokens from the sender to the recipient using the exact input amount. It will use the specified logic contract.
     * WARNING: The route is not validated and could contain malicious data. The caller must ensure that the route is valid
     * and does not lead to unexpected behavior.
     *
     * Emits a {SwapExactIn} event.
     *
     * Requirements:
     * - The logic contract must be a trusted logic contract.
     * - The recipient address must not be zero or the router address.
     * - The deadline must not have passed.
     * - The input token and output token must not be the same.
     * - If the amountIn is zero, the entire balance of the input token will be used and it must not be zero.
     * - The entire amountIn of the input token must be spent.
     * - The actual amount of tokenOut received must be greater than or equal to the amountOutMin.
     */
    function swapExactIn(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address to,
        uint256 deadline,
        bytes calldata route
    ) external payable override nonReentrant returns (uint256 totalIn, uint256 totalOut) {
        if (amountIn == 0) amountIn = tokenIn == address(0) ? msg.value : TokenLib.balanceOf(tokenIn, msg.sender);

        _verifyParameters(amountIn, amountOutMin, to, deadline);

        (totalIn, totalOut) = _swap(logic, tokenIn, tokenOut, amountIn, amountOutMin, msg.sender, to, route, true);

        emit SwapExactIn(msg.sender, to, tokenIn, tokenOut, totalIn, totalOut);
    }

    /**
     * @dev Swaps tokens from the sender to the recipient using the exact output amount. It will use the specified logic contract.
     * WARNING: The route is not validated and could contain malicious data. The caller must ensure that the route is valid
     * and does not lead to unexpected behavior.
     *
     * Emits a {SwapExactOut} event.
     *
     * Requirements:
     * - The logic contract must be a trusted logic contract.
     * - The recipient address must not be zero or the router address.
     * - The deadline must not have passed.
     * - The input token and output token must not be the same.
     * - If the amountInMax is zero, the entire balance of the input token will be used and it must not be zero.
     * - The actual amount of tokenIn spent must be less than or equal to the amountInMax.
     * - The actual amount of tokenOut received must be greater than or equal to the amountOut.
     */
    function swapExactOut(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountOut,
        uint256 amountInMax,
        address to,
        uint256 deadline,
        bytes calldata route
    ) external payable override nonReentrant returns (uint256 totalIn, uint256 totalOut) {
        _verifyParameters(amountInMax, amountOut, to, deadline);

        (totalIn, totalOut) = _swap(logic, tokenIn, tokenOut, amountInMax, amountOut, msg.sender, to, route, false);

        emit SwapExactOut(msg.sender, to, tokenIn, tokenOut, totalIn, totalOut);
    }

    /**
     * @dev Simulates the swap of tokens using multiple routes and the specified logic contract.
     * The simulation will revert with an array of amounts if the swap is valid.
     */
    function simulate(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address to,
        bool exactIn,
        bytes[] calldata multiRoutes
    ) external payable override {
        uint256 length = multiRoutes.length;

        uint256[] memory amounts = new uint256[](length);
        for (uint256 i; i < length;) {
            (, bytes memory data) = address(this).delegatecall(
                abi.encodeWithSelector(
                    IRouter.simulateSingle.selector,
                    logic,
                    tokenIn,
                    tokenOut,
                    amountIn,
                    amountOut,
                    to,
                    exactIn,
                    multiRoutes[i++]
                )
            );

            if (bytes4(data) == IRouter.Router__SimulateSingle.selector) {
                assembly ("memory-safe") {
                    mstore(add(amounts, mul(i, 32)), mload(add(data, 36)))
                }
            } else {
                amounts[i - 1] = exactIn ? 0 : type(uint256).max;
            }
        }

        revert Router__Simulations(amounts);
    }

    /**
     * @dev Simulates the swap of tokens using a single route and the specified logic contract.
     * The simulation will revert with the total amount of tokenIn or tokenOut if the swap is valid.
     */
    function simulateSingle(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address to,
        bool exactIn,
        bytes calldata route
    ) external payable override {
        _verifyParameters(amountIn, amountOut, to, block.timestamp);

        (uint256 totalIn, uint256 totalOut) =
            _swap(logic, tokenIn, tokenOut, amountIn, amountOut, msg.sender, to, route, exactIn);

        revert Router__SimulateSingle(exactIn ? totalOut : totalIn);
    }

    /**
     * @dev Updates the logic contract address.
     *
     * Emits a {RouterLogicUpdated} event.
     *
     * Requirements:
     * - The caller must be the owner.
     */
    function updateRouterLogic(address logic, bool add) external override onlyOwner {
        if (add) {
            if (!_trustedLogics.add(logic)) revert Router__LogicAlreadyAdded(logic);
        } else {
            if (!_trustedLogics.remove(logic)) revert Router__LogicNotFound(logic);
        }

        emit RouterLogicUpdated(logic, add);
    }

    /**
     * @dev Helper function to verify the input parameters of a swap.
     *
     * Requirements:
     * - The recipient address must not be zero or the router address.
     * - The deadline must not have passed.
     * - The amounts must not be zero.
     */
    function _verifyParameters(uint256 amountIn, uint256 amountOut, address to, uint256 deadline) internal view {
        if (to == address(0) || to == address(this)) revert Router__InvalidTo();
        if (block.timestamp > deadline) revert Router__DeadlineExceeded();
        if (amountIn == 0 || amountOut == 0) revert Router__ZeroAmount();
    }

    /**
     * @dev Helper function to verify the output of a swap.
     *
     * Requirements:
     * - The actual amount of tokenOut returned by the logic contract must be greater than the amountOutMin.
     * - The actual balance increase of the recipient must be greater than the amountOutMin.
     */
    function _verifySwap(address tokenOut, address to, uint256 balance, uint256 amountOutMin, uint256 amountOut)
        internal
        view
        returns (uint256)
    {
        if (amountOut < amountOutMin) revert Router__InsufficientOutputAmount(amountOut, amountOutMin);

        uint256 balanceAfter = TokenLib.universalBalanceOf(tokenOut, to);

        if (balanceAfter < balance + amountOutMin) {
            revert Router__InsufficientAmountReceived(balance, balanceAfter, amountOutMin);
        }

        unchecked {
            return balanceAfter - balance;
        }
    }

    /**
     * @dev Helper function to call the logic contract to swap tokens.
     * It will use the specified logic contract to swap the input token to the output token.
     * This function will wrap the input token if it is native and unwrap the output token if it is native.
     * It will also refund the sender if there is any excess amount of native token.
     * It will allow the logic contract to spend at most amountIn of the input token from the sender, and reset
     * the allowance after the swap, see {RouterLib.swap}.
     *
     * Requirements:
     * - The logic contract must be a trusted logic contract.
     * - If the swap is exactIn, the totalIn must be equal to the amountIn.
     * - If the swap is exactOut, the totalIn must be less than or equal to the amountIn.
     */
    function _swap(
        address logic,
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOut,
        address from,
        address to,
        bytes calldata route,
        bool exactIn
    ) internal returns (uint256 totalIn, uint256 totalOut) {
        if (!_trustedLogics.contains(logic)) revert Router__UntrustedLogic(logic);

        address recipient;
        (recipient, tokenOut) = tokenOut == address(0) ? (address(this), WNATIVE) : (to, tokenOut);

        if (tokenIn == address(0)) {
            tokenIn = WNATIVE;
            from = address(this);
            TokenLib.wrap(WNATIVE, amountIn);
        }

        if (tokenIn == tokenOut) revert Router__IdenticalTokens();

        uint256 balance = TokenLib.universalBalanceOf(tokenOut, recipient);

        address logic_ = logic;

        (totalIn, totalOut) =
            RouterLib.swap(_allowances, tokenIn, tokenOut, amountIn, amountOut, from, recipient, route, exactIn, logic_);

        if (recipient == address(this)) {
            totalOut = _verifySwap(tokenOut, recipient, balance, amountOut, totalOut);

            TokenLib.unwrap(WNATIVE, totalOut);
            TokenLib.transferNative(to, totalOut);
        } else {
            totalOut = _verifySwap(tokenOut, to, balance, amountOut, totalOut);
        }

        unchecked {
            uint256 refund;
            if (from == address(this)) {
                uint256 unwrap = amountIn - totalIn;
                if (unwrap > 0) TokenLib.unwrap(WNATIVE, unwrap);

                refund = msg.value + unwrap - amountIn;
            } else {
                refund = msg.value;
            }

            if (refund > 0) TokenLib.transferNative(msg.sender, refund);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"wnative","type":"address"},{"internalType":"address","name":"initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RouterLib__InsufficientAllowance","type":"error"},{"inputs":[],"name":"RouterLib__ZeroAmount","type":"error"},{"inputs":[],"name":"Router__DeadlineExceeded","type":"error"},{"inputs":[],"name":"Router__IdenticalTokens","type":"error"},{"inputs":[{"internalType":"uint256","name":"balanceBefore","type":"uint256"},{"internalType":"uint256","name":"balanceAfter","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"}],"name":"Router__InsufficientAmountReceived","type":"error"},{"inputs":[{"internalType":"uint256","name":"outputAmount","type":"uint256"},{"internalType":"uint256","name":"minOutputAmount","type":"uint256"}],"name":"Router__InsufficientOutputAmount","type":"error"},{"inputs":[],"name":"Router__InvalidTo","type":"error"},{"inputs":[],"name":"Router__InvalidWnative","type":"error"},{"inputs":[{"internalType":"address","name":"routerLogic","type":"address"}],"name":"Router__LogicAlreadyAdded","type":"error"},{"inputs":[{"internalType":"address","name":"routerLogic","type":"address"}],"name":"Router__LogicNotFound","type":"error"},{"inputs":[],"name":"Router__OnlyWnative","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Router__SimulateSingle","type":"error"},{"inputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"Router__Simulations","type":"error"},{"inputs":[{"internalType":"address","name":"routerLogic","type":"address"}],"name":"Router__UntrustedLogic","type":"error"},{"inputs":[],"name":"Router__ZeroAmount","type":"error"},{"inputs":[],"name":"TokenLib__BalanceOfFailed","type":"error"},{"inputs":[],"name":"TokenLib__NativeTransferFailed","type":"error"},{"inputs":[],"name":"TokenLib__TransferFailed","type":"error"},{"inputs":[],"name":"TokenLib__TransferFromFailed","type":"error"},{"inputs":[],"name":"TokenLib__UnwrapFailed","type":"error"},{"inputs":[],"name":"TokenLib__WrapFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"routerLogic","type":"address"},{"indexed":false,"internalType":"bool","name":"added","type":"bool"}],"name":"RouterLogicUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"SwapExactIn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"SwapExactOut","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"WNATIVE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getTrustedLogicAt","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTrustedLogicLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bool","name":"exactIn","type":"bool"},{"internalType":"bytes[]","name":"multiRoutes","type":"bytes[]"}],"name":"simulate","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bool","name":"exactIn","type":"bool"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"simulateSingle","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"swapExactIn","outputs":[{"internalType":"uint256","name":"totalIn","type":"uint256"},{"internalType":"uint256","name":"totalOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"swapExactOut","outputs":[{"internalType":"uint256","name":"totalIn","type":"uint256"},{"internalType":"uint256","name":"totalOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"bool","name":"add","type":"bool"}],"name":"updateRouterLogic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106100d65760003560e01c8063b381cf401161007f578063de55a52711610059578063de55a527146102a7578063e30c3978146102c7578063f1910f70146102f2578063f2fde38b146103055761014c565b8063b381cf4014610238578063c7a3e3ce1461026c578063cfc6cb69146102945761014c565b806379ba5097116100b057806379ba5097146101e55780638da5cb5b146101fa578063a4b77eb9146102255761014c565b8063470a2fd01461016357806354f461a1146101ad578063715018a6146101d05761014c565b3661014c573373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a161461014a576040517f589a15c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b005b34801561015857600080fd5b5061014a6005610325565b34801561016f57600080fd5b5061018361017e366004611773565b61044d565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b3480156101b957600080fd5b506101c2610460565b6040519081526020016101a4565b3480156101dc57600080fd5b5061014a610471565b3480156101f157600080fd5b5061014a610485565b34801561020657600080fd5b5060005473ffffffffffffffffffffffffffffffffffffffff16610183565b61014a6102333660046117c5565b6104fc565b34801561024457600080fd5b506101837f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a81565b61027f61027a3660046118ed565b610783565b604080519283526020830191909152016101a4565b61014a6102a2366004611993565b610837565b3480156102b357600080fd5b5061014a6102c2366004611a1d565b61089e565b3480156102d357600080fd5b5060015473ffffffffffffffffffffffffffffffffffffffff16610183565b61027f6103003660046118ed565b6109b9565b34801561031157600080fd5b5061014a610320366004611a50565b610a89565b600435606090811c90601835811c90602c35901c6040356000808061037088883389606092831b600090815291831b60145290911b602852603c812081526020919091526040902090565b905080549250838310610387576001915083830381555b836000036103c1576040517f2af6418c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8160000361040a576040517fc67b4be300000000000000000000000000000000000000000000000000000000815260048101849052602481018590526044015b60405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff861630146104385761043387878787610b39565b610443565b610443878686610c25565b5050505050505050565b600061045a600383610d04565b92915050565b600061046c6003610d17565b905090565b610479610d21565b6104836000610d74565b565b600154339073ffffffffffffffffffffffffffffffffffffffff1681146104f0576040517f118cdaa700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82166004820152602401610401565b6104f981610d74565b50565b8060008167ffffffffffffffff81111561051857610518611a6b565b604051908082528060200260200182016040528015610541578160200160208202803683370190505b50905060005b8281101561074e576000307fcfc6cb69000000000000000000000000000000000000000000000000000000008e8e8e8e8e8e8e8e8e8c61058681611ac9565b9d5081811061059757610597611b01565b90506020028101906105a99190611b30565b6040516024016105c199989796959493929190611b95565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529181526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090941693909317909252905161064a9190611c71565b600060405180830381855af49150503d8060008114610685576040519150601f19603f3d011682016040523d82523d6000602084013e61068a565b606091505b5091507f4e37d9e50000000000000000000000000000000000000000000000000000000090506106b982611ca0565b7fffffffff0000000000000000000000000000000000000000000000000000000016036106f157602481015160208302840152610748565b8661071c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff61071f565b60005b8361072b600185611d0c565b8151811061073b5761073b611b01565b6020026020010181815250505b50610547565b50806040517fbec3e3fa0000000000000000000000000000000000000000000000000000000081526004016104019190611d1f565b60008061078e610da5565b61079a87898888610de6565b6107ad8b8b8b8a8c338c8b8b6000610ed7565b6040805173ffffffffffffffffffffffffffffffffffffffff808b168252808f1660208301528d16918101919091526060810183905260808101829052919350915033907fbdf9df8586c933e26c968397ba74608d4b9accd48f470ef60ec2d8b98067e5b29060a0015b60405180910390a26108296001600255565b995099975050505050505050565b61084386868642610de6565b6000806108588b8b8b8b8b338c8b8b8e610ed7565b91509150846108675781610869565b805b6040517f4e37d9e500000000000000000000000000000000000000000000000000000000815260040161040191815260200190565b6108a6610d21565b801561090a576108b7600383611171565b610905576040517f3863741800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83166004820152602401610401565b610963565b610915600383611193565b610963576040517fc10f959000000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83166004820152602401610401565b8173ffffffffffffffffffffffffffffffffffffffff167f25e48677e09b350ea4357542e7ea3d9b4a6665edbc68a909f93ed335dce512f6826040516109ad911515815260200190565b60405180910390a25050565b6000806109c4610da5565b876000036109fc5773ffffffffffffffffffffffffffffffffffffffff8a16156109f7576109f28a336111b5565b6109f9565b345b97505b610a0888888888610de6565b610a1b8b8b8b8b8b338c8b8b6001610ed7565b6040805173ffffffffffffffffffffffffffffffffffffffff808b168252808f1660208301528d16918101919091526060810183905260808101829052919350915033907fd9a8cfa901e597f6bbb7ea94478cf9ad6f38d0dc3fd24d493e99cb40692e39f19060a001610817565b610a91610d21565b6001805473ffffffffffffffffffffffffffffffffffffffff83167fffffffffffffffffffffffff00000000000000000000000000000000000000009091168117909155610af460005473ffffffffffffffffffffffffffffffffffffffff1690565b73ffffffffffffffffffffffffffffffffffffffff167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b60008060006040516060516323b872dd600052876020528660405285606052602060006064601c60008d5af194503d935060005192508160405280606052505082600003610bbb57610b8961122e565b6040517f7695ba3a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8115610bcb578060011415610be5565b73ffffffffffffffffffffffffffffffffffffffff87163b155b15610c1c576040517f7695ba3a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b50505050505050565b600080600060405163a9059cbb6000528560205284604052602060006044601c60008b5af193503d92506000519150806040525082600003610c9b57610c6961122e565b6040517f87c6ec7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8115610cab578060011415610cc5565b73ffffffffffffffffffffffffffffffffffffffff86163b155b15610cfc576040517f87c6ec7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050505050565b6000610d10838361123e565b9392505050565b600061045a825490565b60005473ffffffffffffffffffffffffffffffffffffffff163314610483576040517f118cdaa7000000000000000000000000000000000000000000000000000000008152336004820152602401610401565b600180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690556104f981611268565b6002805403610de0576040517f3ee5aeb500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60028055565b73ffffffffffffffffffffffffffffffffffffffff82161580610e1e575073ffffffffffffffffffffffffffffffffffffffff821630145b15610e55576040517fc9d3e5fb00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80421115610e8f576040517fb9f421fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b831580610e9a575082155b15610ed1576040517f98bbadf500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b50505050565b600080610ee560038d6112dd565b610f33576040517f94fad8f100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8d166004820152602401610401565b600073ffffffffffffffffffffffffffffffffffffffff8b1615610f5857868b610f7b565b307f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a5b9b50905073ffffffffffffffffffffffffffffffffffffffff8c16610fea577f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a9b50309750610fea7f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a8b61130c565b8a73ffffffffffffffffffffffffffffffffffffffff168c73ffffffffffffffffffffffffffffffffffffffff160361104f576040517fe454f9b700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600061105b8c8361136a565b90508d61107260058f8f8f8f8f898f8f8f8b6113b4565b90955093503073ffffffffffffffffffffffffffffffffffffffff8416036110dc576110a18d84848e886114ce565b93506110cd7f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a85611583565b6110d789856115e1565b6110ec565b6110e98d8a848e886114ce565b93505b60003073ffffffffffffffffffffffffffffffffffffffff8c160361114b57858d038d871461113f5761113f7f0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a82611583565b34018d9003905061114e565b50345b801561115e5761115e33826115e1565b505050509a509a98505050505050505050565b6000610d108373ffffffffffffffffffffffffffffffffffffffff8416611631565b6000610d108373ffffffffffffffffffffffffffffffffffffffff8416611680565b60008060006370a0823160005283602052602060006024601c885afa91503d90506000519250816000036111eb576111eb61122e565b6020811015611226576040517f07e05a0c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505092915050565b3d15610483573d6000803e3d6000fd5b600082600001828154811061125557611255611b01565b9060005260206000200154905092915050565b6000805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b73ffffffffffffffffffffffffffffffffffffffff811660009081526001830160205260408120541515610d10565b600063d0e30db06000526000806004601c85875af19050806000036113655761133361122e565b6040517fdc0c8cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050565b600073ffffffffffffffffffffffffffffffffffffffff8316156113975761139283836111b5565b610d10565b5073ffffffffffffffffffffffffffffffffffffffff1631919050565b60608a811b600090815282821b6014529087901b602852603c8120815260208c905260408120819060006113ea87610100611d62565b905060008167ffffffffffffffff81111561140757611407611a6b565b6040519080825280601f01601f191660200182016040528015611431576020820181803683370190505b5090508c8355866001811461144c5763cb7e00078252611454565b63bd08443582525b508e60208201528d60408201528c60608201528b60808201528a60a08201528960c082015260e0808201528761010082015287896101208301376040600060048401601c840160008a5af16114ad573d6000803e3d6000fd5b60005194506020519350600083555050509b509b9950505050505050505050565b600082821015611514576040517f8de8583f0000000000000000000000000000000000000000000000000000000081526004810183905260248101849052604401610401565b6000611520878761136a565b905061152c8486611d62565b811015611576576040517fdae5794a000000000000000000000000000000000000000000000000000000008152600481018690526024810182905260448101859052606401610401565b9390930395945050505050565b6000632e1a7d4d600052816020526000806024601c6000875af1905080600003611365576115af61122e565b6040517fa39163c000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600080600080600085875af1905080600003611365576115ff61122e565b6040517fa01b460600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008181526001830160205260408120546116785750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561045a565b50600061045a565b600081815260018301602052604081205480156117695760006116a4600183611d0c565b85549091506000906116b890600190611d0c565b905080821461171d5760008660000182815481106116d8576116d8611b01565b90600052602060002001549050808760000184815481106116fb576116fb611b01565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061172e5761172e611d75565b60019003818190600052602060002001600090559055856001016000868152602001908152602001600020600090556001935050505061045a565b600091505061045a565b60006020828403121561178557600080fd5b5035919050565b803573ffffffffffffffffffffffffffffffffffffffff811681146117b057600080fd5b919050565b803580151581146117b057600080fd5b60008060008060008060008060006101008a8c0312156117e457600080fd5b6117ed8a61178c565b98506117fb60208b0161178c565b975061180960408b0161178c565b965060608a0135955060808a0135945061182560a08b0161178c565b935061183360c08b016117b5565b925060e08a013567ffffffffffffffff81111561184f57600080fd5b8a01601f81018c1361186057600080fd5b803567ffffffffffffffff81111561187757600080fd5b8c60208260051b840101111561188c57600080fd5b60208201935080925050509295985092959850929598565b60008083601f8401126118b657600080fd5b50813567ffffffffffffffff8111156118ce57600080fd5b6020830191508360208285010111156118e657600080fd5b9250929050565b60008060008060008060008060006101008a8c03121561190c57600080fd5b6119158a61178c565b985061192360208b0161178c565b975061193160408b0161178c565b965060608a0135955060808a0135945061194d60a08b0161178c565b935060c08a0135925060e08a013567ffffffffffffffff81111561197057600080fd5b61197c8c828d016118a4565b915080935050809150509295985092959850929598565b60008060008060008060008060006101008a8c0312156119b257600080fd5b6119bb8a61178c565b98506119c960208b0161178c565b97506119d760408b0161178c565b965060608a0135955060808a013594506119f360a08b0161178c565b9350611a0160c08b016117b5565b925060e08a013567ffffffffffffffff81111561197057600080fd5b60008060408385031215611a3057600080fd5b611a398361178c565b9150611a47602084016117b5565b90509250929050565b600060208284031215611a6257600080fd5b610d108261178c565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203611afa57611afa611a9a565b5060010190565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112611b6557600080fd5b83018035915067ffffffffffffffff821115611b8057600080fd5b6020019150368190038213156118e657600080fd5b73ffffffffffffffffffffffffffffffffffffffff8a16815273ffffffffffffffffffffffffffffffffffffffff8916602082015273ffffffffffffffffffffffffffffffffffffffff8816604082015286606082015285608082015273ffffffffffffffffffffffffffffffffffffffff851660a082015283151560c082015261010060e0820152816101008201528183610120830137600081830161012090810191909152601f9092017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016010198975050505050505050565b6000825160005b81811015611c925760208186018101518583015201611c78565b506000920191825250919050565b805160208201517fffffffff00000000000000000000000000000000000000000000000000000000811691906004821015611d05577fffffffff00000000000000000000000000000000000000000000000000000000808360040360031b1b82161692505b5050919050565b8181038181111561045a5761045a611a9a565b602080825282518282018190526000918401906040840190835b81811015611d57578351835260209384019390920191600101611d39565b509095945050505050565b8082018082111561045a5761045a611a9a565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fdfea26469706673582212207f37aede16ea53dcfdca06f4d6a29efad5e8b9579161690a0a47bc7424cb812764736f6c634300081a0033

0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a0000000000000000000000004a04d5bfff5332dea73774d35c1afdb7a6542187

-----Decoded View---------------
Arg [0] : wnative (address): 0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A
Arg [1] : initialOwner (address): 0x4A04d5BfFF5332DeA73774d35c1aFDB7a6542187

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000003bd359c1119da7da1d913d1c4d2b7c461115433a
Arg [1] : 0000000000000000000000004a04d5bfff5332dea73774d35c1afdb7a6542187

38273:11922:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39338:10;:21;39352:7;39338:21;;39334:55;;39368:21;;;;;;;;;;;;;;39334:55;38273:11922;;;;;;;;;;;;39518:42;39548:11;39518:29;:42::i;39666:133::-;;;;;;;;;;-1:-1:-1;39666:133:0;;;;;:::i;:::-;;:::i;:::-;;;421:42:1;409:55;;;391:74;;379:2;364:18;39666:133:0;;;;;;;;39885:123;;;;;;;;;;;;;:::i;:::-;;;622:25:1;;;610:2;595:18;39885:123:0;476:177:1;29182:103:0;;;;;;;;;;;;;:::i;37861:235::-;;;;;;;;;;;;;:::i;28507:87::-;;;;;;;;;;-1:-1:-1;28553:7:0;28580:6;;;28507:87;;43421:1241;;;;;;:::i;:::-;;:::i;38395:32::-;;;;;;;;;;;;;;;42611:604;;;;;;:::i;:::-;;:::i;:::-;;;;3848:25:1;;;3904:2;3889:18;;3882:34;;;;3821:18;42611:604:0;3674:248:1;44887:562:0;;;;;;:::i;:::-;;:::i;45646:356::-;;;;;;;;;;-1:-1:-1;45646:356:0;;;;;:::i;:::-;;:::i;36949:101::-;;;;;;;;;;-1:-1:-1;37029:13:0;;;;36949:101;;40935:719;;;;;;:::i;:::-;;:::i;37249:181::-;;;;;;;;;;-1:-1:-1;37249:181:0;;;;;:::i;:::-;;:::i;31854:1119::-;32174:1;32161:15;32157:2;32153:24;;;;32220:2;32207:16;32199:25;;;32265:2;32252:16;32244:25;;32306:2;32293:16;31955:13;;;32356:53;32373:10;32153:24;32392:10;32199:25;31104:2;31100:14;;;31028:9;31090:25;;;31140:15;;;31136:2;31129:27;31308:13;;;31304:2;31297:25;31362:2;31349:16;;31381:14;;-1:-1:-1;31409:27:0;;;;31470:2;31457:16;;;30839:652;32356:53;32332:77;;32481:13;32475:20;32462:33;;32535:6;32524:9;32521:21;32511:144;;32574:1;32563:12;;32632:6;32621:9;32617:22;32602:13;32595:45;32511:144;32682:6;32692:1;32682:11;32678:47;;32702:23;;;;;;;;;;;;;;32678:47;32771:7;32782:1;32771:12;32767:76;;32792:51;;;;;;;;3848:25:1;;;3889:18;;;3882:34;;;3821:18;;32792:51:0;;;;;;;;32767:76;32856:21;;;32872:4;32856:21;:109;;32919:46;32941:5;32948:4;32954:2;32958:6;32919:21;:46::i;:::-;32856:109;;;32880:36;32898:5;32905:2;32909:6;32880:17;:36::i;:::-;31944:1029;;;;;;;31854:1119;:::o;39666:133::-;39740:7;39767:24;:14;39785:5;39767:17;:24::i;:::-;39760:31;39666:133;-1:-1:-1;;39666:133:0:o;39885:123::-;39950:7;39977:23;:14;:21;:23::i;:::-;39970:30;;39885:123;:::o;29182:103::-;28393:13;:11;:13::i;:::-;29247:30:::1;29274:1;29247:18;:30::i;:::-;29182:103::o:0;37861:235::-;37029:13;;813:10;;37958:24;37029:13;37958:24;;37954:98;;38006:34;;;;;421:42:1;409:55;;38006:34:0;;;391:74:1;364:18;;38006:34:0;245:226:1;37954:98:0;38062:26;38081:6;38062:18;:26::i;:::-;37903:193;37861:235::o;43421:1241::-;43715:11;43698:14;43715:11;43773:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43773:21:0;;43746:48;;43810:9;43805:802;43825:6;43821:1;:10;43805:802;;;43852:17;43881:4;43963:31;44017:5;44045:7;44075:8;44106;44137:9;44169:2;44194:7;44224:11;;44236:3;;;;:::i;:::-;;;44224:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;43918:341;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43873:401;;;;43918:341;43873:401;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43849:425:0;-1:-1:-1;44311:39:0;;-1:-1:-1;44295:12:0;43849:425;44295:12;:::i;:::-;:55;;;44291:305;;44468:2;44462:4;44458:13;44452:20;44446:2;44443:1;44439:10;44430:7;44426:24;44419:54;44291:305;;;44549:7;:31;;44563:17;44549:31;;;44559:1;44549:31;44532:7;44540:5;44544:1;44540;:5;:::i;:::-;44532:14;;;;;;;;:::i;:::-;;;;;;:48;;;;;44291:305;43834:773;43805:802;;;;44646:7;44626:28;;;;;;;;;;;:::i;42611:604::-;42902:15;42919:16;19343:21;:19;:21::i;:::-;42948:55:::1;42966:11;42979:9;42990:2;42994:8;42948:17;:55::i;:::-;43038:85;43044:5;43051:7;43060:8;43070:11;43083:9;43094:10;43106:2;43110:5;;43117;43038;:85::i;:::-;43141:66;::::0;;9884:42:1;9872:55;;;9854:74;;9964:55;;;9959:2;9944:18;;9937:83;10056:55;;10036:18;;;10029:83;;;;10143:2;10128:18;;10121:34;;;10186:3;10171:19;;10164:35;;;43016:107:0;;-1:-1:-1;43016:107:0;-1:-1:-1;43154:10:0::1;::::0;43141:66:::1;::::0;9841:3:1;9826:19;43141:66:0::1;;;;;;;;19387:20:::0;18678:1;19929:7;:21;19746:212;19387:20;42611:604;;;;;;;;;;;;:::o;44887:562::-;45162:59;45180:8;45190:9;45201:2;45205:15;45162:17;:59::i;:::-;45235:15;45252:16;45285:84;45291:5;45298:7;45307:8;45317;45327:9;45338:10;45350:2;45354:5;;45361:7;45285:5;:84::i;:::-;45234:135;;;;45412:7;:28;;45433:7;45412:28;;;45422:8;45412:28;45389:52;;;;;;;;;622:25:1;;610:2;595:18;;476:177;45646:356:0;28393:13;:11;:13::i;:::-;45741:3:::1;45737:210;;;45766:25;:14;45785:5:::0;45766:18:::1;:25::i;:::-;45761:71;;45800:32;::::0;::::1;::::0;;421:42:1;409:55;;45800:32:0::1;::::0;::::1;391:74:1::0;364:18;;45800:32:0::1;245:226:1::0;45761:71:0::1;45737:210;;;45870:28;:14;45892:5:::0;45870:21:::1;:28::i;:::-;45865:70;;45907:28;::::0;::::1;::::0;;421:42:1;409:55;;45907:28:0::1;::::0;::::1;391:74:1::0;364:18;;45907:28:0::1;245:226:1::0;45865:70:0::1;45983:5;45964:30;;;45990:3;45964:30;;;;10375:14:1::0;10368:22;10350:41;;10338:2;10323:18;;10210:187;45964:30:0::1;;;;;;;;45646:356:::0;;:::o;40935:719::-;41225:15;41242:16;19343:21;:19;:21::i;:::-;41275:8:::1;41287:1;41275:13:::0;41271:105:::1;;41301:21;::::0;::::1;::::0;:75:::1;;41337:39;41356:7;41365:10;41337:18;:39::i;:::-;41301:75;;;41325:9;41301:75;41290:86;;41271:105;41389:55;41407:8;41417:12;41431:2;41435:8;41389:17;:55::i;:::-;41479:84;41485:5;41492:7;41501:8;41511;41521:12;41535:10;41547:2;41551:5;;41558:4;41479:5;:84::i;:::-;41581:65;::::0;;9884:42:1;9872:55;;;9854:74;;9964:55;;;9959:2;9944:18;;9937:83;10056:55;;10036:18;;;10029:83;;;;10143:2;10128:18;;10121:34;;;10186:3;10171:19;;10164:35;;;41457:106:0;;-1:-1:-1;41457:106:0;-1:-1:-1;41593:10:0::1;::::0;41581:65:::1;::::0;9841:3:1;9826:19;41581:65:0::1;9595:610:1::0;37249:181:0;28393:13;:11;:13::i;:::-;37339::::1;:24:::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;37404:7:::1;28553::::0;28580:6;;;;28507:87;37404:7:::1;37379:43;;;;;;;;;;;;37249:181:::0;:::o;25356:944::-;25455:15;25481:18;25510:19;25601:4;25595:11;25639:4;25633:11;25670:10;25667:1;25660:21;25747:4;25743:2;25736:16;25777:2;25773;25766:14;25805:6;25801:2;25794:18;25873:2;25870:1;25865:3;25861:2;25858:1;25851:5;25844;25839:37;25828:48;;25906:16;25892:30;;25957:1;25951:8;25936:23;;25988:5;25982:4;25975:19;26021:5;26015:4;26008:19;;;26054:7;26065:1;26054:12;26050:119;;26083:22;:20;:22::i;:::-;26127:30;;;;;;;;;;;;;;26050:119;26185:15;;:68;;26237:11;26252:1;26237:16;;26185:68;;;26203:26;;;;:31;26185:68;26181:111;;;26262:30;;;;;;;;;;;;;;26181:111;25444:856;;;25356:944;;;;:::o;24284:804::-;24365:15;24391:18;24420:19;24511:4;24505:11;24542:10;24539:1;24532:21;24607:2;24603;24596:14;24635:6;24631:2;24624:18;24702:2;24699:1;24695:2;24691;24688:1;24681:5;24674;24669:36;24658:47;;24735:16;24721:30;;24786:1;24780:8;24765:23;;24817:5;24811:4;24804:19;;24850:7;24861:1;24850:12;24846:115;;24879:22;:20;:22::i;:::-;24923:26;;;;;;;;;;;;;;24846:115;24977:15;;:68;;25029:11;25044:1;25029:16;;24977:68;;;24995:26;;;;:31;24977:68;24973:107;;;25054:26;;;;;;;;;;;;;;24973:107;24354:734;;;24284:804;;;:::o;10922:158::-;10996:7;11047:22;11051:3;11063:5;11047:3;:22::i;:::-;11039:31;10922:158;-1:-1:-1;;;10922:158:0:o;10451:117::-;10514:7;10541:19;10549:3;5751:18;;5668:109;28672:166;28553:7;28580:6;28732:23;28580:6;813:10;28732:23;28728:103;;28779:40;;;;;813:10;28779:40;;;391:74:1;364:18;;28779:40:0;245:226:1;37620:156:0;37710:13;37703:20;;;;;;37734:34;37759:8;37734:24;:34::i;19423:315::-;18721:1;19552:7;;:18;19548:88;;19594:30;;;;;;;;;;;;;;19548:88;18721:1;19713:17;;19423:315::o;46286:349::-;46409:16;;;;;:39;;-1:-1:-1;46429:19:0;;;46443:4;46429:19;46409:39;46405:71;;;46457:19;;;;;;;;;;;;;;46405:71;46509:8;46491:15;:26;46487:65;;;46526:26;;;;;;;;;;;;;;46487:65;46567:13;;;:31;;-1:-1:-1;46584:14:0;;46567:31;46563:64;;;46607:20;;;;;;;;;;;;;;46563:64;46286:349;;;;:::o;48378:1814::-;48648:15;;48699:30;:14;48723:5;48699:23;:30::i;:::-;48694:73;;48738:29;;;;;421:42:1;409:55;;48738:29:0;;;391:74:1;364:18;;48738:29:0;245:226:1;48694:73:0;48780:17;48832:22;;;;:66;;48885:2;48889:8;48832:66;;;48866:4;48873:7;48832:66;48808:90;-1:-1:-1;48808:90:0;-1:-1:-1;48915:21:0;;;48911:153;;48963:7;48953:17;;49000:4;48985:20;;49020:32;49034:7;49043:8;49020:13;:32::i;:::-;49091:8;49080:19;;:7;:19;;;49076:57;;49108:25;;;;;;;;;;;;;;49076:57;49146:15;49164:48;49192:8;49202:9;49164:27;:48::i;:::-;49146:66;-1:-1:-1;49242:5:0;49295:108;49310:11;49323:7;49332:8;49342;49352:9;49363:4;49369:9;49380:5;;49387:7;49242:5;49295:14;:108::i;:::-;49260:143;;-1:-1:-1;49260:143:0;-1:-1:-1;49441:4:0;49420:26;;;;49416:334;;49474:62;49486:8;49496:9;49507:7;49516:9;49527:8;49474:11;:62::i;:::-;49463:73;;49553:34;49569:7;49578:8;49553:15;:34::i;:::-;49602:37;49626:2;49630:8;49602:23;:37::i;:::-;49416:334;;;49683:55;49695:8;49705:2;49709:7;49718:9;49729:8;49683:11;:55::i;:::-;49672:66;;49416:334;49787:14;49836:4;49820:21;;;;49816:282;;49879:18;;;49920:10;;;49916:48;;49932:32;49948:7;49957:6;49932:15;:32::i;:::-;49994:9;:18;:29;;;;-1:-1:-1;49816:282:0;;;-1:-1:-1;50073:9:0;49816:282;50118:10;;50114:59;;50130:43;50154:10;50166:6;50130:23;:43::i;:::-;49762:423;48683:1509;;;48378:1814;;;;;;;;;;;;;:::o;9626:152::-;9696:4;9720:50;9725:3;9745:23;;;9720:4;:50::i;9954:158::-;10027:4;10051:53;10059:3;10079:23;;;10051:7;:53::i;20895:751::-;20969:14;20996:15;21022:22;21107:10;21104:1;21097:21;21165:7;21161:2;21154:19;21236:2;21233:1;21229:2;21225;21218:5;21211;21200:39;21189:50;;21273:16;21255:34;;21321:1;21315:8;21305:18;;21350:7;21361:1;21350:12;21346:40;;21364:22;:20;:22::i;:::-;21600:2;21583:14;:19;21579:59;;;21611:27;;;;;;;;;;;;;;21579:59;20985:661;;20895:751;;;;:::o;26604:251::-;26703:16;26700:137;;;26760:16;26757:1;;26739:38;26805:16;26757:1;26795:27;6131:120;6198:7;6225:3;:11;;6237:5;6225:18;;;;;;;;:::i;:::-;;;;;;;;;6218:25;;6131:120;;;;:::o;29820:191::-;29894:16;29913:6;;;29930:17;;;;;;;;;;29963:40;;29913:6;;;;;;;29963:40;;29894:16;29963:40;29883:128;29820:191;:::o;10198:167::-;10332:23;;;10278:4;5548:21;;;:14;;;:21;;;;;;:26;;10302:55;5451:131;22947:378;23014:15;23092:10;23089:1;23082:21;23182:1;23179;23176;23172:2;23164:6;23155:7;23148:5;23143:41;23132:52;;23211:7;23222:1;23211:12;23207:111;;23240:22;:20;:22::i;:::-;23284;;;;;;;;;;;;;;23207:111;23003:322;22947:378;;:::o;22005:190::-;22088:14;22122:19;;;;:65;;22162:25;22172:5;22179:7;22162:9;:25::i;:::-;22122:65;;;-1:-1:-1;22144:15:0;;;;22005:190;-1:-1:-1;22005:190:0:o;34340:1738::-;31104:2;31100:14;;;34670:15;31090:25;;;31140:15;;;31136:2;31129:27;31308:13;;;;31304:2;31297:25;31362:2;31349:16;;31381:14;;-1:-1:-1;31409:27:0;;;31470:2;31457:16;;34670:15;;34803:14;34820:18;34826:5;34820:3;:18;:::i;:::-;34803:35;;34884:17;34914:6;34904:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34904:17:0;;34884:37;;34996:8;34981:13;34974:31;35028:7;35225:1;35220:35;;;;35292:10;35286:4;35279:24;35021:284;;35220:35;35242:10;35236:4;35229:24;35021:284;;35343:7;35338:2;35332:4;35328:13;35321:30;35387:8;35382:2;35376:4;35372:13;35365:31;35432:8;35427:2;35421:4;35417:13;35410:31;35478:9;35472:3;35466:4;35462:14;35455:33;35525:4;35519:3;35513:4;35509:14;35502:28;35567:2;35561:3;35555:4;35551:14;35544:26;35607:3;35601;35595:4;35591:14;35584:27;35663:12;35657:3;35651:4;35647:14;35640:36;35733:12;35719;35713:3;35707:4;35703:14;35690:56;35828:2;35825:1;35821;35813:6;35809:14;35804:2;35798:4;35794:13;35791:1;35784:5;35777;35772:59;35762:188;;35873:16;35870:1;35867;35852:38;35918:16;35915:1;35908:27;35762:188;35983:1;35977:8;35966:19;;36017:2;36011:9;35999:21;;36058:1;36043:13;36036:24;34959:1112;;;34340:1738;;;;;;;;;;;;;;:::o;46956:601::-;47115:7;47156:12;47144:9;:24;47140:94;;;47177:57;;;;;;;;3848:25:1;;;3889:18;;;3882:34;;;3821:18;;47177:57:0;3674:248:1;47140:94:0;47247:20;47270:41;47298:8;47308:2;47270:27;:41::i;:::-;47247:64;-1:-1:-1;47343:22:0;47353:12;47343:7;:22;:::i;:::-;47328:12;:37;47324:148;;;47389:71;;;;;;;;10734:25:1;;;10775:18;;;10768:34;;;10818:18;;;10811:34;;;10707:18;;47389:71:0;10532:319:1;47324:148:0;47516:22;;;;;46956:601;-1:-1:-1;;;;;46956:601:0:o;23599:418::-;23668:15;23746:10;23743:1;23736:21;23803:6;23799:2;23792:18;23872:1;23869;23865:2;23861;23858:1;23849:7;23842:5;23837:37;23826:48;;23901:7;23912:1;23901:12;23897:113;;23930:22;:20;:22::i;:::-;23974:24;;;;;;;;;;;;;;22336:337;22408:15;22520:1;22517;22514;22511;22503:6;22499:2;22492:5;22487:35;22476:46;;22549:7;22560:1;22549:12;22545:121;;22578:22;:20;:22::i;:::-;22622:32;;;;;;;;;;;;;;3373:416;3436:4;5548:21;;;:14;;;:21;;;;;;3453:329;;-1:-1:-1;3496:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;3681:18;;3657:21;;;:14;;;:21;;;;;;:42;;;;3714:11;;3453:329;-1:-1:-1;3765:5:0;3758:12;;3965:1400;4031:4;4162:21;;;:14;;;:21;;;;;;4200:13;;4196:1162;;4573:18;4594:12;4605:1;4594:8;:12;:::i;:::-;4641:18;;4573:33;;-1:-1:-1;4621:17:0;;4641:22;;4662:1;;4641:22;:::i;:::-;4621:42;;4698:9;4684:10;:23;4680:385;;4728:17;4748:3;:11;;4760:9;4748:22;;;;;;;;:::i;:::-;;;;;;;;;4728:42;;4898:9;4872:3;:11;;4884:10;4872:23;;;;;;;;:::i;:::-;;;;;;;;;;;;:35;;;;5013:25;;;:14;;;:25;;;;;:36;;;4680:385;5146:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;5252:3;:14;;:21;5267:5;5252:21;;;;;;;;;;;5245:28;;;5297:4;5290:11;;;;;;;4196:1162;5341:5;5334:12;;;;;14:226:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;187:23:1;;14:226;-1:-1:-1;14:226:1:o;658:196::-;726:20;;786:42;775:54;;765:65;;755:93;;844:1;841;834:12;755:93;658:196;;;:::o;859:160::-;924:20;;980:13;;973:21;963:32;;953:60;;1009:1;1006;999:12;1024:1224;1181:6;1189;1197;1205;1213;1221;1229;1237;1245;1298:3;1286:9;1277:7;1273:23;1269:33;1266:53;;;1315:1;1312;1305:12;1266:53;1338:29;1357:9;1338:29;:::i;:::-;1328:39;;1386:38;1420:2;1409:9;1405:18;1386:38;:::i;:::-;1376:48;;1443:38;1477:2;1466:9;1462:18;1443:38;:::i;:::-;1433:48;-1:-1:-1;1550:2:1;1535:18;;1522:32;;-1:-1:-1;1651:3:1;1636:19;;1623:33;;-1:-1:-1;1701:39:1;1735:3;1720:19;;1701:39;:::i;:::-;1691:49;;1759:36;1790:3;1779:9;1775:19;1759:36;:::i;:::-;1749:46;;1846:3;1835:9;1831:19;1818:33;1874:18;1866:6;1863:30;1860:50;;;1906:1;1903;1896:12;1860:50;1929:22;;1982:4;1974:13;;1970:27;-1:-1:-1;1960:55:1;;2011:1;2008;2001:12;1960:55;2051:2;2038:16;2077:18;2069:6;2066:30;2063:50;;;2109:1;2106;2099:12;2063:50;2162:7;2157:2;2147:6;2144:1;2140:14;2136:2;2132:23;2128:32;2125:45;2122:65;;;2183:1;2180;2173:12;2122:65;2214:2;2210;2206:11;2196:21;;2236:6;2226:16;;;;1024:1224;;;;;;;;;;;:::o;2253:347::-;2304:8;2314:6;2368:3;2361:4;2353:6;2349:17;2345:27;2335:55;;2386:1;2383;2376:12;2335:55;-1:-1:-1;2409:20:1;;2452:18;2441:30;;2438:50;;;2484:1;2481;2474:12;2438:50;2521:4;2513:6;2509:17;2497:29;;2573:3;2566:4;2557:6;2549;2545:19;2541:30;2538:39;2535:59;;;2590:1;2587;2580:12;2535:59;2253:347;;;;;:::o;2605:1064::-;2738:6;2746;2754;2762;2770;2778;2786;2794;2802;2855:3;2843:9;2834:7;2830:23;2826:33;2823:53;;;2872:1;2869;2862:12;2823:53;2895:29;2914:9;2895:29;:::i;:::-;2885:39;;2943:38;2977:2;2966:9;2962:18;2943:38;:::i;:::-;2933:48;;3000:38;3034:2;3023:9;3019:18;3000:38;:::i;:::-;2990:48;-1:-1:-1;3107:2:1;3092:18;;3079:32;;-1:-1:-1;3208:3:1;3193:19;;3180:33;;-1:-1:-1;3258:39:1;3292:3;3277:19;;3258:39;:::i;:::-;3248:49;-1:-1:-1;3370:3:1;3355:19;;3342:33;;-1:-1:-1;3452:3:1;3437:19;;3424:33;3480:18;3469:30;;3466:50;;;3512:1;3509;3502:12;3466:50;3551:58;3601:7;3592:6;3581:9;3577:22;3551:58;:::i;:::-;3525:84;;3628:8;3618:18;;;3655:8;3645:18;;;2605:1064;;;;;;;;;;;:::o;3927:1012::-;4057:6;4065;4073;4081;4089;4097;4105;4113;4121;4174:3;4162:9;4153:7;4149:23;4145:33;4142:53;;;4191:1;4188;4181:12;4142:53;4214:29;4233:9;4214:29;:::i;:::-;4204:39;;4262:38;4296:2;4285:9;4281:18;4262:38;:::i;:::-;4252:48;;4319:38;4353:2;4342:9;4338:18;4319:38;:::i;:::-;4309:48;-1:-1:-1;4426:2:1;4411:18;;4398:32;;-1:-1:-1;4527:3:1;4512:19;;4499:33;;-1:-1:-1;4577:39:1;4611:3;4596:19;;4577:39;:::i;:::-;4567:49;;4635:36;4666:3;4655:9;4651:19;4635:36;:::i;:::-;4625:46;;4722:3;4711:9;4707:19;4694:33;4750:18;4742:6;4739:30;4736:50;;;4782:1;4779;4772:12;4944:254;5009:6;5017;5070:2;5058:9;5049:7;5045:23;5041:32;5038:52;;;5086:1;5083;5076:12;5038:52;5109:29;5128:9;5109:29;:::i;:::-;5099:39;;5157:35;5188:2;5177:9;5173:18;5157:35;:::i;:::-;5147:45;;4944:254;;;;;:::o;5203:186::-;5262:6;5315:2;5303:9;5294:7;5290:23;5286:32;5283:52;;;5331:1;5328;5321:12;5283:52;5354:29;5373:9;5354:29;:::i;5394:184::-;5446:77;5443:1;5436:88;5543:4;5540:1;5533:15;5567:4;5564:1;5557:15;5583:184;5635:77;5632:1;5625:88;5732:4;5729:1;5722:15;5756:4;5753:1;5746:15;5772:195;5811:3;5842:66;5835:5;5832:77;5829:103;;5912:18;;:::i;:::-;-1:-1:-1;5959:1:1;5948:13;;5772:195::o;5972:184::-;6024:77;6021:1;6014:88;6121:4;6118:1;6111:15;6145:4;6142:1;6135:15;6161:580;6238:4;6244:6;6304:11;6291:25;6394:66;6383:8;6367:14;6363:29;6359:102;6339:18;6335:127;6325:155;;6476:1;6473;6466:12;6325:155;6503:33;;6555:20;;;-1:-1:-1;6598:18:1;6587:30;;6584:50;;;6630:1;6627;6620:12;6584:50;6663:4;6651:17;;-1:-1:-1;6694:14:1;6690:27;;;6680:38;;6677:58;;;6731:1;6728;6721:12;6746:1159;7105:42;7097:6;7093:55;7082:9;7075:74;7197:42;7189:6;7185:55;7180:2;7169:9;7165:18;7158:83;7289:42;7281:6;7277:55;7272:2;7261:9;7257:18;7250:83;7369:6;7364:2;7353:9;7349:18;7342:34;7413:6;7407:3;7396:9;7392:19;7385:35;7469:42;7461:6;7457:55;7451:3;7440:9;7436:19;7429:84;7564:6;7557:14;7550:22;7544:3;7533:9;7529:19;7522:51;7610:3;7604;7593:9;7589:19;7582:32;7651:6;7645:3;7634:9;7630:19;7623:35;7709:6;7701;7695:3;7684:9;7680:19;7667:49;7766:1;7736:22;;;7760:3;7732:32;;;7725:43;;;;7820:2;7808:15;;;7825:66;7804:88;7789:104;7785:114;;6746:1159;-1:-1:-1;;;;;;;;6746:1159:1:o;7910:412::-;8039:3;8077:6;8071:13;8102:1;8112:129;8126:6;8123:1;8120:13;8112:129;;;8224:4;8208:14;;;8204:25;;8198:32;8185:11;;;8178:53;8141:12;8112:129;;;-1:-1:-1;8296:1:1;8260:16;;8285:13;;;-1:-1:-1;8260:16:1;7910:412;-1:-1:-1;7910:412:1:o;8327:514::-;8444:12;;8492:4;8481:16;;8475:23;8524:66;8516:75;;;8444:12;8614:1;8603:13;;8600:235;;;8758:66;8688;8678:6;8675:1;8671:14;8668:1;8664:22;8660:95;8656:2;8652:104;8648:177;8639:186;;8600:235;;;8327:514;;;:::o;8846:128::-;8913:9;;;8934:11;;;8931:37;;;8948:18;;:::i;8979:611::-;9169:2;9181:21;;;9251:13;;9154:18;;;9273:22;;;9121:4;;9352:15;;;9326:2;9311:18;;;9121:4;9395:169;9409:6;9406:1;9403:13;9395:169;;;9470:13;;9458:26;;9513:2;9539:15;;;;9504:12;;;;9431:1;9424:9;9395:169;;;-1:-1:-1;9581:3:1;;8979:611;-1:-1:-1;;;;;8979:611:1:o;10402:125::-;10467:9;;;10488:10;;;10485:36;;;10501:18;;:::i;10856:184::-;10908:77;10905:1;10898:88;11005:4;11002:1;10995:15;11029:4;11026:1;11019:15

ipfs://7f37aede16ea53dcfdca06f4d6a29efad5e8b9579161690a0a47bc7424cb8127