// app.jsx — BRRR landing page v2 (dark, Printr-style) const { useState, useEffect, useMemo } = React; const TWEAK_DEFAULTS = /*EDITMODE-BEGIN*/{ "ticker": "BRRR", "primary": "#7C4DFF", "secondary": "#FF4DCB", "feePercent": 3, "buybackSplit": 80, "liveTicker": true }/*EDITMODE-END*/; const fmtUSD = (n, dp = 0) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: dp, maximumFractionDigits: dp }); const fmtNum = (n, dp = 0) => n.toLocaleString("en-US", { minimumFractionDigits: dp, maximumFractionDigits: dp }); const rand = (seed) => { let s = seed; return () => { s = (s * 9301 + 49297) % 233280; return s / 233280; }; }; // ---------- NAV ---------- function Nav({ t }) { return ( ); } // ---------- HERO ---------- function Hero({ t }) { const [live, setLive] = useState({ lastBuyback: 12480, totalBought: 2_418_902, pending: 248.32, block: 8_421_904, }); useEffect(() => { if (!t.liveTicker) return; const id = setInterval(() => { setLive((p) => ({ lastBuyback: p.lastBuyback + Math.round(Math.random() * 60), totalBought: p.totalBought + Math.round(Math.random() * 80), pending: +(p.pending + Math.random() * 2.3).toFixed(2), block: p.block + 1, })); }, 1400); return () => clearInterval(id); }, [t.liveTicker]); return (
BUYBACK ACTIVE · BLOCK #{fmtNum(live.block)}

Every fee compounds. The printer runs in reverse.

{t.ticker} is a self-reinforcing token. A {t.feePercent}% fee on every trade — {" "}{t.buybackSplit}% routes on-chain to buy back and burn supply. No admin key, no pause button. Just code that keeps bidding.

Buy {t.ticker} ↗ See the mechanism ● Live buybacks
{/* featured live buyback card */}
Live · last buyback executed
{fmtUSD(live.lastBuyback)}
Spent from the fee vault to market-buy {t.ticker}. Bought tokens were routed to 0x000…dead.
Block {fmtNum(live.block)}
Tokens bought {fmtNum(291_428)} {t.ticker}
30d bought back {fmtUSD(live.totalBought)}
Pending in vault {fmtUSD(live.pending, 2)}
{/* meta grid */}
Market cap
{fmtUSD(4_280_000)}
▲ +$520k · 24h
Holders
{fmtNum(12_408)}
▲ +342 today
Burned supply
5.82%
of 1,000,000,000 {t.ticker}
Chain
Solana · SPL
Immutable · no proxy
); } // ---------- MARQUEE ---------- function Marquee({ t }) { const items = [ [`${t.ticker}/USD 0.04281`, "up"], [`24H +12.4%`, "up"], [`VOL $1.28M`, null], [`BUYBACK POOL $248.32`, null], [`LAST BB $12,480`, "up"], [`HOLDERS 12,408`, null], [`FEE ${t.feePercent}%`, null], [`SPLIT ${t.buybackSplit}% → BB / ${100 - t.buybackSplit}% → LP`, null], [`CHAIN SOLANA`, null], [`STATUS RUNNING IN REVERSE`, null], ]; const row = [...items, ...items].map(([txt, cls], i) => ( ◆ {txt} )); return (
{row}
); } // ---------- MECHANISM ---------- function Mechanism({ t }) { const steps = [ { n: "01", icon: "$", h: "User trades", d: `Any buy or sell on ${t.ticker} triggers a ${t.feePercent}% fee, collected automatically at the protocol layer.` }, { n: "02", icon: "/", h: "Fees pool", d: "Fees accumulate in a transparent on-chain vault. Anyone can read it — nobody can withdraw it." }, { n: "03", icon: "⇢", h: "Auto-route", d: `Every 200 blocks, ${t.buybackSplit}% of the vault market-buys ${t.ticker} from the open market.`, hot: true }, { n: "04", icon: "×", h: "Supply burned", d: `Bought tokens are sent to a dead address. Float shrinks. Floor compounds.` }, ]; return (
01 · Mechanism

The fees don't leave.
They come home.

Most tokens leak value to treasuries, LPs, or a dev wallet. {t.ticker} routes{" "} {t.buybackSplit}% of every fee directly into on-chain buybacks. It's a tight loop, written into the token itself — no multisig, no timelock, no trust required.

{steps.map((s) => (
{s.icon}
STEP {s.n}
{s.h}
{s.d}
))}
Flow of funds
{`   TRADE              FEE                VAULT
   ┌─────┐   ${t.feePercent}%    ┌─────┐           ┌──────────┐
   │ USD │ ───────→ │ FEE │ ────────→ │  VAULT   │
   └─────┘          └─────┘           └────┬─────┘
                                           │ every 200 blocks
                           ${t.buybackSplit}% ┌──────────┴──────────┐ ${100 - t.buybackSplit}%
                              ↓                           ↓
                         ┌────────┐                 ┌─────────┐
                         │ BUYBACK│ ──→ BURN       │   LP    │
                         └────────┘                 └─────────┘
`}
Why it works
    {[ ["Demand floor", "Every fee becomes a buy. Volume alone sustains price pressure."], ["Supply sink", "Bought tokens go to a dead address. Float only shrinks."], ["No gatekeeper", "The buyback runs in the contract. No admin key. No pausing."], ["Fully auditable", "Every receipt is on-chain. We print them to the ledger below."], ].map(([h, d]) => (
  • →

    {h}

    {d}

    • ))}
); } // ---------- STATS + LEDGER ---------- function StatsAndLedger({ t }) { const stats = [ { k: "Fees collected · all-time", v: fmtUSD(3_124_820), d: "+$8,240 today", cls: "" }, { k: `${t.ticker} bought back`, v: fmtNum(58_204_910), d: "73.2% of fee pool", cls: "cyan" }, { k: `${t.ticker} burned`, v: fmtNum(58_204_910), d: "100% of buybacks", cls: "pink" }, { k: "Buyback events", v: fmtNum(1842), d: "every ~200 blocks", cls: "green" }, ]; const rows = useMemo(() => { const r = rand(11); const out = []; for (let i = 0; i < 8; i++) { const amt = Math.round((120 + r() * 24_000)); const tokens = Math.round(amt / 0.0428); const mins = Math.round(r() * 600); out.push({ id: `BB-${String(8421904 - i * 200).slice(-6)}`, time: mins < 60 ? `${mins}m ago` : `${Math.floor(mins / 60)}h ${mins % 60}m ago`, amt, tokens, }); } return out; }, []); return (
02 · By the numbers

Proof, not promises.

Every fee collected, every token bought, every burn — printed to the ledger. Updated block-by-block. This page reflects the on-chain state.

{stats.map((s) => (
{s.k}
{s.v}
▲ {s.d}
))}
Recent buybacks
● LIVE · refreshes every block
ID Time Tokens bought USD routed Status
{rows.map((r) => (
{r.id} {r.time} {fmtNum(r.tokens)} {t.ticker} {fmtUSD(r.amt)} BURN
))}
); } // ---------- WORDMARK ---------- function Wordmark({ t }) { const block = (key) => [ PRINT., ◆, BURN., ◆, REPEAT., ///, {t.ticker}, ◆, ]; return (
{block("a")}{block("b")}{block("c")}
); } // ---------- ROADMAP ---------- function Roadmap({ t }) { const phases = [ { n: "Phase 01", title: "Press start", done: true, items: ["Token deployed on Solana", "Buyback contract audited", "Liquidity locked · 24 months", "First 10k holders"] }, { n: "Phase 02", title: "Distribute", done: true, items: ["CEX listings · 3 major", "Ledger explorer v1", "Auto-burn activated", "Community grants open"] }, { n: "Phase 03", title: "Print loop", done: false, items: ["Cross-chain buybacks · Base, BNB", "On-chain receipts widget", "Partner integrations", "Dashboard v2"] }, { n: "Phase 04", title: "The endgame", done: false, items: ["Buyback-as-a-service SDK", "Public index of BB tokens", "Sub-second settlement", "Float approaches zero"] }, ]; return (
03 · Roadmap

From fee loop to infrastructure.

{t.ticker} starts as a memecoin with a working mechanism. The goal is to make that mechanism the default — a standard every new token can plug into.

{phases.map((p) => (
{p.n} · {p.done ? "shipped" : "in flight"}
{p.title}
    {p.items.map((it) =>
  • {it}
    • )}
))}
); } // ---------- BUY ---------- function Buy({ t }) { const [copied, setCopied] = useState(false); const addr = "BrRRfeeP1nTrXm0n3yP0w3rM1ntF33dL00pS0l"; const copy = () => { navigator.clipboard?.writeText(addr); setCopied(true); setTimeout(() => setCopied(false), 1500); }; return (
04 · How to buy

Four steps. No permission slip.

{[ ["Get a Solana wallet", "Phantom, Solflare, Backpack — any SPL-compatible wallet works. Fund it with SOL from your exchange of choice."], [`Copy the ${t.ticker} contract`, "Use the official contract address on the right. Always verify the first and last 6 characters — impostors are inevitable."], ["Swap on Jupiter or Raydium", "Paste the contract into your DEX of choice. Set slippage to 2%. Hit confirm. Your trade itself contributes to the next buyback."], ["Hold. Watch the ledger.", `Every 200 blocks you'll see a new entry in the ledger above. That's your fee — coming home as a buyback.`], ].map(([h, d], i) => (
0{i + 1}

{h}

{d}

))}
Contract · Solana
{addr}
ChainSolana · SPL
Supply1,000,000,000
Fee{t.feePercent}% · buy + sell
Buyback split{t.buybackSplit}%
BurnAutomatic
LP lock24 months
TaxesImmutable
Jupiter ↗ Raydium ↗
); } // ---------- FAQ ---------- function FAQ({ t }) { const [open, setOpen] = useState(0); const qs = [ [`Is ${t.ticker} a memecoin or a utility token?`, `Both. The meme is the mechanism. ${t.ticker} is transparently a memecoin — no pretense of product-market fit — but it carries a working buyback loop that behaves more like protocol infrastructure than marketing copy.`], ["Where does the fee go if it's not buying back?", `The ${100 - t.buybackSplit}% that doesn't go to buybacks refills the liquidity pool, which keeps slippage low and trades deep. Nothing is sent to a team wallet. There is no team wallet.`], ["Can the buyback be paused or rug-pulled?", "No. The buyback logic lives inside the token itself, not a separate contract controlled by an admin. There is no pause function, no upgrade proxy, and no admin key. The code is the contract."], ["How often does the buyback execute?", "Every 200 blocks on Solana — roughly every 80 seconds. Each execution prints a receipt to the on-chain ledger, mirrored on this page."], ["What happens to the bought tokens?", `They're sent to 0x000…dead — a provably-unspendable address. This permanently shrinks float. Every fee makes the remaining supply scarcer.`], ["Who pays for the buyback transaction gas?", "The buyback tx is paid from the fee vault itself — never from users. On Solana, the cost is under a cent per execution."], ]; return (
05 · FAQ

Questions, answered on the record.

{qs.map(([q, a], i) => (
setOpen(open === i ? -1 : i)}>

{q}

+
{a}
))}
); } // ---------- FOOTER ---------- function Footer({ t }) { return ( ); } // ---------- APP ---------- function App() { const [t, setTweak] = useTweaks(TWEAK_DEFAULTS); useEffect(() => { const root = document.documentElement; root.style.setProperty("--violet", t.primary); root.style.setProperty("--pink", t.secondary); root.style.setProperty( "--grad-primary", `linear-gradient(135deg, ${t.primary} 0%, ${t.secondary} 100%)` ); root.style.setProperty( "--grad-spectrum", `linear-gradient(90deg, var(--cyan) 0%, ${t.primary} 50%, ${t.secondary} 100%)` ); }, [t.primary, t.secondary]); return ( <>