Contract Address Details

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

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

interface IBuyBurn {
    function queued() external view returns (uint256);
    function burned() external view returns (uint256);
    function pair() external view returns (address);
    function router() external view returns (address);
}

interface IEKGMint {
    function mint(address to, uint256 amount) external;
    function distribute() external payable;
    function setExcluded(address account, bool value) external;
    function totalSupply() external view returns (uint256);
    function eligibleSupply() external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IRouterLiquidity {
    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}

/// @title Mine
/// @notice The whole emission schedule. 36 halvings, 369,000,000 tokens, and
///         never one more.
///
///         There is no clock anywhere in here. Halving one holds half of
///         everything at one flat price; when it is mined out the next opens
///         at double, in the same transaction if the same buy pays for it.
///         Bitcoin's arithmetic - 36 doublings, boundaries on clean powers of
///         two - with demand as the only pacing.
///
///         Nothing can be mined before the market exists. openMine() runs
///         once: it mines the pool's EKG side at full halving one price,
///         pairs it with PLS on PulseX, and burns the LP tokens, so the
///         founding liquidity can never be withdrawn by anyone. Only then
///         does mine() open. The buy and burn therefore has a pool to buy
///         from before the first ordinary mine ever queues its seven percent.
///
///         You commit PLS. Ninety percent of it is set aside for you and comes
///         back after 24 hours. The protocol keeps ten, so your real cost is a
///         tenth of the headline rate, and of that ten:
///
///             70 percent into the buy and burn, which takes it to the open
///                market, buys EKG with it and destroys what it buys
///             20 percent paid straight out to everyone holding
///             10 percent to operations
///
///         Measured against the whole commit that is 7, 2 and 1 percent.
///
///         The money set aside for miners is accounted separately and nothing
///         in this contract can spend it. It is theirs from the moment they
///         commit.
contract Mine is ReentrancyGuard {
    uint256 public constant CAP = 369_000_000e18;
    uint256 public constant HALVINGS = 36;
    uint256 public constant RETURN_WINDOW = 24 hours;

    uint256 public constant RETURN_BPS = 9000; // comes back to the miner
    uint256 public constant KEEP_BPS = 1000; // the real cost

    // of the ten percent kept
    uint256 public constant FLOOR_BPS = 7000;
    uint256 public constant DIV_BPS = 2000;
    uint256 public constant OPS_BPS = 1000;


    /// @notice The smallest mine the contract will accept, in whole tokens.
    ///         Without it, a commit small enough to round to zero PLS mints
    ///         free tokens, and a supply of a few wei is the lever that turns
    ///         the dividend accumulator into a weapon.
    uint256 public constant MIN_MINE = 1e18;

    /// @notice Below this eligible supply the holders' share is held rather
    ///         than paid, because the token cannot divide it fairly.
    uint256 public constant MIN_ELIGIBLE_TO_PAY = 1e18;

    IEKGMint public immutable token;
    address payable public immutable buyBurn;
    address public immutable ops;

    /// @notice PLS per whole token in the first halving, fixed forever at deploy.
    uint256 public immutable rate0;

    /// @notice Which halving is live. Only mining moves it. There is no clock
    ///         in this contract and no way to advance it by waiting.
    uint256 public halvingNow;
    /// @notice Tokens taken out of the live halving so far.
    uint256 public halvingMinted;
    uint256 public minted;

    uint256 public opsOwed;
    /// @notice Every PLS in this contract that belongs to a miner, not to us.
    uint256 public reserved;
    /// @notice Holders' PLS that arrived while there were no holders. It is
    ///         paid out in full on the next mine that has somebody to pay.
    uint256 public pendingDiv;
    bool public wired;

    /// @notice True once openMine() has created and funded the pool. Every
    ///         ordinary mine is refused until then, so there is never a moment
    ///         where the buy and burn holds money with nothing to buy.
    bool public opened;

    /// @notice Where the founding LP tokens go. Nothing at this address can
    ///         act, so the founding liquidity is locked in the pool forever.
    address public constant LP_GRAVE = 0x000000000000000000000000000000000000dEaD;

    struct Position {
        uint128 committed; // what they sent in
        uint128 returning; // the ninety percent coming back
        uint128 tokens; // what they mined
        uint64 minedAt;
        uint64 unlockAt;
        bool claimed;
    }

    mapping(address => Position[]) private _positions;

    event Mined(
        address indexed account,
        uint256 indexed index,
        uint256 halving,
        uint256 tokens,
        uint256 committed,
        uint256 returning,
        uint256 unlockAt
    );
    event Returned(address indexed account, uint256 indexed index, uint256 amount);
    event HalvingAdvanced(uint256 indexed halving, uint256 newRate);
    event Claimed(address indexed account, uint256 amount);
    event Opened(address indexed pair, uint256 ekgSide, uint256 plsSide);

    error MiningOver();
    error Underpaid();
    error NothingToClaim();
    error TransferFailed();
    error ZeroAmount();
    error AlreadyWired();
    error NoPairYet();
    error NotYet();
    error TooSmall();
    error BadRange();
    error PriceMoved();
    error NoEligibleSupply();
    error NotOpen();
    error AlreadyOpen();
    error NoLiquidity();

    constructor(address token_, address payable buyBurn_, address ops_, uint256 rate0_) {
        // A zero opening rate would mint the entire cap for nothing, and there
        // is no owner and no second chance.
        if (rate0_ == 0) revert ZeroAmount();
        token = IEKGMint(token_);
        buyBurn = buyBurn_;
        ops = ops_;
        rate0 = rate0_;
    }

    /// @notice Keeps the protocol's own contracts out of the dividend split.
    ///         Takes no argument and runs once, so nobody can point it at a holder.
    function wire() external {
        if (wired) revert AlreadyWired();
        wired = true;
        token.setExcluded(buyBurn, true);
        token.setExcluded(address(this), true);
    }

    /// @notice Take the trading pair out of the dividend split, once it exists.
    ///
    ///         The pool holds a large EKG balance that belongs to liquidity
    ///         providers rather than to any one holder, and nothing can claim
    ///         on its behalf. Left in the split, a growing share of every
    ///         dividend would accrue to an address that can never withdraw it,
    ///         and that share would be lost to everybody.
    ///
    ///         Anyone may call this and the caller chooses nothing: the address
    ///         comes from the factory, not from the arguments, so the only
    ///         address it can ever exclude is the real EKG pair. Exclusion is
    ///         one way in the token, so calling it twice does nothing.
    function excludePair() external returns (address p) {
        p = IBuyBurn(buyBurn).pair();
        if (p == address(0)) revert NoPairYet();
        token.setExcluded(p, true);
    }

    // ------------------------------------------------------------------ views

    /// @notice What halving `k` holds in total.
    ///
    ///         Halving one holds half of everything, two a quarter, and so on,
    ///         exactly as Bitcoin's first epoch mints half of all bitcoin. The
    ///         last one sweeps whatever rounding left behind, so the total is
    ///         the cap to the wei with nothing stranded.
    function halvingAllowance(uint256 k) public pure returns (uint256) {
        if (k >= HALVINGS) return 0;
        if (k == HALVINGS - 1) {
            uint256 taken;
            for (uint256 i = 0; i < HALVINGS - 1; i++) taken += CAP >> (i + 1);
            return CAP - taken;
        }
        return CAP >> (k + 1);
    }

    function halving() public view returns (uint256) {
        return halvingNow;
    }

    /// @notice What is left in the halving that is live right now.
    function available() public view returns (uint256) {
        if (halvingNow >= HALVINGS) return 0;
        uint256 all = halvingAllowance(halvingNow);
        return all > halvingMinted ? all - halvingMinted : 0;
    }

    /// @notice Everything left to mine across every halving still to come.
    function remaining() public view returns (uint256) {
        return CAP > minted ? CAP - minted : 0;
    }

    function finished() public view returns (bool) {
        return halvingNow >= HALVINGS || minted >= CAP;
    }

    /// @notice What a token costs in the halving that is live right now. Flat
    ///         inside a halving, doubled at the boundary. Bitcoin's arithmetic
    ///         and nothing else in the way.
    function scheduleRate() public view returns (uint256) {
        if (halvingNow >= HALVINGS) return rate0 << (HALVINGS - 1);
        return rate0 << halvingNow;
    }

    /// @notice The headline rate right now.
    ///
    ///         There used to be a second rule here, a guard tied to a
    ///         redemption pot. The pot is gone, so there is nothing a mint can
    ///         dilute and nothing for a guard to protect. What is left is the
    ///         schedule, and no function anywhere lowers it.
    function rate() public view returns (uint256) {
        return scheduleRate();
    }

    /// @notice What a token actually costs, after the ninety percent returns.
    function trueCost() public view returns (uint256) {
        return (rate() * KEEP_BPS) / 10_000;
    }

    /// @notice What `amount` tokens cost right now, walking across halvings if
    ///         the amount is bigger than what this one has left.
    ///
    ///         This is the whole point of the design. A buyer is never turned
    ///         away and never told to come back later: they simply pay this
    ///         halving's price for what is left of it, the next halving's price
    ///         for the next slice, and so on. Wanting more supply costs
    ///         exponentially more, which is the only fair way to ration it.
    function costOf(uint256 amount) public view returns (uint256 cost) {
        uint256 k = halvingNow;
        uint256 mintedHere = halvingMinted;
        while (amount > 0 && k < HALVINGS) {
            uint256 all = halvingAllowance(k);
            uint256 left = all > mintedHere ? all - mintedHere : 0;
            uint256 take = amount < left ? amount : left;
            if (take > 0) {
                cost += _cost(take, rate0 << k);
                amount -= take;
            }
            if (amount == 0) break;
            k += 1;
            mintedHere = 0;
        }
    }

    /// @notice How many tokens `pls` buys right now, across as many halvings as
    ///         it reaches.
    function quote(uint256 pls) public view returns (uint256 tokens, uint256 spend) {
        uint256 k = halvingNow;
        uint256 mintedHere = halvingMinted;
        uint256 budget = pls;
        while (budget > 0 && k < HALVINGS) {
            uint256 r = rate0 << k;
            uint256 all = halvingAllowance(k);
            uint256 left = all > mintedHere ? all - mintedHere : 0;
            if (left == 0) { k += 1; mintedHere = 0; continue; }
            uint256 affordable = (budget * 1e18) / r;
            uint256 take = affordable < left ? affordable : left;
            if (take == 0) break;
            uint256 c = _cost(take, r);
            if (c > budget) break;
            tokens += take;
            spend += c;
            budget -= c;
            if (take < left) break;
            k += 1;
            mintedHere = 0;
        }
    }

    function _cost(uint256 amount, uint256 r) internal pure returns (uint256) {
        if (amount == 0) return 0;
        // Rounded up, so the scraps of a halving always cost at least one wei
        // and can always be bought. Rounded down, a remainder small enough to
        // price at zero could never be mined and the curve would stop there.
        return (amount * r + 1e18 - 1) / 1e18;
    }

    // --------------------------------------------------------- your positions

    function positionCount(address account) external view returns (uint256) {
        return _positions[account].length;
    }

    function positionAt(address account, uint256 index) external view returns (Position memory) {
        return _positions[account][index];
    }

    /// @notice Everything the front end needs for one wallet in a single read.
    function positionsOf(address account, uint256 from, uint256 count)
        external
        view
        returns (Position[] memory out)
    {
        Position[] storage all = _positions[account];
        if (from >= all.length) return new Position[](0);
        uint256 room = all.length - from;
        uint256 end = from + (count < room ? count : room);
        out = new Position[](end - from);
        for (uint256 i = from; i < end; i++) out[i - from] = all[i];
    }

    /// @notice Returns that have matured and are waiting to be taken.
    ///         Unbounded: use `claimableReturnsRange` once an account has a lot
    ///         of positions, because this one eventually costs more gas than a
    ///         node will spend on a call.
    function claimableReturns(address account) public view returns (uint256 amount, uint256 count) {
        Position[] storage all = _positions[account];
        for (uint256 i = 0; i < all.length; i++) {
            Position storage q = all[i];
            if (!q.claimed && block.timestamp >= q.unlockAt) {
                amount += q.returning;
                count += 1;
            }
        }
    }

    /// @notice Returns still inside the 24 hour window.
    function pendingReturns(address account) public view returns (uint256 amount, uint256 count) {
        Position[] storage all = _positions[account];
        for (uint256 i = 0; i < all.length; i++) {
            Position storage q = all[i];
            if (!q.claimed && block.timestamp < q.unlockAt) {
                amount += q.returning;
                count += 1;
            }
        }
    }

    /// @notice The same reading over a slice of the positions.
    function claimableReturnsRange(address account, uint256 from, uint256 count)
        external
        view
        returns (uint256 amount, uint256 found)
    {
        Position[] storage all = _positions[account];
        if (from >= all.length) return (0, 0);
        uint256 room = all.length - from;
        uint256 end = from + (count < room ? count : room);
        for (uint256 i = from; i < end; i++) {
            Position storage q = all[i];
            if (!q.claimed && block.timestamp >= q.unlockAt) {
                amount += q.returning;
                found += 1;
            }
        }
    }

    // ------------------------------------------------------------------ mining

    /// @notice Spend whatever you send. Pass `type(uint256).max` as `maxRate`
    ///         to accept any price, or a number to refuse a bad one.
    ///
    ///         There is no cap on how much you may mine in one go and no clock
    ///         telling you to come back tomorrow. A large buy simply walks up
    ///         the halvings, paying each one's price for the slice it takes,
    ///         and stops when the money runs out or the cap does.
    /// @notice The one-time launch. Mines the pool's EKG side at the ordinary
    ///         halving one price, creates the EKG/WPLS pair on PulseX, funds it
    ///         with everything sent beyond the mining cost, and burns the LP
    ///         tokens. Runs once, then ordinary mining opens.
    ///
    ///         Nothing here is a premine: the EKG side is bought through the
    ///         same accounting as any other mine - ninety percent of its cost
    ///         comes back to the caller in 24 hours, and the kept tenth splits
    ///         70/20/10 like every commit after it. And nothing here is a rug:
    ///         the LP tokens go to an address nothing can act from, so the
    ///         founding liquidity can never be pulled back out.
    ///
    ///         Anyone can be the caller. Being first costs full price and
    ///         hands the protocol a permanent pool; there is nothing to win.
    function openMine(uint256 ekgSide) external payable nonReentrant returns (address pairAddr) {
        if (opened) revert AlreadyOpen();
        if (ekgSide < MIN_MINE) revert TooSmall();

        uint256 committed = costOf(ekgSide);
        if (msg.value <= committed) revert NoLiquidity();
        uint256 plsSide = msg.value - committed;

        opened = true;
        _take(ekgSide);

        uint256 returning = (committed * RETURN_BPS) / 10_000;
        reserved += returning;
        _positions[msg.sender].push(
            Position({
                committed: uint128(committed),
                returning: uint128(returning),
                tokens: uint128(ekgSide),
                minedAt: uint64(block.timestamp),
                unlockAt: uint64(block.timestamp + RETURN_WINDOW),
                claimed: false
            })
        );
        _split(committed - returning);

        // The pool's EKG side is minted here and spent into the pair in the
        // same transaction. This contract holds tokens for no other reason and
        // at no other time.
        token.mint(address(this), ekgSide);
        address routerAddr = IBuyBurn(buyBurn).router();
        token.approve(routerAddr, ekgSide);
        IRouterLiquidity(routerAddr).addLiquidityETH{value: plsSide}(
            address(token), ekgSide, ekgSide, plsSide, LP_GRAVE, block.timestamp
        );

        pairAddr = IBuyBurn(buyBurn).pair();
        // The pair holds EKG that belongs to the locked liquidity, not to any
        // holder, so it is taken out of the dividend split before a single
        // dividend exists.
        token.setExcluded(pairAddr, true);

        emit Opened(pairAddr, ekgSide, plsSide);
        emit Mined(
            msg.sender,
            _positions[msg.sender].length - 1,
            halvingNow,
            ekgSide,
            committed,
            returning,
            block.timestamp + RETURN_WINDOW
        );
    }

    function mine(uint256 maxRate) external payable nonReentrant returns (uint256 amount) {
        return _mine(type(uint256).max, maxRate);
    }

    /// @notice Buy an exact number of tokens, at no worse than `maxRate` for
    ///         the first token. Anything the current halving cannot cover is
    ///         filled from the next one at its own, higher price.
    function mineExact(uint256 want, uint256 maxRate)
        external
        payable
        nonReentrant
        returns (uint256 amount)
    {
        return _mine(want, maxRate);
    }

    function _mine(uint256 want, uint256 maxRate) internal returns (uint256 amount) {
        // The pool exists before the first mine, always. See openMine().
        if (!opened) revert NotOpen();
        if (finished()) revert MiningOver();

        uint256 opening = rate();
        if (opening > maxRate) revert PriceMoved();

        uint256 committed;
        if (want == type(uint256).max) {
            (amount, committed) = quote(msg.value);
        } else {
            amount = want;
            uint256 left = remaining();
            if (amount > left) amount = left;
            committed = costOf(amount);
        }
        if (amount == 0) revert ZeroAmount();
        // A mine below one whole token is refused, because a supply of a few
        // wei is the lever behind more than one way to kill this.
        //
        // The exception is taking everything on offer. The late halvings hold
        // less than a whole token each - halving thirty holds about a sixth of
        // one - so without this, those halvings could never be cleared by
        // anybody, the schedule would stop there, and the cap would never be
        // reached. Taking all of what is available cannot be a dust attack:
        // it is the only move that exists.
        if (amount < MIN_MINE && amount < available()) revert TooSmall();
        if (msg.value < committed) revert Underpaid();

        _take(amount);

        uint256 returning = (committed * RETURN_BPS) / 10_000;
        uint256 kept = committed - returning;
        reserved += returning;

        _positions[msg.sender].push(
            Position({
                committed: uint128(committed),
                returning: uint128(returning),
                tokens: uint128(amount),
                minedAt: uint64(block.timestamp),
                unlockAt: uint64(block.timestamp + RETURN_WINDOW),
                claimed: false
            })
        );

        // Paid out before the new tokens exist, so a miner is never handed a
        // slice of their own dividend.
        _split(kept);
        token.mint(msg.sender, amount);

        uint256 refund = msg.value - committed;
        if (refund > 0) {
            (bool ok,) = msg.sender.call{value: refund}("");
            if (!ok) revert TransferFailed();
        }

        emit Mined(
            msg.sender,
            _positions[msg.sender].length - 1,
            halvingNow,
            amount,
            committed,
            returning,
            block.timestamp + RETURN_WINDOW
        );
    }

    /// @notice Walk the halvings, taking `amount` tokens out of the schedule,
    ///         advancing the halving as each one empties. The only thing in
    ///         this contract that moves the schedule.
    function _take(uint256 amount) internal {
        uint256 left = amount;
        while (left > 0 && halvingNow < HALVINGS) {
            uint256 all = halvingAllowance(halvingNow);
            uint256 room = all > halvingMinted ? all - halvingMinted : 0;
            uint256 take = left < room ? left : room;
            halvingMinted += take;
            left -= take;
            if (halvingMinted >= all) {
                halvingNow += 1;
                halvingMinted = 0;
                if (halvingNow < HALVINGS) {
                    emit HalvingAdvanced(halvingNow, rate0 << halvingNow);
                }
            }
        }
        minted += amount;
    }

    function _split(uint256 kept) internal {
        uint256 divShare = (kept * DIV_BPS) / 10_000;
        uint256 opsShare = (kept * OPS_BPS) / 10_000;
        opsOwed += opsShare;

        // Every rounding remainder goes to the buy and burn, computed as the
        // remainder rather than as its own percentage so the three slices add
        // up to the whole kept amount exactly and no wei is ever left behind in
        // this contract. Crumbs that belong to nobody should end up buying the
        // token back rather than sitting in a mine that cannot spend them.
        uint256 burnShare = kept - divShare - opsShare;

        // On the very first mine, and any time every token has been redeemed,
        // there is nobody holding to pay. The holders' share is kept here and
        // handed over whole on the next mine that has somebody to pay, rather
        // than being quietly turned into something else.
        // Held back whenever there is nobody meaningful to pay, not only when
        // there is nobody at all. The token refuses to divide by less than one
        // whole token, so pushing a payment against a dust supply would credit
        // a rounding crumb and destroy the rest.
        if (token.eligibleSupply() < MIN_ELIGIBLE_TO_PAY) {
            pendingDiv += divShare;
        } else {
            uint256 owed = divShare + pendingDiv;
            pendingDiv = 0;
            token.distribute{value: owed}();
        }

        (bool ok,) = buyBurn.call{value: burnShare}("");
        if (!ok) revert TransferFailed();
    }


    // ------------------------------------------------------------------ claims

    /// @notice Take back the ninety percent from one matured position.
    function claimReturn(uint256 index) external nonReentrant {
        if (index >= _positions[msg.sender].length) revert BadRange();
        Position storage p = _positions[msg.sender][index];
        if (p.claimed) revert NothingToClaim();
        if (block.timestamp < p.unlockAt) revert NotYet();
        uint256 amount = p.returning;
        p.claimed = true;
        reserved -= amount;
        (bool ok,) = msg.sender.call{value: amount}("");
        if (!ok) revert TransferFailed();
        emit Returned(msg.sender, index, amount);
    }

    /// @notice Take back everything that has matured between two indexes.
    ///         A wallet with thousands of positions cannot sweep them in one
    ///         transaction at any gas limit, so the sweep is bounded and the
    ///         caller walks it. Nothing is ever locked: `claimReturn` reaches
    ///         any single position directly.
    function claimReturns(uint256 from, uint256 count) external nonReentrant returns (uint256 amount) {
        Position[] storage all = _positions[msg.sender];
        if (from >= all.length) revert BadRange();
        uint256 room = all.length - from;
        uint256 end = from + (count < room ? count : room);
        for (uint256 i = from; i < end; i++) {
            Position storage p = all[i];
            if (!p.claimed && block.timestamp >= p.unlockAt) {
                p.claimed = true;
                amount += p.returning;
                emit Returned(msg.sender, i, p.returning);
            }
        }
        if (amount == 0) revert NothingToClaim();
        reserved -= amount;
        (bool ok,) = msg.sender.call{value: amount}("");
        if (!ok) revert TransferFailed();
    }

    /// @notice Take back everything that has matured, in one transaction.
    ///         Fine for a normal wallet. See `claimReturns` for a large one.
    function claimAllReturns() external nonReentrant returns (uint256 amount) {
        Position[] storage all = _positions[msg.sender];
        for (uint256 i = 0; i < all.length; i++) {
            Position storage p = all[i];
            if (!p.claimed && block.timestamp >= p.unlockAt) {
                p.claimed = true;
                amount += p.returning;
                emit Returned(msg.sender, i, p.returning);
            }
        }
        if (amount == 0) revert NothingToClaim();
        reserved -= amount;
        (bool ok,) = msg.sender.call{value: amount}("");
        if (!ok) revert TransferFailed();
    }

    function claimOps() external nonReentrant {
        uint256 amount = opsOwed;
        if (amount == 0) revert NothingToClaim();
        opsOwed = 0;
        (bool ok,) = ops.call{value: amount}("");
        if (!ok) revert TransferFailed();
        emit Claimed(ops, amount);
    }
}
        

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

pragma solidity ^0.8.20;

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

/**
 * @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].
 *
 * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced
 * by the {ReentrancyGuardTransient} variant in v6.0.
 *
 * @custom:stateless
 */
abstract contract ReentrancyGuard {
    using StorageSlot for bytes32;

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant REENTRANCY_GUARD_STORAGE =
        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;

    // 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;

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

    constructor() {
        _reentrancyGuardStorageSlot().getUint256Slot().value = 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();
    }

    /**
     * @dev A `view` only version of {nonReentrant}. Use to block view functions
     * from being called, preventing reading from inconsistent contract state.
     *
     * CAUTION: This is a "view" modifier and does not change the reentrancy
     * status. Use it only on view functions. For payable or non-payable functions,
     * use the standard {nonReentrant} modifier instead.
     */
    modifier nonReentrantView() {
        _nonReentrantBeforeView();
        _;
    }

    function _nonReentrantBeforeView() private view {
        if (_reentrancyGuardEntered()) {
            revert ReentrancyGuardReentrantCall();
        }
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        _nonReentrantBeforeView();

        // Any calls to nonReentrant after this point will fail
        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _reentrancyGuardStorageSlot().getUint256Slot().value = 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 _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;
    }

    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {
        return REENTRANCY_GUARD_STORAGE;
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }
}