Contract Address Details

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

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

interface IEKG {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function burnFrom(address account, uint256 amount) external;
}

interface IPulseXFactory {
    function getPair(address a, address b) external view returns (address);
}

interface IPulseXPair {
    function getReserves() external view returns (uint112, uint112, uint32);
    function token0() external view returns (address);
}

interface IPulseXRouter {
    function factory() external view returns (address);
    function WPLS() external view returns (address);
    function swapExactETHForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline)
        external
        payable
        returns (uint256[] memory amounts);
}

/// @title BuyBurn
/// @notice Seven percent of every mine lands here, and the only thing this
///         contract can do with it is walk onto PulseX, buy EKG on the open
///         market at whatever the market is asking, and destroy what it buys.
///
///         There is no owner, no pause, no withdraw and no way to point it at
///         a different token or a different pool. It does not add to the
///         liquidity pool, it does not hold EKG, and it never sells. PLS goes
///         in from the Mine and leaves as a market buy; EKG arrives from the
///         pool and leaves by being burned. Those are the only two directions
///         that exist in this code.
///
///         Anyone may fire it. That is deliberate: a buyback that depends on
///         one particular wallet remembering to call it is a buyback that
///         stops the day that wallet stops caring.
contract BuyBurn is ReentrancyGuard {
    IEKG public immutable token;

    /// @notice The only address allowed to add PLS. See `receive`.
    address public immutable mine;

    IPulseXRouter public immutable router;
    IPulseXFactory public immutable factory;
    address public immutable WPLS;

    /// @notice The most a single buy is allowed to lift the pool price, in
    ///         basis points. Fifteen percent.
    ///
    ///         Without it, a queue that has grown large against a thin pool
    ///         would go through in one transaction, spike the price on a candle
    ///         nobody can trade against, and hand most of the money to whoever
    ///         was watching the mempool. With it, the buy is cut to the largest
    ///         size whose price impact lands on this number, the rest stays
    ///         queued, and the next call can spend more because the pool it is
    ///         buying into is deeper than it was.
    uint256 public constant GATE_BPS = 1500;

    /// @notice PulseX takes 0.29 percent of a swap. Measured against the live
    ///         router rather than assumed: 1,000 PLS through the WPLS/DAI pool
    ///         returns exactly the amount 9971/10000 predicts.
    uint256 public constant FEE_NUM = 9971;
    uint256 public constant FEE_DEN = 10000;

    /// @notice Below this the gas costs more than the burn is worth.
    uint256 public constant MIN_BUY = 1e18;

    /// @notice One buy per minute at most, so the queue cannot be ground down
    ///         by a run of sandwiched calls inside a single block.
    uint256 public constant COOLDOWN = 60;

    /// @notice PLS waiting to be spent.
    uint256 public queued;
    /// @notice PLS this contract has ever spent buying EKG.
    uint256 public spent;
    /// @notice EKG this contract has ever destroyed.
    uint256 public burned;
    /// @notice When the last buy landed.
    uint64 public lastBuyAt;

    event Funded(address indexed from, uint256 amount);
    event BoughtAndBurned(
        address indexed caller, uint256 plsSpent, uint256 ekgBurned, uint256 queuedAfter, uint256 priceImpactBps
    );

    error NotTheMine();
    error NoPair();
    error NothingQueued();
    error TooSoon();
    error BelowMinimum();
    error GotNothing();

    constructor(address token_, address mine_, address router_) {
        token = IEKG(token_);
        mine = mine_;
        router = IPulseXRouter(router_);
        factory = IPulseXFactory(IPulseXRouter(router_).factory());
        WPLS = IPulseXRouter(router_).WPLS();
        // The token gates burning to this address and still spends an
        // allowance, so this contract has to be allowed to burn its own
        // balance. Set once, here, where nobody has to remember to do it.
        IEKG(token_).approve(address(this), type(uint256).max);
    }

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

    /// @notice The EKG/PLS pair, once somebody has created it. Read from the
    ///         factory every time rather than stored, so this contract can be
    ///         deployed before the pool exists.
    function pair() public view returns (address) {
        return factory.getPair(address(token), WPLS);
    }

    /// @notice What the pool is holding, PLS side first.
    function reserves() public view returns (uint256 plsSide, uint256 ekgSide) {
        address p = pair();
        if (p == address(0)) return (0, 0);
        (uint112 r0, uint112 r1,) = IPulseXPair(p).getReserves();
        return IPulseXPair(p).token0() == WPLS ? (uint256(r0), uint256(r1)) : (uint256(r1), uint256(r0));
    }

    /// @notice The largest amount of PLS that can be spent into a pool holding
    ///         `plsSide` without lifting the price by more than GATE_BPS.
    ///
    ///         Buying with x against reserves (R, T) leaves the pool at
    ///
    ///             newPrice / oldPrice = (R + x)(R + fx) / R^2,   f = FEE_NUM/FEE_DEN
    ///
    ///         Setting that equal to 1 + g and solving the quadratic gives
    ///
    ///             x = R * ( sqrt(10000*A^2 + 4*n*d*g_bps) - 100*A ) / (200*n)
    ///
    ///         with A = n + d. At a 15 percent gate and a 0.29 percent fee that
    ///         is 7.2486 percent of the PLS side of the pool. The square root is
    ///         taken on a value scaled by 1e12 so the ratio keeps seven digits,
    ///         and it truncates downwards, which can only ever make the buy
    ///         smaller than the gate allows. Never larger.
    function gateCap(uint256 plsSide) public pure returns (uint256) {
        if (plsSide == 0) return 0;
        uint256 A = FEE_NUM + FEE_DEN;
        uint256 disc = (10_000 * A * A + 4 * FEE_NUM * FEE_DEN * GATE_BPS) * 1e12;
        uint256 num = _sqrt(disc) - 100 * A * 1e6;
        uint256 den = 200 * FEE_NUM * 1e6;
        return (plsSide * num) / den;
    }

    /// @notice What the next call to `executeBuyback` would actually spend.
    ///         Zero when there is no pool, nothing queued, or the clock is not
    ///         up yet.
    function spendable() public view returns (uint256) {
        if (block.timestamp < uint256(lastBuyAt) + COOLDOWN) return 0;
        (uint256 plsSide,) = reserves();
        if (plsSide == 0) return 0;
        uint256 cap = gateCap(plsSide);
        uint256 amount = queued < cap ? queued : cap;
        return amount < MIN_BUY ? 0 : amount;
    }

    /// @notice Standard constant product output, at the router's own fee.
    function amountOut(uint256 amountIn, uint256 rIn, uint256 rOut) public pure returns (uint256) {
        if (amountIn == 0 || rIn == 0 || rOut == 0) return 0;
        uint256 inAfterFee = amountIn * FEE_NUM;
        return (inAfterFee * rOut) / (rIn * FEE_DEN + inAfterFee);
    }

    // ----------------------------------------------------------------- action

    /// @notice Spend what the gate allows, buy EKG with it, and burn every
    ///         token that comes back. Anyone may call this and the caller takes
    ///         nothing: there is no reward, no refund and no discount, so the
    ///         only reason to call it is to want the supply smaller.
    ///
    /// @param  minOut A floor the caller can demand on top of the contract's
    ///         own. The contract computes what the pool should return from the
    ///         reserves it has just read and will not accept less, so passing
    ///         zero is safe; passing a higher number makes the call revert
    ///         rather than execute at a price the caller dislikes.
    function executeBuyback(uint256 minOut) external nonReentrant returns (uint256 plsSpent, uint256 ekgBurned) {
        if (block.timestamp < uint256(lastBuyAt) + COOLDOWN) revert TooSoon();
        address p = pair();
        if (p == address(0)) revert NoPair();
        if (queued == 0) revert NothingQueued();

        (uint256 plsSide, uint256 ekgSide) = reserves();
        if (plsSide == 0 || ekgSide == 0) revert NoPair();

        uint256 cap = gateCap(plsSide);
        plsSpent = queued < cap ? queued : cap;
        if (plsSpent < MIN_BUY) revert BelowMinimum();

        // What this pool owes for that much PLS, from the reserves as they are
        // in this transaction. A router that returns less than its own maths
        // says is a router this contract will not trade with.
        uint256 floorOut = amountOut(plsSpent, plsSide, ekgSide);
        if (floorOut == 0) revert GotNothing();
        uint256 demand = minOut > floorOut ? minOut : floorOut;

        // Books first, then the call out. Nothing here reads a balance to
        // decide anything, so a token that behaves oddly cannot move the
        // accounting, and the queue is already reduced before any external
        // code runs.
        queued -= plsSpent;
        spent += plsSpent;
        lastBuyAt = uint64(block.timestamp);

        address[] memory path = new address[](2);
        path[0] = WPLS;
        path[1] = address(token);
        router.swapExactETHForTokens{value: plsSpent}(demand, path, address(this), block.timestamp);

        // Burn the whole balance rather than the swap's return value, so EKG
        // anybody sends to this address is destroyed on the next buy instead of
        // sitting here forever.
        ekgBurned = token.balanceOf(address(this));
        if (ekgBurned == 0) revert GotNothing();
        burned += ekgBurned;
        token.burnFrom(address(this), ekgBurned);

        emit BoughtAndBurned(msg.sender, plsSpent, ekgBurned, queued, _impactBps(plsSide, plsSpent));
    }

    /// @notice Destroy any EKG sitting here without waiting for a buy. Anyone
    ///         may call it and it can only ever reduce the supply.
    function burnStray() external nonReentrant returns (uint256 amount) {
        amount = token.balanceOf(address(this));
        if (amount == 0) revert GotNothing();
        burned += amount;
        token.burnFrom(address(this), amount);
    }

    // --------------------------------------------------------------- internal

    /// @notice What a buy of `x` into a pool holding `R` did to the price, in
    ///         basis points. Reported on the event so the gate can be checked
    ///         against the chain rather than taken on trust.
    function _impactBps(uint256 R, uint256 x) internal pure returns (uint256) {
        if (R == 0) return 0;
        uint256 after_ = (R + x) * (R * FEE_DEN + x * FEE_NUM);
        uint256 before_ = R * R * FEE_DEN;
        return ((after_ * 10_000) / before_) - 10_000;
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    /// @notice PLS in, and only from the Mine. There is no other way to fund
    ///         this contract and no way at all to take PLS back out of it
    ///         except by buying EKG with it.
    receive() external payable {
        if (msg.sender != mine) revert NotTheMine();
        queued += msg.value;
        emit Funded(msg.sender, msg.value);
    }
}
        

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