TetraSpektra

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

interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  function getRoundData(
    uint80 _roundId
  ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

  function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

// Copyright 2021-2022, Offchain Labs, Inc.
// For license information, see https://github.com/nitro/blob/master/LICENSE
// SPDX-License-Identifier: BUSL-1.1

pragma solidity >=0.4.21 <0.9.0;

interface ArbGasInfo {
    // return gas prices in wei, assuming the specified aggregator is used
    //        (
    //            per L2 tx,
    //            per L1 calldata unit, (zero byte = 4 units, nonzero byte = 16 units)
    //            per storage allocation,
    //            per ArbGas base,
    //            per ArbGas congestion,
    //            per ArbGas total
    //        )
    function getPricesInWeiWithAggregator(address aggregator) external view returns (uint, uint, uint, uint, uint, uint);

    // return gas prices in wei, as described above, assuming the caller's preferred aggregator is used
    //     if the caller hasn't specified a preferred aggregator, the default aggregator is assumed
    function getPricesInWei() external view returns (uint, uint, uint, uint, uint, uint);

    // return prices in ArbGas (per L2 tx, per L1 calldata unit, per storage allocation),
    //       assuming the specified aggregator is used
    function getPricesInArbGasWithAggregator(address aggregator) external view returns (uint, uint, uint);

    // return gas prices in ArbGas, as described above, assuming the caller's preferred aggregator is used
    //     if the caller hasn't specified a preferred aggregator, the default aggregator is assumed
    function getPricesInArbGas() external view returns (uint, uint, uint);

    // return gas accounting parameters (speedLimitPerSecond, gasPoolMax, maxTxGasLimit)
    function getGasAccountingParams() external view returns (uint, uint, uint);

    // get ArbOS's estimate of the L1 gas price in wei
    function getL1GasPriceEstimate() external view returns(uint);

    // set ArbOS's estimate of the L1 gas price in wei
    // reverts unless called by chain owner or designated gas oracle (if any)
    function setL1GasPriceEstimate(uint priceInWei) external;

    // get L1 gas fees paid by the current transaction (txBaseFeeWei, calldataFeeWei)
    function getCurrentTxL1GasFees() external view returns(uint);
}

// Copyright 2021-2022, Offchain Labs, Inc.
// For license information, see https://github.com/nitro/blob/master/LICENSE
// SPDX-License-Identifier: BUSL-1.1

pragma solidity >=0.4.21 <0.9.0;

/**
 * @title System level functionality
 * @notice For use by contracts to interact with core L2-specific functionality.
 * Precompiled contract that exists in every Arbitrum chain at address(100), 0x0000000000000000000000000000000000000064.
 */
interface ArbSys {
    /**
     * @notice Get Arbitrum block number (distinct from L1 block number; Arbitrum genesis block has block number 0)
     * @return block number as int
     */
    function arbBlockNumber() external view returns (uint256);

    /**
     * @notice Get Arbitrum block hash (reverts unless currentBlockNum-256 <= arbBlockNum < currentBlockNum)
     * @return block hash
     */
    function arbBlockHash(uint256 arbBlockNum) external view returns (bytes32);

    /**
     * @notice Gets the rollup's unique chain identifier
     * @return Chain identifier as int
     */
    function arbChainID() external view returns (uint256);

    /**
     * @notice Get internal version number identifying an ArbOS build
     * @return version number as int
     */
    function arbOSVersion() external view returns (uint256);

    /**
     * @notice Returns 0 since Nitro has no concept of storage gas
     * @return uint 0
     */
    function getStorageGasAvailable() external view returns (uint256);

    /**
     * @notice (deprecated) check if current call is top level (meaning it was triggered by an EoA or a L1 contract)
     * @dev this call has been deprecated and may be removed in a future release
     * @return true if current execution frame is not a call by another L2 contract
     */
    function isTopLevelCall() external view returns (bool);

    /**
     * @notice map L1 sender contract address to its L2 alias
     * @param sender sender address
     * @param unused argument no longer used
     * @return aliased sender address
     */
    function mapL1SenderContractAddressToL2Alias(address sender, address unused)
        external
        pure
        returns (address);

    /**
     * @notice check if the caller (of this caller of this) is an aliased L1 contract address
     * @return true iff the caller's address is an alias for an L1 contract address
     */
    function wasMyCallersAddressAliased() external view returns (bool);

    /**
     * @notice return the address of the caller (of this caller of this), without applying L1 contract address aliasing
     * @return address of the caller's caller, without applying L1 contract address aliasing
     */
    function myCallersAddressWithoutAliasing() external view returns (address);

    /**
     * @notice Send given amount of Eth to dest from sender.
     * This is a convenience function, which is equivalent to calling sendTxToL1 with empty data.
     * @param destination recipient address on L1
     * @return unique identifier for this L2-to-L1 transaction.
     */
    function withdrawEth(address destination)
        external
        payable
        returns (uint256);

    /**
     * @notice Send a transaction to L1
     * @dev it is not possible to execute on the L1 any L2-to-L1 transaction which contains data
     * to a contract address without any code (as enforced by the Bridge contract).
     * @param destination recipient address on L1
     * @param data (optional) calldata for L1 contract call
     * @return a unique identifier for this L2-to-L1 transaction.
     */
    function sendTxToL1(address destination, bytes calldata data)
        external
        payable
        returns (uint256);

    /**
     * @notice Get send Merkle tree state
     * @return size number of sends in the history
     * @return root root hash of the send history
     * @return partials hashes of partial subtrees in the send history tree
     */
    function sendMerkleTreeState()
        external
        view
        returns (
            uint256 size,
            bytes32 root,
            bytes32[] memory partials
        );

    /**
     * @notice creates a send txn from L2 to L1
     * @param position = (level << 192) + leaf = (0 << 192) + leaf = leaf
     */
    event L2ToL1Tx(
        address caller,
        address indexed destination,
        uint256 indexed hash,
        uint256 indexed position,
        uint256 arbBlockNum,
        uint256 ethBlockNum,
        uint256 timestamp,
        uint256 callvalue,
        bytes data
    );

    /// @dev DEPRECATED in favour of the new L2ToL1Tx event above after the nitro upgrade
    event L2ToL1Transaction(
        address caller,
        address indexed destination,
        uint256 indexed uniqueId,
        uint256 indexed batchNumber,
        uint256 indexInBatch,
        uint256 arbBlockNum,
        uint256 ethBlockNum,
        uint256 timestamp,
        uint256 callvalue,
        bytes data
    );

    /**
     * @notice logs a merkle branch for proof synthesis
     * @param reserved an index meant only to align the 4th index with L2ToL1Transaction's 4th event
     * @param hash the merkle hash
     * @param position = (level << 192) + leaf
     */
    event SendMerkleUpdate(
        uint256 indexed reserved,
        bytes32 indexed hash,
        uint256 indexed position
    );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Base64.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 */
library Base64 {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

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

interface BlockhashStoreInterface {
  function getBlockhash(uint256 number) external view returns (bytes32);
}

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

import {ArbSys} from "./vendor/@arbitrum/nitro-contracts/src/precompiles/ArbSys.sol";
import {ArbGasInfo} from "./vendor/@arbitrum/nitro-contracts/src/precompiles/ArbGasInfo.sol";

//@dev A library that abstracts out opcodes that behave differently across chains.
//@dev The methods below return values that are pertinent to the given chain.
//@dev For instance, ChainSpecificUtil.getBlockNumber() returns L2 block number in L2 chains
library ChainSpecificUtil {
  address private constant ARBSYS_ADDR = address(0x0000000000000000000000000000000000000064);
  ArbSys private constant ARBSYS = ArbSys(ARBSYS_ADDR);
  address private constant ARBGAS_ADDR = address(0x000000000000000000000000000000000000006C);
  ArbGasInfo private constant ARBGAS = ArbGasInfo(ARBGAS_ADDR);
  uint256 private constant ARB_MAINNET_CHAIN_ID = 42161;
  uint256 private constant ARB_GOERLI_TESTNET_CHAIN_ID = 421613;
  uint256 private constant ARB_SEPOLIA_TESTNET_CHAIN_ID = 421614;

  function getBlockhash(uint64 blockNumber) internal view returns (bytes32) {
    uint256 chainid = block.chainid;
    if (
      chainid == ARB_MAINNET_CHAIN_ID ||
      chainid == ARB_GOERLI_TESTNET_CHAIN_ID ||
      chainid == ARB_SEPOLIA_TESTNET_CHAIN_ID
    ) {
      if ((getBlockNumber() - blockNumber) > 256 || blockNumber >= getBlockNumber()) {
        return "";
      }
      return ARBSYS.arbBlockHash(blockNumber);
    }
    return blockhash(blockNumber);
  }

  function getBlockNumber() internal view returns (uint256) {
    uint256 chainid = block.chainid;
    if (chainid == ARB_MAINNET_CHAIN_ID || chainid == ARB_GOERLI_TESTNET_CHAIN_ID) {
      return ARBSYS.arbBlockNumber();
    }
    return block.number;
  }

  function getCurrentTxL1GasFees() internal view returns (uint256) {
    uint256 chainid = block.chainid;
    if (chainid == ARB_MAINNET_CHAIN_ID || chainid == ARB_GOERLI_TESTNET_CHAIN_ID) {
      return ARBGAS.getCurrentTxL1GasFees();
    }
    return 0;
  }

  /**
   * @notice Returns the gas cost in wei of calldataSizeBytes of calldata being posted
   * @notice to L1.
   */
  function getL1CalldataGasCost(uint256 calldataSizeBytes) internal view returns (uint256) {
    uint256 chainid = block.chainid;
    if (chainid == ARB_MAINNET_CHAIN_ID || chainid == ARB_GOERLI_TESTNET_CHAIN_ID) {
      (, uint256 l1PricePerByte, , , , ) = ARBGAS.getPricesInWei();
      // see https://developer.arbitrum.io/devs-how-tos/how-to-estimate-gas#where-do-we-get-all-this-information-from
      // for the justification behind the 140 number.
      return l1PricePerByte * (calldataSizeBytes + 140);
    }
    return 0;
  }
}

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

import "./ConfirmedOwnerWithProposal.sol";

/**
 * @title The ConfirmedOwner contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract ConfirmedOwner is ConfirmedOwnerWithProposal {
  constructor(address newOwner) ConfirmedOwnerWithProposal(newOwner, address(0)) {}
}

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

import "../interfaces/IOwnable.sol";

/**
 * @title The ConfirmedOwner contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract ConfirmedOwnerWithProposal is IOwnable {
  address private s_owner;
  address private s_pendingOwner;

  event OwnershipTransferRequested(address indexed from, address indexed to);
  event OwnershipTransferred(address indexed from, address indexed to);

  constructor(address newOwner, address pendingOwner) {
    require(newOwner != address(0), "Cannot set owner to zero");

    s_owner = newOwner;
    if (pendingOwner != address(0)) {
      _transferOwnership(pendingOwner);
    }
  }

  /**
   * @notice Allows an owner to begin transferring ownership to a new address,
   * pending.
   */
  function transferOwnership(address to) public override onlyOwner {
    _transferOwnership(to);
  }

  /**
   * @notice Allows an ownership transfer to be completed by the recipient.
   */
  function acceptOwnership() external override {
    require(msg.sender == s_pendingOwner, "Must be proposed owner");

    address oldOwner = s_owner;
    s_owner = msg.sender;
    s_pendingOwner = address(0);

    emit OwnershipTransferred(oldOwner, msg.sender);
  }

  /**
   * @notice Get the current owner
   */
  function owner() public view override returns (address) {
    return s_owner;
  }

  /**
   * @notice validate, transfer ownership, and emit relevant events
   */
  function _transferOwnership(address to) private {
    require(to != msg.sender, "Cannot transfer to self");

    s_pendingOwner = to;

    emit OwnershipTransferRequested(s_owner, to);
  }

  /**
   * @notice validate access
   */
  function _validateOwnership() internal view {
    require(msg.sender == s_owner, "Only callable by owner");
  }

  /**
   * @notice Reverts if called by anyone other than the contract owner.
   */
  modifier onlyOwner() {
    _validateOwnership();
    _;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/access/Ownable.sol";

import "@chainlink/contracts/src/v0.8/shared/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFCoordinatorV2.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";

import "./utils/ExecutorManager.sol";
import "./utils/TransferHelper.sol";
import "./interfaces/ISwapRouter.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/ITetraSpektra.sol";

contract Excavator is Ownable, ExecutorManager, VRFConsumerBaseV2 {
    ISwapRouter public immutable uniswapRouter;
    VRFCoordinatorV2 public immutable vrfCoordinator;

    address public immutable WETH;
    address public immutable LINK;
    bytes32 public immutable KEY_HASH;

    uint64 public vrfSubscriptionId;
    ITetraSpektra immutable tetraSpektra;

    uint32 _gasFeeLimit = 420_000;

    constructor(
        address executor,
        address tetraSpektraAddress_,
        address uniswapRouterAddress_,
        address vrfCoordinatorAddress_,
        bytes32 vrfKeyHash_,
        address wethTokenAddress_,
        address linkTokenAddress_
    )
        Ownable(msg.sender)
        ExecutorManager(executor)
        VRFConsumerBaseV2(vrfCoordinatorAddress_)
    {
        tetraSpektra = ITetraSpektra(tetraSpektraAddress_);

        uniswapRouter = ISwapRouter(uniswapRouterAddress_);

        vrfCoordinator = VRFCoordinatorV2(vrfCoordinatorAddress_);

        WETH = wethTokenAddress_;
        LINK = linkTokenAddress_;
        KEY_HASH = vrfKeyHash_;

        TransferHelper.safeApprove(
            WETH,
            address(uniswapRouter),
            type(uint256).max
        );

        LinkTokenInterface(LINK).approve(
            address(vrfCoordinator),
            type(uint256).max
        );
    }

    function initialize() public payable onlyOwner {
        vrfSubscriptionId = vrfCoordinator.createSubscription();

        require(isInitialized(), "0");

        vrfCoordinator.addConsumer(vrfSubscriptionId, address(this));

        IWETH(WETH).deposit{value: msg.value}();

        uint256 outputAmount = _swapWethForLink(msg.value, address(this));

        LinkTokenInterface(LINK).transferAndCall(
            address(vrfCoordinator),
            outputAmount,
            abi.encode(vrfSubscriptionId)
        );
    }

    function fund() external payable {
        require(isInitialized(), "0");
        IWETH(WETH).deposit{value: msg.value}();

        uint256 outputAmount = _swapWethForLink(msg.value, address(this));

        LinkTokenInterface(LINK).transferAndCall(
            address(vrfCoordinator),
            outputAmount,
            abi.encode(vrfSubscriptionId)
        );
    }

    function fundWithWeth(uint256 amount) external {
        require(isInitialized(), "0");
        require(amount > 0, "1");
        require(IERC20(WETH).transferFrom(msg.sender, address(this), amount));

        uint256 fundAmount = _swapWethForLink(amount, address(this));
        require(fundAmount > 0, "2");
        LinkTokenInterface(LINK).transferAndCall(
            address(vrfCoordinator),
            fundAmount,
            abi.encode(vrfSubscriptionId)
        );
    }

    function fundWithLink(uint256 amount) external {
        require(isInitialized(), "0");
        require(amount > 0, "1");
        require(IERC20(LINK).transferFrom(msg.sender, address(this), amount));

        uint256 fundAmount = IERC20(LINK).balanceOf(address(this));
        LinkTokenInterface(LINK).transferAndCall(
            address(vrfCoordinator),
            fundAmount,
            abi.encode(vrfSubscriptionId)
        );
    }

    function isInitialized() public view returns (bool) {
        return vrfSubscriptionId != 0;
    }

    function getLinkPrice() external view returns (uint256) {
        (, int answer, , , ) = vrfCoordinator.LINK_ETH_FEED().latestRoundData();
        uint256 linkPrice = (answer <= 0)
            ? 6_500_000_000_000_000
            : uint256(answer);
        return linkPrice;
    }

    function _swapWethForLink(
        uint256 amountIn,
        address recipient
    ) private returns (uint256) {
        return
            uniswapRouter.exactInputSingle(
                ISwapRouter.ExactInputSingleParams({
                    tokenIn: WETH,
                    tokenOut: LINK,
                    fee: 3_000,
                    recipient: recipient,
                    amountIn: amountIn,
                    amountOutMinimum: 2,
                    sqrtPriceLimitX96: 0
                })
            );
    }

    function beginExcavation() public onlyOwner returns (uint256) {
        uint256 excavationId = vrfCoordinator.requestRandomWords(
            KEY_HASH,
            vrfSubscriptionId,
            3,
            _gasFeeLimit,
            1
        );
        return excavationId;
    }

    function updateGasFeeLimit(uint32 gasFeeLimit) external onlyExecutor {
        require(gasFeeLimit > 330_000, "TOO_LOW");
        _gasFeeLimit = gasFeeLimit;
    }

    function fulfillRandomWords(
        uint256 excavationId,
        uint256[] memory values
    ) internal override {
        tetraSpektra.excavate(excavationId, values[0]);
    }

    function forceExcavate(
        uint256 excavationId,
        uint256 value
    ) public onlyOwner {
        tetraSpektra.excavate(excavationId, value);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

abstract contract ExecutorManager {
    error NotExecutor(address attempted);
    error CannotRemoveSelf();

    mapping(address => bool) public executors;

    constructor(address initialExecutor) {
        _addExecutor(initialExecutor);
    }

    modifier onlyExecutor() {
        if (isExecutor(msg.sender) != true) revert NotExecutor(msg.sender);
        _;
    }

    function isExecutor(address _executor) public view returns (bool) {
        return (executors[_executor] == true);
    }

    function _addExecutor(address _toAdd) internal {
        executors[_toAdd] = true;
    }

    function addExecutor(address _toAdd) external virtual onlyExecutor {
        _addExecutor(_toAdd);
    }

    function _removeExecutor(address _toRemove) internal {
        if (_toRemove == msg.sender) revert CannotRemoveSelf();
        executors[_toRemove] = false;
    }

    function removeExecutor(address _toRemove) external virtual onlyExecutor {
        _removeExecutor(_toRemove);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

interface IBountyVault {
    function distribute(
        address recipient,
        uint256 amount,
        uint256 amountForCreator
    ) external;

    function claimBounty(address tokenOwner, uint256 tokenId) external;

    function isVaultUnlocked() external returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

interface IClaimsManager {
    function isClaimsSessionExpired() external view returns (bool);

    function getTimeRemainingForClaimsSession() external view returns (uint256);

    function getClaimsSessionId() external view returns (uint256);

    function enable() external;

    function claim(address recipient, uint256 tokenId) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

interface IERC677Receiver {
  function onTokenTransfer(address sender, uint256 amount, bytes calldata data) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/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`.
     *
     * 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;

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

pragma solidity ^0.8.20;

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

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

interface IOwnable {
  function owner() external returns (address);

  function transferOwnership(address recipient) external;

  function acceptOwnership() external;
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.7.0 <0.9.0;

interface IPriceOracle {
    function getPrice(
        address token0Address,
        address token1Address,
        uint128 amount,
        uint24 poolFee
    ) external view returns (uint256 priceU18);

    function getBasePrice(
        address token0Address,
        address token1Address,
        uint24 poolFee
    ) external view returns (uint256 priceU18);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

interface IProspektorFundManager {
    function getTick() external view returns (int24);

    function collectLPFees() external returns (uint256, uint256);

    function addLiquidity(
        uint token0Amount,
        uint token1Amount
    )
        external
        returns (uint128 liquidity, uint256 token0Value, uint256 token1Value);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/access/Ownable.sol";

interface IRandomizer {
    function random() external returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

interface ISwapRouter {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        // uint deadline;
        uint amountIn;
        uint amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    function exactInputSingle(
        ExactInputSingleParams calldata params
    ) external payable returns (uint amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        //uint deadline;
        uint amountIn;
        uint amountOutMinimum;
    }

    function exactInput(
        ExactInputParams calldata params
    ) external payable returns (uint amountOut);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

interface ITetraSpektra is IERC721 {
    function excavate(uint256 excavationId, uint256 value) external;

    function exchange(uint256[4] memory tokenIds) external;

    function getGlyphKeys(uint256 tokenId) external returns (bytes32[3] memory);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

import './pool/IUniswapV3PoolImmutables.sol';
import './pool/IUniswapV3PoolState.sol';
import './pool/IUniswapV3PoolDerivedState.sol';
import './pool/IUniswapV3PoolActions.sol';
import './pool/IUniswapV3PoolOwnerActions.sol';
import './pool/IUniswapV3PoolEvents.sol';

/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface IUniswapV3Pool is
    IUniswapV3PoolImmutables,
    IUniswapV3PoolState,
    IUniswapV3PoolDerivedState,
    IUniswapV3PoolActions,
    IUniswapV3PoolOwnerActions,
    IUniswapV3PoolEvents
{

}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Permissionless pool actions
/// @notice Contains pool methods that can be called by anyone
interface IUniswapV3PoolActions {
    /// @notice Sets the initial price for the pool
    /// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
    /// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
    function initialize(uint160 sqrtPriceX96) external;

    /// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
    /// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
    /// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
    /// on tickLower, tickUpper, the amount of liquidity, and the current price.
    /// @param recipient The address for which the liquidity will be created
    /// @param tickLower The lower tick of the position in which to add liquidity
    /// @param tickUpper The upper tick of the position in which to add liquidity
    /// @param amount The amount of liquidity to mint
    /// @param data Any data that should be passed through to the callback
    /// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
    /// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
    function mint(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount,
        bytes calldata data
    ) external returns (uint256 amount0, uint256 amount1);

    /// @notice Collects tokens owed to a position
    /// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
    /// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
    /// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
    /// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
    /// @param recipient The address which should receive the fees collected
    /// @param tickLower The lower tick of the position for which to collect fees
    /// @param tickUpper The upper tick of the position for which to collect fees
    /// @param amount0Requested How much token0 should be withdrawn from the fees owed
    /// @param amount1Requested How much token1 should be withdrawn from the fees owed
    /// @return amount0 The amount of fees collected in token0
    /// @return amount1 The amount of fees collected in token1
    function collect(
        address recipient,
        int24 tickLower,
        int24 tickUpper,
        uint128 amount0Requested,
        uint128 amount1Requested
    ) external returns (uint128 amount0, uint128 amount1);

    /// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
    /// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
    /// @dev Fees must be collected separately via a call to #collect
    /// @param tickLower The lower tick of the position for which to burn liquidity
    /// @param tickUpper The upper tick of the position for which to burn liquidity
    /// @param amount How much liquidity to burn
    /// @return amount0 The amount of token0 sent to the recipient
    /// @return amount1 The amount of token1 sent to the recipient
    function burn(
        int24 tickLower,
        int24 tickUpper,
        uint128 amount
    ) external returns (uint256 amount0, uint256 amount1);

    /// @notice Swap token0 for token1, or token1 for token0
    /// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
    /// @param recipient The address to receive the output of the swap
    /// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
    /// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
    /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
    /// value after the swap. If one for zero, the price cannot be greater than this value after the swap
    /// @param data Any data to be passed through to the callback
    /// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
    /// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);

    /// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
    /// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
    /// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
    /// with 0 amount{0,1} and sending the donation amount(s) from the callback
    /// @param recipient The address which will receive the token0 and token1 amounts
    /// @param amount0 The amount of token0 to send
    /// @param amount1 The amount of token1 to send
    /// @param data Any data to be passed through to the callback
    function flash(
        address recipient,
        uint256 amount0,
        uint256 amount1,
        bytes calldata data
    ) external;

    /// @notice Increase the maximum number of price and liquidity observations that this pool will store
    /// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
    /// the input observationCardinalityNext.
    /// @param observationCardinalityNext The desired minimum number of observations for the pool to store
    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that is not stored
/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
/// blockchain. The functions here may have variable gas costs.
interface IUniswapV3PoolDerivedState {
    /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
    /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
    /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
    /// you must call it with secondsAgos = [3600, 0].
    /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
    /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
    /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
    /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
    /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
    /// timestamp
    function observe(uint32[] calldata secondsAgos)
        external
        view
        returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);

    /// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
    /// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
    /// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
    /// snapshot is taken and the second snapshot is taken.
    /// @param tickLower The lower tick of the range
    /// @param tickUpper The upper tick of the range
    /// @return tickCumulativeInside The snapshot of the tick accumulator for the range
    /// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
    /// @return secondsInside The snapshot of seconds per liquidity for the range
    function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
        external
        view
        returns (
            int56 tickCumulativeInside,
            uint160 secondsPerLiquidityInsideX128,
            uint32 secondsInside
        );
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IUniswapV3PoolEvents {
    /// @notice Emitted exactly once by a pool when #initialize is first called on the pool
    /// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
    /// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
    /// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
    event Initialize(uint160 sqrtPriceX96, int24 tick);

    /// @notice Emitted when liquidity is minted for a given position
    /// @param sender The address that minted the liquidity
    /// @param owner The owner of the position and recipient of any minted liquidity
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount The amount of liquidity minted to the position range
    /// @param amount0 How much token0 was required for the minted liquidity
    /// @param amount1 How much token1 was required for the minted liquidity
    event Mint(
        address sender,
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

    /// @notice Emitted when fees are collected by the owner of a position
    /// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
    /// @param owner The owner of the position for which fees are collected
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount0 The amount of token0 fees collected
    /// @param amount1 The amount of token1 fees collected
    event Collect(
        address indexed owner,
        address recipient,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount0,
        uint128 amount1
    );

    /// @notice Emitted when a position's liquidity is removed
    /// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
    /// @param owner The owner of the position for which liquidity is removed
    /// @param tickLower The lower tick of the position
    /// @param tickUpper The upper tick of the position
    /// @param amount The amount of liquidity to remove
    /// @param amount0 The amount of token0 withdrawn
    /// @param amount1 The amount of token1 withdrawn
    event Burn(
        address indexed owner,
        int24 indexed tickLower,
        int24 indexed tickUpper,
        uint128 amount,
        uint256 amount0,
        uint256 amount1
    );

    /// @notice Emitted by the pool for any swaps between token0 and token1
    /// @param sender The address that initiated the swap call, and that received the callback
    /// @param recipient The address that received the output of the swap
    /// @param amount0 The delta of the token0 balance of the pool
    /// @param amount1 The delta of the token1 balance of the pool
    /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
    /// @param liquidity The liquidity of the pool after the swap
    /// @param tick The log base 1.0001 of price of the pool after the swap
    event Swap(
        address indexed sender,
        address indexed recipient,
        int256 amount0,
        int256 amount1,
        uint160 sqrtPriceX96,
        uint128 liquidity,
        int24 tick
    );

    /// @notice Emitted by the pool for any flashes of token0/token1
    /// @param sender The address that initiated the swap call, and that received the callback
    /// @param recipient The address that received the tokens from flash
    /// @param amount0 The amount of token0 that was flashed
    /// @param amount1 The amount of token1 that was flashed
    /// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
    /// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
    event Flash(
        address indexed sender,
        address indexed recipient,
        uint256 amount0,
        uint256 amount1,
        uint256 paid0,
        uint256 paid1
    );

    /// @notice Emitted by the pool for increases to the number of observations that can be stored
    /// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
    /// just before a mint/swap/burn.
    /// @param observationCardinalityNextOld The previous value of the next observation cardinality
    /// @param observationCardinalityNextNew The updated value of the next observation cardinality
    event IncreaseObservationCardinalityNext(
        uint16 observationCardinalityNextOld,
        uint16 observationCardinalityNextNew
    );

    /// @notice Emitted when the protocol fee is changed by the pool
    /// @param feeProtocol0Old The previous value of the token0 protocol fee
    /// @param feeProtocol1Old The previous value of the token1 protocol fee
    /// @param feeProtocol0New The updated value of the token0 protocol fee
    /// @param feeProtocol1New The updated value of the token1 protocol fee
    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);

    /// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
    /// @param sender The address that collects the protocol fees
    /// @param recipient The address that receives the collected protocol fees
    /// @param amount0 The amount of token0 protocol fees that is withdrawn
    /// @param amount0 The amount of token1 protocol fees that is withdrawn
    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IUniswapV3PoolImmutables {
    /// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
    /// @return The contract address
    function factory() external view returns (address);

    /// @notice The first of the two tokens of the pool, sorted by address
    /// @return The token contract address
    function token0() external view returns (address);

    /// @notice The second of the two tokens of the pool, sorted by address
    /// @return The token contract address
    function token1() external view returns (address);

    /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
    /// @return The fee
    function fee() external view returns (uint24);

    /// @notice The pool tick spacing
    /// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
    /// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
    /// This value is an int24 to avoid casting even though it is always positive.
    /// @return The tick spacing
    function tickSpacing() external view returns (int24);

    /// @notice The maximum amount of position liquidity that can use any tick in the range
    /// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
    /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
    /// @return The max amount of liquidity per tick
    function maxLiquidityPerTick() external view returns (uint128);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IUniswapV3PoolOwnerActions {
    /// @notice Set the denominator of the protocol's % share of the fees
    /// @param feeProtocol0 new protocol fee for token0 of the pool
    /// @param feeProtocol1 new protocol fee for token1 of the pool
    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;

    /// @notice Collect the protocol fee accrued to the pool
    /// @param recipient The address to which collected protocol fees should be sent
    /// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
    /// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
    /// @return amount0 The protocol fee collected in token0
    /// @return amount1 The protocol fee collected in token1
    function collectProtocol(
        address recipient,
        uint128 amount0Requested,
        uint128 amount1Requested
    ) external returns (uint128 amount0, uint128 amount1);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;

/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IUniswapV3PoolState {
    /// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
    /// when accessed externally.
    /// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
    /// tick The current tick of the pool, i.e. according to the last tick transition that was run.
    /// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
    /// boundary.
    /// observationIndex The index of the last oracle observation that was written,
    /// observationCardinality The current maximum number of observations stored in the pool,
    /// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
    /// feeProtocol The protocol fee for both tokens of the pool.
    /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
    /// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
    /// unlocked Whether the pool is currently locked to reentrancy
    function slot0()
        external
        view
        returns (
            uint160 sqrtPriceX96,
            int24 tick,
            uint16 observationIndex,
            uint16 observationCardinality,
            uint16 observationCardinalityNext,
            uint8 feeProtocol,
            bool unlocked
        );

    /// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
    /// @dev This value can overflow the uint256
    function feeGrowthGlobal0X128() external view returns (uint256);

    /// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
    /// @dev This value can overflow the uint256
    function feeGrowthGlobal1X128() external view returns (uint256);

    /// @notice The amounts of token0 and token1 that are owed to the protocol
    /// @dev Protocol fees will never exceed uint128 max in either token
    function protocolFees() external view returns (uint128 token0, uint128 token1);

    /// @notice The currently in range liquidity available to the pool
    /// @dev This value has no relationship to the total liquidity across all ticks
    function liquidity() external view returns (uint128);

    /// @notice Look up information about a specific tick in the pool
    /// @param tick The tick to look up
    /// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
    /// tick upper,
    /// liquidityNet how much liquidity changes when the pool price crosses the tick,
    /// feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
    /// feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
    /// tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
    /// secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
    /// secondsOutside the seconds spent on the other side of the tick from the current tick,
    /// initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
    /// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
    /// In addition, these values are only relative and must be used only in comparison to previous snapshots for
    /// a specific position.
    function ticks(int24 tick)
        external
        view
        returns (
            uint128 liquidityGross,
            int128 liquidityNet,
            uint256 feeGrowthOutside0X128,
            uint256 feeGrowthOutside1X128,
            int56 tickCumulativeOutside,
            uint160 secondsPerLiquidityOutsideX128,
            uint32 secondsOutside,
            bool initialized
        );

    /// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
    function tickBitmap(int16 wordPosition) external view returns (uint256);

    /// @notice Returns the information about a position by the position's key
    /// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
    /// @return _liquidity The amount of liquidity in the position,
    /// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
    /// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
    /// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
    /// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
    function positions(bytes32 key)
        external
        view
        returns (
            uint128 _liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    /// @notice Returns data about a specific observation index
    /// @param index The element of the observations array to fetch
    /// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
    /// ago, rather than at a specific index in the array.
    /// @return blockTimestamp The timestamp of the observation,
    /// Returns tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
    /// Returns secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
    /// Returns initialized whether the observation has been initialized and the values are safe to use
    function observations(uint256 index)
        external
        view
        returns (
            uint32 blockTimestamp,
            int56 tickCumulative,
            uint160 secondsPerLiquidityCumulativeX128,
            bool initialized
        );
}

// SPDX-License-Identifier: UNLICENSED
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

pragma solidity >=0.7.0 <0.9.0;

interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint amount) external;
}

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

interface LinkTokenInterface {
  function allowance(address owner, address spender) external view returns (uint256 remaining);

  function approve(address spender, uint256 value) external returns (bool success);

  function balanceOf(address owner) external view returns (uint256 balance);

  function decimals() external view returns (uint8 decimalPlaces);

  function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);

  function increaseApproval(address spender, uint256 subtractedValue) external;

  function name() external view returns (string memory tokenName);

  function symbol() external view returns (string memory tokenSymbol);

  function totalSupply() external view returns (uint256 totalTokensIssued);

  function transfer(address to, uint256 value) external returns (bool success);

  function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);

  function transferFrom(address from, address to, uint256 value) external returns (bool success);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

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

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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

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

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

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

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

    constructor() {
        _status = NOT_ENTERED;
    }

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./SvgHelper.sol";

library RenderHelper {
    function getJson(
        uint256 tokenId,
        uint8[7] memory tetra,
        string[] memory colorNames,
        string[] memory colorHexCodes
    ) public pure returns (string memory) {
        bytes memory dataURI = abi.encodePacked(
            "{",
            _prop("description", "TetraSpektra"),
            _prop("name", string.concat("Tetra #", Strings.toString(tokenId))),
            '"attributes": [',
            string(_getAttributes(tetra, colorNames)),
            "],",
            _prop(
                "image",
                _getBase64Image(_render(tetra, colorHexCodes)),
                false
            ),
            "}"
        );

        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(dataURI)
                )
            );
    }

    function _getTrait(
        string memory traitType,
        string memory traitValue
    ) private pure returns (string memory) {
        return _getTrait(traitType, traitValue, true);
    }

    function _getTrait(
        string memory traitType,
        string memory traitValue,
        bool addComma
    ) private pure returns (string memory) {
        return
            string.concat(
                "{",
                _prop("trait_type", traitType),
                _prop("value", traitValue, false),
                "}",
                addComma ? "," : ""
            );
    }

    function _prop(
        string memory name,
        string memory value
    ) private pure returns (string memory) {
        return _prop(name, value, false, true);
    }

    function _prop(
        string memory name,
        string memory value,
        bool addComma
    ) private pure returns (string memory) {
        return _prop(name, value, false, addComma);
    }

    function _prop(
        string memory name,
        string memory value,
        bool isNumber,
        bool addComma
    ) private pure returns (string memory) {
        return
            string.concat(
                ' "',
                name,
                '": ',
                isNumber ? "" : '"',
                value,
                isNumber ? "" : '"',
                addComma ? ", " : " "
            );
    }

    function _getBase64Image(
        bytes memory data
    ) private pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    "data:image/svg+xml;base64,",
                    Base64.encode(data)
                )
            );
    }

    function _getAttributes(
        uint8[7] memory tetra,
        string[] memory colorNames
    ) private pure returns (bytes memory) {
        return
            abi.encodePacked(
                _getTrait("Inner Kore #1", colorNames[tetra[0]]),
                _getTrait("Inner Kore #2", colorNames[tetra[1]]),
                _getTrait("Inner Kore #3", colorNames[tetra[2]]),
                _getTrait("Inner Kore #4", colorNames[tetra[3]]),
                _getTrait("Outer Kore", colorNames[tetra[4]]),
                _getTrait("Mantle", colorNames[tetra[5]]),
                _getTrait("Krust", colorNames[tetra[6]], false)
            );
    }

    function _renderUnexcavated() private pure returns (bytes memory) {
        return
            abi.encodePacked(
                "<svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinYMin meet' viewBox='0 0 15 15' width='100%' height='auto' shape-rendering='crispEdges' >",
                "<style type='text/css'> @media screen and (-webkit-min-device-pixel-ratio: 0) and (min-resolution: 0.001dpcm) {.static { background: repeating-radial-gradient(#000 0 0.0001%,#fff 0 0.0002%) 50% 0/2500px 2500px,repeating-conic-gradient(#000 0 0.0001%,#fff 0 0.0002%) 60% 60%/2500px 2500px; background-blend-mode: difference; animation: st .2s infinite alternate; mix-blend-mode: multiply;} @keyframes st{ 100% {background-position: 20% 0, 20% 50%} } @media screen and (-webkit-min-device-pixel-ratio: 0) { _::-webkit-full-page-media, .static { background:none; }}</style>",
                "<filter id='g'><feGaussianBlur stdDeviation='.14' result='cb' /><feMerge><feMergeNode in='cb' /><feMergeNode in='SourceGraphic' /></feMerge></filter><rect x='0' y='0' height='100%' width='100%' fill='black' /><g transform='translate(.5 .5)'><rect x='6.125' y='6.125' height='.75' width='.75' stroke='#FFFFFF' stroke-width='.01'><animate attributeName='opacity' values='1;0;1' dur='4s' repeatCount='indefinite' /></rect><rect x='7.125' y='6.125' height='.75' width='.75' stroke='#FFFFFF' stroke-width='.01'><animate attributeName='opacity' values='1;0;1' dur='2s' repeatCount='indefinite' /></rect><rect x='6.125' y='7.125' height='.75' width='.75' stroke='#FFFFFF' stroke-width='.01'><animate attributeName='opacity' values='1;0;1' dur='3s' repeatCount='indefinite' /></rect><rect x='7.125' y='7.125' height='.75' width='.75' stroke='#FFFFFF' stroke-width='.01'><animate attributeName='opacity' values='1;0;1' dur='1s' repeatCount='indefinite' /></rect></g><g transform='translate(.5 .5)'><g><circle cx='7' cy='7' r='2' fill='none' opacity='1' stroke='#FFFFFF' stroke-width='0.1' filter='' ><animate attributeName='r' values='2.5;6.9;' dur='6s' repeatCount='indefinite' /><animate attributeName='stroke-width' values='0;.1;' dur='6s' repeatCount='indefinite' /><animate attributeName='opacity' values='0;1;0;' dur='6s' repeatCount='indefinite' /></circle></g></g>",
                "<foreignObject class='static' x='0' y='0' width='100' height='100'><div class='logoGradient' xmlns='http://www.w3.org/1999/xhtml'></div></foreignObject></svg>"
            );
    }

    function _renderKrust(
        uint8[7] memory tetra,
        string[] memory colorHexCodes
    ) private pure returns (string memory) {
        return
            string.concat(
                SvgHelper.rectangle(
                    "0",
                    "0",
                    "6",
                    ".1",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "0",
                    "0",
                    ".1",
                    "7",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "0",
                    "7",
                    "7",
                    ".1",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "0",
                    "13.9",
                    ".1",
                    "6",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "7",
                    "13.9",
                    ".1",
                    "7",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "13.9",
                    "8",
                    "6",
                    ".1",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "13.9",
                    "0",
                    "7",
                    ".1",
                    colorHexCodes[tetra[6]]
                ),
                SvgHelper.rectangle(
                    "8",
                    "0",
                    ".1",
                    "6",
                    colorHexCodes[tetra[6]]
                )
            );
    }

    function _renderMantle(
        uint8[7] memory tetra,
        string[] memory colorHexCodes
    ) private pure returns (string memory) {
        return
            string.concat(
                SvgHelper.rectangle(
                    "2",
                    "2",
                    ".1",
                    "7",
                    colorHexCodes[tetra[5]]
                ),
                SvgHelper.rectangle(
                    "2",
                    "2",
                    "1",
                    ".1",
                    colorHexCodes[tetra[5]]
                ),
                //
                SvgHelper.rectangle(
                    "2",
                    "5",
                    "7",
                    ".1",
                    colorHexCodes[tetra[5]]
                ),
                SvgHelper.rectangle(
                    "2",
                    "11.9",
                    ".1",
                    "1",
                    colorHexCodes[tetra[5]]
                ),
                //
                SvgHelper.rectangle(
                    "5",
                    "11.9",
                    ".1",
                    "7",
                    colorHexCodes[tetra[5]]
                ),
                SvgHelper.rectangle(
                    "11.9",
                    "10.9",
                    "1",
                    ".1",
                    colorHexCodes[tetra[5]]
                ),
                //
                SvgHelper.rectangle(
                    "11.9",
                    "2",
                    "7",
                    ".1",
                    colorHexCodes[tetra[5]]
                ),
                SvgHelper.rectangle(
                    "10.9",
                    "2",
                    ".1",
                    "1",
                    colorHexCodes[tetra[5]]
                )
            );
    }

    function _renderNucleus(
        uint8[7] memory tetra,
        string[] memory colorHexCodes
    ) private pure returns (string memory) {
        return
            string.concat(
                SvgHelper.square(
                    "6.125",
                    "6.125",
                    ".75",
                    colorHexCodes[tetra[0]],
                    SvgHelper.animate("opacity", "1;0.2;1;", "3s")
                ),
                SvgHelper.square(
                    "7.125",
                    "6.125",
                    ".75",
                    colorHexCodes[tetra[1]],
                    SvgHelper.animate("opacity", "1;0.2;1;", "2s")
                ),
                SvgHelper.square(
                    "6.125",
                    "7.125",
                    ".75",
                    colorHexCodes[tetra[2]],
                    SvgHelper.animate("opacity", "1;0.2;1;", "4s")
                ),
                SvgHelper.square(
                    "7.125",
                    "7.125",
                    ".75",
                    colorHexCodes[tetra[3]],
                    SvgHelper.animate("opacity", "1;0.2;1;", "5s")
                )
            );
    }

    function _render(
        uint8[7] memory tetra,
        string[] memory colorHexCodes
    ) private pure returns (bytes memory) {
        if (tetra[0] == 0) return _renderUnexcavated();
        string memory str = string.concat(
            "<g filter='url(#g)'>",
            _renderKrust(tetra, colorHexCodes),
            _renderMantle(tetra, colorHexCodes),
            SvgHelper.circle(
                "7",
                "7",
                "2.5",
                "1",
                "none",
                colorHexCodes[tetra[4]],
                "0.1"
            ),
            "</g>",
            "<g>",
            SvgHelper.circle(
                "7",
                "7",
                "2",
                "1",
                "none",
                colorHexCodes[tetra[4]],
                "0.1",
                SvgHelper.getStandardAnimationGroup("8s")
            ),
            SvgHelper.circle(
                "7",
                "7",
                "2",
                "1",
                "none",
                colorHexCodes[tetra[6]],
                "0.1",
                SvgHelper.getStandardAnimationGroup("6s")
            ),
            SvgHelper.circle(
                "7",
                "7",
                "2",
                "1",
                "none",
                colorHexCodes[tetra[5]],
                "0.1",
                SvgHelper.getStandardAnimationGroup("4s")
            ),
            SvgHelper.circle(
                "7",
                "7",
                "2",
                "1",
                "none",
                colorHexCodes[tetra[4]],
                "0.1",
                SvgHelper.getStandardAnimationGroup("2s")
            ),
            "</g>",
            _renderNucleus(tetra, colorHexCodes)
        );

        return
            abi.encodePacked(
                "<svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinYMin meet' viewBox='0 0 15 15' width='100%' height='auto' shape-rendering='crispEdges'><filter id='g'><feGaussianBlur stdDeviation='.14' result='cb' /><feMerge><feMergeNode in='cb'/><feMergeNode in='SourceGraphic' /></feMerge></filter>",
                "<style type='text/css'> @media screen and (-webkit-min-device-pixel-ratio: 0) and (min-resolution: 0.001dpcm) {.static { background: repeating-radial-gradient(#000 0 0.0001%,#fff 0 0.0002%) 50% 0/2500px 2500px,repeating-conic-gradient(#000 0 0.0001%,#fff 0 0.0002%) 60% 60%/2500px 2500px; background-blend-mode: difference; animation: st .2s infinite alternate; mix-blend-mode: multiply;} @keyframes st{ 100% {background-position: 20% 0, 20% 50%} } @media screen and (-webkit-min-device-pixel-ratio: 0) { _::-webkit-full-page-media, .static { background:none; }}</style>",
                SvgHelper.rectangle("0", "0", "100%", "100%", colorHexCodes[0]),
                "<g transform='translate(.5 .5)'>",
                str,
                "</g><foreignObject class='static' x='0' y='0' width='100' height='100'><div class='logoGradient' xmlns='http://www.w3.org/1999/xhtml'></div></foreignObject></svg>"
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/utils/Strings.sol";

library SvgHelper {
    function circle(
        string memory x,
        string memory y,
        string memory r,
        string memory color
    ) public pure returns (string memory) {
        return circle(x, y, r, "1", color, "", "0");
    }

    function circle(
        uint256 x,
        uint256 y,
        uint256 r,
        string memory opacity,
        string memory color,
        string memory strokeColor,
        string memory strokeWidth
    ) public pure returns (string memory) {
        return
            circle(
                Strings.toString(x),
                Strings.toString(y),
                Strings.toString(r),
                opacity,
                color,
                strokeColor,
                strokeWidth,
                ""
            );
    }

    function circle(
        string memory x,
        string memory y,
        string memory r,
        string memory opacity,
        string memory color,
        string memory strokeColor,
        string memory strokeWidth
    ) public pure returns (string memory) {
        return circle(x, y, r, opacity, color, strokeColor, strokeWidth, "");
    }

    function circle(
        string memory x,
        string memory y,
        string memory r,
        string memory opacity,
        string memory color,
        string memory strokeColor,
        string memory strokeWidth,
        string memory animation
    ) public pure returns (string memory) {
        return
            circle(
                x,
                y,
                r,
                opacity,
                color,
                strokeColor,
                strokeWidth,
                animation,
                ""
            );
    }

    function circle(
        string memory x,
        string memory y,
        string memory r,
        string memory opacity,
        string memory color,
        string memory strokeColor,
        string memory strokeWidth,
        string memory animation,
        string memory filter
    ) public pure returns (string memory) {
        return
            string.concat(
                "<circle cx='",
                x,
                "' cy='",
                y,
                "' r='",
                r,
                "' fill='",
                color,
                "' opacity='",
                opacity,
                "' stroke='",
                keccak256(abi.encodePacked(strokeColor)) != ""
                    ? strokeColor
                    : "",
                "' stroke-width='",
                keccak256(abi.encodePacked(strokeColor)) != ""
                    ? strokeWidth
                    : "",
                "'",
                keccak256(abi.encodePacked(filter)) == ""
                    ? ""
                    : string.concat(" filter='", filter, "'"),
                keccak256(abi.encodePacked((animation))) == ""
                    ? "/>"
                    : string.concat(" >", animation, "</circle>")
            );
    }

    function triangle(
        string memory x0,
        string memory y0,
        string memory x1,
        string memory y1,
        string memory x2,
        string memory y2,
        string memory color
    ) public pure returns (string memory) {
        return
            string.concat(
                "<polygon points='",
                x0,
                " ",
                y0,
                ", ",
                x1,
                " ",
                y1,
                ", ",
                x2,
                " ",
                y2,
                "'  fill='",
                color,
                "'/>"
            );
    }

    function square(
        string memory x,
        string memory y,
        string memory size,
        string memory color
    ) public pure returns (string memory) {
        return square(x, y, size, color, "");
    }

    function square(
        string memory x,
        string memory y,
        string memory size,
        string memory color,
        string memory animation
    ) public pure returns (string memory) {
        return rectangle(x, y, size, size, color, "", "", animation);
    }

    function animate(
        string memory attributeName,
        string memory values,
        string memory duration
    ) public pure returns (string memory) {
        return
            string.concat(
                "<animate attributeName='",
                attributeName,
                "' values='",
                values,
                "' dur='",
                duration,
                "' repeatCount='",
                "indefinite",
                "' />"
            );
    }

    function rectangle(
        string memory x,
        string memory y,
        string memory h,
        string memory w,
        string memory color
    ) public pure returns (string memory) {
        return rectangle(x, y, h, w, color, "", "", "");
    }

    function rectangle(
        string memory x,
        string memory y,
        string memory h,
        string memory w,
        string memory color,
        string memory stroke,
        string memory strokeWidth,
        string memory animation
    ) public pure returns (string memory) {
        return
            string.concat(
                "<rect x='",
                x,
                "' y='",
                y,
                "' height='",
                h,
                "' width='",
                w,
                "' fill='",
                color,
                "' stroke='",
                stroke,
                "' stroke-width='",
                strokeWidth,
                "'",
                keccak256(abi.encodePacked((animation))) == ""
                    ? "/>"
                    : string.concat(" >", animation, "</rect>")
            );
    }

    function getStandardAnimationGroup(
        string memory s
    ) public pure returns (string memory) {
        return
            string.concat(
                animate("r", "2.5;6.9;", s),
                animate("stroke-width", "0;.1;", s),
                animate("opacity", "1;0;", s)
            );
    }
}

// SPDX-License-Identifier: MIT

/******* TetraSpektra.sol ******
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░█████████░░░███████████░░ *
 * ░░██░░░░░░░░░░░░░░░░░░░██░░ *
 * ░░██░░░██████░░░████░░░██░░ *
 * ░░██░░░██░░░░░░░░░██░░░██░░ *
 * ░░██░░░░░░░▒▒░██░░██░░░░░░░ *
 * ░░░░░░░██░░▓▓░▒▒░░░░░░░██░░ *
 * ░░██░░░██░░░░░░░░░██░░░██░░ *
 * ░░██░░░████░░░██████░░░██░░ *
 * ░░██░░░░░░░░░░░░░░░░░░░██░░ *
 * ░░███████████░░░█████████░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 ******************************/

/*
  ___                           _            _    _   
 / _ \__  __/\   /\___ _ __ ___| |_ ___  ___| | _| |_ 
| | | \ \/ /\ \ / / _ \ '__/ __| __/ _ \/ __| |/ / __|
| |_| |>  <  \ V /  __/ |  \__ \ ||  __/ (__|   <| |_ 
 \___//_/\_\  \_/ \___|_|  |___/\__\___|\___|_|\_\\__|
 
 */

pragma solidity >=0.7.0 <0.9.0;

import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

import {IUniswapV3Pool} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import {Excavator} from "./Excavator.sol";
import "./interfaces/ISwapRouter.sol";
import "./interfaces/IClaimsManager.sol";
import "./interfaces/IRandomizer.sol";
import "./interfaces/IPriceOracle.sol";
import "./interfaces/IBountyVault.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IProspektorFundManager.sol";

import "./utils/TransferHelper.sol";
import "./utils/RenderHelper.sol";
import "./utils/ExecutorManager.sol";

enum CreatorBountyTier {
    None,
    Low,
    Medium,
    High,
    Ultra
}

enum BountyTier {
    Silver,
    Gold,
    Platinum
}

enum DiscoveryType {
    Prospekted,
    Reforged,
    Refined
}

struct BountySwapConfig {
    uint256 tokenCount;
    uint256 innerCount;
    uint256 outerCount;
}

struct TetraSpektraConfig {
    uint256 maxSupply;
    uint256 prospektPrice;
    uint256 refreshPrice;
    uint256 flashBountyValue;
    uint8 excavatorFundingPercentage;
    uint16 maxSilver2Swaps;
    uint8 silver2UnlockCadence;
    uint8 silver2UnlockAmount;
    string[] colorHexCodes;
    string[] colorNames;
}

struct AddressConfig {
    address randomizerAddress;
    address claimsManagerAddress;
    address priceOracleAddress;
    address bountyVaultAddress;
    address uniswapRouterAddress;
}

struct ColorConfig {
    string[] colorHexCodes;
    string[] colorNames;
    uint8 maxColors;
}

struct ExcavatorConfig {
    address vrfCoordinatorAddress;
    bytes32 vrfKeyHash;
    address linkTokenAddress;
}

struct TokenConfig {
    address wethTokenAddress;
    address porkTokenAddress;
}

/**
 * @title TetraSpektra
 * @author 0xVersteckt
 * @notice Hello prospektor...
 */
contract TetraSpektra is
    ERC721,
    IERC721Receiver,
    ExecutorManager,
    Pausable,
    ReentrancyGuard
{
    error InsufficientPayment();
    error NotSoldOut();
    error InvalidTokenOwner();
    error InvalidToken();
    error NotMatched();
    error InvalidTokenCompare();
    error TooManySilver2Swaps();
    error InvalidTokenCount();
    error ExcavationInProgress();
    error ExcavationGroupNotReady();

    event Swapped(
        address indexed prospektor,
        uint256 indexed tier,
        uint256 bountyValue,
        uint256 tokenId_0,
        uint256 tokenId_1,
        uint256 tokenId_2,
        uint256 tokenId_3
    );

    event Discovery(
        address indexed prospektor,
        uint256 indexed tokenId,
        DiscoveryType discoveryType
    );

    event Excavated(
        address indexed prospektor,
        uint256 indexed tokenId,
        bytes32 silverTetraKey,
        bytes32 goldTetraKey,
        bytes32 platinumTetraKey
    );

    event AddedLiquidityForBounty(
        address indexed prospektor,
        uint256 interactionCount,
        uint256 porkAmount,
        uint256 wethAmount,
        uint256 canAddLiquidityAfter
    );

    event CollectedFeesForBounty(
        address indexed prospektor,
        uint256 interactionCount,
        uint256 porkAmount,
        uint256 canCollectFeesAfter
    );

    event ExcavationComplete(
        uint256 indexed excavationId,
        uint256 indexed value
    );

    event ExcavationContracted(
        uint256 excavationId,
        uint256 tokenId_0,
        uint256 tokenId_1,
        uint256 tokenId_2,
        uint256 tokenId_3,
        uint256 tokenId_4
    );

    event ExcavatedFlashBounty(
        bytes32 silverTetraKey,
        bytes32 goldTetraKey,
        bytes32 platinumTetraKey
    );

    event ClaimedFlashBounty(
        address indexed prospektor,
        uint256 indexed tokenId,
        bytes32 tetraKey,
        uint256 bountyValue
    );

    event Claimed(
        address indexed prospektor,
        uint256 claimsSessionId,
        uint256 claimedTokenId,
        uint256 tokenId
    );

    IProspektorFundManager public prospektorFundManager;
    IClaimsManager public claimsManager;
    IRandomizer public randomizer;
    IPriceOracle public priceOracle;
    IBountyVault public bountyVault;
    Excavator public excavator;

    IUniswapV3Pool public uniswapPool;
    ISwapRouter public uniswapRouter;

    address public immutable WETH;
    address public immutable PORK;

    uint256 public immutable maxSupply;

    /// @notice Used to prevent underflow
    uint256 public constant MIN_WETH_AMOUNT = 1_000_000_000_000_000; // .001 ether
    uint256 public constant MIN_PORK_AMOUNT = 100_000_000;

    bytes32 public immutable BASE_TETRA_KEY = getTetraKey(0, BountyTier.Silver);
    uint24 public constant PORK_WETH_POOL_FEE = 10_000;
    uint24 public constant DEFAULT_POOL_FEE = 3_000;
    uint8 public constant MAX_TO_PROSPEKT = 5;
    uint8 private constant CADENCE = 5;
    uint8 public constant SWAP_PERCENTAGE_INCREMENT = 8;

    uint8 public fundingPercentage;

    uint16 public maxSilver2Swaps;
    uint8 public silver2UnlockCadence;
    uint8 public silver2UnlockAmount;

    uint256 public silver2Swaps = 0;

    uint256 public canCollectFeesAfter = 20;
    uint256 public feeCollectorBounty = 20_000_000_000_000_000;
    uint256 public feeCollectorCadence = 20;

    uint256 public canAddLiquidityAfter = 10;
    uint256 public liquidityAdderBounty = 25_000_000_000_000_000;
    uint256 public liquidityAdderCadence = 12;

    uint256 private _prospektCount = 1;
    uint256 public interactionCount = 0;
    uint256 public swapPercentage = 55;
    uint256 public prospektPrice;
    uint256 public refreshPrice;

    uint256 public refreshCount = 0;

    bool public isInitialized;

    uint256 public flashBountyValue;
    bool public flashBountyEnabled;

    mapping(uint256 => uint256) private _tetraSeeds;
    mapping(uint256 => uint256) private _excavationResults;

    mapping(uint256 => uint256) public tetraExcavationIds;
    mapping(uint256 => uint256) public excavationTracker;

    uint256 public excavationGroup;

    uint256[3][3] private _bounties;

    ColorConfig public colorConfig;

    uint24[5][2] private _priceHistory;
    uint8 private _priceHistoryIndex;

    constructor(
        AddressConfig memory addressConfig,
        TokenConfig memory tokenConfig,
        ExcavatorConfig memory excavatorConfig,
        TetraSpektraConfig memory tetraSpektraConfig,
        uint256[3][3] memory bounties
    ) payable ExecutorManager(msg.sender) ERC721("TetraSpektra", "TETRA") {
        require(
            tetraSpektraConfig.colorHexCodes.length ==
                tetraSpektraConfig.colorNames.length,
            "0"
        );
        claimsManager = IClaimsManager(addressConfig.claimsManagerAddress);
        randomizer = IRandomizer(addressConfig.randomizerAddress);
        priceOracle = IPriceOracle(addressConfig.priceOracleAddress);
        bountyVault = IBountyVault(addressConfig.bountyVaultAddress);
        uniswapRouter = ISwapRouter(addressConfig.uniswapRouterAddress);

        WETH = tokenConfig.wethTokenAddress;
        PORK = tokenConfig.porkTokenAddress;

        maxSupply = tetraSpektraConfig.maxSupply;
        prospektPrice = tetraSpektraConfig.prospektPrice;
        refreshPrice = tetraSpektraConfig.refreshPrice;

        flashBountyValue = tetraSpektraConfig.flashBountyValue == 0
            ? _percentage(tetraSpektraConfig.prospektPrice, 70) * 10
            : tetraSpektraConfig.flashBountyValue;

        fundingPercentage = tetraSpektraConfig.excavatorFundingPercentage;

        maxSilver2Swaps = tetraSpektraConfig.maxSilver2Swaps;
        silver2UnlockCadence = tetraSpektraConfig.silver2UnlockCadence;
        silver2UnlockAmount = tetraSpektraConfig.silver2UnlockAmount;

        colorConfig = ColorConfig({
            colorHexCodes: tetraSpektraConfig.colorHexCodes,
            colorNames: tetraSpektraConfig.colorNames,
            maxColors: uint8(tetraSpektraConfig.colorNames.length)
        });

        excavator = new Excavator(
            msg.sender,
            address(this),
            address(uniswapRouter),
            excavatorConfig.vrfCoordinatorAddress,
            excavatorConfig.vrfKeyHash,
            WETH,
            excavatorConfig.linkTokenAddress
        );

        TransferHelper.safeApprove(WETH, address(excavator), type(uint256).max);

        IWETH(WETH).deposit{value: _percentage(msg.value, 20)}();
        excavator.initialize{value: _percentage(msg.value, 80)}();

        _bounties = bounties;
    }

    function _unsafeIncrement(uint256 x) private pure returns (uint256) {
        unchecked {
            return x + 1;
        }
    }

    modifier mustOwnToken(address addr, uint256 tokenId) {
        if (ownerOf(tokenId) != addr) revert InvalidTokenOwner();
        _;
    }

    modifier checkPayment(uint256 value) {
        if (msg.value < value) revert InsufficientPayment();
        _;
    }

    modifier mustBeSoldOut() {
        if (totalSupply() != maxSupply) revert NotSoldOut();
        _;
    }

    function getBounties() public view returns (uint256[3][3] memory) {
        return _bounties;
    }

    function totalSupply() public view returns (uint256) {
        return _prospektCount - 1;
    }

    function getTetrasRemaining() public view returns (uint256) {
        return maxSupply - totalSupply();
    }

    function claimVaultBounty(
        uint256 tokenId
    ) public mustOwnToken(msg.sender, tokenId) {
        bountyVault.claimBounty(msg.sender, tokenId);
    }

    function getTotalBounty(
        uint256 tierIndex,
        uint256 countIndex
    ) private view returns (uint256) {
        return
            address(this).balance >= _bounties[tierIndex][countIndex]
                ? _bounties[tierIndex][countIndex]
                : address(this).balance;
    }

    function isFlashBountyEnabled() public view returns (bool) {
        return flashBountyEnabled && isExcavated(0);
    }

    function isExcavated(uint256 tokenId) public view returns (bool) {
        return getTetraKey(tokenId, BountyTier.Silver) != BASE_TETRA_KEY;
    }

    function _percentage(
        uint256 value,
        uint256 percentage
    ) private pure returns (uint256) {
        return (value * percentage) / 100;
    }

    function _fundExcavatorWhenReady() internal {
        if (
            fundingPercentage > 0 &&
            interactionCount > 0 &&
            interactionCount % CADENCE == 0
        ) {
            uint256 fundAmount = (_percentage(
                excavator.getLinkPrice(),
                fundingPercentage
            ) * CADENCE);
            require(
                IERC20(WETH).balanceOf(address(this)) > fundAmount,
                "INVALID_WETH"
            );
            excavator.fundWithWeth(fundAmount);
        }
    }

    function updateExcavatorFundingPercentage(
        uint8 percentage
    ) public onlyExecutor {
        require(percentage >= 0 && percentage <= 100, "0");
        fundingPercentage = percentage;
    }

    function prospekt(
        uint256 count
    )
        external
        payable
        whenNotPaused
        nonReentrant
        checkPayment(prospektPrice * count)
        returns (uint256[MAX_TO_PROSPEKT] memory tokenIds)
    {
        require(count > 0 && count <= MAX_TO_PROSPEKT, "1");
        require(totalSupply() + count <= maxSupply, "2");

        for (uint256 i = 0; i < count; i = _unsafeIncrement(i))
            tokenIds[i] = _prospekt(msg.sender);

        IWETH(WETH).deposit{value: msg.value}();

        _fundExcavatorWhenReady();

        /// @dev Attempt to buffer for liquidity adder
        ///      and fee collector bounty
        uint256 wethToSwap = IERC20(WETH).balanceOf(address(this));
        if (wethToSwap / liquidityAdderBounty == 1)
            wethToSwap -= liquidityAdderBounty;
        if (wethToSwap > 0)
            _swapWethForToken(
                PORK,
                _percentage(wethToSwap, swapPercentage),
                address(this)
            );

        return tokenIds;
    }

    /// @dev User pays to re-excavate and claim tokens owned by contract
    function refine(
        uint256[] memory tokenIds
    )
        external
        payable
        whenNotPaused
        nonReentrant
        checkPayment(refreshPrice * tokenIds.length)
        mustBeSoldOut
    {
        IWETH(WETH).deposit{value: msg.value}();

        for (uint256 i = 0; i < tokenIds.length; i = _unsafeIncrement(i)) {
            if (ownerOf(tokenIds[i]) != address(this))
                revert InvalidTokenOwner();

            _transfer(address(this), msg.sender, tokenIds[i]);

            _processRefresh(DiscoveryType.Refined, tokenIds[i]);
        }

        /// @dev Attempt to buffer for liquidity adder
        ///      and fee collector bounty
        uint256 wethToSwap = IERC20(WETH).balanceOf(address(this));
        if (wethToSwap / liquidityAdderBounty == 1)
            wethToSwap -= liquidityAdderBounty;
        if (wethToSwap > 0)
            _swapWethForToken(
                PORK,
                _percentage(wethToSwap, swapPercentage),
                address(this)
            );
    }

    /// @dev User pays to re-excavate tokens they own
    function reforge(
        uint256[] memory tokenIds
    )
        external
        payable
        whenNotPaused
        nonReentrant
        checkPayment(refreshPrice * tokenIds.length)
        mustBeSoldOut
    {
        IWETH(WETH).deposit{value: msg.value}();

        for (uint256 i = 0; i < tokenIds.length; i = _unsafeIncrement(i)) {
            if (ownerOf(tokenIds[i]) != msg.sender) revert InvalidTokenOwner();

            _resetTetra(tokenIds[i]);

            _processRefresh(DiscoveryType.Reforged, tokenIds[i]);
        }

        /// @dev Attempt to buffer for liquidity adder
        ///      and fee collector bounty
        uint256 wethToSwap = IERC20(WETH).balanceOf(address(this));
        if (wethToSwap / liquidityAdderBounty == 1)
            wethToSwap -= liquidityAdderBounty;
        if (wethToSwap > 0)
            _swapWethForToken(
                PORK,
                _percentage(wethToSwap, swapPercentage),
                address(this)
            );
    }

    /// @dev Swap matching owned tokens for bounty
    function swapForBounty(
        uint256[4] memory tokenIds,
        CreatorBountyTier creatorBountyTier
    ) external whenNotPaused nonReentrant {
        BountySwapConfig memory bountySwapConfig;
        bountySwapConfig.tokenCount = 0;

        uint8[7] memory tetra0 = _getTetra(tokenIds[0]);
        for (uint256 i = 0; i < tokenIds.length; i = _unsafeIncrement(i)) {
            if (tokenIds[i] == 0) break;
            else bountySwapConfig.tokenCount++;
            if (ownerOf(tokenIds[i]) != msg.sender) revert InvalidTokenOwner();

            uint8[7] memory currentTetra = _getTetra(tokenIds[i]);

            if (i < tokenIds.length - 1)
                for (
                    uint256 k = i + 1;
                    k < tokenIds.length;
                    k = _unsafeIncrement(k)
                ) {
                    if (tokenIds[k] == 0) break;
                    if (tokenIds[i] == tokenIds[k])
                        revert InvalidTokenCompare();
                    if (
                        getTetraKey(tokenIds[i], BountyTier.Silver) !=
                        getTetraKey(tokenIds[k], BountyTier.Silver)
                    ) revert NotMatched();
                }
            if (i != 0) {
                if (
                    tetra0[5] != 0 &&
                    currentTetra[5] != 0 &&
                    tetra0[5] == currentTetra[5]
                )
                    bountySwapConfig.innerCount = _unsafeIncrement(
                        bountySwapConfig.innerCount
                    );
                if (
                    /// @notice Cant compare if not excavated
                    tetra0[6] != 0 &&
                    currentTetra[6] != 0 &&
                    tetra0[6] == currentTetra[6]
                )
                    bountySwapConfig.outerCount = _unsafeIncrement(
                        bountySwapConfig.outerCount
                    );
            }
        }
        if (bountySwapConfig.tokenCount < 2) revert InvalidTokenCount();

        uint256 tierIndex = 0;
        /// @notice Check to see if shell_0 matches
        if (bountySwapConfig.innerCount == bountySwapConfig.tokenCount - 1) {
            tierIndex = _unsafeIncrement(tierIndex);

            /// @notice Check to see if shell_1 matches
            if (bountySwapConfig.outerCount == bountySwapConfig.tokenCount - 1)
                tierIndex = _unsafeIncrement(tierIndex);
        }

        /// @notice Limit silver2Swaps
        if (tierIndex == 0 && bountySwapConfig.tokenCount == 2) {
            if (silver2Swaps == maxSilver2Swaps) revert TooManySilver2Swaps();
            silver2Swaps = _unsafeIncrement(silver2Swaps);
        }

        for (
            uint256 i = 0;
            i < bountySwapConfig.tokenCount;
            i = _unsafeIncrement(i)
        ) {
            _resetTetra(tokenIds[i]);
            safeTransferFrom(msg.sender, address(this), tokenIds[i]);
        }

        uint256 totalValueEth = getTotalBounty(
            tierIndex,
            bountySwapConfig.tokenCount - 2
        );

        uint256 bountyValue = priceOracle.getPrice(
            WETH,
            PORK,
            uint128(totalValueEth),
            PORK_WETH_POOL_FEE
        );

        require(
            IERC20(PORK).balanceOf(address(bountyVault)) > bountyValue,
            "NOT_ENOUGH_BALANCE"
        );

        uint256 creatorBountyPercentage = uint256(
            creatorBountyTier == CreatorBountyTier.Low
                ? 5
                : creatorBountyTier == CreatorBountyTier.Medium
                ? 10
                : creatorBountyTier == CreatorBountyTier.High
                ? 20
                : creatorBountyTier == CreatorBountyTier.Ultra
                ? 40
                : 0
        );

        bountyVault.distribute(
            msg.sender,
            _percentage(bountyValue, 100 - creatorBountyPercentage),
            _percentage(bountyValue, creatorBountyPercentage)
        );

        emit Swapped(
            msg.sender,
            tierIndex,
            bountyValue,
            tokenIds[0],
            tokenIds[1],
            tokenIds[2],
            /// @notice Make sure that token[2] exists so tokenId isn't "spoofed"
            bountySwapConfig.tokenCount > 3 ? tokenIds[3] : 0
        );
    }

    function _processRefresh(
        DiscoveryType discoveryType,
        uint256 tokenId
    ) private {
        _excavateWhenReady(tokenId);

        _fundExcavatorWhenReady();

        if (
            ++refreshCount % silver2UnlockCadence == 0 &&
            silver2Swaps > silver2UnlockAmount
        ) silver2Swaps -= silver2UnlockAmount;

        emit Discovery(msg.sender, tokenId, discoveryType);
    }

    function _swapWethForToken(
        address token,
        uint256 ethAmount,
        address recipient
    ) internal returns (uint256 amount) {
        uint256 currWethBalance = IWETH(WETH).balanceOf(address(this));
        if (ethAmount > currWethBalance) ethAmount = currWethBalance;

        // TODO: Set min value req
        if (ethAmount > 0) {
            amount = _swapTokens(WETH, token, ethAmount, recipient);
        }
    }

    function _resetTetra(uint256 tokenId) private {
        delete _tetraSeeds[tokenId];
        delete tetraExcavationIds[tokenId];
    }

    function _beginGroupExcavation() private {
        require(excavator.isInitialized(), "NO_SUBSCRIPTION");
        uint256 excavationId = excavator.beginExcavation();

        require(excavationId != 0, "EXCAVATION_FAILED");
        excavationTracker[excavationId] = excavationGroup;

        for (uint256 i = 0; i < CADENCE; i = _unsafeIncrement(i))
            tetraExcavationIds[
                uint256(uint16(excavationTracker[excavationId] >> (16 * i)))
            ] = excavationId;

        emit ExcavationContracted(
            excavationId,
            uint256(uint16(excavationGroup >> 0)),
            uint256(uint16(excavationGroup >> 16)),
            uint256(uint16(excavationGroup >> 32)),
            uint256(uint16(excavationGroup >> 48)),
            uint256(uint16(excavationGroup >> 64))
        );

        delete excavationGroup;
    }

    function excavate(uint256 excavationId, uint256 value) external {
        require(
            msg.sender == address(excavator.vrfCoordinator()) ||
                msg.sender == address(excavator),
            "INVALID_SENDER"
        );

        _excavate(excavationId, value);

        emit ExcavationComplete(excavationId, value);
    }

    function forceExcavate(uint256 excavationId) public onlyExecutor {
        /// @notice Prevents executor from breaking unfilled excavation groups
        for (uint256 i = 0; i < CADENCE; i = _unsafeIncrement(i)) {
            uint256 tokenId = uint256(
                uint16(excavationTracker[excavationId] >> (16 * i))
            );
            if (tokenId == 0) revert ExcavationGroupNotReady();
        }
        excavator.forceExcavate(excavationId, randomizer.random());
    }

    function _prospekt(address recipient) private returns (uint256) {
        require(totalSupply() < maxSupply);

        uint256 tokenId = _prospektCount;
        _prospektCount = _unsafeIncrement(_prospektCount);
        _safeMint(recipient, tokenId);

        _excavateWhenReady(tokenId);

        emit Discovery(msg.sender, tokenId, DiscoveryType.Prospekted);

        return tokenId;
    }

    function collectFeesForBounty() external nonReentrant {
        require(balanceOf(msg.sender) > 0, "NOT_TETRA_OWNER");
        require(canCollectFees(), "NOT_READY");
        uint256 preBalance = IERC20(PORK).balanceOf(address(bountyVault));
        prospektorFundManager.collectLPFees();
        uint256 postBalance = IERC20(PORK).balanceOf(address(bountyVault));

        emit CollectedFeesForBounty(
            msg.sender,
            interactionCount,
            postBalance - preBalance,
            canCollectFeesAfter
        );

        canCollectFeesAfter = interactionCount + feeCollectorCadence;
        IERC20(WETH).approve(msg.sender, feeCollectorBounty);
        IERC20(WETH).transfer(msg.sender, feeCollectorBounty);
    }

    function addLiquidityForBounty() external nonReentrant {
        require(balanceOf(msg.sender) > 0, "NOT_TETRA_OWNER");
        require(canAddLiquidity(), "NOT_READY");
        (uint256 addedPorkAmount, uint256 addedWethAmount) = _addLiquidity();
        canAddLiquidityAfter = interactionCount + liquidityAdderCadence;

        emit AddedLiquidityForBounty(
            msg.sender,
            interactionCount,
            addedPorkAmount,
            addedWethAmount,
            canAddLiquidityAfter
        );

        IERC20(WETH).approve(msg.sender, liquidityAdderBounty);
        IERC20(WETH).transfer(msg.sender, liquidityAdderBounty);
    }

    function canAddLiquidity() public view returns (bool) {
        return
            interactionCount >= canAddLiquidityAfter &&
            IERC20(WETH).balanceOf(address(this)) > liquidityAdderBounty;
    }

    function canCollectFees() public view returns (bool) {
        return
            interactionCount >= canCollectFeesAfter &&
            IERC20(WETH).balanceOf(address(this)) > feeCollectorBounty;
    }

    function _addLiquidity()
        private
        returns (uint256 addedPorkAmount, uint256 addedWethAmount)
    {
        uint256 initialPorkBalance = _getBalanceMinusSaver(PORK);
        uint256 initialWethBalance = _getBalanceMinusSaver(WETH) -
            liquidityAdderBounty;

        (, addedPorkAmount, addedWethAmount) = prospektorFundManager
            .addLiquidity(initialPorkBalance, initialWethBalance);

        uint256 remainingPorkAmount = initialPorkBalance - addedPorkAmount;
        uint256 remainingWethAmount = initialWethBalance - addedWethAmount;

        uint256 porkWethValue = priceOracle.getPrice(
            PORK,
            WETH,
            uint128(remainingPorkAmount),
            PORK_WETH_POOL_FEE
        );

        if (
            porkWethValue > remainingWethAmount &&
            swapPercentage - SWAP_PERCENTAGE_INCREMENT > 0
        ) swapPercentage -= SWAP_PERCENTAGE_INCREMENT;

        if (
            porkWethValue < remainingWethAmount &&
            swapPercentage + SWAP_PERCENTAGE_INCREMENT < 90
        ) swapPercentage += SWAP_PERCENTAGE_INCREMENT;
    }

    function _getBalanceMinusSaver(
        address erc20Address
    ) internal view returns (uint256 balance) {
        balance = IERC20(erc20Address).balanceOf(address(this));
        if (erc20Address == WETH) balance -= MIN_WETH_AMOUNT;
        else if (erc20Address == PORK) balance -= MIN_PORK_AMOUNT;
    }

    function getTetraExcavationId(
        uint256 tokenId
    ) external view returns (uint256) {
        return tetraExcavationIds[tokenId];
    }

    function isExcavating(uint256 tokenId) public view returns (bool) {
        return
            tetraExcavationIds[tokenId] != 0 &&
            _excavationResults[tetraExcavationIds[tokenId]] == 0;
    }

    function _excavateWhenReady(uint256 tokenId) internal {
        if (isExcavating(tokenId)) revert ExcavationInProgress();

        if (interactionCount % CADENCE == 0) excavationGroup = tokenId;
        else excavationGroup |= tokenId << (16 * (interactionCount % CADENCE));

        /// @notice Temporarily set to value
        tetraExcavationIds[tokenId] = 1;

        _createTetraSeed(tokenId);

        if ((++interactionCount) % CADENCE == 0) _beginGroupExcavation();
    }

    /**
     * Flash bounties
     */
    function enableFlashBounty() public onlyExecutor {
        require(!isFlashBountyEnabled());
        flashBountyEnabled = true;
        _createTetraSeed(0);
        _excavate(0, randomizer.random());
    }

    function _disableFlashBounty() private {
        require(isFlashBountyEnabled(), "NOT_ENABLED");
        flashBountyEnabled = false;
        delete _excavationResults[0];
    }

    function isFlashBountyMatch(uint256 tokenId) public view returns (bool) {
        return
            flashBountyEnabled
                ? getTetraKey(0, BountyTier.Silver) ==
                    getTetraKey(tokenId, BountyTier.Silver)
                : false;
    }

    function claimFlashBounty(
        uint256 tokenId
    ) public nonReentrant mustOwnToken(msg.sender, tokenId) {
        require(flashBountyEnabled && isFlashBountyMatch(tokenId), "0");
        _disableFlashBounty();

        uint256 bountyValue = priceOracle.getPrice(
            WETH,
            PORK,
            uint128(flashBountyValue),
            PORK_WETH_POOL_FEE
        );

        bountyVault.distribute(msg.sender, bountyValue, 0);

        emit ClaimedFlashBounty(
            msg.sender,
            tokenId,
            getTetraKey(tokenId, BountyTier.Silver),
            bountyValue
        );
    }

    function claim(uint256 claimTokenId) public nonReentrant returns (uint256) {
        claimsManager.claim(msg.sender, claimTokenId);
        uint256 tokenId = _prospekt(msg.sender);
        emit Claimed(
            msg.sender,
            claimsManager.getClaimsSessionId(),
            claimTokenId,
            tokenId
        );
        return tokenId;
    }

    function getTetraKey(
        uint256 tokenId,
        BountyTier tier
    ) public view returns (bytes32) {
        if (tier == BountyTier.Silver)
            return _getTetraKey(tokenId, false, false);
        if (tier == BountyTier.Gold) {
            return _getTetraKey(tokenId, true, false);
        }
        if (tier == BountyTier.Platinum)
            return _getTetraKey(tokenId, true, true);
        return 0;
    }

    function getTetraKeys(
        uint256 tokenId
    ) public view returns (bytes32[3] memory) {
        bytes32[3] memory tetraKeys = [
            getTetraKey(tokenId, BountyTier.Silver),
            getTetraKey(tokenId, BountyTier.Gold),
            getTetraKey(tokenId, BountyTier.Platinum)
        ];
        return tetraKeys;
    }

    function _getTetra(uint256 tokenId) public view returns (uint8[7] memory) {
        if (
            isExcavating(tokenId) ||
            (tokenId == 0 && !flashBountyEnabled) ||
            /// @notice Check if slot is uninitialized
            uint256(uint16(_tetraSeeds[tokenId] >> 16)) == 0
        ) return [0, 0, 0, 0, 0, 0, 0];
        return [
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 16))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 32))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 48))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 64))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 80))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 96))
            ),
            _modToColorIndex(
                _excavationResults[tetraExcavationIds[tokenId]],
                uint256(uint16(_tetraSeeds[tokenId] >> 112))
            )
        ];
    }

    function _getTetraKey(
        uint256 tokenId,
        bool includeMantle,
        bool includeKrust
    ) private view returns (bytes32) {
        uint8[7] memory tetra = _getTetra(tokenId);
        return
            bytes32(
                (uint256(tetra[0]) + 1) *
                    10 ** 12 +
                    (uint256(tetra[1]) + 1) *
                    10 ** 10 +
                    (uint256(tetra[2]) + 1) *
                    10 ** 8 +
                    (uint256(tetra[3]) + 1) *
                    10 ** 6 +
                    (uint256(tetra[4]) + 1) *
                    10 ** 4 +
                    (includeMantle ? (uint256(tetra[5]) + 1) * 10 ** 2 : 0) +
                    (includeKrust ? (uint256(tetra[6]) + 1) : 0)
            );
    }

    function tokenURI(
        uint256 tokenId
    ) public view override returns (string memory) {
        return
            RenderHelper.getJson(
                tokenId,
                _getTetra(tokenId),
                colorConfig.colorNames,
                colorConfig.colorHexCodes
            );
    }

    function _modToColorIndex(
        uint256 value,
        uint256 seed
    ) public view returns (uint8) {
        unchecked {
            return uint8((value / seed) % (colorConfig.maxColors - 1)) + 1;
        }
    }

    function _createTetraSeed(uint256 tokenId) private {
        uint256 tetra;
        uint256 rand = randomizer.random();

        for (uint256 i = 0; i < 7; i = _unsafeIncrement(i)) tetra |= rand << 16;

        _tetraSeeds[tokenId] = tetra;
    }

    function _excavate(uint256 excavationId, uint256 value) internal {
        _excavationResults[excavationId] = value;

        /// @dev Is Flash Bounty
        if (excavationId == 0) {
            emit ExcavatedFlashBounty(
                getTetraKey(0, BountyTier.Silver),
                getTetraKey(0, BountyTier.Gold),
                getTetraKey(0, BountyTier.Platinum)
            );
        } else {
            for (uint256 i = 0; i < CADENCE; i = _unsafeIncrement(i)) {
                uint256 tokenId = uint256(
                    uint16(excavationTracker[excavationId] >> (16 * i))
                );
                emit Excavated(
                    ownerOf(tokenId),
                    tokenId,
                    getTetraKey(tokenId, BountyTier.Silver),
                    getTetraKey(tokenId, BountyTier.Gold),
                    getTetraKey(tokenId, BountyTier.Platinum)
                );
            }
            delete excavationTracker[excavationId];
        }
    }

    function _swapTokens(
        address fromToken,
        address toToken,
        uint256 amountIn,
        address recipient
    ) internal returns (uint256) {
        uint24 _poolFee = fromToken == PORK || toToken == PORK
            ? PORK_WETH_POOL_FEE
            : DEFAULT_POOL_FEE;
        return
            uniswapRouter.exactInputSingle(
                ISwapRouter.ExactInputSingleParams({
                    tokenIn: fromToken,
                    tokenOut: toToken,
                    fee: _poolFee,
                    recipient: recipient,
                    amountIn: amountIn,
                    amountOutMinimum: 0,
                    sqrtPriceLimitX96: 0
                })
            );
    }

    function initialize(
        address prospektorFundManagerAddress
    ) public onlyExecutor {
        require(!isInitialized, "ALREADY_INITIALIZED");
        isInitialized = true;
        /// @notice Setup ProspektorFundManager
        prospektorFundManager = IProspektorFundManager(
            prospektorFundManagerAddress
        );

        TransferHelper.safeApprove(
            WETH,
            prospektorFundManagerAddress,
            type(uint256).max
        );

        TransferHelper.safeApprove(
            PORK,
            prospektorFundManagerAddress,
            type(uint256).max
        );

        /// @notice Setup Uniswap Router
        TransferHelper.safeApprove(
            WETH,
            address(uniswapRouter),
            type(uint256).max
        );

        TransferHelper.safeApprove(
            PORK,
            address(uniswapRouter),
            type(uint256).max
        );
    }

    function pause() public onlyExecutor {
        _pause();
    }

    function unpause() public onlyExecutor {
        _unpause();
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}