Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.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 EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

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

    uint256 private _status;

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

    constructor() {
        _status = NOT_ENTERED;
    }

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

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

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

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

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

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

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; 

interface IERC20 {
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
}

interface IERC20Metadata {
    function decimals() external view returns (uint8);
}

interface IERC20Permit {
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v, bytes32 r, bytes32 s
    ) external;
}

interface IERC20Burnable is IERC20 {
    function burnFrom(address account, uint256 amount) external;
}

abstract contract Ownable {
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    address public owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    constructor(address initialOwner) {
        require(initialOwner != address(0), "owner=0");
        owner = initialOwner;
        emit OwnershipTransferred(address(0), initialOwner);
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "new owner=0");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}

contract HyprBurnTier is Ownable, ReentrancyGuard {
    enum BurnMode { TransferToDead } // default: TransferToDead
    enum Tier { Commonr, Supr, Hypr }         // 0,1,2

    event Burned(address indexed account, uint256 amount, BurnMode mode);
    event BurnedFor(address indexed account, address destinationAccount, uint256 amount, BurnMode mode);
    event TierThresholdsUpdated(uint256 suprThreshold, uint256 hyprThreshold);
    event TierUpdated(address indexed account, Tier newTier);

    IERC20 public immutable token;
    address public deadAddress = 0x000000000000000000000000000000000000dEaD;
    BurnMode public burnMode = BurnMode.TransferToDead;

    // Thresholds are stored in the token's smallest unit (raw).
    // Commoner threshold is implicitly 0.
    uint256 public suprThresholdRaw;
    uint256 public hyprThresholdRaw;

    // Per-wallet cumulative burned amount (raw)
    mapping(address => uint256) public totalBurned;

    // Per-wallet tier status
    mapping(address => Tier) public currentTier;

    constructor(address _token, address _owner) Ownable(_owner) {
        require(_token != address(0), "token=0");
        token = IERC20(_token);

        // Set sensible defaults based on decimals() if available (fallback 18)
        uint8 dec = _tokenDecimals();
        suprThresholdRaw = 20_000 * (10 ** dec);
        hyprThresholdRaw = 50_000 * (10 ** dec);
        emit TierThresholdsUpdated(suprThresholdRaw, hyprThresholdRaw);
    }

    // -------------------- User actions --------------------

    /**
     * @notice Burn tokens by amount. User must have approved this contract first (unless using permit).
     * In TransferToDead mode: transfers tokens to the dead address.
     * In BurnFrom mode: calls token.burnFrom(msg.sender, amount) (token must support it).
     */
    function burn(uint256 amount) external nonReentrant {
        _burnInternal(amount, msg.sender);
    }

    function burnFor(uint256 amount, address destinationAccount) external nonReentrant{
         _burnInternal(amount, destinationAccount);
    }

    function _burnInternal(uint256 amount, address creditTo) internal {
        require(amount > 0, "amount=0");

    
        _requireAllowance(msg.sender, amount);
        _safeTransferFrom(msg.sender, deadAddress, amount);

        _updateTier(amount, creditTo);

        if (creditTo == msg.sender) {
            emit Burned(msg.sender, amount, burnMode);
        } else {
            emit BurnedFor(msg.sender, creditTo, amount, burnMode);
        }
    }

    function _updateTier(uint256 amount, address account) internal {
        uint256 burned = totalBurned[account] + amount;
        totalBurned[account] = burned;
        Tier oldTier = currentTier[account];

        if (burned >= hyprThresholdRaw) currentTier[account] = Tier.Hypr;
        else if (burned >= suprThresholdRaw) currentTier[account] = Tier.Supr;
        else currentTier[account] = Tier.Commonr;

        if (oldTier != currentTier[account]) emit TierUpdated(account, currentTier[account]);
    }

    function totalBurnedTokens() external view returns (uint256) {
        return token.balanceOf(deadAddress);
    }

    // -------------------- Owner controls --------------------

    /**
     * @notice Set raw thresholds (smallest units). Must satisfy: hypr >= supr >= 0.
     * Commoner remains 0 by definition.
     */
    function setTierThresholdsRaw(uint256 newSuprRaw, uint256 newHyprRaw) external onlyOwner {
        require(newSuprRaw >= 0 && newHyprRaw >= 0, "supr or hypr < 0" );
        require(newHyprRaw >= newSuprRaw, "hypr < supr");
        suprThresholdRaw = newSuprRaw;
        hyprThresholdRaw = newHyprRaw;
        emit TierThresholdsUpdated(newSuprRaw, newHyprRaw);
    }

    /**
     * @notice Convenience setter using whole-token amounts (e.g., 100_000 means 100k tokens).
     * This scales by token decimals() if available; fallback is 18 decimals.
     */
    function setTierThresholdsTokens(uint256 newSuprTokens, uint256 newHyprTokens) external onlyOwner {
        require(newSuprTokens >= 0 && newHyprTokens >= 0, "supr or hypr < 0" );
        uint8 dec = _tokenDecimals();
        uint256 suprRaw = newSuprTokens * (10 ** dec);
        uint256 hyprRaw = newHyprTokens * (10 ** dec);
        require(hyprRaw >= suprRaw, "hypr < supr");
        suprThresholdRaw = suprRaw;
        hyprThresholdRaw = hyprRaw;
        emit TierThresholdsUpdated(suprRaw, hyprRaw);
    }

    // -------------------- Views --------------------

    function tierOf(address account) public view returns (Tier) {
        return currentTier[account];
    }

    function tierNameOf(address account) external view returns (string memory) {
        Tier t = tierOf(account);
        if (t == Tier.Hypr) return "Hypr";
        if (t == Tier.Supr) return "Supr";
        return "Commonr";
    }

    function thresholdsRaw() external view returns (uint256 suprRaw, uint256 hyprRaw) {
        return (suprThresholdRaw, hyprThresholdRaw);
    }

    function tokenDecimals() external view returns (uint8) {
        return _tokenDecimals();
    }

    // -------------------- Internal utils --------------------

    function _tokenDecimals() internal view returns (uint8) {
        // Try/catch to avoid revert if token lacks decimals()
        try IERC20Metadata(address(token)).decimals() returns (uint8 dec) {
            return dec;
        } catch {
            return 18; // sensible default
        }
    }

    function _requireAllowance(address from, uint256 amount) internal view {
        require(token.allowance(from, address(this)) >= amount, "insufficient allowance");
    }

    // Minimal safe transferFrom (revert on false)
    function _safeTransferFrom(address from, address to, uint256 amount) internal {
        bool ok = token.transferFrom(from, to, amount);
        require(ok, "transferFrom failed");
    }
}