Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IBlazeToken.sol";
import "./interfaces/IBlazeBurner.sol";

/**
 * @title Bonfire Party Contract
 * @dev This contract manages token burn events ("Bonfire Parties") to systematically reduce the token supply.
 * It schedules events, manages funds, and conducts burns in a controlled manner.
 */
contract BlazeBonfire is Ownable2Step {
    using SafeERC20 for IBlazeToken;
 
    /// @notice The ERC20 token used for burning
    IBlazeToken public blz;

    /// @notice contract to swap eth and burn blaze tokens
    IBlazeBurner public burner;

    struct Event {
        uint256 totalFunds; // Total ETH allocated for burning
        uint256 fundsBurned; // Total ETH already burned
        uint256 lastBurnTime; // Timestamp of the last burn
        uint256 intervalBurnAmount; // ETH to burn per interval
        uint256 eventStartTime; // Event start timestamp
        bool isActive; // Activation status of the event
    }

    /// @notice Cooldown period between burns, set at one hour
    uint256 public constant cooldownPeriod = 15 minutes;

    /// @notice Maps each event date to its corresponding event details
    mapping(uint256 => Event) public events;

    /// @notice Number of burn intervals per event
    uint256 public constant INTERVAL_IN_EVENT = 400;

    /// @notice Interval between events in days
    uint256 public constant INTERVAL_BETWEEN_EVENTS = 108 days;

    /// @notice Index to track the next active event
    uint256 public nextActiveEventIndex;

    /// @notice Initial timestamp from which time-based calculations are conducted
    uint256 public immutable i_initialTimestamp;

    /// @notice Start Time for bonfire. Day 286 of titanX.
    uint256 public constant BONFIRE_START_TIMESTAMP = 1723101323;

    /// @notice Event emitted when bonfire is burned.
    event BonfireBurn(uint256 cycle, address burner, uint256 burnAmount, uint256 incentive);

    /**
     * @dev Constructor setting up initial values and the token contract address.
     * @param blazeAddress Address of the BlazeERC20 token.
     */
    constructor(address blazeAddress, address blazeBurnerAddress) Ownable(_msgSender()) {
        blz = IBlazeToken(blazeAddress);
        burner = IBlazeBurner(blazeBurnerAddress);
        i_initialTimestamp = BONFIRE_START_TIMESTAMP;
    }

    receive() external payable {}

    /**
     * @dev Initiates the burning process for the current event, activates it if not active.
     */
    function initiateBonfireBurn() external {
        uint256 currentDate = (block.timestamp - i_initialTimestamp) / INTERVAL_BETWEEN_EVENTS;

        require(currentDate >= nextActiveEventIndex, "BlazeBonfire: Event not started");
        
        if(nextActiveEventIndex < currentDate ){
            events[nextActiveEventIndex].isActive = false;
            nextActiveEventIndex ++;
        }

        if (events[currentDate].totalFunds == 0) {
            events[currentDate] = Event({
                totalFunds: address(this).balance,
                fundsBurned: 0,
                lastBurnTime: 0,
                intervalBurnAmount: address(this).balance / INTERVAL_IN_EVENT,
                eventStartTime: i_initialTimestamp + (currentDate * INTERVAL_BETWEEN_EVENTS),
                isActive: false
            });
        }

        require(events[currentDate].totalFunds > events[currentDate].fundsBurned, "BlazeBonfire: All funds burned");

        if (!events[currentDate].isActive) {
            events[currentDate].isActive = true;
            events[currentDate].lastBurnTime = block.timestamp - cooldownPeriod; // Enable immediate burning
        }

        _burn(currentDate);
    }

    function setBlazeBurnerAddress(address burnerAddress) external onlyOwner {
        require(burnerAddress != address(0), "Invalid burner address");
        burner = IBlazeBurner(burnerAddress);
    }

    /**
     * @dev Performs the actual burning of tokens.
     * @param currentDate The index of the current event day.
     */
    function _burn(uint256 currentDate) internal {
        require(events[currentDate].isActive, "BlazeBonfire: Event inactive");
        require(block.timestamp - events[currentDate].lastBurnTime >= cooldownPeriod, 
            "BlazeBonfire: Cooldown not elapsed");

        uint256 burnAmount = calculateIntervalBurnAmount(currentDate);
        require(burnAmount > 0, "BlazeBonfire: Invalid burn amount");
        require(events[currentDate].fundsBurned + burnAmount <= events[currentDate].totalFunds, 
            "BlazeBonfire: Invalid burn amount");
        events[currentDate].fundsBurned += burnAmount;
        events[currentDate].lastBurnTime = block.timestamp;

        uint256 incentive = (burnAmount * 15) / 1000;
        burnAmount -= incentive;
        burner.swapETHForBlazeAndBurn{value: burnAmount}();

        if (events[currentDate].fundsBurned >= events[currentDate].totalFunds) {
            events[currentDate].isActive = false;
            nextActiveEventIndex++;
        }

        (bool sent, ) = payable(_msgSender()).call{value: incentive}("");
        require(sent, "Blaze: Refund failed");

        emit BonfireBurn(currentDate, _msgSender(), burnAmount, incentive);
    }

    /**
     * @dev Calculates the amount of tokens to burn depending on the time passed since the last burn.
     * @param currentDate The current event index date for which to calculate the burn amount.
     * @return The calculated burn amount.
     */
    function calculateIntervalBurnAmount(uint256 currentDate) public view returns (uint256) {
        uint256 timeSinceStart = block.timestamp - events[currentDate].eventStartTime;
        uint256 intervalsPassed = (timeSinceStart / (15 minutes)) + 1;

        // Calculate total burn amount up to the current interval
        uint256 totalBurnAmount = intervalsPassed * events[currentDate].intervalBurnAmount;

        if (intervalsPassed >= INTERVAL_IN_EVENT || totalBurnAmount > events[currentDate].totalFunds) {
            totalBurnAmount = events[currentDate].totalFunds;
        }

        // Return the remaining amount to be burned
        return totalBurnAmount - events[currentDate].fundsBurned;
    }

    /**
     * @dev Public view function to get the current day index since the initial timestamp.
     * @return The current day index.
     */
    function getCurrentDay() public view returns (uint256) {
        return (block.timestamp - i_initialTimestamp) / 1 days;
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

// SPDX-License-Identifier: MIT
// 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/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

interface IBlazeBurner {
    function swapETHForBlazeAndBurn() external payable;
        
}

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

interface IBlazeToken {
    function burn(uint256 amount) external;

    function balanceOf(address account) external view returns (uint256);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"blazeAddress","type":"address"},{"internalType":"address","name":"blazeBurnerAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cycle","type":"uint256"},{"indexed":false,"internalType":"address","name":"burner","type":"address"},{"indexed":false,"internalType":"uint256","name":"burnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"incentive","type":"uint256"}],"name":"BonfireBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"BONFIRE_START_TIMESTAMP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INTERVAL_BETWEEN_EVENTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INTERVAL_IN_EVENT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"blz","outputs":[{"internalType":"contract IBlazeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burner","outputs":[{"internalType":"contract IBlazeBurner","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"currentDate","type":"uint256"}],"name":"calculateIntervalBurnAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cooldownPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"events","outputs":[{"internalType":"uint256","name":"totalFunds","type":"uint256"},{"internalType":"uint256","name":"fundsBurned","type":"uint256"},{"internalType":"uint256","name":"lastBurnTime","type":"uint256"},{"internalType":"uint256","name":"intervalBurnAmount","type":"uint256"},{"internalType":"uint256","name":"eventStartTime","type":"uint256"},{"internalType":"bool","name":"isActive","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentDay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"i_initialTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initiateBonfireBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nextActiveEventIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"burnerAddress","type":"address"}],"name":"setBlazeBurnerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000fcd7ccee4071aa4ecfac1683b7cc0afecaf42a360000000000000000000000006a865a915aa14f92ac3e2d5fdfd4cc2918fd550e

-----Decoded View---------------
Arg [0] : blazeAddress (address): 0xfcd7cceE4071aA4ecFAC1683b7CC0aFeCAF42A36
Arg [1] : blazeBurnerAddress (address): 0x6A865a915aA14f92AC3e2d5FDFD4CC2918fD550e

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000fcd7ccee4071aa4ecfac1683b7cc0afecaf42a36
Arg [1] : 0000000000000000000000006a865a915aa14f92ac3e2d5fdfd4cc2918fd550e