TacoBurn

[
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "founder",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "founderBps",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "constructor"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "owner",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "spender",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Approval",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [],
    "name": "OwnershipRenounced",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "pair",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "bool",
        "name": "isAmm",
        "type": "bool"
      }
    ],
    "name": "PairSet",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "seller",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "sold",
        "type": "uint256"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "burned",
        "type": "uint256"
      }
    ],
    "name": "Tacoed",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "from",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  },
  {
    "inputs": [],
    "name": "SELL_BURN_BPS",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "allowance",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "s",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "v",
        "type": "uint256"
      }
    ],
    "name": "approve",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "decimals",
    "outputs": [
      {
        "internalType": "uint8",
        "name": "",
        "type": "uint8"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "isPair",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "name",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "renounceOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "pair",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "isAmm",
        "type": "bool"
      }
    ],
    "name": "setPair",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "symbol",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalBurned",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalSupply",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "v",
        "type": "uint256"
      }
    ],
    "name": "transfer",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "f",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "v",
        "type": "uint256"
      }
    ],
    "name": "transferFrom",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  }
]

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

/**
 * $TACO — a deflationary meme token for Robinhood Chain.
 *
 * THESIS: selling is chickening out. Every time a holder "tacos" (sells into an
 * AMM pair), a fixed slice of that sell is burned forever. Paper hands fuel the
 * scarcity; diamond hands benefit. Buys and plain wallet-to-wallet transfers are
 * untaxed, so entering and moving the token is frictionless.
 *
 * DESIGN CHOICES THAT MAKE THIS AN HONEST TAX TOKEN (not a honeypot):
 *   - 100% of the tax is BURNED. Nothing routes to a team wallet. Ever.
 *   - The burn rate is a compile-time constant. There is NO setter, so the owner
 *     can never crank it up to trap sellers (the classic honeypot move).
 *   - The founder allocation is a single, visible wallet (no laundering across a
 *     cluster) and it is NOT exempt from the sell burn — the founder pays the same
 *     tax as everyone when selling.
 *   - The only owner power is registering AMM pair addresses so the contract knows
 *     what counts as a "sell"; owner should renounce after LP is set.
 *
 * Runs on a Uniswap V2 style AMM (RH Chain has several), whose
 * ...SupportingFeeOnTransferTokens swap functions handle fee-on-transfer tokens.
 * It is NOT compatible with a naive Uniswap V3 pool.
 *
 * UNAUDITED DRAFT. Do not deploy with real value before an audit.
 */
contract TacoBurn {
    // ----------------------------------------------------------------- ERC20
    string public constant name = "TrumpAlwaysChickensOut";
    string public constant symbol = "TACO";
    uint8  public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // ----------------------------------------------------------------- taco config
    // 4% of every sell is burned. IMMUTABLE — no function can change this.
    uint256 public constant SELL_BURN_BPS = 400;
    uint256 public totalBurned;

    address public owner;                       // only registers pairs, then renounces
    mapping(address => bool) public isPair;      // selling INTO these burns; buying FROM them does not

    event PairSet(address indexed pair, bool isAmm);
    event Tacoed(address indexed seller, uint256 sold, uint256 burned);   // a sell + its burn
    event OwnershipRenounced();

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

    /**
     * @param founder   wallet that receives the founder allocation (single, visible)
     * @param founderBps founder cut in bps (e.g. 300 = 3%); the rest mints to the
     *                   deployer to seed the LP. Keep this modest and disclosed.
     */
    constructor(address founder, uint256 founderBps) {
        require(founder != address(0), "founder=0");           // don't mint the founder cut into the void
        require(founderBps <= 1000, "founder cut too high");   // hard cap 10% as a guardrail
        owner = msg.sender;
        totalSupply = 1_000_000_000 * 1e18;                    // 1B

        uint256 founderCut = (totalSupply * founderBps) / 10_000;
        uint256 lpAlloc = totalSupply - founderCut;            // deployer seeds the pool with this
        balanceOf[founder] = founderCut;
        balanceOf[msg.sender] = lpAlloc;
        emit Transfer(address(0), founder, founderCut);
        emit Transfer(address(0), msg.sender, lpAlloc);
    }

    // ----------------------------------------------------------------- owner (minimal, temporary)
    /// Register (or unregister) an AMM pair so the contract knows a transfer INTO
    /// it is a sell. Call once after creating the LP, then renounce.
    function setPair(address pair, bool isAmm) external onlyOwner {
        isPair[pair] = isAmm;
        emit PairSet(pair, isAmm);
    }
    /// Drop all owner power. After this, pairs are frozen and nothing is upgradeable.
    function renounceOwnership() external onlyOwner {
        owner = address(0);
        emit OwnershipRenounced();
    }

    // ----------------------------------------------------------------- ERC20 core
    function transfer(address to, uint256 v) external returns (bool) { _xfer(msg.sender, to, v); return true; }
    function approve(address s, uint256 v) external returns (bool) {
        allowance[msg.sender][s] = v; emit Approval(msg.sender, s, v); return true;
    }
    function transferFrom(address f, address to, uint256 v) external returns (bool) {
        uint256 a = allowance[f][msg.sender];
        if (a != type(uint256).max) { require(a >= v, "allowance"); allowance[f][msg.sender] = a - v; }
        _xfer(f, to, v); return true;
    }

    /**
     * Core transfer. A SELL is a transfer INTO a registered pair from a non-pair
     * sender. Only sells are taxed; buys (from a pair) and normal transfers pass
     * through untouched. The taxed amount is truly burned (totalSupply shrinks).
     */
    function _xfer(address f, address to, uint256 v) internal {
        require(balanceOf[f] >= v, "balance");
        unchecked { balanceOf[f] -= v; }

        uint256 burnAmt = 0;
        if (isPair[to] && !isPair[f]) {                        // this is a sell
            burnAmt = (v * SELL_BURN_BPS) / 10_000;
        }

        if (burnAmt > 0) {
            unchecked { totalSupply -= burnAmt; totalBurned += burnAmt; }
            emit Transfer(f, address(0), burnAmt);             // canonical burn event
            emit Tacoed(f, v, burnAmt);
        }
        uint256 rest = v - burnAmt;
        unchecked { balanceOf[to] += rest; }
        emit Transfer(f, to, rest);
    }
}