DragonX

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

/* Common */
uint256 constant BASIS = 10_000;
uint256 constant SECONDS_IN_DAY = 86400;
uint256 constant SCALING_FACTOR_1e3 = 1e3;
uint256 constant SCALING_FACTOR_1e6 = 1e6;
uint256 constant SCALING_FACTOR_1e7 = 1e7;
uint256 constant SCALING_FACTOR_1e11 = 1e11;
uint256 constant SCALING_FACTOR_1e18 = 1e18;

/* TitanX staking */
uint256 constant TITANX_MAX_STAKE_PER_WALLET = 1000;
uint256 constant TITANX_MIN_STAKE_LENGTH = 28;
uint256 constant TITANX_MAX_STAKE_LENGTH = 3500;

/* TitanX Stake Longer Pays Better bonus */
uint256 constant TITANX_LPB_MAX_DAYS = 2888;
uint256 constant TITANX_LPB_PER_PERCENT = 825;

uint256 constant TITANX_BPB_MAX_TITAN = 100 * 1e9 * SCALING_FACTOR_1e18; //100 billion
uint256 constant TITANX_BPB_PER_PERCENT = 1_250_000_000_000 *
    SCALING_FACTOR_1e18;

/* Addresses */
address constant TITANX_ADDRESS = 0xF19308F923582A6f7c465e5CE7a9Dc1BEC6665B1;
address constant WETH9_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant UNI_SWAP_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
address constant UNI_FACTORY = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
address constant UNI_NONFUNGIBLEPOSITIONMANAGER = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;

/* Uniswap Liquidity Pools (DragonX, TitanX) */
uint24 constant FEE_TIER = 10000;
int24 constant MIN_TICK = -887200;
int24 constant MAX_TICK = 887200;
uint160 constant INITIAL_SQRT_PRICE_TITANX_DRAGONX = 79228162514264337593543950336; // 1:1

/* DragonX Constants */
uint256 constant INCENTIVE_FEE = 300;

// 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/Create2.sol)

pragma solidity ^0.8.20;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Not enough balance for performing a CREATE2 deploy.
     */
    error Create2InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev There's no code to deploy.
     */
    error Create2EmptyBytecode();

    /**
     * @dev The deployment failed.
     */
    error Create2FailedDeployment();

    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        if (address(this).balance < amount) {
            revert Create2InsufficientBalance(address(this).balance, amount);
        }
        if (bytecode.length == 0) {
            revert Create2EmptyBytecode();
        }
        /// @solidity memory-safe-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        if (addr == address(0)) {
            revert Create2FailedDeployment();
        }
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;

// OpenZeppelin
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// Library
import "./interfaces/ITitanX.sol";
import "../DragonX.sol";
import "./Constants.sol";

/**
 * @title A contract managed and deployed by DragonX to initialise the maximum amount of stakes per address
 * @author The DragonX devs
 * @notice This contract is instantiated by DragonX and will not be deployed as a separate entity
 */
contract DragonStake is Ownable {
    using SafeERC20 for IERC20;
    using SafeERC20 for ITitanX;

    // -----------------------------------------
    // Type declarations
    // -----------------------------------------

    // -----------------------------------------
    // State variables
    // -----------------------------------------
    uint256 public openedStakes;

    // -----------------------------------------
    // Errors
    // -----------------------------------------
    /**
     * @dev Error emitted when a user tries to end a stake but is not mature yet.
     */
    error StakeNotMature();

    // -----------------------------------------
    // Events
    // -----------------------------------------

    // -----------------------------------------
    // Modifiers
    // -----------------------------------------

    // -----------------------------------------
    // Constructor
    // -----------------------------------------
    constructor() Ownable(msg.sender) {}

    // -----------------------------------------
    // Receive function
    // -----------------------------------------
    /**
     * @dev Receive function to handle plain Ether transfers.
     * Reverts if the sender is not the allowed address.
     */
    receive() external payable {
        require(msg.sender == TITANX_ADDRESS, "Sender not authorized");
    }

    // -----------------------------------------
    // Fallback function
    // -----------------------------------------
    /**
     * @dev Fallback function to handle non-function calls or Ether transfers if receive() doesn't exist.
     * Reverts if the sender is not the allowed address.
     */
    fallback() external payable {
        revert("Fallback triggered");
    }

    // -----------------------------------------
    // External functions
    // -----------------------------------------
    /**
     * TitanX Staking Function
     * @notice Stakes all available TitanX tokens held by this contract.
     * @dev Initializes the TitanX contract, calculates the stakable balance, and opens a new stake.
     *      This function can only be called by the contract owner.
     */
    function stake() external onlyOwner {
        // Initialize TitanX contract reference
        ITitanX titanX = ITitanX(TITANX_ADDRESS);

        // Fetch the current balance of TitanX tokens in this contract
        uint256 amountToStake = titanX.balanceOf(address(this));

        // Initiate staking of the fetched amount for the maximum defined stake length
        titanX.startStake(amountToStake, TITANX_MAX_STAKE_LENGTH);

        // Increment the count of active stakes
        openedStakes += 1;
    }

    /**
     * Claim ETH Rewards from TitanX Staking
     * @notice Allows the contract owner to claim accumulated ETH rewards from TitanX staking.
     * @dev Retrieves the total claimable ETH amount and, if any, claims it and sends it to the owner's address.
     *      This function can only be called by the contract owner.
     * @return claimable The total amount of ETH claimed.
     */
    function claim() external onlyOwner returns (uint256 claimable) {
        // Initialize TitanX contract reference
        ITitanX titanX = ITitanX(TITANX_ADDRESS);

        // Determine the total amount of ETH that can be claimed by this contract
        claimable = titanX.getUserETHClaimableTotal(address(this));

        // Proceed with claiming if there is any claimable ETH
        if (claimable > 0) {
            // Claim the available ETH from TitanX
            titanX.claimUserAvailableETHPayouts();

            // Transfer the claimed ETH to the contract owner
            Address.sendValue(payable(owner()), claimable);
        }
    }

    /**
     * @dev Ends a stake after it has reached its maturity.
     *
     * This function interacts with the ITitanX contract to handle stake operations.
     * It requires the stake ID (sId) to be valid and within the range of opened stakes.
     * If the current block timestamp is greater than or equal to the stake's maturity timestamp,
     * the function ends the stake and transfers the unstaked TitanX tokens to the DragonX contract.
     * If the stake has not yet matured, the function will revert.
     *
     * @param sId The ID of the stake to be ended.
     * @notice The function is callable externally and interacts with ITitanX and IERC20 contracts.
     * @notice It is required that the stake ID is valid and the stake is matured.
     * @notice The function will revert if the stake is not matured.
     */
    function endStakeAfterMaturity(uint256 sId) external {
        ITitanX titanX = ITitanX(TITANX_ADDRESS);
        require(sId > 0 && sId <= openedStakes, "invalid ID");

        UserStakeInfo memory stakeInfo = titanX.getUserStakeInfo(
            address(this),
            sId
        );

        // End stake if matured
        if (block.timestamp >= stakeInfo.maturityTs) {
            // track TitanX balance
            uint256 before = titanX.balanceOf(address(this));

            // End the stake
            titanX.endStake(sId);

            // Send total amount unstaked back to DragonX
            uint256 unstaked = titanX.balanceOf(address(this)) - before;

            // Transfer TitanX to DragonX
            IERC20(TITANX_ADDRESS).safeTransfer(owner(), unstaked);

            // Update DragonX
            DragonX(payable(owner())).stakeEnded(unstaked);
        } else {
            revert StakeNotMature();
        }
    }

    /**
     * Send TitanX Balance to DragonX
     *
     * @dev This function transfers any TitanX tokens held by this contract to the owner,
     * representing the DragonX account. This is a safety mechanism to handle
     * rare situations where TitanX tokens are accidentally sent to this contract or are
     * left over from operations like calling `TitanX#endStakeForOthers`.
     *
     * It's important to note that this function could lead to slight discrepancies in
     * DragonX's accounting, specifically in the `totalTitanUnstaked` value - there is 
     * no way to distinguish between TitanX send to this contract by accident or
     * users calling `TitanX#endStakeForOthers`.
     *
     * @notice Use this function to transfer TitanX tokens from the contract to the DragonX
     * owner address in case of accidental transfers or calling `TitanX#endStakeForOthers`
     */
    function sendTitanX() external {
        IERC20 titanX = IERC20(TITANX_ADDRESS);

        // transfer
        titanX.safeTransfer(owner(), titanX.balanceOf(address(this)));

        // update the vault
        DragonX(payable(owner())).updateVault();
    }

    /**
     * @dev Calculates the total amount of Ethereum claimable by the contract.
     *      Calls `getUserETHClaimableTotal` from the TitanX contract to retrieve the total claimable amount.
     * @return claimable The total amount of Ethereum claimable by the contract.
     */
    function totalEthClaimable() external view returns (uint256 claimable) {
        // Initialize TitanX contract reference
        ITitanX titanX = ITitanX(TITANX_ADDRESS);

        claimable = titanX.getUserETHClaimableTotal(address(this));
    }

    /**
     * @dev Determines whether any of the stakes have reached their maturity date.
     *      Iterates through all user stakes and checks if the current block timestamp
     *      is at or past the stake's maturity timestamp.
     * @return A boolean indicating whether at least one stake has reached maturity.
     */
    function stakeReachedMaturity() external view returns (bool, uint256) {
        ITitanX titanX = ITitanX(TITANX_ADDRESS);
        UserStake[] memory stakes = titanX.getUserStakes(address(this));

        for (uint256 idx; idx < stakes.length; idx++) {
            if (block.timestamp > stakes[idx].stakeInfo.maturityTs) {
                return (true, stakes[idx].sId);
            }
        }

        return (false, 0);
    }

    // -----------------------------------------
    // Public functions
    // -----------------------------------------

    // -----------------------------------------
    // Internal functions
    // -----------------------------------------

    // -----------------------------------------
    // Private functions
    // -----------------------------------------
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;

// OpenZeppelin
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Create2.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

// Library
import "./lib/DragonStake.sol";
import "./lib/Constants.sol";
import "./lib/Types.sol";
import "./lib/interfaces/ITitanX.sol";

/**
 * @title The DragonX Contranct
 * @author The DragonX devs
 */
contract DragonX is ERC20, Ownable2Step, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeERC20 for ITitanX;

    // -----------------------------------------
    // Type declarations
    // -----------------------------------------

    // -----------------------------------------
    // State variables
    // -----------------------------------------
    /**
     * @notice The TitanX buy contract address.
     * Set at runtime, this address allows for upgrading the buy contract version.
     */
    address public titanBuyAddress;

    /**
     * @notice The DragonX buy and burn contract address.
     * Set at runtime, this allows for upgrading the DragonX buy and burn contract.
     */
    address public dragonBuyAndBurnAddress;

    /**
     * @notice The start time of the mint phase, expressed in UTC seconds.
     * Indicates when the minting phase for tokens begins.
     */
    uint256 public mintPhaseBegin;

    /**
     * @notice The end time of the mint phase, expressed in UTC seconds.
     * Indicates when the minting phase for tokens ends.
     */
    uint256 public mintPhaseEnd;

    /**
     * @notice mint ratios from launch for 84 days (12 weeks)
     */
    uint256 public constant mintRatioWeekOne = BASIS;
    uint256 public constant mintRatioWeekTwo = BASIS;
    uint256 public constant mintRatioWeekThree = 9500;
    uint256 public constant mintRatioWeekFour = 9000;
    uint256 public constant mintRatioWeekFive = 8500;
    uint256 public constant mintRatioWeekSix = 8000;
    uint256 public constant mintRatioWeekSeven = 7500;
    uint256 public constant mintRatioWeekEight = 7000;
    uint256 public constant mintRatioWeekNine = 6500;
    uint256 public constant mintRatioWeekTen = 6000;
    uint256 public constant mintRatioWeekEleven = 5500;
    uint256 public constant mintRatioWeekTwelve = 5000;

    /**
     * @notice The time when it's possible to open a new TitanX stake after the cooldown.
     * This cooldown period controls the frequency of new stakes being initiated.
     */
    uint256 public nextStakeTs;

    /**
     * @notice The number of DragonStake contracts that have been deployed.
     * Tracks how many DragonStake contracts exist within the system.
     */
    uint256 public numDragonStakeContracts;

    /**
     * @notice The address of the currently active DragonStake contract instance.
     * This contract is used for initiating new TitanX stakes.
     */
    address public activeDragonStakeContract;

    /**
     * @notice A mapping from an ID to a deployed instance of the DragonStake contract.
     * The index starts at zero. Use a loop to iterate through instances, e.g., for(uint256 idx = 0; idx < numDragonStakeContracts; idx++).
     */
    mapping(uint256 => address) public dragonStakeContracts;

    /**
     * @notice The amount of TitanX currently held by this contract and not used in stakes.
     * Represents the reserve of TitanX tokens that are available but not currently staked.
     */
    uint256 public vault;

    /**
     * @notice The total amount of Titan staked by DragonX
     */
    uint256 public totalTitanStaked;

    /**
     * @notice The total amount of Titan unstaked by DragonX
     */
    uint256 public totalTitanUnstaked;

    /**
     * @notice The total amount of ETH claimed by DragonX
     */
    uint256 public totalEthClaimed;

    /**
     * Indicates that the initial liquidity has been minted
     */
    InitialLiquidityMinted public initalLiquidityMinted;

    /**
     * @dev Mapping of amounts allocated to the genesis address held by this contract.
     * - address(0): Represents the ETH allocated.
     * - address(TitanX): Represents the TitanX tokens allocated.
     * - address(this): Represents the DragonX tokens allocated.
     */
    mapping(address => uint256) private _genesisVault;

    /**
     * @dev Mapping of address to bool indicating if an address is allowed to send ETH
     * to DragonX limiting EOA addresses from accidently sending ETH to DragonX
     */
    mapping(address => bool) private _receiveEthAllowlist;

    /**
     * @dev Mapping of address to bool indicating if an address is a DragonStake instance
     */
    mapping(address => bool) private _dragonStakeAllowlist;

    // -----------------------------------------
    // Events
    // -----------------------------------------
    /**
     * @dev Event emitted when a new Dragon stake instance is created.
     * @param stakeContractId Unique identifier of the stake contract.
     * @param stakeContractAddress Address of the newly created stake contract.
     */
    event DragonStakeInstanceCreated(
        uint256 indexed stakeContractId,
        address indexed stakeContractAddress
    );

    /**
     * @notice Emitted when staking rewards are claimed.
     * @param caller The address of the caller who initiated the transaction.
     * @param totalClaimed The total amount of ETH claimed.
     * @param titanBuy Amount transfered to TitanBuy.
     * @param dragonBuyAndBurn Amount transfered to DragonBuyAndBurn
     * @param genesis Amount accounted to genesis
     * @param incentiveFee Incentive see send to caller
     * (this might include the incentice for calling triggerPayouts on TitanX)
     */
    event Claimed(
        address indexed caller,
        uint256 indexed totalClaimed,
        uint256 titanBuy,
        uint256 dragonBuyAndBurn,
        uint256 genesis,
        uint256 incentiveFee
    );

    /**
     * @notice Emitted when a new TitanX stake is opened by Dragonx
     * @param dragonStakeAddress The DragonStake instance used for this stake
     * @param amount The amount staked
     */
    event TitanStakeStarted(address indexed dragonStakeAddress, uint256 amount);

    /**
     * @notice Emitted when TitanX stakes are ended by Dragonx
     * @param dragonStakeAddress The DragonStake instance used for this action
     * @param amount The amount unstaked
     */
    event TitanStakesEnded(address indexed dragonStakeAddress, uint256 amount);

    // -----------------------------------------
    // Errors
    // -----------------------------------------
    /**
     * @dev Error emitted when a user tries to mint but the minting phase has not started.
     * This prevents actions related to minting before the official commencement of the minting period.
     */
    error MintingNotYetActive();

    /**
     * @dev Error when a user tries to mint but the minting phase has ended.
     * This ensures minting operations are restricted to the designated minting timeframe.
     */
    error MintingPeriodOver();

    /**
     * @dev Emitted when a user tries to mint but the TitanX allowance for this contract is too low.
     * Indicates that the contract does not have enough TitanX tokens allocated to it for the minting operation.
     */
    error InsufficientTitanXAllowance();

    /**
     * @dev Emitted when a user tries to mint without having enough TitanX tokens.
     * This ensures that users have a sufficient balance of TitanX tokens to perform the minting operation.
     */
    error InsufficientTitanXBalance();

    /**
     * @dev Error emitted when the stake function is currently in the cooldown period and cannot be called.
     * This enforces a waiting period before the stake function can be executed again.
     */
    error CooldownPeriodActive();

    /**
     * @dev Emitted when no additional stakes can be opened.
     * This is triggered when the maximum limit of open stakes is reached.
     */
    error NoAdditionalStakesAllowed();

    /**
     * @dev Error emitted when there is no ETH claimable by the function caller.
     * This ensures that the claim operation is only performed when there is ETH available to be claimed.
     */
    error NoEthClaimable();

    /**
     * @dev Error emitted when there are no tokens available to stake.
     * This ensures that the staking operation is only executed when there are tokens to be staked.
     */
    error NoTokensToStake();

    /**
     * @dev Error emitted when there is no need for creating a new Dragon stake instance.
     * This occurs when attempting to create a redundant Dragon stake instance.
     */
    error NoNeedForNewDragonStakeInstance();

    /**
     * @dev Error emitted when an invalid address is given to a function.
     * This occurs when the genesis address manages an address and passes address(0) by accident.
     */
    error InvalidAddress();

    /**
     * @dev Error emitted when a user attempts to mint but the initial liquidity has net yet been mined
     */
    error LiquidityNotMintedYet();

    /**
     * @dev Thrown when the function caller is not authorized or expected.
     */
    error InvalidCaller();

    // -----------------------------------------
    // Modifiers
    // -----------------------------------------
    /**
     * @dev Modifier to restrict function access to allowed DragonStake contracts.
     *
     * This modifier ensures that the function can only be called by addresses that are
     * present in the `_dragonStakeAllowlist`. If the calling address is not on the allowlist,
     * the transaction will revert with the message "not allowed".
     * @notice Use this modifier to restrict function access to specific addresses only.
     */
    modifier onlyDragonStake() {
        require(_dragonStakeAllowlist[_msgSender()], "not allowed");
        _;
    }

    // -----------------------------------------
    // Constructor
    // -----------------------------------------
    /**
     * @notice Constructor for the DragonX ERC20 Token Contract.
     * @dev Initializes the contract, sets up the minting phase, and deploys the first DragonStake instance.
     *      - Inherits from ERC20 and sets token name to "DragonX" and symbol to "DRAGONX".
     *      - Calculates and sets the start and end times for the minting phase based on current time.
     *      - Sets the time for the next restake opportunity.
     *      - Deploys the first DragonStake contract instance.
     *      - Transfers ownership to contract deployer.
     *      - Set the initial TitanBuy and DragonBuyAndBurn contract addresses.
     * @param titanBuyAddress_ The address of the TitanBuy contract instance.
     * @param dragonBuyAndBurnAdddress_ The address of the DragonBuyAndBurn contract instance.
     */
    constructor(
        address titanBuyAddress_,
        address dragonBuyAndBurnAdddress_
    ) ERC20("DragonX", "DRAGONX") Ownable(msg.sender) {
        if (titanBuyAddress_ == address(0)) {
            revert InvalidAddress();
        }
        if (dragonBuyAndBurnAdddress_ == address(0)) {
            revert InvalidAddress();
        }

        // Deploy stake contract instance setting DragonX as its owner
        _deployDragonStakeInstance();

        // Set contract addresses
        titanBuyAddress = titanBuyAddress_;
        dragonBuyAndBurnAddress = dragonBuyAndBurnAdddress_;

        // set other states
        initalLiquidityMinted = InitialLiquidityMinted.No;

        // Allow TitanX to send ETH to DragonX (incentive fee)
        _receiveEthAllowlist[TITANX_ADDRESS] = true;
    }

    // -----------------------------------------
    // Receive function
    // -----------------------------------------
    /**
     * @dev Receive function to handle plain Ether transfers.
     * Reverts if the sender is not one of the DragonStake contracts.
     */
    receive() external payable {
        require(_receiveEthAllowlist[msg.sender], "Sender not authorized");
    }

    // -----------------------------------------
    // Fallback function
    // -----------------------------------------
    /**
     * @dev Fallback function to handle non-function calls or Ether transfers if receive() doesn't exist.
     * Always revert
     */
    fallback() external {
        revert("Fallback triggered");
    }

    // -----------------------------------------
    // External functions
    // -----------------------------------------
    /**
     * This function enables the minting of DragonX tokens in exchange for TitanX.
     * Users can transfer TitanX to the DragonX contract to mint an equivalent amount of DragonX tokens.
     * The minting process is available only during a specified time frame.
     * When minting, 8% of the total minted DragonX supply and 8% of the TitanX used for minting
     * are allocated to the genesis address. The remaining TitanX is retained within the contract.
     * Minting starts once the initial liquidity has been minted (indicating all other contracts)
     * have been deployed and initialized successfully by the genesis address.
     * @param amount The amount of DragonX tokens to be minted.
     */
    function mint(uint256 amount) external {
        // Cache state variables
        uint256 mintPhaseBegin_ = mintPhaseBegin;

        // To avoid being frontrun, minting creating DragonX tokens will only
        // be able once the inital liqudiity ahs been created
        if (initalLiquidityMinted != InitialLiquidityMinted.Yes) {
            revert LiquidityNotMintedYet();
        }

        // Check if the minting phase is currently active
        if (block.timestamp < mintPhaseBegin_) {
            revert MintingNotYetActive();
        }

        if (block.timestamp > mintPhaseEnd) {
            revert MintingPeriodOver();
        }

        ITitanX titanX = ITitanX(TITANX_ADDRESS);
        // Ensure the user has sufficient TitanX and has granted enough allowance
        if (titanX.allowance(_msgSender(), address(this)) < amount) {
            revert InsufficientTitanXAllowance();
        }
        if (titanX.balanceOf(_msgSender()) < amount) {
            revert InsufficientTitanXBalance();
        }

        // Transfer TitanX from the user to this contract
        titanX.safeTransferFrom(_msgSender(), address(this), amount);

        uint256 ratio;
        if (block.timestamp < mintPhaseBegin_ + 7 days) {
            // week 1
            ratio = mintRatioWeekOne;
        } else if (block.timestamp < mintPhaseBegin_ + 14 days) {
            // week 2
            ratio = mintRatioWeekTwo;
        } else if (block.timestamp < mintPhaseBegin_ + 21 days) {
            // week 3
            ratio = mintRatioWeekThree;
        } else if (block.timestamp < mintPhaseBegin_ + 28 days) {
            // week 4
            ratio = mintRatioWeekFour;
        } else if (block.timestamp < mintPhaseBegin_ + 35 days) {
            // week 5
            ratio = mintRatioWeekFive;
        } else if (block.timestamp < mintPhaseBegin_ + 42 days) {
            // week 6
            ratio = mintRatioWeekSix;
        } else if (block.timestamp < mintPhaseBegin_ + 49 days) {
            // week 7
            ratio = mintRatioWeekSeven;
        } else if (block.timestamp < mintPhaseBegin_ + 56 days) {
            // week 8
            ratio = mintRatioWeekEight;
        } else if (block.timestamp < mintPhaseBegin_ + 63 days) {
            // weeek 9
            ratio = mintRatioWeekNine;
        } else if (block.timestamp < mintPhaseBegin_ + 70 days) {
            // week 10
            ratio = mintRatioWeekTen;
        } else if (block.timestamp < mintPhaseBegin_ + 77 days) {
            // week 11
            ratio = mintRatioWeekEleven;
        } else {
            // week 12
            ratio = mintRatioWeekTwelve;
        }

        // calculate the amount to mint
        uint256 mintAmount = (amount * ratio) / BASIS;

        // Mint an equivalent amount of DragonX tokens
        _mint(_msgSender(), mintAmount);

        // Calculate and mint the genesis 8% share (of total supply minted)
        uint256 dragonGenesisShare = (mintAmount * 800) / BASIS;
        _mint(address(this), dragonGenesisShare);

        // Allocate 8% of DragonX to the genesis vault
        _genesisVault[address(this)] += dragonGenesisShare;

        // Allocate 8% of total TitanX send to DragonX to genesis vault
        uint256 titanGenesisShare = (amount * 800) / BASIS;
        _genesisVault[address(titanX)] += titanGenesisShare;

        // Retain the remaining TitanX within the contract's vault
        vault += amount - titanGenesisShare;
    }

    /**
     * This function allows users to open a new TitanX stake through the DragonX contract.
     * Each stake runs for the maximum duration, and upon completion, the TitanX is burned.
     *
     * A stake can be opened when either of the following conditions is met:
     * 1. The vault has sufficient TitanX tokens to achieve the maximum 'bigger pays better' bonus.
     * 2. If the vault doesn't have enough tokens, the function can be invoked after a cooldown
     *    period of 1 week. This delay allows the accumulation of sufficient TitanX to gain
     *    the 'bigger pays better' bonus.
     */
    function stake() external {
        DragonStake dragonStake = DragonStake(
            payable(activeDragonStakeContract)
        );

        if (dragonStake.openedStakes() >= TITANX_MAX_STAKE_PER_WALLET) {
            revert NoAdditionalStakesAllowed();
        }

        updateVault();

        // Cache state variables
        uint256 vault_ = vault;

        if (vault_ == 0) {
            revert NoTokensToStake();
        }

        if (vault_ >= TITANX_BPB_MAX_TITAN) {
            // Start a stake using the currently active DragonStake instance
            _startStake();

            // Schedule the next possible stake after a 7-day cooldown period
            nextStakeTs = block.timestamp + 7 days;
        } else {
            // If the vault lacks sufficient TitanX, a stake can be opened only
            // after a cooldown period of 7 days to allow for token accumulation.
            if (block.timestamp < nextStakeTs) {
                revert CooldownPeriodActive();
            }

            // Start a new stake using the currently active DragonStake instance
            _startStake();

            // Schedule the next possible stake after a 7-day cooldown period.
            nextStakeTs = block.timestamp + 7 days;
        }
    }

    /**
     * Claim Function for ETH Rewards
     * This function claims ETH rewards based on TitanX stakes and allocates them according to predefined shares.
     * @dev The function performs the following operations:
     *      1. Retrieves the claimable ETH amount from TitanX stakes.
     *      2. Validates if there is any ETH to claim, and reverts if none is available.
     *      3. Claims the available ETH payouts.
     *      4. Calculates and distributes the ETH according to predefined shares:
     *         - 8% is allocated as a genesis share.
     *         - 3% is sent as a tip to the caller of the function.
     *         - 44.5% is used for buying and burning DragonX tokens.
     *         - The remaining 44.5% is used for buying and burning TitanX tokens.
     *      5. Updates the respective vaults with their allocated shares.
     *      6. Sends the tip to the caller of the function.
     */
    function claim() external nonReentrant returns (uint256 claimedAmount) {
        //prevent contract accounts (bots) from calling this function
        if (msg.sender != tx.origin) {
            revert InvalidCaller();
        }

        // Trigger payouts on TitanX
        // This potentially sends an incentive fee to DragonX
        // The incentive fee is transparently forwarded to the caller
        uint256 ethBalanceBefore = address(this).balance;
        ITitanX(TITANX_ADDRESS).triggerPayouts();
        uint256 triggerPayoutsIncentiveFee = address(this).balance -
            ethBalanceBefore;

        // Retrieve the total claimable ETH amount.
        for (uint256 idx; idx < numDragonStakeContracts; idx++) {
            DragonStake dragonStake = DragonStake(
                payable(dragonStakeContracts[idx])
            );
            claimedAmount += dragonStake.claim();
        }

        // Check if there is any claimable ETH, revert if none.
        if (claimedAmount == 0) {
            revert NoEthClaimable();
        }

        // Calculate the genesis share (8%).
        uint256 genesisShare = (claimedAmount * 800) / BASIS;

        // Calculate the tip for the caller (3%).
        uint256 incentiveFee = (claimedAmount * INCENTIVE_FEE) / BASIS;

        // Calculate the Buy and Burn share for DragonX (44.5%).
        uint256 buyAndBurnDragonX = (claimedAmount * 4450) / BASIS;

        // Calculate the Buy and Burn share for TitanX (remainder, ~44.5%).
        uint256 buyTitanX = claimedAmount -
            genesisShare -
            buyAndBurnDragonX -
            incentiveFee;

        // Update the genesis vault with the genesis share.
        _genesisVault[address(0)] += genesisShare;

        // Send to the Buy and Burn contract for DragonX.
        Address.sendValue(payable(dragonBuyAndBurnAddress), buyAndBurnDragonX);

        // Send to the buy contract for TitanX.
        Address.sendValue(payable(titanBuyAddress), buyTitanX);

        // Send the tip to the function caller.
        address sender = _msgSender();
        Address.sendValue(
            payable(sender),
            incentiveFee + triggerPayoutsIncentiveFee
        );

        // update state
        totalEthClaimed += claimedAmount;

        // Emit event
        emit Claimed(
            sender,
            claimedAmount,
            buyTitanX,
            buyAndBurnDragonX,
            genesisShare,
            incentiveFee + triggerPayoutsIncentiveFee
        );
    }

    /**
     * @notice Factory function to deploy a new DragonStake contract instance.
     * @dev This function deploys a new DragonStake instance if the number of open stakes in the current
     *      active instance exceeds the maximum allowed per wallet.
     *      It reverts with NoNeedForNewDragonStakeInstance if the condition is not met.
     *      Only callable externally.
     */
    function deployNewDragonStakeInstance() external {
        DragonStake dragonStake = DragonStake(
            payable(activeDragonStakeContract)
        );

        // Check if the maximum number of stakes per wallet has been reached
        if (dragonStake.openedStakes() < TITANX_MAX_STAKE_PER_WALLET) {
            revert NoNeedForNewDragonStakeInstance();
        }

        // Deploy a new DragonStake instance
        _deployDragonStakeInstance();
    }

    /**
     * @notice Mints the initial liquidity for the DragonX token.
     * @dev This function mints a specified amount of tokens and sets up the minting phases.
     * It can only be called once by the authorized address.
     * @param amount The amount of DragonX tokens to be minted for initial liquidity.
     */
    function mintInitialLiquidity(uint256 amount) external {
        // Cache state variables
        address dragonBuyAndBurnAddress_ = dragonBuyAndBurnAddress;

        // Verify that the caller is authorized to mint initial liquidity
        require(msg.sender == dragonBuyAndBurnAddress_, "not authorized");

        // Ensure that initial liquidity hasn't been minted before
        require(
            initalLiquidityMinted == InitialLiquidityMinted.No,
            "already minted"
        );

        // Mint the specified amount of DragonX tokens to the authorized address
        _mint(dragonBuyAndBurnAddress_, amount);

        // Update the state to reflect that initial liquidity has been minted
        initalLiquidityMinted = InitialLiquidityMinted.Yes;

        // Set up the minting phase timings
        uint256 currentTimestamp = block.timestamp;
        uint256 secondsUntilMidnight = 86400 - (currentTimestamp % 86400);

        // The mint phase is open for 84 days (12 weeks) and begins at midnight
        // once contracts are fully set up
        uint256 mintPhaseBegin_ = currentTimestamp + secondsUntilMidnight;

        // Update storage
        mintPhaseBegin = mintPhaseBegin_;

        // Set mint phase end
        mintPhaseEnd = mintPhaseBegin_ + 84 days;

        // Allow the first stake after 7 days of mint-phase begin
        nextStakeTs = mintPhaseBegin_ + 7 days;
    }

    /**
     *  Token Burn Function
     * @notice Allows a token holder to burn all of their tokens.
     * @dev Burns the entire token balance of the caller. This function calls `_burn`
     *      with the caller's address and their full token balance.
     *      This function can be called by any token holder wishing to burn their tokens.
     *      Tokens burned are permanently removed from the circulation.
     * @custom:warning WARNING: This function will irreversibly burn all tokens in the caller's account.
     * Ensure you understand the consequences before calling.
     */
    function burn() external {
        address sender = _msgSender();
        _burn(sender, balanceOf(sender));
    }

    /**
     * @notice Calculates the total number of stakes opened across all DragonStake contract instances.
     * @dev This function iterates over all the DragonStake contract instances recorded in the contract:
     *      1. For each DragonStake contract, it gets a reference to the contract instance.
     *      2. It then calls the `openedStakes` function on each instance to get the number of opened stakes.
     *      3. These values are summed up to calculate the total number of stakes opened across all instances.
     * @return totalStakes The total number of stakes opened across all DragonStake contract instances.
     */
    function totalStakesOpened() external view returns (uint256 totalStakes) {
        // Iterate over all DragonStake contract instances
        for (uint256 idx; idx < numDragonStakeContracts; idx++) {
            // Get a reference to each DragonStake contract
            DragonStake dragonStake = DragonStake(
                payable(dragonStakeContracts[idx])
            );

            // Add the stakes opened by this DragonStake instance
            totalStakes += dragonStake.openedStakes();
        }
    }

    /**
     * @dev Calculate the incentive fee a user will receive for calling the claim function.
     * This function computes the fee based on the total amount of Ethereum claimable
     * and a predefined incentive fee rate.
     *
     * @notice Used to determine the fee awarded for claiming Ethereum.
     *
     * @return fee The calculated incentive fee, represented as a uint256.
     * This value is calculated by taking the product of `totalEthClaimable()` and
     * `INCENTIVE_FEE`, then dividing by `BASIS` to normalize the fee calculation.
     */
    function incentiveFeeForClaim() external view returns (uint256 fee) {
        fee = (totalEthClaimable() * INCENTIVE_FEE) / BASIS;
    }

    /**
     * @dev Checks all DragonStake contract instances to determine if any stake has reached maturity.
     *      Iterates through each DragonStake contract instance and checks for stakes that have reached maturity.
     *      If a stake has reached maturity in a particular instance, it returns true along with the instance's address and the ID.
     *      If no stakes have reached maturity in any instance, it returns false and a zero address and zero for the ID.
     * @return hasStakesToEnd A boolean indicating if there is at least one stake that has reached maturity.
     * @return instanceAddress The address of the DragonStake contract instance that has a stake which reached maturity.
     * @return sId The ID of the stake which reached maturity
     *         Returns zero address if no such instance is found.
     * @notice This function is used to identify if and where stakes have reached maturity across multiple contract instances.
     */
    function stakeReachedMaturity()
        external
        view
        returns (bool hasStakesToEnd, address instanceAddress, uint256 sId)
    {
        // Iterate over all DragonStake contract instances
        for (uint256 idx; idx < numDragonStakeContracts; idx++) {
            address instance = dragonStakeContracts[idx];

            // Get a reference to each DragonStake contract
            DragonStake dragonStake = DragonStake(payable(instance));

            (bool reachedMaturity, uint256 id) = dragonStake
                .stakeReachedMaturity();

            // Exit if this instance contains a stake that reached maturity
            if (reachedMaturity) {
                return (true, instance, id);
            }
        }

        return (false, address(0), 0);
    }

    /**
     * @dev Sets the address used for buying and burning DRAGONX tokens.
     * @notice This function can only be called by the contract owner.
     * @param dragonBuyAndBurn The address to be set for the DRAGONX buy and burn operation.
     * If this address is the zero address, the transaction is reverted.
     * @custom:throws InvalidAddress if the provided address is the zero address.
     */
    function setDragonBuyAndBurnAddress(
        address dragonBuyAndBurn
    ) external onlyOwner {
        if (dragonBuyAndBurn == address(0)) {
            revert InvalidAddress();
        }
        dragonBuyAndBurnAddress = dragonBuyAndBurn;
    }

    /**
     * @dev Sets the address used for buying TITANX tokens.
     * @notice This function can only be called by the contract owner.
     * @param titanBuy The address to be set for the TITANX buy operation.
     * If this address is the zero address, the transaction is reverted.
     * @custom:throws InvalidAddress if the provided address is the zero address.
     */
    function setTitanBuyAddress(address titanBuy) external onlyOwner {
        if (titanBuy == address(0)) {
            revert InvalidAddress();
        }
        titanBuyAddress = titanBuy;
    }

    /**
     * @notice Transfers the accumulated balance of a specified asset from the Genesis Vault to the owner.
     * @dev This function allows the contract owner to claim assets accumulated in the Genesis Vault. It supports both Ether and ERC20 tokens.
     *      The function performs the following operations:
     *        1. Retrieves the balance of the specified asset from the `_genesisVault`.
     *        2. Sets the balance of the asset in the vault to zero, effectively resetting it.
     *        3. Checks that the retrieved balance is greater than zero, and reverts if it's not.
     *        4. If the asset is Ether (denoted by `asset` being the zero address), it transfers the Ether to the owner using `Address.sendValue`.
     *        5. If the asset is an ERC20 token, it transfers the token amount to the owner using `safeTransfer` from the ERC20 token's contract.
     * @param asset The address of the asset to be claimed. A zero address indicates Ether, and a non-zero address indicates an ERC20 token.
     */
    function claimGenesis(address asset) external onlyOwner {
        uint256 balance = _genesisVault[asset];
        _genesisVault[asset] = 0;

        require(balance > 0, "no balance");
        if (asset == address(0)) {
            Address.sendValue(payable(owner()), balance);
        } else {
            IERC20 erc20 = IERC20(asset);
            erc20.safeTransfer(owner(), balance);
        }
    }

    /**
     * @dev Updates the state when a TitanX stake has ended and the tokens are unstaked.
     *
     * This function should be called after unstaking TitanX tokens. It updates the vault
     * and the total amount of TitanX tokens that have been unstaked. This function can only
     * be called by an address that is allowed to end stakes (enforced by the `onlyDragonStake` modifier).
     *
     * @param amountUnstaked The amount of TitanX tokens that have been unstaked.
     * @notice This function is callable externally but restricted to allowed addresses (DragonStake contracts).
     * @notice It emits the `TitanStakesEnded` event after updating the total unstaked amount.
     */
    function stakeEnded(uint256 amountUnstaked) external onlyDragonStake {
        // Update vault (TitanX is transfered to DragonX)
        updateVault();

        // Update state
        totalTitanUnstaked += amountUnstaked;

        // Emit event
        emit TitanStakesEnded(_msgSender(), amountUnstaked);
    }

    // -----------------------------------------
    // Public functions
    // -----------------------------------------
    /**
     * @notice Updates the vault balance based on the current TITANX token balance.
     * @dev This function calculates the vault balance by subtracting the initial
     *      balance of TITANX tokens stored in `_genesisVault` from the current balance of
     *      TITANX tokens held by this contract.
     *      Steps involved in the function:
     *        1. Create an instance of the IERC20 interface for the TITANX token.
     *        2. Fetch the current TITANX token balance of this contract.
     *        3. Subtract the initial TITANX token balance (recorded in `_genesisVault`)
     *           from the current balance.
     *        4. Update the `vault` variable with the resulting value.
     *      The `vault` variable represents the net amount of TITANX tokens that have
     *      been accumulated in this contract since its inception (excluding the initial amount).
     *      This function should be called to reflect the latest state of the vault balance.
     */
    function updateVault() public {
        IERC20 titanX = IERC20(TITANX_ADDRESS);
        uint256 balance = titanX.balanceOf(address(this));

        vault = balance - _genesisVault[address(titanX)];
    }

    /**
     * @notice Calculates the total amount of ETH claimable from all DragonStake contract instances.
     * @dev Iterates through all deployed DragonStake contract instances and sums up the ETH claimable from each.
     *      This function is read-only and can be called externally.
     * @return claimable The total amount of ETH claimable across all DragonStake contract instances.
     */
    function totalEthClaimable() public view returns (uint256 claimable) {
        // Iterate over all DragonStake contract instances
        for (uint256 idx; idx < numDragonStakeContracts; idx++) {
            // Get a reference to each DragonStake contract
            DragonStake dragonStake = DragonStake(
                payable(dragonStakeContracts[idx])
            );

            // Add the claimable ETH from each DragonStake to the total
            claimable += dragonStake.totalEthClaimable();
        }
    }

    // -----------------------------------------
    // Internal functions
    // -----------------------------------------

    // -----------------------------------------
    // Private functions
    // -----------------------------------------
    /**
     * @dev Private function to deploy a DragonStake contract instance.
     *      It deploys a new DragonStake contract using create2 for deterministic addresses,
     *      and updates the activeDragonStakeContract and dragonStakeContracts mapping.
     *      An event DragonStakeInstanceCreated is emitted after successful deployment.
     *      This function is called by the deployNewDragonStakeInstance function.
     */
    function _deployDragonStakeInstance() private {
        // Deploy an instance of dragon staking contract
        bytes memory bytecode = type(DragonStake).creationCode;
        uint256 stakeContractId = numDragonStakeContracts;

        // Create a unique salt for deployment
        bytes32 salt = keccak256(
            abi.encodePacked(address(this), stakeContractId)
        );

        // Deploy a new DragonStake contract instance
        address newDragonStakeContract = Create2.deploy(0, salt, bytecode);

        // Set new contract as active
        activeDragonStakeContract = newDragonStakeContract;

        // Update storage
        dragonStakeContracts[stakeContractId] = newDragonStakeContract;

        // Allow the DragonStake instance to send ETH to DragonX
        _receiveEthAllowlist[newDragonStakeContract] = true;

        // For functions limited to DragonStake
        _dragonStakeAllowlist[newDragonStakeContract] = true;

        // Emit an event to track the creation of a new stake contract
        emit DragonStakeInstanceCreated(
            stakeContractId,
            newDragonStakeContract
        );

        // Increment the counter for DragonStake contracts
        numDragonStakeContracts += 1;
    }

    /**
     * @dev Private function to start a new stake using the currently active DragonStake instance.
     *      It transfers all TitanX tokens held by this contract to the active DragonStake instance
     *      and then initiates a new stake with the total amount transferred.
     *      This function is meant to be called internally by other contract functions.
     */
    function _startStake() private {
        // Cache state variables
        address activeDragonStakeContract_ = activeDragonStakeContract;

        // Initialize TitanX contract reference
        ITitanX titanX = ITitanX(TITANX_ADDRESS);
        DragonStake dragonStake = DragonStake(
            payable(activeDragonStakeContract_)
        );
        uint256 amountToStake = vault;
        vault = 0;

        // Transfer TitanX tokens to the active DragonStake contract
        titanX.safeTransfer(activeDragonStakeContract_, amountToStake);

        // Open a new stake with the total amount transferred
        dragonStake.stake();

        // Update states
        totalTitanStaked += amountToStake;

        // Emit event
        emit TitanStakeStarted(activeDragonStakeContract_, amountToStake);
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// 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/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

// OpenZeppelin
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Enum for stake status
enum StakeStatus {
    ACTIVE,
    ENDED,
    BURNED
}

// Struct for user stake information
struct UserStakeInfo {
    uint152 titanAmount;
    uint128 shares;
    uint16 numOfDays;
    uint48 stakeStartTs;
    uint48 maturityTs;
    StakeStatus status;
}

// Struct for user stake
struct UserStake {
    uint256 sId;
    uint256 globalStakeId;
    UserStakeInfo stakeInfo;
}

// Interface for the contract
interface IStakeInfo {
    /**
     * @notice Get all stake info of a given user address.
     * @param user The address of the user to query stake information for.
     * @return An array of UserStake structs containing all stake info for the given address.
     */
    function getUserStakes(
        address user
    ) external view returns (UserStake[] memory);

    /** @notice get stake info with stake id
     * @return stakeInfo stake info
     */
    function getUserStakeInfo(
        address user,
        uint256 id
    ) external view returns (UserStakeInfo memory);
}

/**
 * @title The TitanX interface used by DragonX to manages stakes
 * @author The DragonX devs
 */
interface ITitanX is IERC20, IStakeInfo {
    /**
     * @notice Start a new stake
     * @param amount The amount of TitanX tokens to stake
     * @param numOfDays The length of the stake in days
     */
    function startStake(uint256 amount, uint256 numOfDays) external;

    /**
     * @notice Claims available ETH payouts for a user based on their shares in various cycles.
     * @dev This function calculates the total reward from different cycles and transfers it to the caller.
     */
    function claimUserAvailableETHPayouts() external;

    /**
     * @notice Calculates the total ETH claimable by a user for all cycles.
     * @dev This function sums up the rewards from various cycles based on user shares.
     * @param user The address of the user for whom to calculate the claimable ETH.
     * @return reward The total ETH reward claimable by the user.
     */
    function getUserETHClaimableTotal(
        address user
    ) external view returns (uint256 reward);

    /**
     * @notice Allows anyone to sync dailyUpdate manually.
     * @dev Function to be called for manually triggering the daily update process.
     * This function is public and can be called by any external entity.
     */
    function manualDailyUpdate() external;

    /**
     * @notice Trigger cycle payouts for days 8, 28, 90, 369, 888, including the burn reward cycle 28.
     * Payouts can be triggered on or after the maturity day of each cycle (e.g., Cycle8 on day 8).
     */
    function triggerPayouts() external;

    /**
     * @notice Create a new mint
     * @param mintPower The power of the mint, ranging from 1 to 100.
     * @param numOfDays The duration of the mint, ranging from 1 to 280 days.
     */
    function startMint(uint256 mintPower, uint256 numOfDays) external payable;

    /**
     * @notice Returns current mint cost
     * @return currentMintCost The current cost of minting.
     */
    function getCurrentMintCost() external view returns (uint256);

    /** @notice end a stake
     * @param id stake id
     */
    function endStake(uint256 id) 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) (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
// 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: UNLICENSED
pragma solidity 0.8.20;

/**
 * A simple enum to indicate of the initial liquidity for DragonX / TitanX pool has been minted
 */
enum InitialLiquidityMinted {
    No,
    Yes
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

{
  "compilationTarget": {
    "contracts/DragonX.sol": "DragonX"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 9999
  },
  "remappings": []
}