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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

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

        (bool success,) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(address target, bool success, bytes memory returndata)
        internal
        view
        returns (bytes memory)
    {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// 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: UNLICENSED
pragma solidity ^0.8.26;

import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "./interfaces/IElement369NFT.sol";
import "./lib/constants.sol";
import "./lib/Time.sol";

/// @title Element 369 Holder Vault Contract
contract Element369HolderVault is Ownable2Step {
    using SafeERC20 for IERC20;

    // --------------------------- STATE VARIABLES --------------------------- //

    struct Cycle {
        bool initialized;
        uint256 infernoPerMulitplier;
        uint256 fluxPerMultiplier;
        uint256 e280PerMultiplier;
    }

    struct Cycle777 {
        uint32 startCycleId;
        uint32 endCycleId;
        uint256 multiplierPool;
        uint256 infernoPool;
        uint256 e280Pool;
    }

    address public immutable E369_NFT;
    address public FluxHub;
    address public devWallet;

    /// @notice The total amount of tokens accumulated.
    mapping(address token => uint256) public totalTokenPool;

    /// @notice The total amount of tokens paid out to users.
    mapping(address token => uint256) public totalTokenPaid;

    /// @notice The minimum pool size required to trigger a new cycle.
    uint256 public minCyclePool;

    /// @notice The last cycle that was finalized.
    uint32 public lastUpdatedCycle;

    /// @notice A mapping of cycle IDs to the corresponding cycle data.
    mapping(uint256 id => Cycle) public cycles;

    /// @notice A mapping of cycle IDs to the corresponding 777 day cycle data.
    mapping(uint256 id => Cycle777) public cycles777;

    /// @notice Amount of tokens claimed as rewards from 777 day cycles by a tokenId.
    mapping(uint256 tokenId => mapping(address token => uint256)) public cycle777AmountClaimed;

    /// @notice Amount of tokens claimed as backing from 777 day cycles by a tokenId.
    mapping(uint256 tokenId => mapping(address token => uint256)) public cycle777BackingClaimed;

    /// @notice A mapping of token IDs to the last claimed rewards cycle ID for each token.
    mapping(uint256 tokenId => uint32) public nftLastClaim;

    /// @notice A mapping of token IDs to the last claimed backing cycle ID for each token.
    mapping(uint256 tokenId => uint32) public nftLastBacking;

    // ------------------------ ERRORS & EVENTS ------------------------ //

    error Unauthorized();
    error ZeroInput();
    error ZeroAddress();
    error NoAllocation();
    error CycleCooldown();
    error NoCyclesAvailable();
    error TokenExists();
    error Prohibited();

    event CycleUpdated();

    // --------------------------- CONSTRUCTOR --------------------------- //

    constructor(address _owner, address _E369_NFT, address _devWallet, uint256 _minCyclePool) Ownable(_owner) {
        if (_owner == address(0)) revert ZeroAddress();
        if (_E369_NFT == address(0)) revert ZeroAddress();
        if (_devWallet == address(0)) revert ZeroAddress();
        if (_minCyclePool == 0) revert ZeroInput();

        E369_NFT = _E369_NFT;
        devWallet = _devWallet;
        minCyclePool = _minCyclePool;

        uint32 initalCycle = (((MINT_START_DATE - FLUX_START_DATE) / 86400) + 1) / 11 - 1;
        cycles[initalCycle].initialized = true;
        lastUpdatedCycle = initalCycle;

        for (uint32 i = 0; i < MAX_777_CYCLES_NUMBER; i++) {
            uint32 startCycle = _getStartCycleForCycle777(i);
            uint32 endCycle = _getEndCycleForCycle777(i);
            cycles777[i] = Cycle777(startCycle, endCycle, 0, 0, 0);
        }
    }

    // --------------------------- PUBLIC FUNCTIONS --------------------------- //

    /// @notice Creates the new cycle by distributing the cycle pool and calculating tokens per NFT.
    function updateCycle() external {
        uint32 finalizedCycle = getCurrentE369Cycle() - 1;
        if (finalizedCycle <= lastUpdatedCycle) revert CycleCooldown();
        _checkCycleCreationDay(finalizedCycle);
        (uint256 infernoPool, uint256 fluxPool, uint256 e280Pool) = _getNextCyclePools();
        uint256 totalMultipliers = IElement369NFT(E369_NFT).multiplierPool();
        uint256 infernoShare = _processTokenPool(INFERNO, infernoPool, totalMultipliers);
        uint256 fluxShare;
        if (fluxPool > 0) {
            fluxShare = _processTokenPool(FLUX, fluxPool, totalMultipliers);
        }
        uint256 e280Share = _processTokenPool(E280, e280Pool, totalMultipliers);
        cycles[finalizedCycle] = Cycle(true, infernoShare, fluxShare, e280Share);
        lastUpdatedCycle = finalizedCycle;
        emit CycleUpdated();
    }

    /// @notice Claims the accumulated rewards for a batch of NFT tokens.
    /// @param tokenIds An array of token IDs for which rewards are being claimed.
    function claimRewards(uint256[] calldata tokenIds) external {
        if (tokenIds.length == 0) revert ZeroInput();
        uint256[] memory nftData = IElement369NFT(E369_NFT).batchGetPackedTokenData(tokenIds, msg.sender);
        uint256 totalInferno;
        uint256 totalFlux;
        uint256 totalE280;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            uint32 lastCycle = nftBurnCycle > 0 ? nftBurnCycle : lastUpdatedCycle + 1;
            uint16 nftMultiplier = _getMultiplier(tokenData);
            uint32 nftLastClaimed = nftLastClaim[tokenId];
            (uint32 endCycle, uint256 infernoPool, uint256 fluxPool, uint256 e280Pool) =
                _processCycles(nftMintCycle, nftMultiplier, nftLastClaimed, lastCycle);
            totalInferno += infernoPool;
            totalFlux += fluxPool;
            totalE280 += e280Pool;
            nftLastClaim[tokenId] = endCycle;
        }
        _processTokenRewardsPayout(INFERNO, msg.sender, totalInferno);
        _processTokenRewardsPayout(FLUX, msg.sender, totalFlux);
        _processTokenRewardsPayout(E280, msg.sender, totalE280);
    }

    /// @notice Claims the accumulated day 777 rewards for a batch of NFT tokens.
    /// @param tokenIds An array of token IDs for which rewards are being claimed.
    function claim777Rewards(uint256[] calldata tokenIds) external {
        if (tokenIds.length == 0) revert ZeroInput();
        uint32 currentCycle777 = getCurrentCycle777();
        if (currentCycle777 == 0) revert NoCyclesAvailable();
        uint32 currentCycle = getCurrentE369Cycle();
        uint256 totalInferno;
        uint256 totalE280;
        uint256[] memory nftData = IElement369NFT(E369_NFT).batchGetPackedTokenData(tokenIds, msg.sender);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            uint32 lastCycle = nftBurnCycle > 0 ? nftBurnCycle : currentCycle;
            uint16 nftMultiplier = _getMultiplier(tokenData);
            (uint256 infernoPool, uint256 e280Pool) =
                _processTokenIdCycles777(tokenIds[i], nftMultiplier, nftMintCycle, lastCycle, currentCycle777);
            totalInferno += infernoPool;
            totalE280 += e280Pool;
        }
        _processTokenRewardsPayout(INFERNO, msg.sender, totalInferno);
        _processTokenRewardsPayout(E280, msg.sender, totalE280);
    }

    /// @notice Claims the accumulated backing for a batch of burned NFT tokens.
    /// @param tokenIds An array of burned token IDs for which backing is being claimed.
    function claimBacking(uint256[] calldata tokenIds) external {
        if (tokenIds.length == 0) revert ZeroInput();
        uint256[] memory nftData = IElement369NFT(E369_NFT).batchGetPackedTokenData(tokenIds, msg.sender);
        uint256 totalInferno;
        uint256 totalFlux;
        uint256 totalE280;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            if (nftBurnCycle == 0) revert TokenExists();
            uint16 nftMultiplier = _getMultiplier(tokenData);
            uint32 lastClaimed = nftLastBacking[tokenId];
            (uint32 endCycle, uint256 infernoPool, uint256 fluxPool, uint256 e280Pool) =
                _processCycles(nftMintCycle, nftMultiplier, lastClaimed, nftBurnCycle);
            totalInferno += infernoPool;
            totalFlux += fluxPool;
            totalE280 += e280Pool;
            nftLastBacking[tokenId] = endCycle;
        }
        _processTokenBackingPayout(INFERNO, msg.sender, totalInferno);
        _processTokenBackingPayout(FLUX, msg.sender, totalFlux);
        _processTokenBackingPayout(E280, msg.sender, totalE280);
    }

    /// @notice Claims the accumulated day 777 backing for a batch of burned NFT tokens.
    /// @param tokenIds An array of burned token IDs for which backing is being claimed.
    function claim777Backing(uint256[] calldata tokenIds) external {
        if (tokenIds.length == 0) revert ZeroInput();
        uint32 currentCycle777 = getCurrentCycle777();
        if (currentCycle777 == 0) revert NoCyclesAvailable();
        uint256[] memory nftData = IElement369NFT(E369_NFT).batchGetPackedTokenData(tokenIds, msg.sender);
        uint256 totalInferno;
        uint256 totalE280;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            if (nftBurnCycle == 0) revert TokenExists();
            uint16 nftMultiplier = _getMultiplier(tokenData);
            (uint256 infernoPool, uint256 e280Pool) =
                _processTokenIdBacking777(tokenIds[i], nftMultiplier, nftMintCycle, nftBurnCycle, currentCycle777);
            totalInferno += infernoPool;
            totalE280 += e280Pool;
        }
        _processTokenBackingPayout(INFERNO, msg.sender, totalInferno);
        _processTokenBackingPayout(E280, msg.sender, totalE280);
    }

    /// @notice Registers token amounts for day 777 cycle.
    /// @param infernoAmount How many Inferno tokens are being received.
    /// @param e280Amount How many Element 280 tokens are being received.
    /// @dev Only callable by Element 369 Holder Vault contract.
    function register777CycleTokens(uint256 infernoAmount, uint256 e280Amount) external {
        if (msg.sender != FluxHub) revert Unauthorized();
        uint32 currentCycleId = getCurrentCycle777() - 1;
        Cycle777 storage current = cycles777[currentCycleId];
        current.infernoPool += infernoAmount;
        current.e280Pool += e280Amount;
        totalTokenPool[INFERNO] += infernoAmount;
        totalTokenPool[E280] += e280Amount;
    }

    /// @notice Stores the total multipliers.
    /// @param cycleId The ID of the 777 cycle to change.
    /// @param totalMultipliers Total current multipliers.
    /// @dev Only callable by Element 369 NFT contract during mint.
    function updateStoredMultipliers(uint32 cycleId, uint256 totalMultipliers) external {
        if (msg.sender != E369_NFT) revert Unauthorized();
        if (cycles777[cycleId].multiplierPool != 0) return;
        cycles777[cycleId].multiplierPool = totalMultipliers;
    }

    /// @notice Decreases the total multipliers for the 777 cycle on burn of eligible NFTs or stores the total multiplers.
    /// @param cycleId The ID of the 777 cycle to change.
    /// @param totalMultipliers Total current multipliers.
    /// @param multiplierDeduction How many multipliers were burned.
    /// @dev Only callable by Element 369 NFT contract.
    function updateStoredMultipliersOnBurn(uint32 cycleId, uint256 totalMultipliers, uint256 multiplierDeduction)
        external
    {
        if (msg.sender != E369_NFT) revert Unauthorized();
        Cycle777 storage current = cycles777[cycleId];
        if (current.multiplierPool == 0) {
            current.multiplierPool = totalMultipliers;
        } else {
            current.multiplierPool -= multiplierDeduction;
        }
    }

    // --------------------------- ADMINISTRATIVE FUNCTIONS --------------------------- //

    /// @notice Sets the minimum pool size required to trigger a new cycle.
    /// @param limit The new minimum pool size in WEI.
    function setMinCyclePool(uint256 limit) external onlyOwner {
        minCyclePool = limit;
    }

    function setFluxHub(address fluxHub) external {
        if (msg.sender != E369_NFT) revert Unauthorized();
        FluxHub = fluxHub;
    }

    // --------------------------- VIEW FUNCTIONS --------------------------- //

    /// @notice Returns the current Element 369 cycle (11 day period).
    function getCurrentE369Cycle() public view returns (uint32) {
        uint32 daysPassed = Time.daysSince(FLUX_START_DATE) + 1;
        return daysPassed / E369_CYCLE_INTERVAL;
    }

    /// @notice Returns the availability and total claimable tokens for a batch of NFT tokenIds.
    /// @param tokenIds An array of token IDs to query.
    /// @param account The address of the token owner.
    /// @param isBacking Should the function calculate backing claim or rewards claim.
    /// @return availability A boolean array indicating whether each token is eligible for claims.
    /// @return burned A boolean array indicating whether each token is burned.
    /// @return infernoPool The total amount of Inferno the account can claim for the eligible provided tokens.
    /// @return fluxPool The total amount of Flux the account can claim for the eligible provided tokens.
    /// @return e280Pool The total amount of Element 280 the account can claim for the eligible provided tokens.
    function getRewards(uint256[] calldata tokenIds, address account, bool isBacking)
        external
        view
        returns (
            bool[] memory availability,
            bool[] memory burned,
            uint256 infernoPool,
            uint256 fluxPool,
            uint256 e280Pool
        )
    {
        if (tokenIds.length == 0) revert ZeroInput();
        availability = new bool[](tokenIds.length);
        burned = new bool[](tokenIds.length);
        uint256[] memory nftData = IElement369NFT(E369_NFT).batchGetPackedTokenData(tokenIds, account);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            uint16 nftMultiplier = _getMultiplier(tokenData);
            bool isBurned = nftBurnCycle > 0;
            burned[i] = isBurned;
            uint32 nftLastClaimed = isBacking ? nftLastBacking[tokenId] : nftLastClaim[tokenId];
            uint32 startCycle = nftLastClaimed == 0 ? nftMintCycle : nftLastClaimed;
            uint32 lastCycle = isBurned ? nftBurnCycle : lastUpdatedCycle + 1;
            bool available = startCycle < lastCycle;
            availability[i] = isBacking ? available && isBurned : available;
            if (available) {
                uint256 endCycle = _applyMaxCycleProtection(startCycle, lastCycle);
                uint256 infernoPerNFt;
                uint256 fluxPerNFt;
                uint256 e280PerNFt;
                unchecked {
                    for (uint256 j = startCycle; j < endCycle; j++) {
                        infernoPerNFt += cycles[j].infernoPerMulitplier;
                        fluxPerNFt += cycles[j].fluxPerMultiplier;
                        e280PerNFt += cycles[j].e280PerMultiplier;
                    }
                    infernoPool += (infernoPerNFt * nftMultiplier) / 1e18;
                    fluxPool += (fluxPerNFt * nftMultiplier) / 1e18;
                    e280Pool += (e280PerNFt * nftMultiplier) / 1e18;
                }
            }
        }
    }

    /// @notice Returns the availability and total claimable tokens from 777 day cycles for a batch of NFT tokenIds.
    /// @param tokenIds An array of token IDs to query.
    /// @param account The address of the token owner.
    /// @param isBacking Should the function calculate backing claim or rewards claim.
    /// @return availability A boolean array indicating whether each token is eligible for claims.
    /// @return burned A boolean array indicating whether each token is burned.
    /// @return infernoPool The total amount of Inferno the account can claim for the eligible provided tokens.
    /// @return e280Pool The total amount of Element 280 the account can claim for the eligible provided tokens.
    function get777Rewards(uint256[] calldata tokenIds, address account, bool isBacking)
        external
        view
        returns (bool[] memory availability, bool[] memory burned, uint256 infernoPool, uint256 e280Pool)
    {
        if (tokenIds.length == 0) revert ZeroInput();
        availability = new bool[](tokenIds.length);
        burned = new bool[](tokenIds.length);
        IElement369NFT nft = IElement369NFT(E369_NFT);
        uint32 currentCycle = getCurrentE369Cycle();
        uint256[] memory nftData = nft.batchGetPackedTokenData(tokenIds, account);
        uint32 currentCycle777 = getCurrentCycle777();
        if (currentCycle777 < 1) return (availability, burned, 0, 0);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            uint256 tokenData = nftData[i];
            uint32 nftMintCycle = _getMintCycle(tokenData);
            uint32 nftBurnCycle = _getBurnCycle(tokenData);
            uint16 nftMultiplier = _getMultiplier(tokenData);
            bool isBurned = nftBurnCycle > 0;
            burned[i] = isBurned;
            uint32 endCycle = isBurned ? nftBurnCycle : currentCycle;
            uint256 infernoPerNFt;
            uint256 e280PerNFt;
            mapping(address => uint256) storage previousClaim =
                isBacking ? cycle777BackingClaimed[tokenId] : cycle777AmountClaimed[tokenId];
            uint256 nftClaimedInferno = previousClaim[INFERNO];
            uint256 nftClaimedE280 = previousClaim[E280];
            for (uint256 j = 0; j < currentCycle777; j++) {
                Cycle777 memory cycle = cycles777[j];
                if (cycle.multiplierPool == 0 || endCycle < cycle.endCycleId) break;
                if (nftMintCycle > cycle.startCycleId) continue;
                infernoPerNFt += calculateCycle777Share(cycle.infernoPool, cycle.multiplierPool);
                e280PerNFt += calculateCycle777Share(cycle.e280Pool, cycle.multiplierPool);
            }
            infernoPerNFt = (infernoPerNFt * nftMultiplier) / 1e18;
            e280PerNFt = (e280PerNFt * nftMultiplier) / 1e18;
            bool available = infernoPerNFt > nftClaimedInferno && e280PerNFt > nftClaimedE280;
            availability[i] = isBacking ? available && isBurned : available;
            if (available) {
                infernoPool += infernoPerNFt - nftClaimedInferno;
                e280Pool += e280PerNFt - nftClaimedE280;
            }
        }
    }

    /// @notice Returns the pool sizes for next cycle creation.
    function getNextCyclePools() public view returns (uint256 infernoPool, uint256 fluxPool, uint256 e280Pool) {
        infernoPool = IERC20(INFERNO).balanceOf(address(this)) + totalTokenPaid[INFERNO] - totalTokenPool[INFERNO];
        fluxPool = IERC20(FLUX).balanceOf(address(this)) + totalTokenPaid[FLUX] - totalTokenPool[FLUX];
        e280Pool = IERC20(E280).balanceOf(address(this)) + totalTokenPaid[E280] - totalTokenPool[E280];
    }

    /// @notice Returns the current 777 day cycle.
    function getCurrentCycle777() public view returns (uint32) {
        uint32 daysPassed = Time.daysSince(FLUX_START_DATE) + 1;
        uint32 totalCycles = daysPassed / CYCLE_777_DAYS;
        return totalCycles > MAX_777_CYCLES_NUMBER ? MAX_777_CYCLES_NUMBER : totalCycles;
    }

    // --------------------------- INTERNAL FUNCTIONS --------------------------- //

    function _checkCycleCreationDay(uint32 cycleId) internal view {
        uint32 maxDay = (cycleId + 1) * E369_CYCLE_INTERVAL + CYCLE_CREATION_OFFSET;
        uint32 daysPassed = Time.daysSince(FLUX_START_DATE) + 1;
        if (daysPassed > maxDay) revert Prohibited();
    }

    function _getNextCyclePools() internal view returns (uint256 infernoPool, uint256 fluxPool, uint256 e280Pool) {
        infernoPool = _getNextCyclePool(INFERNO);
        fluxPool = _getNextCyclePool(FLUX);
        e280Pool = _getNextCyclePool(E280);
    }

    function _getNextCyclePool(address token) public view returns (uint256) {
        uint256 pool = IERC20(token).balanceOf(address(this)) + totalTokenPaid[token] - totalTokenPool[token];
        if (pool < minCyclePool) {
            if (token == FLUX) return 0;
            revert NoAllocation();
        }
        return pool;
    }

    function _processTokenPool(address token, uint256 amount, uint256 totalMultipliers)
        internal
        returns (uint256 share)
    {
        share = (amount * 1e18) / (totalMultipliers * 2);
        totalTokenPool[token] += amount;
    }

    function _processTokenRewardsPayout(address token, address account, uint256 amount) internal {
        totalTokenPaid[token] += amount;
        IERC20(token).safeTransfer(account, amount);
    }

    function _processTokenBackingPayout(address token, address account, uint256 amount) internal {
        totalTokenPaid[token] += amount;
        uint256 devFee = amount / PERCENTAGE_BASE;
        uint256 totalFee = amount * BACKING_CLAIM_TAX / PERCENTAGE_BASE;
        IERC20(token).safeTransfer(devWallet, devFee);
        IERC20(token).safeTransfer(account, amount - totalFee);
    }

    function _processCycles(uint32 nftMintCycle, uint16 nftMultiplier, uint32 lastClaim, uint32 maxCycle)
        internal
        view
        returns (uint32 endCycle, uint256 infernoPool, uint256 fluxPool, uint256 e280Pool)
    {
        uint32 startCycle = lastClaim == 0 ? nftMintCycle : lastClaim;
        if (startCycle == maxCycle) revert NoCyclesAvailable();
        endCycle = _applyMaxCycleProtection(startCycle, maxCycle);
        unchecked {
            for (uint256 i = startCycle; i < endCycle; i++) {
                Cycle memory cycle = cycles[i];
                if (!cycle.initialized) continue;
                infernoPool += cycle.infernoPerMulitplier;
                fluxPool += cycle.fluxPerMultiplier;
                e280Pool += cycle.e280PerMultiplier;
            }
        }
        infernoPool = (infernoPool * nftMultiplier) / 1e18;
        fluxPool = (fluxPool * nftMultiplier) / 1e18;
        e280Pool = (e280Pool * nftMultiplier) / 1e18;
    }

    function _processTokenIdCycles777(
        uint256 tokenId,
        uint16 nftMultiplier,
        uint256 nftMintCycle,
        uint256 lastCycle,
        uint32 totalCycles
    ) internal returns (uint256 infernoPool, uint256 e280Pool) {
        uint256 nftClaimedInferno = cycle777AmountClaimed[tokenId][INFERNO];
        uint256 nftClaimedE280 = cycle777AmountClaimed[tokenId][E280];
        for (uint256 i = 0; i < totalCycles; i++) {
            Cycle777 memory cycle = cycles777[i];
            if (cycle.multiplierPool == 0 || lastCycle < cycle.endCycleId) break;
            if (nftMintCycle > cycle.startCycleId) continue;
            infernoPool += calculateCycle777Share(cycle.infernoPool, cycle.multiplierPool);
            e280Pool += calculateCycle777Share(cycle.e280Pool, cycle.multiplierPool);
        }
        infernoPool = (infernoPool * nftMultiplier) / 1e18;
        e280Pool = (e280Pool * nftMultiplier) / 1e18;
        if (infernoPool == nftClaimedInferno || e280Pool == nftClaimedE280) revert NoAllocation();
        cycle777AmountClaimed[tokenId][INFERNO] = infernoPool;
        cycle777AmountClaimed[tokenId][E280] = e280Pool;
        infernoPool -= nftClaimedInferno;
        e280Pool -= nftClaimedE280;
    }

    function _processTokenIdBacking777(
        uint256 tokenId,
        uint16 nftMultiplier,
        uint256 nftMintCycle,
        uint256 lastCycle,
        uint32 totalCycles
    ) internal returns (uint256 infernoPool, uint256 e280Pool) {
        uint256 nftClaimedInferno = cycle777BackingClaimed[tokenId][INFERNO];
        uint256 nftClaimedE280 = cycle777BackingClaimed[tokenId][E280];
        for (uint256 i = 0; i < totalCycles; i++) {
            Cycle777 memory cycle = cycles777[i];
            if (cycle.multiplierPool == 0 || lastCycle < cycle.endCycleId) break;
            if (nftMintCycle > cycle.startCycleId) continue;
            infernoPool += calculateCycle777Share(cycle.infernoPool, cycle.multiplierPool);
            e280Pool += calculateCycle777Share(cycle.e280Pool, cycle.multiplierPool);
        }
        infernoPool = (infernoPool * nftMultiplier) / 1e18;
        e280Pool = (e280Pool * nftMultiplier) / 1e18;
        if (infernoPool == nftClaimedInferno || e280Pool == nftClaimedE280) revert NoAllocation();
        cycle777BackingClaimed[tokenId][INFERNO] = infernoPool;
        cycle777BackingClaimed[tokenId][E280] = e280Pool;
        infernoPool -= nftClaimedInferno;
        e280Pool -= nftClaimedE280;
    }

    function calculateCycle777Share(uint256 amount, uint256 multipliers) internal pure returns (uint256) {
        return (amount * 1e18) / (multipliers * 2);
    }

    function _applyMaxCycleProtection(uint32 startCycle, uint32 currentCycle) internal pure returns (uint32) {
        uint32 maxEndCycle = startCycle + MAX_CYCLES_PER_CLAIM;
        return currentCycle < maxEndCycle ? currentCycle : maxEndCycle;
    }

    function _getNftTier(uint256 packedData) internal pure returns (uint8) {
        return uint8(packedData & BITMASK_NFT_TIER);
    }

    function _getMultiplier(uint256 packedData) internal pure returns (uint16) {
        return uint16((packedData >> BITPOS_MULTIPLIER) & BITMASK_MULTIPLIER);
    }

    function _getMintCycle(uint256 packedData) internal pure returns (uint32) {
        return uint32((packedData >> BITPOS_MINT_CYCLE) & BITMASK_MINT_CYCLE);
    }

    function _getBurnCycle(uint256 packedData) internal pure returns (uint32) {
        return uint32((packedData >> BITPOS_BURN_CYCLE) & BITMASK_BURN_CYCLE);
    }

    function _getBurnAddress(uint256 packedData) internal pure returns (address) {
        return address(uint160((packedData >> BITPOS_BURN_ADDRESS) & BITMASK_BURN_ADDRESS));
    }

    function _getStartCycleForCycle777(uint32 cycle777Id) public pure returns (uint32) {
        return ((CYCLE_777_DAYS * cycle777Id) + CYCLE_777_DAYS / 2) / E369_CYCLE_INTERVAL - 1;
    }

    function _getEndCycleForCycle777(uint32 cycle777Id) public pure returns (uint32) {
        return ((CYCLE_777_DAYS * (cycle777Id + 1)) / E369_CYCLE_INTERVAL);
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
        external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

interface IElement369NFT {
    function multiplierPool() external view returns (uint256);
    function batchGetPackedTokenData(uint256[] memory tokenIds, address account)
        external
        view
        returns (uint256[] memory data);
}

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

interface ITitanOnBurn {
    function onBurn(address user, uint256 amount) external;
}

// 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) (access/Ownable2Step.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

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

library Time {
    ///@notice Gets the current timestamp
    function blockTs() internal view returns (uint32 ts) {
        assembly {
            ts := timestamp()
        }
    }

    ///@notice Gets the the day count from a timestamp
    function dayCountByT(uint32 t) internal pure returns (uint32 dayCount) {
        assembly {
            let adjustedTime := sub(t, 61200)
            dayCount := div(adjustedTime, 86400)
        }
    }

    ///@notice Gets the week count, since a starting timestamp
    function weekSince(uint32 t) internal view returns (uint32 weeksPassed) {
        assembly {
            let currentTime := timestamp()
            let timeElapsed := sub(currentTime, t)

            weeksPassed := div(timeElapsed, 604800)
        }
    }

    function daysSince(uint32 t) public view returns (uint32 daysPassed) {
        assembly {
            // Get the current block timestamp
            let currentTime := timestamp()

            daysPassed := div(sub(currentTime, t), 86400)
        }
    }
}

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

import "../interfaces/ITitanOnBurn.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";

// ===================== Contract Addresses =====================================
address constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant TITANX = 0xF19308F923582A6f7c465e5CE7a9Dc1BEC6665B1;
address constant FLUX = 0xBFDE5ac4f5Adb419A931a5bF64B0f3BB5a623d06;
address constant FLUX_STAKING = 0xd605a87187563C94c577a6E57e4a36eC8433B9aE;
address constant FLUX_AUCTIONS = 0x36e5a8105f000029d4B3B99d0C3D0e24aaA52adF;
address constant HELIOS = 0x2614f29C39dE46468A921Fd0b41fdd99A01f2EDf;
address constant INFERNO = 0x00F116ac0c304C570daAA68FA6c30a86A04B5C5F;
address constant E280 = 0xe9A53C43a0B58706e67341C4055de861e29Ee943;

// ===================== POOLS ==================================================
address constant TITANX_WETH_POOL = 0xc45A81BC23A64eA556ab4CdF08A86B61cdcEEA8b;
address constant TITANX_INFERNO_POOL = 0x1E90B67149e688DfB95fD73Acacd8ADefd16d88D;
address constant TITANX_HELIOS_POOL = 0x2C83C54C5612BfD62a78124D4A0eA001278a689c;

// ===================== FLUX ===================================================
uint32 constant FLUX_START_DATE = 1727024400;

// ===================== NFT ====================================================
uint32 constant MINT_START_DATE = FLUX_START_DATE + 60 days;
uint32 constant ELEMENT_END_DATE = FLUX_START_DATE + 2331 days;
uint32 constant MINT_CYCLE_LENGTH = 44;
uint8 constant DEV_PERCENT = 8;

uint256 constant BITPOS_NFT_TIER = 0;
uint256 constant BITMASK_NFT_TIER = (1 << 8) - 1;

uint256 constant BITPOS_MULTIPLIER = 8;
uint256 constant BITMASK_MULTIPLIER = (1 << 16) - 1;

uint256 constant BITPOS_MINT_CYCLE = 24;
uint256 constant BITMASK_MINT_CYCLE = (1 << 32) - 1;

uint256 constant BITPOS_BURN_CYCLE = 56;
uint256 constant BITMASK_BURN_CYCLE = (1 << 32) - 1;

uint256 constant BITPOS_BURN_ADDRESS = 88;
uint256 constant BITMASK_BURN_ADDRESS = (1 << 160) - 1;

// ===================== FLUX HUB ===============================================
uint32 constant MAX_DURATION = 2888 days;
uint32 constant MAX_STAKES_PER_CLAIM = 100;
uint32 constant TREASURY_PERCENTS = 70;
uint32 constant DAY_777_OFFSET = 3;
uint32 constant INFERNO_SWAP_PERCENTAGE = 42;
uint32 constant BURN_PERCENTAGE = 16;

uint32 constant INCENTIVE_FEE_BASE = 100_000;
uint32 constant BPS_BASE = 10_000;
uint32 constant PERCENTAGE_BASE = 100;

// ===================== Holder Vault ===========================================
uint32 constant CYCLE_CREATION_OFFSET = 2;
uint32 constant MAX_777_CYCLES_NUMBER = 4;
uint32 constant CYCLE_777_DAYS = 777;
uint32 constant E369_CYCLE_INTERVAL = 11;
uint16 constant MAX_CYCLES_PER_CLAIM = 100;
uint8 constant BACKING_CLAIM_TAX = 3;

// ===================== UNISWAP Interface ======================================

address constant UNISWAP_V2_FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address constant UNISWAP_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant UNISWAP_V3_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
uint24 constant POOL_FEE_1PERCENT = 10000;

// ===================== Interface IDs ==========================================
bytes4 constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
bytes4 constant INTERFACE_ID_ERC20 = type(IERC20).interfaceId;
bytes4 constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 constant INTERFACE_ID_ERC721Metadata = 0x5b5e139f;
bytes4 constant INTERFACE_ID_ITITANONBURN = type(ITitanOnBurn).interfaceId;

{
  "compilationTarget": {
    "contracts/Element369HolderVault.sol": "Element369HolderVault"
  },
  "evmVersion": "paris",
  "libraries": {
    "contracts/lib/Time.sol:Time": "0xbbf25ca275325ef4682851a12bd8e9aa714da2f4"
  },
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "viaIR": true
}