Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity 0.8.17;
// SPDX-License-Identifier: MIT

/* fabrik HausToken Bridge

Post-deployment operations:
- 1. Set hausToken addresses using the setHausToken() function.
        - Set the _setLegacy flag to 'true' to set the old haustokens address. 'false' to set the new one'
- 2. Set the merkle root hash for missing rewards of oldHT using the setMerkleRoot() function.
- 3. Unpause the contract
*/

import { ReentrancyGuard } from "./lib/solmate/utils/ReentrancyGuard.sol";
import { Pausable } from "@openzeppelin/contracts/security/Pausable.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

interface IERC20 {
    function burn(uint256 amount) external;
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function mint(address _to, uint _amount) external;
}

contract HTConvert is Ownable, Pausable, ReentrancyGuard {
    constructor() {
        _pause();
    }
    /////////////////////////////////////////////////////////
    /// Global variables
    /////////////////////////////////////////////////////////
    IERC20 LHT;
    IERC20 HT;

    mapping (address => uint) public missingTokensClaimed;
    bytes32 merkleRoot;

    /////////////////////////////////////////////////////////
    /// Modifiers
    /////////////////////////////////////////////////////////
    modifier callerIsUser() {
        require(tx.origin == msg.sender, "The caller is another contract");
        _;
    }

    /////////////////////////////////////////////////////////
    /// Main functions
    /////////////////////////////////////////////////////////

    /// @notice                     Convert legacy hausTokens to new haustokens
    /// @param _amount              Amount of HT to convert
    function convert(uint _amount) public nonReentrant whenNotPaused {
        require(LHT.allowance(msg.sender, address(this)) >= _amount, "Not enough allowance");
        bool ts = LHT.transferFrom(msg.sender, address(this), _amount);
        require(ts, "Transfer unsuccessful");
        HT.mint(msg.sender, _amount);
    }

    /// @notice                     Claim missing oldHT balances in newHT
    /// @param _amount              Amount of tokens to claim
    /// @param _allowedQuantity     Maximum allowed tokens to claim
    /// @param _proof               Merkle proof
    function claimMissingTokens(uint _amount, uint _allowedQuantity, bytes32[] calldata _proof) external callerIsUser {
        require(verifyMP(msg.sender, _allowedQuantity, _proof), "Whitelist check failed");
        require(missingTokensClaimed[msg.sender] + _amount <= _allowedQuantity, "Exceeding allowance");
        missingTokensClaimed[msg.sender] += _amount;
        HT.mint(msg.sender, _amount * 1e18);
    }

    /// @notice     Burns all the legacy hausTokens that are stored in the contract
    function burnLegacy() external onlyOwner {
        LHT.burn(LHT.balanceOf(address(this)));
    }
    
    /////////////////////////////////////////////////////////
    /// Helper functions
    /////////////////////////////////////////////////////////
    /// @notice                         Verify merkle proof validity
    /// @param _account                 Address
    /// @param _allowedQuantity         Maximum amount of haustokens allowed to claim
    /// @param _proof                   Merkle proof
    function verifyMP(address _account, uint256 _allowedQuantity, bytes32[] calldata _proof) public view returns (bool) {
        return MerkleProof.verify(
            _proof,
            merkleRoot,
            keccak256(abi.encodePacked(_account, _allowedQuantity))
        );
    }

    /////////////////////////////////////////////////////////
    /// SET Functions
    /////////////////////////////////////////////////////////
    /// @notice     Sets the hausToken contract address
    /// @param _setLegacy       false - set new haustoken address; true - set legacy haustoken address
    function setHausToken(bool _setLegacy, address _hausToken) external onlyOwner {
        _setLegacy ? LHT = IERC20(_hausToken) : HT = IERC20(_hausToken);
    }

    /// @notice     Sets the merkle root for missing oldHT whitelist
    /// @param _merkleRoot      Root hash of the whitelist
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    /// @notice     Pause/unpause the contract
    /// @param _state           True/false
    function pause(bool _state) external onlyOwner {
        _state ? _pause() : _unpause();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

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

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

        locked = 2;

        _;

        locked = 1;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"burnLegacy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_allowedQuantity","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"claimMissingTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"convert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"missingTokensClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_setLegacy","type":"bool"},{"internalType":"address","name":"_hausToken","type":"address"}],"name":"setHausToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_allowedQuantity","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"verifyMP","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

1103:3702:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4709:94;;;;;;:::i;:::-;;:::i;:::-;;1615:84:1;1662:4;1685:7;-1:-1:-1;;;1685:7:1;;;;1615:84;;;548:14:6;;541:22;523:41;;511:2;496:18;1615:84:1;;;;;;;;3625:281:4;;;;;;:::i;:::-;;:::i;1831:101:0:-;;;:::i;4509:104:4:-;;;;;;:::i;:::-;;:::i;4217:158::-;;;;;;:::i;:::-;;:::i;1201:85:0:-;1247:7;1273:6;1201:85;;-1:-1:-1;;;;;1273:6:0;;;2360:51:6;;2348:2;2333:18;1201:85:0;2214:203:6;2610:414:4;;;;;;:::i;:::-;;:::i;2029:322::-;;;;;;:::i;:::-;;:::i;1391:53::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;3522:25:6;;;3510:2;3495:18;1391:53:4;3376:177:6;3114:96:4;;;:::i;2081:198:0:-;;;;;;:::i;:::-;;:::i;4709:94:4:-;1094:13:0;:11;:13::i;:::-;4766:6:4::1;:30;;4786:10;:8;:10::i;:::-;4709:94:::0;:::o;4766:30::-:1;4775:8;:6;:8::i;3625:281::-:0;3735:4;3758:141;3790:6;;3758:141;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3810:10:4;;3844:44;;-1:-1:-1;;3735:2:6;3731:15;;;3727:53;3844:44:4;;;3715:66:6;3797:12;;;3790:28;;;3810:10:4;;-1:-1:-1;3834:12:6;;;-1:-1:-1;3844:44:4;;;;;;;;;;;;3834:55;;;;;;3758:18;:141::i;:::-;3751:148;3625:281;-1:-1:-1;;;;;3625:281:4:o;1831:101:0:-;1094:13;:11;:13::i;:::-;1895:30:::1;1922:1;1895:18;:30::i;:::-;1831:101::o:0;4509:104:4:-;1094:13:0;:11;:13::i;:::-;4582:10:4::1;:24:::0;4509:104::o;4217:158::-;1094:13:0;:11;:13::i;:::-;4305:10:4::1;:63;;4345:2;:23:::0;;-1:-1:-1;;;;;4345:23:4;::::1;-1:-1:-1::0;;;;;;4345:23:4;;::::1;;::::0;;4217:158;;:::o;4305:63::-:1;4318:3;:24:::0;;-1:-1:-1;;;;;4318:24:4;::::1;-1:-1:-1::0;;;;;;4318:24:4;;::::1;;::::0;;4217:158;;:::o;2610:414::-;1659:9;1672:10;1659:23;1651:66;;;;-1:-1:-1;;;1651:66:4;;4059:2:6;1651:66:4;;;4041:21:6;4098:2;4078:18;;;4071:30;4137:32;4117:18;;;4110:60;4187:18;;1651:66:4;;;;;;;;;2742:46:::1;2751:10;2763:16;2781:6;;2742:8;:46::i;:::-;2734:81;;;::::0;-1:-1:-1;;;2734:81:4;;4418:2:6;2734:81:4::1;::::0;::::1;4400:21:6::0;4457:2;4437:18;;;4430:30;-1:-1:-1;;;4476:18:6;;;4469:52;4538:18;;2734:81:4::1;4216:346:6::0;2734:81:4::1;2854:10;2833:32;::::0;;;:20:::1;:32;::::0;;;;;2879:16;;2833:42:::1;::::0;2868:7;;2833:42:::1;:::i;:::-;:62;;2825:94;;;::::0;-1:-1:-1;;;2825:94:4;;5031:2:6;2825:94:4::1;::::0;::::1;5013:21:6::0;5070:2;5050:18;;;5043:30;-1:-1:-1;;;5089:18:6;;;5082:49;5148:18;;2825:94:4::1;4829:343:6::0;2825:94:4::1;2950:10;2929:32;::::0;;;:20:::1;:32;::::0;;;;:43;;2965:7;;2929:32;:43:::1;::::0;2965:7;;2929:43:::1;:::i;:::-;::::0;;;-1:-1:-1;;2982:2:4::1;::::0;-1:-1:-1;;;;;2982:2:4::1;:7;2990:10;3002:14;:7:::0;3012:4:::1;3002:14;:::i;:::-;2982:35;::::0;-1:-1:-1;;;;;;2982:35:4::1;::::0;;;;;;-1:-1:-1;;;;;5542:32:6;;;2982:35:4::1;::::0;::::1;5524:51:6::0;5591:18;;;5584:34;5497:18;;2982:35:4::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;2610:414:::0;;;;:::o;2029:322::-;512:6:5;;522:1;512:11;504:34;;;;-1:-1:-1;;;504:34:5;;5831:2:6;504:34:5;;;5813:21:6;5870:2;5850:18;;;5843:30;-1:-1:-1;;;5889:18:6;;;5882:40;5939:18;;504:34:5;5629:334:6;504:34:5;558:1;549:6;:10;1239:19:1::1;:17;:19::i;:::-;2112:3:4::2;::::0;:40:::2;::::0;-1:-1:-1;;;2112:40:4;;2126:10:::2;2112:40;::::0;::::2;6180:34:6::0;2146:4:4::2;6230:18:6::0;;;6223:43;2156:7:4;;-1:-1:-1;;;;;2112:3:4::2;::::0;:13:::2;::::0;6115:18:6;;2112:40:4::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:51;;2104:84;;;::::0;-1:-1:-1;;;2104:84:4;;6668:2:6;2104:84:4::2;::::0;::::2;6650:21:6::0;6707:2;6687:18;;;6680:30;-1:-1:-1;;;6726:18:6;;;6719:50;6786:18;;2104:84:4::2;6466:344:6::0;2104:84:4::2;2208:3;::::0;:52:::2;::::0;-1:-1:-1;;;2208:52:4;;2225:10:::2;2208:52;::::0;::::2;7055:34:6::0;2245:4:4::2;7105:18:6::0;;;7098:43;7157:18;;;7150:34;;;2198:7:4::2;::::0;-1:-1:-1;;;;;2208:3:4::2;::::0;:16:::2;::::0;6990:18:6;;2208:52:4::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2198:62;;2278:2;2270:36;;;::::0;-1:-1:-1;;;2270:36:4;;7647:2:6;2270:36:4::2;::::0;::::2;7629:21:6::0;7686:2;7666:18;;;7659:30;-1:-1:-1;;;7705:18:6;;;7698:51;7766:18;;2270:36:4::2;7445:345:6::0;2270:36:4::2;2316:2;::::0;:28:::2;::::0;-1:-1:-1;;;2316:28:4;;2324:10:::2;2316:28;::::0;::::2;5524:51:6::0;5591:18;;;5584:34;;;-1:-1:-1;;;;;2316:2:4;;::::2;::::0;:7:::2;::::0;5497:18:6;;2316:28:4::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;591:1:5;582:10;;-1:-1:-1;;;;2029:322:4:o;3114:96::-;1094:13:0;:11;:13::i;:::-;3165:3:4::1;::::0;3174:28:::1;::::0;-1:-1:-1;;;3174:28:4;;3196:4:::1;3174:28;::::0;::::1;2360:51:6::0;-1:-1:-1;;;;;3165:3:4;;::::1;::::0;:8:::1;::::0;:3;;3174:13:::1;::::0;2333:18:6;;3174:28:4::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3165:38;;;;;;;;;;;;;3522:25:6::0;;3510:2;3495:18;;3376:177;3165:38:4::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;3114:96::o:0;2081:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2169:22:0;::::1;2161:73;;;::::0;-1:-1:-1;;;2161:73:0;;7997:2:6;2161:73:0::1;::::0;::::1;7979:21:6::0;8036:2;8016:18;;;8009:30;8075:34;8055:18;;;8048:62;-1:-1:-1;;;8126:18:6;;;8119:36;8172:19;;2161:73:0::1;7795:402:6::0;2161:73:0::1;2244:28;2263:8;2244:18;:28::i;1359:130::-:0;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;719:10:2;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;8404:2:6;1414:68:0;;;8386:21:6;;;8423:18;;;8416:30;8482:34;8462:18;;;8455:62;8534:18;;1414:68:0;8202:356:6;2433:117:1;1486:16;:14;:16::i;:::-;2501:5:::1;2491:15:::0;;-1:-1:-1;;;;2491:15:1::1;::::0;;2521:22:::1;719:10:2::0;2530:12:1::1;2521:22;::::0;-1:-1:-1;;;;;2378:32:6;;;2360:51;;2348:2;2333:18;2521:22:1::1;;;;;;;2433:117::o:0;2186:115::-;1239:19;:17;:19::i;:::-;2245:7:::1;:14:::0;;-1:-1:-1;;;;2245:14:1::1;-1:-1:-1::0;;;2245:14:1::1;::::0;;2274:20:::1;2281:12;719:10:2::0;;640:96;1153:184:3;1274:4;1326;1297:25;1310:5;1317:4;1297:12;:25::i;:::-;:33;;1153:184;-1:-1:-1;;;;1153:184:3:o;2433:187:0:-;2506:16;2525:6;;-1:-1:-1;;;;;2541:17:0;;;-1:-1:-1;;;;;;2541:17:0;;;;;;2573:40;;2525:6;;;;;;;2573:40;;2506:16;2573:40;2496:124;2433:187;:::o;1767:106:1:-;1662:4;1685:7;-1:-1:-1;;;1685:7:1;;;;1836:9;1828:38;;;;-1:-1:-1;;;1828:38:1;;8765:2:6;1828:38:1;;;8747:21:6;8804:2;8784:18;;;8777:30;-1:-1:-1;;;8823:18:6;;;8816:46;8879:18;;1828:38:1;8563:340:6;1945:106:1;1662:4;1685:7;-1:-1:-1;;;1685:7:1;;;;2003:41;;;;-1:-1:-1;;;2003:41:1;;9110:2:6;2003:41:1;;;9092:21:6;9149:2;9129:18;;;9122:30;-1:-1:-1;;;9168:18:6;;;9161:50;9228:18;;2003:41:1;8908:344:6;1991:290:3;2074:7;2116:4;2074:7;2130:116;2154:5;:12;2150:1;:16;2130:116;;;2202:33;2212:12;2226:5;2232:1;2226:8;;;;;;;;:::i;:::-;;;;;;;2202:9;:33::i;:::-;2187:48;-1:-1:-1;2168:3:3;;;;:::i;:::-;;;;2130:116;;;-1:-1:-1;2262:12:3;-1:-1:-1;1991:290:3;;;;;:::o;8054:147::-;8117:7;8147:1;8143;:5;:51;;8275:13;8366:15;;;8401:4;8394:15;;;8447:4;8431:21;;8143:51;;;8275:13;8366:15;;;8401:4;8394:15;;;8447:4;8431:21;;8151:20;8136:58;8054:147;-1:-1:-1;;;8054:147:3:o;14:118:6:-;100:5;93:13;86:21;79:5;76:32;66:60;;122:1;119;112:12;137:241;193:6;246:2;234:9;225:7;221:23;217:32;214:52;;;262:1;259;252:12;214:52;301:9;288:23;320:28;342:5;320:28;:::i;575:173::-;643:20;;-1:-1:-1;;;;;692:31:6;;682:42;;672:70;;738:1;735;728:12;672:70;575:173;;;:::o;753:367::-;816:8;826:6;880:3;873:4;865:6;861:17;857:27;847:55;;898:1;895;888:12;847:55;-1:-1:-1;921:20:6;;964:18;953:30;;950:50;;;996:1;993;986:12;950:50;1033:4;1025:6;1021:17;1009:29;;1093:3;1086:4;1076:6;1073:1;1069:14;1061:6;1057:27;1053:38;1050:47;1047:67;;;1110:1;1107;1100:12;1047:67;753:367;;;;;:::o;1125:579::-;1229:6;1237;1245;1253;1306:2;1294:9;1285:7;1281:23;1277:32;1274:52;;;1322:1;1319;1312:12;1274:52;1345:29;1364:9;1345:29;:::i;:::-;1335:39;;1421:2;1410:9;1406:18;1393:32;1383:42;;1476:2;1465:9;1461:18;1448:32;1503:18;1495:6;1492:30;1489:50;;;1535:1;1532;1525:12;1489:50;1574:70;1636:7;1627:6;1616:9;1612:22;1574:70;:::i;:::-;1125:579;;;;-1:-1:-1;1663:8:6;-1:-1:-1;;;;1125:579:6:o;1709:180::-;1768:6;1821:2;1809:9;1800:7;1796:23;1792:32;1789:52;;;1837:1;1834;1827:12;1789:52;-1:-1:-1;1860:23:6;;1709:180;-1:-1:-1;1709:180:6:o;1894:315::-;1959:6;1967;2020:2;2008:9;1999:7;1995:23;1991:32;1988:52;;;2036:1;2033;2026:12;1988:52;2075:9;2062:23;2094:28;2116:5;2094:28;:::i;:::-;2141:5;-1:-1:-1;2165:38:6;2199:2;2184:18;;2165:38;:::i;:::-;2155:48;;1894:315;;;;;:::o;2422:573::-;2526:6;2534;2542;2550;2603:2;2591:9;2582:7;2578:23;2574:32;2571:52;;;2619:1;2616;2609:12;2571:52;2655:9;2642:23;2632:33;;2712:2;2701:9;2697:18;2684:32;2674:42;;2767:2;2756:9;2752:18;2739:32;2794:18;2786:6;2783:30;2780:50;;;2826:1;2823;2816:12;3185:186;3244:6;3297:2;3285:9;3276:7;3272:23;3268:32;3265:52;;;3313:1;3310;3303:12;3265:52;3336:29;3355:9;3336:29;:::i;4567:127::-;4628:10;4623:3;4619:20;4616:1;4609:31;4659:4;4656:1;4649:15;4683:4;4680:1;4673:15;4699:125;4764:9;;;4785:10;;;4782:36;;;4798:18;;:::i;5177:168::-;5250:9;;;5281;;5298:15;;;5292:22;;5278:37;5268:71;;5319:18;;:::i;6277:184::-;6347:6;6400:2;6388:9;6379:7;6375:23;6371:32;6368:52;;;6416:1;6413;6406:12;6368:52;-1:-1:-1;6439:16:6;;6277:184;-1:-1:-1;6277:184:6:o;7195:245::-;7262:6;7315:2;7303:9;7294:7;7290:23;7286:32;7283:52;;;7331:1;7328;7321:12;7283:52;7363:9;7357:16;7382:28;7404:5;7382:28;:::i;9257:127::-;9318:10;9313:3;9309:20;9306:1;9299:31;9349:4;9346:1;9339:15;9373:4;9370:1;9363:15;9389:135;9428:3;9449:17;;;9446:43;;9469:18;;:::i;:::-;-1:-1:-1;9516:1:6;9505:13;;9389:135::o

ipfs://b25770aec86ecae1a274c3c4054305d035ec8c6befdcd24a4c2c5a2bd450d7bf