RobinBurner

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

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

/// @notice Minimal Uniswap V3 SwapRouter surface — exact-input single-hop, payable (wraps native ETH when
///         tokenIn is WETH and msg.value == amountIn).
interface ISwapRouter {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
}

/// @title RobinBurner
/// @notice The $ROBIN buyback-and-burn sink. The BondingCurveFactory routes a "burn" slice of every token's
///         trade fees here as native ETH; `buyAndBurn` market-buys $ROBIN on the Uniswap V3 ETH/$ROBIN pool
///         and sends it straight to the dead address.
///
/// @dev    There is NO withdraw — once ETH is in this contract it can only ever become burned $ROBIN
///         (the swap output recipient is hard-coded to DEAD). Inert until $ROBIN + its pool exist: the owner
///         calls `setConfig` after the fair-launched $ROBIN graduates to Uniswap V3. `buyAndBurn` is gated
///         to owner/keeper so a sane `minRobinOut` (from an off-chain quote) guards against sandwiching.
contract RobinBurner is Ownable {
    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;

    address public robin; // $ROBIN token — the thing we buy and burn
    address public router; // Uniswap V3 SwapRouter
    address public weth; // wrapped native ETH (the swap's tokenIn)
    uint24 public poolFee = 10000; // ETH/$ROBIN fee tier — curve graduates into the 1% tier (10000)
    address public keeper; // optional trigger besides owner (a cron that computes minOut from a quote)

    uint256 public totalEthSpent; // lifetime ETH spent buying $ROBIN
    uint256 public totalRobinBurned; // lifetime $ROBIN sent to DEAD

    event Burned(uint256 ethIn, uint256 robinBurned);
    event ConfigSet(address robin, address router, address weth, uint24 poolFee);
    event KeeperSet(address keeper);

    constructor(address owner_) Ownable(owner_) {}

    /// @notice Accept the factory's burn-leg ETH (and any voluntary top-ups).
    receive() external payable {}

    /// @notice Market-buy $ROBIN with ALL held ETH and burn it (output recipient = DEAD). Owner or keeper
    ///         only — the caller supplies a sane `minRobinOut` from an off-chain quote to bound slippage.
    function buyAndBurn(uint256 minRobinOut) external returns (uint256 robinOut) {
        require(msg.sender == owner() || msg.sender == keeper, "auth");
        require(robin != address(0) && router != address(0) && weth != address(0), "unset");
        uint256 ethBal = address(this).balance;
        require(ethBal > 0, "no eth");
        robinOut = ISwapRouter(router).exactInputSingle{value: ethBal}(
            ISwapRouter.ExactInputSingleParams({
                tokenIn: weth,
                tokenOut: robin,
                fee: poolFee,
                recipient: DEAD, // bought $ROBIN goes straight to the burn address
                deadline: block.timestamp,
                amountIn: ethBal,
                amountOutMinimum: minRobinOut,
                sqrtPriceLimitX96: 0
            })
        );
        totalEthSpent += ethBal;
        totalRobinBurned += robinOut;
        emit Burned(ethBal, robinOut);
    }

    /// @notice Point the burner at the live $ROBIN token + the chain's Uniswap V3 router/WETH + fee tier.
    function setConfig(address robin_, address router_, address weth_, uint24 poolFee_) external onlyOwner {
        require(robin_ != address(0) && router_ != address(0) && weth_ != address(0), "zero");
        robin = robin_;
        router = router_;
        weth = weth_;
        poolFee = poolFee_;
        emit ConfigSet(robin_, router_, weth_, poolFee_);
    }

    function setKeeper(address k) external onlyOwner {
        keeper = k;
        emit KeeperSet(k);
    }
}