Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./TokenAppController.sol";
import "./IERC20.sol";
import "./IERC721.sol";
import "./IXStore.sol";
import "./SafeMath.sol";
import "./SafeERC20.sol";
import "./ReentrancyGuard.sol";

contract XBounties is TokenAppController, ReentrancyGuard {
    using SafeMath for uint256;

    using SafeERC20 for IERC20;

    uint256 public constant BASE = 10**18;
    uint256 public interval = 15 * 60; // 15 minutes
    uint256 public start = 1608667200; // Tue Dec 22 2020, 12pm PST
    uint64 public vestedUntil = 1609876800; // Tue, Jan 5 2021, 12pm PST

    IERC20 public nftxToken;
    address payable public daoMultiSig;

    struct Bounty {
        address tokenContract;
        uint256 nftxPrice;
        uint256 paidOut;
        uint256 payoutCap;
    }

    event NewBountyAdded(uint256 bountyId);
    event BountyFilled(
        uint256 bountyId,
        uint256 nftxAmount,
        uint256 assetAmount,
        address sender,
        uint64 start,
        uint64 cliff,
        uint64 vested
    );
    event NftxPriceSet(uint256 bountyId, uint256 newNftxPrice);
    event PayoutCapSet(uint256 bountyId, uint256 newCap);
    event BountyClosed(uint256 bountyId);
    event EthWithdrawn(uint256 amount);
    event Erc20Withdrawn(address tokenContract, uint256 amount);
    event Erc721Withdrawn(address nftContract, uint256 tokenId);

    Bounty[] internal bounties;

    constructor(
        address _tokenManager,
        address payable _daoMultiSig,
        address _nftxToken,
        address _xStore
    ) public {
        initTAC();
        setTokenManager(_tokenManager);
        daoMultiSig = _daoMultiSig;
        nftxToken = IERC20(_nftxToken);

        IXStore xStore = IXStore(_xStore);

        createEthBounty(130 * BASE, 65000 * BASE);
        createEthBounty(65 * BASE, 65000 * BASE);
        createEthBounty(BASE.mul(130).div(3), 65000 * BASE);
        createBounty(
            xStore.xTokenAddress(0), // PUNK-BASIC
            390 * BASE,
            31200 * BASE
        );
        createBounty(
            xStore.xTokenAddress(15), // PUNK-FEMALE
            520 * BASE,
            15600 * BASE
        );
        createBounty(
            xStore.xTokenAddress(1), // PUNK-ATTR-4
            585 * BASE,
            14625 * BASE
        );
        createBounty(
            xStore.xTokenAddress(2), // PUNK-ATTR-5
            1950 * BASE,
            15600 * BASE
        );
        createBounty(
            xStore.xTokenAddress(3), // PUNK-ZOMBIE
            8450 * BASE,
            16900 * BASE
        );
        createBounty(
            xStore.xTokenAddress(4), // AXIE-ORIGIN
            130 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(5), // AXIE-MYSTIC-1
            780 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(6), // AXIE-MYSTIC-2
            3900 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(7), // KITTY-GEN-0
            325 * BASE.div(10),
            6760 * BASE
        );
        createBounty(
            xStore.xTokenAddress(8), // KITTY-GEN-0-F
            39 * BASE,
            6240 * BASE
        );
        createBounty(
            xStore.xTokenAddress(9), // KITTY-FOUNDER
            6175 * BASE,
            6175 * BASE
        );
        createBounty(
            xStore.xTokenAddress(10), // AVASTR-BASIC
            195 * BASE.div(10),
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(11), // AVASTR-RANK-30
            26 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(12), // AVASTR-RANK-60
            195 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(13), // GLYPH
            1300 * BASE,
            23400 * BASE
        );
        createBounty(
            xStore.xTokenAddress(14), // JOY
            650 * BASE,
            11700 * BASE
        );
    }

    function setStart(uint256 newStart) public onlyOwner {
        start = newStart;
    }

    function setInterval(uint256 newInterval) public onlyOwner {
        interval = newInterval;
    }

    function setVestedUntil(uint64 newTime) public onlyOwner {
        vestedUntil = newTime;
    }

    function getBountyInfo(uint256 bountyId)
        public
        view
        returns (address, uint256, uint256, uint256)
    {
        require(bountyId < bounties.length, "Invalid bountyId");
        return (
            bounties[bountyId].tokenContract,
            bounties[bountyId].nftxPrice,
            bounties[bountyId].paidOut,
            bounties[bountyId].payoutCap
        );
    }

    function getMaxPayout() public view returns (uint256) {
        uint256 tMinus4 = start.sub(interval.mul(4));
        uint256 tMinus3 = start.sub(interval.mul(3));
        uint256 tMinus2 = start.sub(interval.mul(2));
        uint256 tMinus1 = start.sub(interval.mul(1));
        uint256 tm4Max = 0;
        uint256 tm3Max = 50 * BASE;
        uint256 tm2Max = 500 * BASE;
        uint256 tm1Max = 5000 * BASE;
        uint256 tm0Max = 50000 * BASE;
        if (now < tMinus4) {
            return 0;
        } else if (now < tMinus3) {
            uint256 progressBigNum = now.sub(tMinus4).mul(BASE).div(interval);
            uint256 addedPayout = tm3Max.sub(tm4Max).mul(progressBigNum).div(
                BASE
            );
            return tm4Max.add(addedPayout);
        } else if (now < tMinus2) {
            uint256 progressBigNum = now.sub(tMinus3).mul(BASE).div(interval);
            uint256 addedPayout = tm2Max.sub(tm3Max).mul(progressBigNum).div(
                BASE
            );
            return tm3Max.add(addedPayout);
        } else if (now < tMinus1) {
            uint256 progressBigNum = now.sub(tMinus2).mul(BASE).div(interval);
            uint256 addedPayout = tm1Max.sub(tm2Max).mul(progressBigNum).div(
                BASE
            );
            return tm2Max.add(addedPayout);
        } else if (now < start) {
            uint256 progressBigNum = now.sub(tMinus1).mul(BASE).div(interval);
            uint256 addedPayout = tm0Max.sub(tm1Max).mul(progressBigNum).div(
                BASE
            );
            return tm1Max.add(addedPayout);
        } else {
            return tm0Max;
        }
    }

    function getBountiesLength() public view returns (uint256) {
        return bounties.length;
    }

    function getIsEth(uint256 bountyId) public view returns (bool) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].tokenContract == address(0);
    }

    function getTokenContract(uint256 bountyId) public view returns (address) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].tokenContract;
    }

    function getNftxPrice(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].nftxPrice;
    }

    function getPayoutCap(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].payoutCap;
    }

    function getPaidOut(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].paidOut;
    }

    function setNftxPrice(uint256 bountyId, uint256 newPrice) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].nftxPrice = newPrice;
        emit NftxPriceSet(bountyId, newPrice);
    }

    function setPayoutCap(uint256 bountyId, uint256 newCap) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].payoutCap = newCap;
        emit PayoutCapSet(bountyId, newCap);
    }

    function createEthBounty(uint256 nftxPricePerEth, uint256 amountOfEth)
        public
        onlyOwner
    {
        createBounty(address(0), nftxPricePerEth, amountOfEth);
    }

    function createBounty(address token, uint256 nftxPrice, uint256 payoutCap)
        public
        onlyOwner
    {
        Bounty memory newBounty;
        newBounty.tokenContract = token;
        newBounty.nftxPrice = nftxPrice;
        newBounty.payoutCap = payoutCap;
        bounties.push(newBounty);
        uint256 bountyId = bounties.length.sub(1);
        emit NewBountyAdded(bountyId);
    }

    function closeBounty(uint256 bountyId) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].payoutCap = bounties[bountyId].paidOut;
        emit BountyClosed(bountyId);
    }

    function fillBounty(uint256 bountyId, uint256 amountBeingSent)
        public
        payable
        nonReentrant
    {
        _fillBountyCustom(
            bountyId,
            amountBeingSent,
            vestedUntil - 2,
            vestedUntil - 1,
            vestedUntil
        );
    }

    /* function fillBountyCustom(
        uint256 bountyId,
        uint256 donationSize,
        uint64 _start,
        uint64 cliff,
        uint64 vested
    ) public payable nonReentrant {
        _fillBountyCustom(bountyId, donationSize, _start, cliff, vested);
    } */

    function _fillBountyCustom(
        uint256 bountyId,
        uint256 donationSize,
        uint64 _start,
        uint64 cliff,
        uint64 vested
    ) internal {
        require(cliff >= vestedUntil - 1 && vested >= vestedUntil, "Not valid");
        require(bountyId < bounties.length, "Invalid bountyId");
        Bounty storage bounty = bounties[bountyId];
        uint256 rewardCap = getMaxPayout();
        require(rewardCap > 0, "Must wait for cap to be lifted");
        uint256 remainingNftx = bounty.payoutCap.sub(bounty.paidOut);
        require(remainingNftx > 0, "Bounty is already finished");
        uint256 requestedNftx = donationSize.mul(bounty.nftxPrice).div(BASE);
        uint256 willGive = remainingNftx < requestedNftx
            ? remainingNftx
            : rewardCap < requestedNftx
            ? rewardCap
            : requestedNftx;
        uint256 willTake = donationSize.mul(willGive).div(requestedNftx);
        if (getIsEth(bountyId)) {
            require(msg.value >= willTake, "Value sent is insufficient");
            if (msg.value > willTake) {
                address payable _sender = msg.sender;
                _sender.transfer(msg.value.sub(willTake));
            }
            daoMultiSig.transfer(willTake);
        } else {
            IERC20 fundToken = IERC20(bounty.tokenContract);
            fundToken.safeTransferFrom(msg.sender, daoMultiSig, willTake);
        }
        if (now > vested) {
            nftxToken.safeTransfer(msg.sender, willGive);
        } else {
            nftxToken.safeTransfer(tokenManagerAddr, willGive);
            callAssignVested(
                msg.sender,
                willGive,
                _start,
                cliff,
                vested,
                false
            );
        }
        bounty.paidOut = bounty.paidOut.add(willGive);
        emit BountyFilled(
            bountyId,
            willGive,
            willTake,
            msg.sender,
            _start,
            cliff,
            vested
        );
    }

    function withdrawEth(uint256 amount) public onlyOwner {
        address payable sender = msg.sender;
        sender.transfer(amount);
        emit EthWithdrawn(amount);
    }

    function withdrawErc20(address tokenContract, uint256 amount)
        public
        onlyOwner
    {
        IERC20 token = IERC20(tokenContract);
        token.safeTransfer(msg.sender, amount);
        emit Erc20Withdrawn(tokenContract, amount);
    }

    function withdrawErc721(address nftContract, uint256 tokenId)
        public
        onlyOwner
    {
        IERC721 nft = IERC721(nftContract);
        nft.safeTransferFrom(address(this), msg.sender, tokenId);
        emit Erc721Withdrawn(nftContract, tokenId);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive vaults via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(
            data
        );
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

/*
 * @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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

/**
 * @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.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
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 of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @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._indexes[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 read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 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 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

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

            // Delete the index for the deleted slot
            delete set._indexes[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._indexes[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)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }

    // 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(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(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(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(uint256(_at(set._inner, index)));
    }

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

import "./IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.4.24 <0.7.0;

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {
    /**
   * @dev Indicates that the contract has been initialized.
   */
    bool private initialized;

    /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
    bool private initializing;

    /**
   * @dev Modifier to use in the initializer function of a contract.
   */
    modifier initializer() {
        require(
            initializing || isConstructor() || !initialized,
            "Contract instance has already been initialized"
        );

        bool isTopLevelCall = !initializing;
        if (isTopLevelCall) {
            initializing = true;
            initialized = true;
        }

        _;

        if (isTopLevelCall) {
            initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        assembly {
            cs := extcodesize(self)
        }
        return cs == 0;
    }

    // Reserved storage space to allow for layout changes in the future.
    uint256[50] private ______gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

interface ITokenManager {
    function mint(address _receiver, uint256 _amount) external;
    function issue(uint256 _amount) external;
    function assign(address _receiver, uint256 _amount) external;
    function burn(address _holder, uint256 _amount) external;
    function assignVested(
        address _receiver,
        uint256 _amount,
        uint64 _start,
        uint64 _cliff,
        uint64 _vested,
        bool _revokable
    ) external returns (uint256);
    function revokeVesting(address _holder, uint256 _vestingId) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./EnumerableSet.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./IXToken.sol";
import "./IERC721.sol";
import "./EnumerableSet.sol";

interface IXStore {
    struct FeeParams {
        uint256 ethBase;
        uint256 ethStep;
    }

    struct BountyParams {
        uint256 ethMax;
        uint256 length;
    }

    struct Vault {
        address xTokenAddress;
        address nftAddress;
        address manager;
        IXToken xToken;
        IERC721 nft;
        EnumerableSet.UintSet holdings;
        EnumerableSet.UintSet reserves;
        mapping(uint256 => address) requester;
        mapping(uint256 => bool) isEligible;
        mapping(uint256 => bool) shouldReserve;
        bool allowMintRequests;
        bool flipEligOnRedeem;
        bool negateEligibility;
        bool isFinalized;
        bool isClosed;
        FeeParams mintFees;
        FeeParams burnFees;
        FeeParams dualFees;
        BountyParams supplierBounty;
        uint256 ethBalance;
        uint256 tokenBalance;
        bool isD2Vault;
        address d2AssetAddress;
        IERC20 d2Asset;
        uint256 d2Holdings;
    }

    function isExtension(address addr) external view returns (bool);

    function randNonce() external view returns (uint256);

    function vaultsLength() external view returns (uint256);

    function xTokenAddress(uint256 vaultId) external view returns (address);

    function nftAddress(uint256 vaultId) external view returns (address);

    function manager(uint256 vaultId) external view returns (address);

    function xToken(uint256 vaultId) external view returns (IXToken);

    function nft(uint256 vaultId) external view returns (IERC721);

    function holdingsLength(uint256 vaultId) external view returns (uint256);

    function holdingsContains(uint256 vaultId, uint256 elem)
        external
        view
        returns (bool);

    function holdingsAt(uint256 vaultId, uint256 index)
        external
        view
        returns (uint256);

    function reservesLength(uint256 vaultId) external view returns (uint256);

    function reservesContains(uint256 vaultId, uint256 elem)
        external
        view
        returns (bool);

    function reservesAt(uint256 vaultId, uint256 index)
        external
        view
        returns (uint256);

    function requester(uint256 vaultId, uint256 id)
        external
        view
        returns (address);

    function isEligible(uint256 vaultId, uint256 id)
        external
        view
        returns (bool);

    function shouldReserve(uint256 vaultId, uint256 id)
        external
        view
        returns (bool);

    function allowMintRequests(uint256 vaultId) external view returns (bool);

    function flipEligOnRedeem(uint256 vaultId) external view returns (bool);

    function negateEligibility(uint256 vaultId) external view returns (bool);

    function isFinalized(uint256 vaultId) external view returns (bool);

    function isClosed(uint256 vaultId) external view returns (bool);

    function mintFees(uint256 vaultId) external view returns (uint256, uint256);

    function burnFees(uint256 vaultId) external view returns (uint256, uint256);

    function dualFees(uint256 vaultId) external view returns (uint256, uint256);

    function supplierBounty(uint256 vaultId)
        external
        view
        returns (uint256, uint256);

    function ethBalance(uint256 vaultId) external view returns (uint256);

    function tokenBalance(uint256 vaultId) external view returns (uint256);

    function isD2Vault(uint256 vaultId) external view returns (bool);

    function d2AssetAddress(uint256 vaultId) external view returns (address);

    function d2Asset(uint256 vaultId) external view returns (IERC20);

    function d2Holdings(uint256 vaultId) external view returns (uint256);

    function setXTokenAddress(uint256 vaultId, address _xTokenAddress) external;

    function setNftAddress(uint256 vaultId, address _assetAddress) external;

    function setManager(uint256 vaultId, address _manager) external;

    function setXToken(uint256 vaultId) external;

    function setNft(uint256 vaultId) external;

    function holdingsAdd(uint256 vaultId, uint256 elem) external;

    function holdingsRemove(uint256 vaultId, uint256 elem) external;

    function reservesAdd(uint256 vaultId, uint256 elem) external;

    function reservesRemove(uint256 vaultId, uint256 elem) external;

    function setRequester(uint256 vaultId, uint256 id, address _requester)
        external;

    function setIsEligible(uint256 vaultId, uint256 id, bool _bool) external;

    function setShouldReserve(uint256 vaultId, uint256 id, bool _shouldReserve)
        external;

    function setAllowMintRequests(uint256 vaultId, bool isAllowed) external;

    function setFlipEligOnRedeem(uint256 vaultId, bool flipElig) external;

    function setNegateEligibility(uint256 vaultId, bool negateElig) external;

    function setIsFinalized(uint256 vaultId, bool _isFinalized) external;

    function setIsClosed(uint256 vaultId, bool _isClosed) external;

    function setMintFees(uint256 vaultId, uint256 ethBase, uint256 ethStep)
        external;

    function setBurnFees(uint256 vaultId, uint256 ethBase, uint256 ethStep)
        external;

    function setDualFees(uint256 vaultId, uint256 ethBase, uint256 ethStep)
        external;

    function setSupplierBounty(uint256 vaultId, uint256 ethMax, uint256 length)
        external;

    function setEthBalance(uint256 vaultId, uint256 _ethBalance) external;

    function setTokenBalance(uint256 vaultId, uint256 _tokenBalance) external;

    function setIsD2Vault(uint256 vaultId, bool _isD2Vault) external;

    function setD2AssetAddress(uint256 vaultId, address _assetAddress) external;

    function setD2Asset(uint256 vaultId) external;

    function setD2Holdings(uint256 vaultId, uint256 _d2Holdings) external;

    ////////////////////////////////////////////////////////////

    function setIsExtension(address addr, bool _isExtension) external;

    function setRandNonce(uint256 _randNonce) external;

    function addNewVault() external returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./IERC20.sol";

interface IXToken is IERC20 {
    function owner() external returns (address);

    function burn(uint256 amount) external;

    function burnFrom(address account, uint256 amount) external;

    function mint(address to, uint256 amount) external;

    function changeName(string calldata name) external;

    function changeSymbol(string calldata symbol) external;

    function setVaultAddress(address vaultAddress) external;

    function transferOwnership(address newOwner) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./Context.sol";
import "./Initializable.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.
 */
contract Ownable is Context, Initializable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function initOwnable() internal virtual initializer {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./Initializable.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].
 */
contract ReentrancyGuard is Initializable {
    // 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 revault on every call to nonReentrant will be lower in
    // amount. Since revaults 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 revault coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    function initReentrancyGuard() internal {
        _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 make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

        // By storing the original value once again, a revault is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value)
        internal
    {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value)
        internal
    {
        uint256 newAllowance = token.allowance(address(this), spender).add(
            value
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value)
        internal
    {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            "SafeERC20: decreased allowance below zero"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage)
        internal
        pure
        returns (uint256)
    {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage)
        internal
        pure
        returns (uint256)
    {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage)
        internal
        pure
        returns (uint256)
    {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./Ownable.sol";
import "./ITokenManager.sol";

contract TokenAppController is Ownable {
    ITokenManager public tokenManager;
    address public tokenManagerAddr;

    function initTAC() internal {
        initOwnable();
    }

    function setTokenManager(address tokenManagerAddress) internal onlyOwner {
        tokenManagerAddr = tokenManagerAddress;
        tokenManager = ITokenManager(tokenManagerAddr);
    }

    function callMint(address _receiver, uint256 _amount) internal onlyOwner {
        tokenManager.mint(_receiver, _amount);
    }

    function callIssue(uint256 _amount) internal onlyOwner {
        tokenManager.issue(_amount);
    }

    function callAssign(address _receiver, uint256 _amount) internal onlyOwner {
        tokenManager.assign(_receiver, _amount);
    }

    function callBurn(address _holder, uint256 _amount) internal onlyOwner {
        tokenManager.burn(_holder, _amount);
    }

    function callAssignVested(
        address _receiver,
        uint256 _amount,
        uint64 _start,
        uint64 _cliff,
        uint64 _vested,
        bool _revokable
    ) internal returns (uint256) {
        return
            tokenManager.assignVested(
                _receiver,
                _amount,
                _start,
                _cliff,
                _vested,
                _revokable
            );
    }

    function callRevokeVesting(address _holder, uint256 _vestingId)
        internal
        onlyOwner
    {
        tokenManager.revokeVesting(_holder, _vestingId);
    }

}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.8;

import "./TokenAppController.sol";
import "./IERC20.sol";
import "./IERC721.sol";
import "./IXStore.sol";
import "./SafeMath.sol";
import "./SafeERC20.sol";
import "./ReentrancyGuard.sol";

contract XBountiesRinkeby is TokenAppController, ReentrancyGuard {
    using SafeMath for uint256;

    using SafeERC20 for IERC20;

    uint256 public constant BASE = 10**18;
    uint256 public interval = 15 * 60; // 15 minutes
    uint256 public start = 1608580800; // Mon, Dec 21 2020, 12pm PST
    uint64 public vestedUntil = 1609876800; // Tue, Jan 5 2021, 12pm PST

    IERC20 public nftxToken;
    address payable public daoMultiSig;

    struct Bounty {
        address tokenContract;
        uint256 nftxPrice;
        uint256 paidOut;
        uint256 payoutCap;
    }

    event NewBountyAdded(uint256 bountyId);
    event BountyFilled(
        uint256 bountyId,
        uint256 nftxAmount,
        uint256 assetAmount,
        address sender,
        uint64 start,
        uint64 cliff,
        uint64 vested
    );
    event NftxPriceSet(uint256 bountyId, uint256 newNftxPrice);
    event PayoutCapSet(uint256 bountyId, uint256 newCap);
    event BountyClosed(uint256 bountyId);
    event EthWithdrawn(uint256 amount);
    event Erc20Withdrawn(address tokenContract, uint256 amount);
    event Erc721Withdrawn(address nftContract, uint256 tokenId);

    Bounty[] internal bounties;

    constructor(
        address _tokenManager,
        address payable _daoMultiSig,
        address _nftxToken,
        address _xStore
    ) public {
        initTAC();
        setTokenManager(_tokenManager);
        daoMultiSig = _daoMultiSig;
        nftxToken = IERC20(_nftxToken);

        IXStore xStore = IXStore(_xStore);

        createEthBounty(130 * BASE, 65000 * BASE);
        createEthBounty(65 * BASE, 65000 * BASE);
        createEthBounty(BASE.mul(130).div(3), 65000 * BASE);
        createBounty(
            xStore.xTokenAddress(0), // PUNK-BASIC
            390 * BASE,
            31200 * BASE
        );
        createBounty(
            xStore.xTokenAddress(1), // PUNK-ATTR-4
            585 * BASE,
            14625 * BASE
        );
        createBounty(
            xStore.xTokenAddress(2), // PUNK-ATTR-5
            1950 * BASE,
            15600 * BASE
        );
        createBounty(
            xStore.xTokenAddress(3), // PUNK-ZOMBIE
            8450 * BASE,
            16900 * BASE
        );
        createBounty(
            xStore.xTokenAddress(4), // AXIE-ORIGIN
            130 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(5), // AXIE-MYSTIC-1
            780 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(6), // AXIE-MYSTIC-2
            3900 * BASE,
            7800 * BASE
        );
        createBounty(
            xStore.xTokenAddress(7), // KITTY-GEN-0
            26 * BASE,
            5850 * BASE
        );
        createBounty(
            xStore.xTokenAddress(8), // KITTY-GEN-0-F
            39 * BASE,
            5850 * BASE
        );
        createBounty(
            xStore.xTokenAddress(9), // KITTY-FOUNDER
            6175 * BASE,
            6175 * BASE
        );
        createBounty(
            xStore.xTokenAddress(10), // AVASTR-BASIC
            20 * BASE,
            6175 * BASE
        );
        createBounty(
            xStore.xTokenAddress(11), // AVASTR-RANK-30
            26 * BASE,
            6175 * BASE
        );
        createBounty(
            xStore.xTokenAddress(12), // AVASTR-RANK-60
            195 * BASE,
            6175 * BASE
        );
        createBounty(
            xStore.xTokenAddress(13), // GLYPH
            1300 * BASE,
            26000 * BASE
        );
        createBounty(
            xStore.xTokenAddress(14), // JOY
            455 * BASE,
            10010 * BASE
        );
    }

    function setStart(uint256 newStart) public onlyOwner {
        start = newStart;
    }

    function setInterval(uint256 newInterval) public onlyOwner {
        interval = newInterval;
    }

    function setVestedUntil(uint64 newTime) public onlyOwner {
        vestedUntil = newTime;
    }

    function getBountyInfo(uint256 bountyId)
        public
        view
        returns (address, uint256, uint256, uint256)
    {
        require(bountyId < bounties.length, "Invalid bountyId");
        return (
            bounties[bountyId].tokenContract,
            bounties[bountyId].nftxPrice,
            bounties[bountyId].paidOut,
            bounties[bountyId].payoutCap
        );
    }

    function getMaxPayout() public view returns (uint256) {
        uint256 tMinus4 = start.sub(interval.mul(4));
        uint256 tMinus3 = start.sub(interval.mul(3));
        uint256 tMinus2 = start.sub(interval.mul(2));
        uint256 tMinus1 = start.sub(interval.mul(1));
        uint256 tm4Max = 0;
        uint256 tm3Max = 50 * BASE;
        uint256 tm2Max = 500 * BASE;
        uint256 tm1Max = 5000 * BASE;
        uint256 tm0Max = 50000 * BASE;
        if (now < tMinus4) {
            return 0;
        } else if (now < tMinus3) {
            uint256 progressBigNum = now.sub(tMinus4).mul(BASE).div(interval);
            uint256 addedPayout = tm3Max.sub(tm4Max).mul(progressBigNum).div(
                BASE
            );
            return tm4Max.add(addedPayout);
        } else if (now < tMinus2) {
            uint256 progressBigNum = now.sub(tMinus3).mul(BASE).div(interval);
            uint256 addedPayout = tm2Max.sub(tm3Max).mul(progressBigNum).div(
                BASE
            );
            return tm3Max.add(addedPayout);
        } else if (now < tMinus1) {
            uint256 progressBigNum = now.sub(tMinus2).mul(BASE).div(interval);
            uint256 addedPayout = tm1Max.sub(tm2Max).mul(progressBigNum).div(
                BASE
            );
            return tm2Max.add(addedPayout);
        } else if (now < start) {
            uint256 progressBigNum = now.sub(tMinus1).mul(BASE).div(interval);
            uint256 addedPayout = tm0Max.sub(tm1Max).mul(progressBigNum).div(
                BASE
            );
            return tm1Max.add(addedPayout);
        } else {
            return tm0Max;
        }
    }

    function getBountiesLength() public view returns (uint256) {
        return bounties.length;
    }

    function getIsEth(uint256 bountyId) public view returns (bool) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].tokenContract == address(0);
    }

    function getTokenContract(uint256 bountyId) public view returns (address) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].tokenContract;
    }

    function getNftxPrice(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].nftxPrice;
    }

    function getPayoutCap(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].payoutCap;
    }

    function getPaidOut(uint256 bountyId) public view returns (uint256) {
        require(bountyId < bounties.length, "Invalid bountyId");
        return bounties[bountyId].paidOut;
    }

    function setNftxPrice(uint256 bountyId, uint256 newPrice) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].nftxPrice = newPrice;
        emit NftxPriceSet(bountyId, newPrice);
    }

    function setPayoutCap(uint256 bountyId, uint256 newCap) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].payoutCap = newCap;
        emit PayoutCapSet(bountyId, newCap);
    }

    function createEthBounty(uint256 nftxPricePerEth, uint256 amountOfEth)
        public
        onlyOwner
    {
        createBounty(address(0), nftxPricePerEth, amountOfEth);
    }

    function createBounty(address token, uint256 nftxPrice, uint256 payoutCap)
        public
        onlyOwner
    {
        Bounty memory newBounty;
        newBounty.tokenContract = token;
        newBounty.nftxPrice = nftxPrice;
        newBounty.payoutCap = payoutCap;
        bounties.push(newBounty);
        uint256 bountyId = bounties.length.sub(1);
        emit NewBountyAdded(bountyId);
    }

    function closeBounty(uint256 bountyId) public onlyOwner {
        require(bountyId < bounties.length, "Invalid bountyId");
        bounties[bountyId].payoutCap = bounties[bountyId].paidOut;
        emit BountyClosed(bountyId);
    }

    function fillBounty(uint256 bountyId, uint256 amountBeingSent)
        public
        payable
        nonReentrant
    {
        _fillBountyCustom(
            bountyId,
            amountBeingSent,
            vestedUntil - 2,
            vestedUntil - 1,
            vestedUntil
        );
    }

    /* function fillBountyCustom(
        uint256 bountyId,
        uint256 donationSize,
        uint64 _start,
        uint64 cliff,
        uint64 vested
    ) public payable nonReentrant {
        _fillBountyCustom(bountyId, donationSize, _start, cliff, vested);
    } */

    function _fillBountyCustom(
        uint256 bountyId,
        uint256 donationSize,
        uint64 _start,
        uint64 cliff,
        uint64 vested
    ) internal {
        require(cliff >= vestedUntil - 1 && vested >= vestedUntil, "Not valid");
        require(bountyId < bounties.length, "Invalid bountyId");
        Bounty storage bounty = bounties[bountyId];
        uint256 rewardCap = getMaxPayout();
        require(rewardCap > 0, "Must wait for cap to be lifted");
        uint256 remainingNftx = bounty.payoutCap.sub(bounty.paidOut);
        require(remainingNftx > 0, "Bounty is already finished");
        uint256 requestedNftx = donationSize.mul(bounty.nftxPrice).div(BASE);
        uint256 willGive = remainingNftx < requestedNftx
            ? remainingNftx
            : rewardCap < requestedNftx
            ? rewardCap
            : requestedNftx;
        uint256 willTake = donationSize.mul(willGive).div(requestedNftx);
        if (getIsEth(bountyId)) {
            require(msg.value >= willTake, "Value sent is insufficient");
            if (msg.value > willTake) {
                address payable _sender = msg.sender;
                _sender.transfer(msg.value.sub(willTake));
            }
            daoMultiSig.transfer(willTake);
        } else {
            IERC20 fundToken = IERC20(bounty.tokenContract);
            fundToken.safeTransferFrom(msg.sender, daoMultiSig, willTake);
        }
        if (now > vested) {
            nftxToken.safeTransfer(msg.sender, willGive);
        } else {
            nftxToken.safeTransfer(tokenManagerAddr, willGive);
            callAssignVested(
                msg.sender,
                willGive,
                _start,
                cliff,
                vested,
                false
            );
        }
        bounty.paidOut = bounty.paidOut.add(willGive);
        emit BountyFilled(
            bountyId,
            willGive,
            willTake,
            msg.sender,
            _start,
            cliff,
            vested
        );
    }

    function withdrawEth(uint256 amount) public onlyOwner {
        address payable sender = msg.sender;
        sender.transfer(amount);
        emit EthWithdrawn(amount);
    }

    function withdrawErc20(address tokenContract, uint256 amount)
        public
        onlyOwner
    {
        IERC20 token = IERC20(tokenContract);
        token.safeTransfer(msg.sender, amount);
        emit Erc20Withdrawn(tokenContract, amount);
    }

    function withdrawErc721(address nftContract, uint256 tokenId)
        public
        onlyOwner
    {
        IERC721 nft = IERC721(nftContract);
        nft.safeTransferFrom(address(this), msg.sender, tokenId);
        emit Erc721Withdrawn(nftContract, tokenId);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_tokenManager","type":"address"},{"internalType":"address payable","name":"_daoMultiSig","type":"address"},{"internalType":"address","name":"_nftxToken","type":"address"},{"internalType":"address","name":"_xStore","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"BountyClosed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"bountyId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"nftxAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"assetAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint64","name":"start","type":"uint64"},{"indexed":false,"internalType":"uint64","name":"cliff","type":"uint64"},{"indexed":false,"internalType":"uint64","name":"vested","type":"uint64"}],"name":"BountyFilled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenContract","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Erc20Withdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nftContract","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Erc721Withdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EthWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"NewBountyAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"bountyId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newNftxPrice","type":"uint256"}],"name":"NftxPriceSet","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":false,"internalType":"uint256","name":"bountyId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCap","type":"uint256"}],"name":"PayoutCapSet","type":"event"},{"inputs":[],"name":"BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"closeBounty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nftxPrice","type":"uint256"},{"internalType":"uint256","name":"payoutCap","type":"uint256"}],"name":"createBounty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"nftxPricePerEth","type":"uint256"},{"internalType":"uint256","name":"amountOfEth","type":"uint256"}],"name":"createEthBounty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"daoMultiSig","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"},{"internalType":"uint256","name":"amountBeingSent","type":"uint256"}],"name":"fillBounty","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getBountiesLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getBountyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getIsEth","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxPayout","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getNftxPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getPaidOut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getPayoutCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"}],"name":"getTokenContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"interval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftxToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newInterval","type":"uint256"}],"name":"setInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"},{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setNftxPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bountyId","type":"uint256"},{"internalType":"uint256","name":"newCap","type":"uint256"}],"name":"setPayoutCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newStart","type":"uint256"}],"name":"setStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"newTime","type":"uint64"}],"name":"setVestedUntil","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenManager","outputs":[{"internalType":"contract ITokenManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenManagerAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestedUntil","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawErc20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"withdrawErc721","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005566b3e5fc300a1b28c214b49a5950c34d00eb3300000000000000000000000040d73df4f99bae688ce3c23a01022224fe16c7b200000000000000000000000087d73e916d7057945c9bcd8cdd94e42a6f47f776000000000000000000000000be54738723cea167a76ad5421b50caa49692e7b7

-----Decoded View---------------
Arg [0] : _tokenManager (address): 0x5566B3E5Fc300A1B28C214b49a5950C34d00eb33
Arg [1] : _daoMultiSig (address): 0x40D73Df4F99bae688CE3C23a01022224FE16C7b2
Arg [2] : _nftxToken (address): 0x87d73E916D7057945c9BcD8cdd94e42A6F47f776
Arg [3] : _xStore (address): 0xBe54738723cea167a76ad5421b50cAa49692E7B7

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000005566b3e5fc300a1b28c214b49a5950c34d00eb33
Arg [1] : 00000000000000000000000040d73df4f99bae688ce3c23a01022224fe16c7b2
Arg [2] : 00000000000000000000000087d73e916d7057945c9bcd8cdd94e42a6f47f776
Arg [3] : 000000000000000000000000be54738723cea167a76ad5421b50caa49692e7b7

247:11944:15:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;196:31:14;;5:9:-1;2:2;;;27:1;24;17:12;2:2;196:31:14;;;:::i;:::-;;;;-1:-1:-1;;;;;196:31:14;;;;;;;;;;;;;;4192:98:15;;5:9:-1;2:2;;;27:1;24;17:12;2:2;4192:98:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4192:98:15;;:::i;:::-;;157:33:14;;5:9:-1;2:2;;;27:1;24;17:12;2:2;157:33:14;;;:::i;6963:187:15:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6963:187:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;6963:187:15;;:::i;:::-;;;;;;;;;;;;;;;;4798:1650;;5:9:-1;2:2;;;27:1;24;17:12;2:2;4798:1650:15;;;:::i;8215:399::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;8215:399:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;8215:399:15;;;;;;;;;;;;;:::i;7156:187::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7156:187:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;7156:187:15;;:::i;615:23::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;615:23:15;;;:::i;7538:243::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7538:243:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;7538:243:15;;;;;;;:::i;1779:145:10:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1779:145:10;;;:::i;4397:395:15:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;4397:395:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4397:395:15;;:::i;:::-;;;;-1:-1:-1;;;;;4397:395:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6558:198;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6558:198:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;6558:198:15;;:::i;:::-;;;;;;;;;;;;;;;;;;11921:268;;5:9:-1;2:2;;;27:1;24;17:12;2:2;11921:268:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;11921:268:15;;;;;;;;:::i;1156:77:10:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1156:77:10;;;:::i;420:33:15:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;420:33:15;;;:::i;6762:195::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6762:195:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;6762:195:15;;:::i;8030:179::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;8030:179:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;8030:179:15;;;;;;;:::i;4296:95::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;4296:95:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4296:95:15;;;;:::i;541:38::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;541:38:15;;;:::i;:::-;;;;;;;;;;;;;;;;;;;8620:232;;5:9:-1;2:2;;;27:1;24;17:12;2:2;8620:232:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;8620:232:15;;:::i;11663:252::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;11663:252:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;11663:252:15;;;;;;;;:::i;473:33::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;473:33:15;;;:::i;11483:174::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;11483:174:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11483:174:15;;:::i;8858:297::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;8858:297:15;;;;;;;:::i;7787:237::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7787:237:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;7787:237:15;;;;;;;:::i;377:37::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;377:37:15;;;:::i;6454:98::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;6454:98:15;;;:::i;7349:183::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;7349:183:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;7349:183:15;;:::i;2073:274:10:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;2073:274:10;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;2073:274:10;-1:-1:-1;;;;;2073:274:10;;:::i;644:34:15:-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;644:34:15;;;:::i;4100:86::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;4100:86:15;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4100:86:15;;:::i;196:31:14:-;;;-1:-1:-1;;;;;196:31:14;;:::o;4192:98:15:-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;4261:8:15::1;:22:::0;4192:98::o;157:33:14:-;;;-1:-1:-1;;;;;157:33:14;;:::o;6963:187:15:-;7062:8;:15;7024:7;;7051:26;;7043:55;;;;;-1:-1:-1;;;7043:55:15;;;;;;;;;;;;-1:-1:-1;;;7043:55:15;;;;;;;;;;;;;;;7115:8;7124;7115:18;;;;;;;;;;;;;;;;;;:28;;;7108:35;;6963:187;;;:::o;4798:1650::-;4843:7;4862:15;4880:26;4890:15;4903:1;4890:8;;:12;;:15;;;;:::i;:::-;4880:5;;;:26;:9;:26;:::i;:::-;4862:44;;4916:15;4934:26;4944:15;4957:1;4944:8;;:12;;:15;;;;:::i;4934:26::-;4916:44;;4970:15;4988:26;4998:15;5011:1;4998:8;;:12;;:15;;;;:::i;4988:26::-;4970:44;;5024:15;5042:26;5052:15;5065:1;5052:8;;:12;;:15;;;;:::i;5042:26::-;5024:44;-1:-1:-1;5078:14:15;5123:9;5159:10;5196:11;5234:12;5260:3;:13;-1:-1:-1;5256:1186:15;;;5296:1;5289:8;;;;;;;;;;;;;5256:1186;5324:7;5318:3;:13;5314:1128;;;5403:8;;5347:22;;5372:40;;:26;408:6;5372:16;:3;5380:7;5372:16;:7;:16;:::i;:::-;:20;:26;:20;:26;:::i;:::-;:30;:40;:30;:40;:::i;:::-;5347:65;-1:-1:-1;5426:19:15;5448:78;408:6;5448:38;5347:65;5448:18;:6;5459;5448:18;:10;:18;:::i;:78::-;5426:100;-1:-1:-1;5547:23:15;:6;5426:100;5547:23;:10;:23;:::i;:::-;5540:30;;;;;;;;;;;;;;;5314:1128;5597:7;5591:3;:13;5587:855;;;5676:8;;5620:22;;5645:40;;:26;408:6;5645:16;:3;5653:7;5645:16;:7;:16;:::i;:40::-;5620:65;-1:-1:-1;5699:19:15;5721:78;408:6;5721:38;5620:65;5721:18;:6;5732;5721:18;:10;:18;:::i;:78::-;5699:100;-1:-1:-1;5820:23:15;:6;5699:100;5820:23;:10;:23;:::i;5587:855::-;5870:7;5864:3;:13;5860:582;;;5949:8;;5893:22;;5918:40;;:26;408:6;5918:16;:3;5926:7;5918:16;:7;:16;:::i;:40::-;5893:65;-1:-1:-1;5972:19:15;5994:78;408:6;5994:38;5893:65;5994:18;:6;6005;5994:18;:10;:18;:::i;:78::-;5972:100;-1:-1:-1;6093:23:15;:6;5972:100;6093:23;:10;:23;:::i;5860:582::-;6143:5;;6137:3;:11;6133:309;;;6220:8;;6164:22;;6189:40;;:26;408:6;6189:16;:3;6197:7;6189:16;:7;:16;:::i;:40::-;6164:65;-1:-1:-1;6243:19:15;6265:78;408:6;6265:38;6164:65;6265:18;:6;6276;6265:18;:10;:18;:::i;:78::-;6243:100;-1:-1:-1;6364:23:15;:6;6243:100;6364:23;:10;:23;:::i;6133:309::-;6425:6;-1:-1:-1;6418:13:15;;-1:-1:-1;;;;;;;;6418:13:15;4798:1650;;:::o;8215:399::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;8337:23:15::1;;:::i;:::-;-1:-1:-1::0;;;;;8370:31:15;;::::1;::::0;;8411:19:::1;::::0;::::1;:31:::0;;;8452:19:::1;::::0;::::1;:31:::0;;;8493:8:::1;27:10:-1::0;;39:1:::1;23:18:::0;;::::1;45:23:::0;;-1:-1;8493:24:15;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;8493:24:15::1;::::0;;;::::1;;::::0;;;;;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;8546:15;:22:::1;::::0;:19:::1;:22::i;:::-;8583:24;::::0;;;;;;;8527:41;;-1:-1:-1;8583:24:15::1;::::0;;;;;::::1;::::0;;::::1;1429:1:10;;8215:399:15::0;;;:::o;7156:187::-;7255:8;:15;7217:7;;7244:26;;7236:55;;;;;-1:-1:-1;;;7236:55:15;;;;;;;;;;;;-1:-1:-1;;;7236:55:15;;;;;;;;;;;;;;;7308:8;7317;7308:18;;;;;;;;;;;;;;;;;;:28;;;7301:35;;7156:187;;;:::o;615:23::-;;;-1:-1:-1;;;615:23:15;;-1:-1:-1;;;;;615:23:15;;:::o;7538:243::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;7642:8:15::1;:15:::0;7631:26;::::1;7623:55;;;::::0;;-1:-1:-1;;;7623:55:15;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;7623:55:15;;;;;;;;;;;;;::::1;;7719:8;7688;7697;7688:18;;;;;;;;;;;;;;;;;;:28;;:39;;;;7742:32;7755:8;7765;7742:32;;;;;;;;;;;;;;;;;;;;;;;;7538:243:::0;;:::o;1779:145:10:-;1370:12;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;1869:6:::1;::::0;1848:40:::1;::::0;1885:1:::1;::::0;-1:-1:-1;;;;;1869:6:10::1;::::0;1848:40:::1;::::0;1885:1;;1848:40:::1;1898:6;:19:::0;;-1:-1:-1;;;;;;1898:19:10::1;::::0;;1779:145::o;4397:395:15:-;4483:7;4492;4501;4510;4552:8;:15;;;;4541:8;:26;4533:55;;;;;-1:-1:-1;;;4533:55:15;;;;;;;;;;;;-1:-1:-1;;;4533:55:15;;;;;;;;;;;;;;;4619:8;4628;4619:18;;;;;;;;;;;;;;;;;;;;;:32;4665:8;:18;;-1:-1:-1;;;;;4619:32:15;;;;4674:8;;4665:18;;;;;;;;;;;;;;;;:28;;;4707:8;4716;4707:18;;;;;;;;;;;;;;;;;;:26;;;4747:8;4756;4747:18;;;;;;;;;;;;;;;;;;:28;;;4598:187;;;;;;;;4397:395;;;;;:::o;6558:198::-;6650:8;:15;6615:4;;6639:26;;6631:55;;;;;-1:-1:-1;;;6631:55:15;;;;;;;;;;;;-1:-1:-1;;;6631:55:15;;;;;;;;;;;;;;;6747:1;-1:-1:-1;;;;;6703:46:15;:8;6712;6703:18;;;;;;;;;;;;;;;;;;;;;:32;-1:-1:-1;;;;;6703:32:15;:46;;6558:198;-1:-1:-1;;6558:198:15:o;11921:268::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;12074:56:15::1;::::0;;-1:-1:-1;;;12074:56:15;;12103:4:::1;12074:56;::::0;::::1;::::0;12110:10:::1;12074:56:::0;;;;;;;;;;;;12052:11;;-1:-1:-1;;;;;12074:20:15;::::1;::::0;::::1;::::0;:56;;;;;12030:11:::1;::::0;12074:56;;;;;;;;12030:11;12074:20;:56;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;12074:56:15;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;-1:-1:::0;;12145:37:15::1;::::0;;-1:-1:-1;;;;;12145:37:15;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;-1:-1:-1;12145:37:15;;;;;;;;-1:-1:-1;12145:37:15::1;1429:1:10;11921:268:15::0;;:::o;1156:77:10:-;1220:6;;-1:-1:-1;;;;;1220:6:10;1156:77;:::o;420:33:15:-;;;;:::o;6762:195::-;6865:8;:15;6827:7;;6854:26;;6846:55;;;;;-1:-1:-1;;;6846:55:15;;;;;;;;;;;;-1:-1:-1;;;6846:55:15;;;;;;;;;;;;;;;6918:8;6927;6918:18;;;;;;;;;;;;;;;;;;;;;:32;-1:-1:-1;;;;;6918:32:15;;6762:195;-1:-1:-1;;6762:195:15:o;8030:179::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;8148:54:15::1;8169:1;8173:15;8190:11;8148:12;:54::i;:::-;8030:179:::0;;:::o;4296:95::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;4363:11:15::1;:21:::0;;-1:-1:-1;;4363:21:15::1;;::::0;;;::::1;::::0;;;::::1;::::0;;4296:95::o;541:38::-;;;;;;:::o;8620:232::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;8705:8:15::1;:15:::0;8694:26;::::1;8686:55;;;::::0;;-1:-1:-1;;;8686:55:15;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;8686:55:15;;;;;;;;;;;;;::::1;;8782:8;8791;8782:18;;;;;;;;;;;;;;;;;;:26;;;8751:8;8760;8751:18;;;;;;;;;;;;;;;;;;:28;;:57;;;;8823:22;8836:8;8823:22;;;;;;;;;;;;;;;;;;8620:232:::0;:::o;11663:252::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;11794:13:15;11818:38:::1;-1:-1:-1::0;;;;;11818:18:15;::::1;11837:10;11849:6:::0;11818:38:::1;:18;:38;:::i;:::-;11871:37;::::0;;-1:-1:-1;;;;;11871:37:15;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;1429:1:10;11663:252:15::0;;:::o;473:33::-;;;;:::o;11483:174::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;11592:23:15::1;::::0;11572:10:::1;::::0;;;11592:23;::::1;;;::::0;11608:6;;11547:22:::1;11592:23:::0;11547:22;11592:23;11608:6;11572:10;11592:23;::::1;;;;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;-1:-1:::0;11630:20:15::1;::::0;;;;;;;::::1;::::0;;;;::::1;::::0;;::::1;1429:1:10;11483:174:15::0;:::o;8858:297::-;1721:1:11;2326:7;;:19;;2318:63;;;;;-1:-1:-1;;;2318:63:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;1721:1;2456:7;:18;9069:11:15::1;::::0;8987:161:::1;::::0;9018:8;;9040:15;;9069:11:::1;;-1:-1:-1::0;;9069:15:15;;;-1:-1:-1;;9098:15:15;;;8987:17:::1;:161::i;:::-;-1:-1:-1::0;;1678:1:11;2630:7;:22;8858:297:15:o;7787:237::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;7889:8:15::1;:15:::0;7878:26;::::1;7870:55;;;::::0;;-1:-1:-1;;;7870:55:15;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;7870:55:15;;;;;;;;;;;;;::::1;;7966:6;7935:8;7944;7935:18;;;;;;;;;;;;;;;;;;:28;;:37;;;;7987:30;8000:8;8010:6;7987:30;;;;;;;;;;;;;;;;;;;;;;;;7787:237:::0;;:::o;377:37::-;408:6;377:37;:::o;6454:98::-;6530:8;:15;6454:98;:::o;7349:183::-;7446:8;:15;7408:7;;7435:26;;7427:55;;;;;-1:-1:-1;;;7427:55:15;;;;;;;;;;;;-1:-1:-1;;;7427:55:15;;;;;;;;;;;;;;;7499:8;7508;7499:18;;;;;;;;;;;;;;;;;;:26;;;7492:33;;7349:183;;;:::o;2073:274:10:-;1370:12;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;-1:-1:-1;;;;;2174:22:10;::::1;2153:107;;;;-1:-1:-1::0;;;2153:107:10::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2296:6;::::0;2275:38:::1;::::0;-1:-1:-1;;;;;2275:38:10;;::::1;::::0;2296:6:::1;::::0;2275:38:::1;::::0;2296:6:::1;::::0;2275:38:::1;2323:6;:17:::0;;-1:-1:-1;;;;;;2323:17:10::1;-1:-1:-1::0;;;;;2323:17:10;;;::::1;::::0;;;::::1;::::0;;2073:274::o;644:34:15:-;;;-1:-1:-1;;;;;644:34:15;;:::o;4100:86::-;1370:12:10;:10;:12::i;:::-;1360:6;;-1:-1:-1;;;;;1360:6:10;;;:22;;;1352:67;;;;;-1:-1:-1;;;1352:67:10;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1352:67:10;;;;;;;;;;;;;;;4163:5:15::1;:16:::0;4100:86::o;2207:459:13:-;2265:7;2506:6;2502:45;;-1:-1:-1;2535:1:13;2528:8;;2502:45;2569:5;;;2573:1;2569;:5;:1;2592:5;;;;;:10;2584:56;;;;-1:-1:-1;;;2584:56:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2658:1;-1:-1:-1;2207:459:13;;;;;:::o;3128:130::-;3186:7;3212:39;3216:1;3219;3212:39;;;;;;;;;;;;;;;;;:3;:39::i;1320:134::-;1378:7;1404:43;1408:1;1411;1404:43;;;;;;;;;;;;;;;;;:3;:43::i;589:104:1:-;676:10;589:104;:::o;873:176:13:-;931:7;962:5;;;985:6;;;;977:46;;;;;-1:-1:-1;;;977:46:13;;;;;;;;;;;;;;;;;;;;;;;;;;;676:209:12;810:58;;;-1:-1:-1;;;;;810:58:12;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;810:58:12;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;758:120:12;;791:5;;758:19;:120::i;:::-;676:209;;;:::o;9438:2039:15:-;9631:11;;-1:-1:-1;;9631:11:15;;;;:15;9622:24;;;;;;;;;:49;;-1:-1:-1;9660:11:15;;;;;;9650:21;;;;;9622:49;9614:71;;;;;-1:-1:-1;;;9614:71:15;;;;;;;;;;;;-1:-1:-1;;;9614:71:15;;;;;;;;;;;;;;;9714:8;:15;9703:26;;9695:55;;;;;-1:-1:-1;;;9695:55:15;;;;;;;;;;;;-1:-1:-1;;;9695:55:15;;;;;;;;;;;;;;;9760:21;9784:8;9793;9784:18;;;;;;;;;;;;;;;;;;9760:42;;9812:17;9832:14;:12;:14::i;:::-;9812:34;;9876:1;9864:9;:13;9856:56;;;;;-1:-1:-1;;;9856:56:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;9922:21;9946:36;9967:6;:14;;;9946:6;:16;;;:20;;:36;;;;:::i;:::-;9922:60;;10016:1;10000:13;:17;9992:56;;;;;-1:-1:-1;;;9992:56:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;10058:21;10082:44;408:6;10082:34;10099:6;:16;;;10082:12;:16;;:34;;;;:::i;:44::-;10058:68;;10136:16;10171:13;10155;:29;:149;;10239:13;10227:9;:25;:77;;10291:13;10227:77;;;10267:9;10227:77;10155:149;;;10199:13;10155:149;10136:168;-1:-1:-1;10314:16:15;10333:45;10364:13;10333:26;:12;10136:168;10333:26;:16;:26;:::i;:45::-;10314:64;;10392:18;10401:8;10392;:18::i;:::-;10388:473;;;10447:8;10434:9;:21;;10426:60;;;;;-1:-1:-1;;;10426:60:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;10516:8;10504:9;:20;10500:154;;;10570:10;;10598:41;10615:23;:9;10629:8;10615:23;:13;:23;:::i;:::-;10598:41;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;10598:41:15;10500:154;;10667:11;;:30;;-1:-1:-1;;;;;10667:11:15;;;;:30;;;;;10688:8;;10667:11;:30;:11;:30;10688:8;10667:11;:30;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;10667:30:15;10388:473;;;10754:20;;10828:11;;-1:-1:-1;;;;;10754:20:15;;;;10789:61;;10754:20;;10816:10;;10828:11;10841:8;10789:61;:26;:61;:::i;:::-;10388:473;;10880:6;10874:12;;:3;:12;10870:360;;;10902:9;;:44;;-1:-1:-1;;;10902:9:15;;-1:-1:-1;;;;;10902:9:15;10925:10;10937:8;10902:22;:44::i;:::-;10870:360;;;11000:16;;10977:9;;:50;;-1:-1:-1;;;;;;;;10977:9:15;;;;;;11000:16;11018:8;10977:22;:50::i;:::-;11041:178;11075:10;11103:8;11129:6;11153:5;11176:6;11200:5;11041:16;:178::i;:::-;;10870:360;11256:14;;;;:28;;11275:8;11256:28;:18;:28;:::i;:::-;11239:14;;;:45;11299:171;;;;;;;;;;;;;;;;;;11391:10;11299:171;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9438:2039;;;;;;;;;;;:::o;3740:300:13:-;3850:7;3888:12;3881:5;3873:28;;;;-1:-1:-1;;;3873:28:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;3873:28:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3911:9;3927:1;3923;:5;;;;;;;3740:300;-1:-1:-1;;;;;3740:300:13:o;1745:215::-;1855:7;1894:12;1886:6;;;;1878:29;;;;-1:-1:-1;;;1878:29:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1878:29:13;-1:-1:-1;;;1929:5:13;;;1745:215::o;3376:843:12:-;3795:23;3821:103;3862:4;3821:103;;;;;;;;;;;;;;;;;3829:5;-1:-1:-1;;;;;3821:27:12;;;:103;;;;;:::i;:::-;3938:17;;3795:129;;-1:-1:-1;3938:21:12;3934:279;;4107:10;4096:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4096:30:12;4071:131;;;;-1:-1:-1;;;4071:131:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;891:275;1081:68;;;-1:-1:-1;;;;;1081:68:12;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;1081:68:12;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;1029:130:12;;1062:5;;1029:19;:130::i;:::-;891:275;;;;:::o;992:434:14:-;1227:12;;:192;;;-1:-1:-1;;;1227:192:14;;-1:-1:-1;;;;;1227:192:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1189:7;;1227:12;;;;;:25;;:192;;;;;;;;;;;;;;;1189:7;1227:12;:192;;;2:2:-1;;;;27:1;24;17:12;2:2;1227:192:14;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1227:192:14;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;1227:192:14;;992:434;-1:-1:-1;;;;;;;992:434:14:o;3681:224:0:-;3814:12;3845:53;3868:6;3876:4;3882:1;3885:12;3845:22;:53::i;:::-;3838:60;3681:224;-1:-1:-1;;;;3681:224:0:o;5250:1016::-;5418:12;5450:18;5461:6;5450:10;:18::i;:::-;5442:60;;;;;-1:-1:-1;;;5442:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5573:12;5587:23;5614:6;-1:-1:-1;;;;;5614:11:0;5633:8;5656:4;5614:56;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;5614:56:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;5572:98:0;;;;5684:7;5680:580;;;5714:10;-1:-1:-1;5707:17:0;;-1:-1:-1;5707:17:0;5680:580;5825:17;;:21;5821:429;;6083:10;6077:17;6143:15;6130:10;6126:2;6122:19;6115:44;6032:145;6215:20;;-1:-1:-1;;;6215:20:0;;;;;;;;;;;;;;;;;6222:12;;6215:20;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;717:433:0;1089:20;1135:8;;;717:433::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://e2ce394f5db69e2f6c189aa6edd57df66bc8d44ea08e1935bd47d9b37d2846be