Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {Ownable} from "./Ownable.sol";

contract WhirlDeposit is Ownable {
    error PausedContract();
    error ZeroAddress();
    error UnsupportedToken();
    error TransferFailed();

    bytes32 private constant DEPOSIT_EVT_SIG
        = 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62;
    address private constant NATIVE
        = 0x0000000000000000000000000000000000000000;

    address public relayer;
    bool public paused;

    mapping(address => bool) supportedTokens;

    event RelayerUpdated(address);
    event PausedUpdated(bool);
    event SupportedTokensUpdated(address, bool);
    event Deposit(address indexed user, address indexed token, uint256 amount);

    constructor(address relayer_) {
        _initializeOwner(msg.sender);

        relayer = relayer_;
    }

    // OWNER

    function updateRelayer(address relayer_) external {
        _checkOwner();

        if (relayer_ == NATIVE)
            _revert(ZeroAddress.selector);

        relayer = relayer_;

        emit RelayerUpdated(relayer_);
    }

    function updateSupportedTokens(address token_, bool enabled_) external {
        _checkOwner();

        if (token_ == NATIVE)
            _revert(ZeroAddress.selector);

        supportedTokens[token_] = enabled_;

        emit SupportedTokensUpdated(token_, enabled_);
    }

    function updatePaused(bool paused_) external {
        _checkOwner();

        paused = paused_;

        emit PausedUpdated(paused_);
    }

    function withdraw(uint256 amount_) external {
        _checkOwner();

        _safeTransferETH(owner(), amount_);
    }

    function withdrawToken(address token_, uint256 amount_) external {
        _checkOwner();

        _safeTransfer(token_, owner(), amount_);
    }

    // PUB/EXTERNAL

    function deposit() external payable {
        if (paused) _revert(PausedContract.selector);

        _safeTransferETH(relayer, msg.value);

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, callvalue())
            log3(0x00, 0x20, DEPOSIT_EVT_SIG, caller(), 0x0)
        }
    }

    function depositToken(address token_, uint256 amount_) external payable {
        if (paused) _revert(PausedContract.selector);
        if (!supportedTokens[token_]) _revert(UnsupportedToken.selector);

        _safeTransferFrom(
            token_,
            msg.sender,
            relayer,
            amount_
        );

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, amount_)
            log3(0x00, 0x20, DEPOSIT_EVT_SIG, caller(), token_)
        }
    }

    // PRV/INTERNAL

    function _safeTransferETH(address to_, uint256 amount_) private {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(gas(), to_, amount_, 0, 0, 0, 0)) {
                mstore(0x0, 0x90b8ec18)
                revert(0x0, 0x4)
            }
        }
    }

    function _safeTransfer(
        address token_,
        address to_,
        uint256 amount_
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to_) // Store the `to` argument.
            mstore(0x34, amount_) // Store the `amount` argument.
            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token_, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    function _safeTransferFrom(
        address token_,
        address from_,
        address to_,
        uint256 amount_
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x60, amount_) // Store the `amount` argument.
            mstore(0x40, to_) // Store the `to` argument.
            mstore(0x2c, shl(96, from_)) // Store the `from` argument.
            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token_, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    function _revert(bytes4 code) private pure {
        assembly {
            mstore(0x0, code)
            revert(0x0, 0x4)
        }
    }
}

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

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"relayer_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"PausedContract","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnsupportedToken","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"","type":"bool"}],"name":"PausedUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"}],"name":"RelayerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"bool","name":"","type":"bool"}],"name":"SupportedTokensUpdated","type":"event"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"depositToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bool","name":"paused_","type":"bool"}],"name":"updatePaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"relayer_","type":"address"}],"name":"updateRelayer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"bool","name":"enabled_","type":"bool"}],"name":"updateSupportedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000cafe63e03d216d17474fdf9208e25d008eef73d1

-----Decoded View---------------
Arg [0] : relayer_ (address): 0xCAFE63E03d216d17474FDf9208E25D008eEf73d1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000cafe63e03d216d17474fdf9208e25d008eef73d1

97:5199:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1395:140;;;;;;;;;;-1:-1:-1;1395:140:1;;;;;:::i;:::-;;:::i;:::-;;9021:617:0;;;:::i;1541:119:1:-;;;;;;;;;;-1:-1:-1;1541:119:1;;;;;:::i;:::-;;:::i;2160:502::-;;;;;;:::i;:::-;;:::i;9720:456:0:-;;;:::i;490:18:1:-;;;;;;;;;;-1:-1:-1;490:18:1;;;;-1:-1:-1;;;490:18:1;;;;;;;;;1151:14:2;;1144:22;1126:41;;1114:2;1099:18;490::1;;;;;;;;8762:100:0;;;:::i;462:22:1:-;;;;;;;;;;-1:-1:-1;462:22:1;;;;-1:-1:-1;;;;;462:22:1;;;;;;-1:-1:-1;;;;;1342:32:2;;;1324:51;;1312:2;1297:18;462:22:1;1178:203:2;11408:182:0;;;;;;;;;;-1:-1:-1;;;11556:18:0;11408:182;;882:225:1;;;;;;;;;;-1:-1:-1;882:225:1;;;;;:::i;:::-;;:::i;1666:145::-;;;;;;;;;;-1:-1:-1;1666:145:1;;;;;:::i;:::-;;:::i;1838:316::-;;;:::i;1113:276::-;;;;;;;;;;-1:-1:-1;1113:276:1;;;;;:::i;:::-;;:::i;10363:708:0:-;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:0;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;;;;1982:25:2;;;1970:2;1955:18;11693:435:0;1836:177:2;1395:140:1;1450:13;:11;:13::i;:::-;1474:6;:16;;;;;-1:-1:-1;;;1474:16:1;-1:-1:-1;;;;1474:16:1;;;;;;1506:22;;;;;;1483:7;1151:14:2;1144:22;1126:41;;1114:2;1099:18;;986:187;1506:22:1;;;;;;;;1395:140;:::o;9021:617:0:-;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;1541:119:1:-;1595:13;:11;:13::i;:::-;1619:34;1636:7;-1:-1:-1;;11556:18:0;;11408:182;1636:7:1;1645;1619:16;:34::i;:::-;1541:119;:::o;2160:502::-;2246:6;;-1:-1:-1;;;2246:6:1;;;;2242:44;;;2254:32;-1:-1:-1;;;2254:7:1;:32::i;:::-;-1:-1:-1;;;;;2301:23:1;;;;;;:15;:23;;;;;;;;2296:64;;2326:34;-1:-1:-1;;;2326:7:1;:34::i;:::-;2446:7;;2371:113;;2402:6;;2422:10;;-1:-1:-1;;;;;2446:7:1;2467;2371:17;:113::i;:::-;2574:7;2568:4;2561:21;2639:6;2629:8;2612:15;2606:4;2600;2595:51;2160:502;;:::o;9720:456:0:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;8762:100::-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;882:225:1:-;942:13;:11;:13::i;:::-;-1:-1:-1;;;;;970:18:1;;966:65;;1002:29;-1:-1:-1;;;1002:7:1;:29::i;:::-;1042:7;:18;;-1:-1:-1;;;;;;1042:18:1;-1:-1:-1;;;;;1042:18:1;;;;;;;;1076:24;;1324:51:2;;;1076:24:1;;1312:2:2;1297:18;1076:24:1;1178:203:2;1666:145:1;1741:13;:11;:13::i;:::-;1765:39;1779:6;1787:7;-1:-1:-1;;11556:18:0;;11408:182;1787:7:1;1796;1765:13;:39::i;:::-;1666:145;;:::o;1838:316::-;1888:6;;-1:-1:-1;;;1888:6:1;;;;1884:44;;;1896:32;-1:-1:-1;;;1896:7:1;:32::i;:::-;1956:7;;1939:36;;-1:-1:-1;;;;;1956:7:1;1965:9;1939:16;:36::i;:::-;2065:11;2059:4;2052:25;2134:3;2124:8;2107:15;2101:4;2095;2090:48;1838:316::o;1113:276::-;1194:13;:11;:13::i;:::-;-1:-1:-1;;;;;1222:16:1;;1218:63;;1252:29;-1:-1:-1;;;1252:7:1;:29::i;:::-;-1:-1:-1;;;;;1292:23:1;;;;;;:15;:23;;;;;;;;;:34;;-1:-1:-1;;1292:34:1;;;;;;;;;;1342:40;;2186:51:2;;;2253:18;;;2246:50;1342:40:1;;2159:18:2;1342:40:1;;;;;;;1113:276;;:::o;10363:708:0:-;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;8348:349::-:0;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;7292:355::-:0;-1:-1:-1;;7498:18:0;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;2689:293:1;2874:1;2871;2868;2865;2856:7;2851:3;2844:5;2839:37;2829:137;;2908:10;2903:3;2896:23;2948:3;2943;2936:16;5156:138;5244:4;5239:3;5232:17;5274:3;5269;5262:16;3969:1181;4194:4;4188:11;4259:7;4253:4;4246:21;4325:3;4319:4;4312:17;4391:5;4387:2;4383:14;4377:4;4370:28;-1:-1:-1;;;4448:4:1;4441:48;4856:4;4850;4844;4838;4835:1;4827:6;4820:5;4815:46;4749:16;4742:24;4738:1;4731:4;4725:11;4722:18;4719:48;4634:245;4607:401;;4925:10;4919:4;4912:24;4989:4;4983;4976:18;4607:401;5034:1;5028:4;5021:15;5090:4;5083:15;-1:-1:-1;;;;3969:1181:1:o;6145:1089:0:-;-1:-1:-1;;7093:16:0;;-1:-1:-1;;;;;6941:26:0;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;2988:975:1:-;3184:3;3178:4;3171:17;3242:7;3236:4;3229:21;-1:-1:-1;;;3302:4:1;3295:48;3698:4;3692;3686;3680;3677:1;3669:6;3662:5;3657:46;3591:16;3584:24;3580:1;3573:4;3567:11;3564:18;3561:48;3476:245;3449:401;;3767:10;3761:4;3754:24;3831:4;3825;3818:18;3449:401;3876:1;3870:4;3863:15;2988:975;;;:::o;14:160:2:-;79:20;;135:13;;128:21;118:32;;108:60;;164:1;161;154:12;108:60;14:160;;;:::o;179:180::-;235:6;288:2;276:9;267:7;263:23;259:32;256:52;;;304:1;301;294:12;256:52;327:26;343:9;327:26;:::i;:::-;317:36;179:180;-1:-1:-1;;;179:180:2:o;364:::-;423:6;476:2;464:9;455:7;451:23;447:32;444:52;;;492:1;489;482:12;444:52;-1:-1:-1;515:23:2;;364:180;-1:-1:-1;364:180:2:o;549:173::-;617:20;;-1:-1:-1;;;;;666:31:2;;656:42;;646:70;;712:1;709;702:12;727:254;795:6;803;856:2;844:9;835:7;831:23;827:32;824:52;;;872:1;869;862:12;824:52;895:29;914:9;895:29;:::i;:::-;885:39;971:2;956:18;;;;943:32;;-1:-1:-1;;;727:254:2:o;1386:186::-;1445:6;1498:2;1486:9;1477:7;1473:23;1469:32;1466:52;;;1514:1;1511;1504:12;1466:52;1537:29;1556:9;1537:29;:::i;1577:254::-;1642:6;1650;1703:2;1691:9;1682:7;1678:23;1674:32;1671:52;;;1719:1;1716;1709:12;1671:52;1742:29;1761:9;1742:29;:::i;:::-;1732:39;;1790:35;1821:2;1810:9;1806:18;1790:35;:::i;:::-;1780:45;;1577:254;;;;;:::o

ipfs://01e0898b398f571d00cdabdf3d62baa422af618602c4c284a92eb9486c7cde52