diff --git a/app/.env.example b/app/.env.example
index 8b82b5fa..5c2f0c4b 100644
--- a/app/.env.example
+++ b/app/.env.example
@@ -52,6 +52,9 @@ IMAGE_STORE=local
# Earn (deposit idle USDC into the reviewed Morpho vault from /me, docs/earn.md) is OFF unless this is "on". On Fly:
# `fly secrets set EARN=on` restarts the app, no deploy; any other value (or unsetting it) switches it off again.
# EARN=on
+# Boost (TWIG sent to 0x…dEaD for a place in the Boosted lane, docs/boost.md) is OFF unless this is "on". On Fly:
+# `fly secrets set BOOST=on` restarts the app, no deploy; any other value (or unsetting it) switches it off again.
+# BOOST=on
# Wallets allowed to moderate posts (comma-separated, lowercase)
ADMIN_WALLETS=
diff --git a/app/db/concurrent-indexes.sql b/app/db/concurrent-indexes.sql
index 5c39f688..e02ee3a2 100644
--- a/app/db/concurrent-indexes.sql
+++ b/app/db/concurrent-indexes.sql
@@ -15,3 +15,5 @@ CREATE INDEX CONCURRENTLY IF NOT EXISTS bb_launch_swaps_trader_idx ON bb_launch_
-- to the season's last block; and transfers out of a launcher or a fee recipient (who got the token from them)
CREATE INDEX CONCURRENTLY IF NOT EXISTS bb_token_transfers_to_idx ON bb_token_transfers (chain_id, token, to_addr, block_number);
CREATE INDEX CONCURRENTLY IF NOT EXISTS bb_token_transfers_from_idx ON bb_token_transfers (chain_id, token, from_addr, block_number);
+-- boosts (2026-10-15): a boost names its launch by position id; the lane joins on it
+CREATE INDEX CONCURRENTLY IF NOT EXISTS bb_launches_chain_token_id_idx ON bb_launches (chain_id, token_id);
diff --git a/app/db/schema.sql b/app/db/schema.sql
index 9a3e5448..cb4814bb 100644
--- a/app/db/schema.sql
+++ b/app/db/schema.sql
@@ -429,3 +429,22 @@ ALTER TABLE bb_seasons ADD COLUMN IF NOT EXISTS computed_until timestamptz; --
ALTER TABLE bb_seasons ADD COLUMN IF NOT EXISTS published_at timestamptz; -- first publish: the season's clock starts here
CREATE INDEX IF NOT EXISTS bb_points_creator_idx ON bb_points (season_id, rank_creator) WHERE rank_creator IS NOT NULL;
CREATE INDEX IF NOT EXISTS bb_points_scout_idx ON bb_points (season_id, rank_scout) WHERE rank_scout IS NOT NULL;
+
+-- ── boosts (TWIG sent to 0x…dEaD for a place in the Boosted lane; lib/launchpad/boost.ts) ──────────────────────────
+-- Raw facts from TWIG Transfer logs to 0x…dEaD on Base whose amount names a launch in its last 12 digits: the tag is
+-- that launch's bb_launches.token_id (its position id). The launch is joined at read time, so a boost indexed before
+-- its launch still counts once the launch is in. Never read by the Live sort, the Trending board or ranking.ts.
+CREATE TABLE IF NOT EXISTS bb_boosts (
+ chain_id integer NOT NULL,
+ tx_hash text NOT NULL,
+ log_index integer NOT NULL,
+ booster text NOT NULL, -- the Transfer's sender (a smart wallet itself, never its bundler)
+ amount numeric(78,0) NOT NULL, -- raw TWIG, the tag included
+ tag bigint NOT NULL, -- amount mod 10^12
+ block_number bigint NOT NULL,
+ block_time timestamptz NOT NULL,
+ PRIMARY KEY (chain_id, tx_hash, log_index)
+);
+CREATE INDEX IF NOT EXISTS bb_boosts_time_idx ON bb_boosts (chain_id, block_time DESC);
+CREATE INDEX IF NOT EXISTS bb_boosts_tag_idx ON bb_boosts (chain_id, tag);
+ALTER TABLE bb_token_settings ADD COLUMN IF NOT EXISTS boost_hidden boolean NOT NULL DEFAULT false; -- admin: kept out of the Boosted lane
diff --git a/app/src/app/(home)/page.tsx b/app/src/app/(home)/page.tsx
index a9f2737f..cfb3a476 100644
--- a/app/src/app/(home)/page.tsx
+++ b/app/src/app/(home)/page.tsx
@@ -15,6 +15,8 @@ import { isFilter } from "@/lib/launchpad/search";
import { nowMs } from "@/lib/launchpad/time";
import { feedKey, inRiverWindow, riverCoverage } from "@/lib/launchpad/river";
import TrendingStrip from "@/components/launchpad/TrendingStrip";
+import BoostedLane from "@/components/launchpad/BoostedLane";
+import { boostLaneOrNull } from "@/lib/launchpad/boostServer";
import LaunchPill from "@/components/launchpad/LaunchPill";
import WhyFree from "@/components/launchpad/WhyFree";
import { MagicCard } from "@/components/vendor/magic-card";
@@ -36,12 +38,13 @@ export default async function Home({ searchParams }: { searchParams: Promise<{ s
const usd = await ethUsd();
const layout = parseLayout((await cookies()).get(LAYOUT_COOKIE)?.value);
const listOpts = { sort, window, chain, filter, limit: PAGE_SIZE, ethUsd: usd };
- const [page, feed, fresh, posts, fetchedTrending] = await Promise.all([
+ const [page, feed, fresh, posts, fetchedTrending, boost] = await Promise.all([
listLaunchesPage(listOpts),
getLaunchFeed(RIVER_SEED, usd),
listLaunchesPage({ sort: "new", limit: JUST_LAUNCHED_SIZE, ethUsd: usd }),
listFeed(30),
isTrendingSource(listOpts) ? null : getTrending(usd),
+ boostLaneOrNull(usd),
]);
const trending = await withBoardTape(fetchedTrending ?? trendingFrom(page.items)); // the default view's first page doubles as the strip's candidates; the tapes are the cards' recent trades
const now = nowMs();
@@ -52,6 +55,8 @@ export default async function Home({ searchParams }: { searchParams: Promise<{ s
{/* what is hot first (names and numbers to act on), then the last half hour as it happens, then every launch */}
item.kind === "swap").map(feedKey)} />
+ {/* paid and labelled, after the facts-only board and never inside it (boost.ts); nothing while BOOST is off */}
+ inRiverWindow(item, now))} recent={feed} serverNow={now} coveredSince={riverCoverage(feed, RIVER_SEED, now)} lastActivityAt={feed[0] ? new Date(feed[0].at).getTime() : 0} />
diff --git a/app/src/app/admin/page.tsx b/app/src/app/admin/page.tsx
index 20f50eab..a4cd8e85 100644
--- a/app/src/app/admin/page.tsx
+++ b/app/src/app/admin/page.tsx
@@ -2,6 +2,7 @@ import type { Metadata } from "next";
import AdminQueue from "@/components/launchpad/AdminQueue";
import ProfileQueue from "@/components/profile/ProfileQueue";
import PointsAdmin from "@/components/points/PointsAdmin";
+import BoostAdmin from "@/components/launchpad/BoostAdmin";
export const metadata: Metadata = { title: "Moderation", robots: { index: false, follow: false } };
export const dynamic = "force-dynamic";
@@ -12,11 +13,12 @@ export default function AdminPage() {
Moderation
-
Reported posts, profiles and season points. Every action is a signature from an admin wallet.
+
Reported posts, profiles, season points and the Boosted lane. Every action is a signature from an admin wallet.
+
);
}
diff --git a/app/src/app/api/boost/mod/route.ts b/app/src/app/api/boost/mod/route.ts
new file mode 100644
index 00000000..f5c41a26
--- /dev/null
+++ b/app/src/app/api/boost/mod/route.ts
@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { rateLimited } from "@/lib/launchpad/editServer";
+import { clientIp, readJson } from "@/lib/profiles/http";
+import { moderateBoost } from "@/lib/launchpad/boostServer";
+
+export const dynamic = "force-dynamic";
+
+/** POST {action: hide|unhide, token, wallet, nonce, ts, signature}: an admin wallet keeps a Base token out of the Boosted lane, or lets it back. */
+export async function POST(req: Request) {
+ if (rateLimited(`boost-mod:ip:${clientIp(req)}`, 30)) return NextResponse.json({ error: "slow down" }, { status: 429 });
+ const b = await readJson(req);
+ if (!b) return NextResponse.json({ error: "bad json" }, { status: 400 });
+ const r = await moderateBoost({ action: b.action, token: b.token, wallet: b.wallet, nonce: b.nonce, ts: b.ts, signature: b.signature });
+ if (!r.ok) return NextResponse.json({ error: r.error }, { status: r.status });
+ return NextResponse.json(r);
+}
diff --git a/app/src/app/api/boost/route.ts b/app/src/app/api/boost/route.ts
new file mode 100644
index 00000000..235c2f60
--- /dev/null
+++ b/app/src/app/api/boost/route.ts
@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+import { isAddress } from "viem";
+import { rateLimited } from "@/lib/launchpad/editServer";
+import { clientIp } from "@/lib/profiles/http";
+import { ethUsd } from "@/lib/launchpad/ethPrice";
+import { BOOST_CHAIN } from "@/lib/launchpad/boost";
+import { boostEnabled, getBoostLane, getTokenBoost } from "@/lib/launchpad/boostServer";
+
+export const dynamic = "force-dynamic";
+
+const NO_STORE = { "cache-control": "no-store" };
+
+/**
+ * GET /api/boost?chain=base → the Boosted lane (`{ enabled, window_h, floor_twig, items }`), or `{ enabled: false }`
+ * while the BOOST switch is off. GET /api/boost?chain=base&token=0x… → one token's boost state (TWIG in the last 24
+ * hours, its place in the lane, whether it is hidden). Boosts exist on Base only. Rate limited per IP.
+ */
+export async function GET(req: Request) {
+ if (rateLimited(`boost:ip:${clientIp(req)}`, 60)) return NextResponse.json({ error: "slow down" }, { status: 429 });
+ const u = new URL(req.url);
+ const chain = u.searchParams.get("chain") ?? BOOST_CHAIN;
+ if (chain !== BOOST_CHAIN) return NextResponse.json({ error: "boosts are on Base only" }, { status: 400 });
+ if (!boostEnabled()) return NextResponse.json({ enabled: false }, { headers: NO_STORE });
+ const token = u.searchParams.get("token");
+ try {
+ if (token !== null) {
+ if (!isAddress(token)) return NextResponse.json({ error: "bad token" }, { status: 400 });
+ return NextResponse.json(await getTokenBoost(token), { headers: NO_STORE });
+ }
+ return NextResponse.json(await getBoostLane(await ethUsd()), { headers: NO_STORE });
+ } catch (err) {
+ console.error("[boost] read failed:", err instanceof Error ? err.message : err);
+ return NextResponse.json({ error: "could not load boosts" }, { status: 502 });
+ }
+}
diff --git a/app/src/app/api/launch/live/route.ts b/app/src/app/api/launch/live/route.ts
index 6f3b699d..cc32155a 100644
--- a/app/src/app/api/launch/live/route.ts
+++ b/app/src/app/api/launch/live/route.ts
@@ -7,10 +7,15 @@ import { ethUsd } from "@/lib/launchpad/ethPrice";
import { memo } from "@/lib/launchpad/memo";
import { listFeed } from "@/lib/launchpad/postsServer";
import { FEED_POSTS_LIMIT, feedPostsKey } from "@/lib/launchpad/posts-paging";
+import { boostEnabled, boostLaneOrNull } from "@/lib/launchpad/boostServer";
export const dynamic = "force-dynamic";
-/** One request for everything live on a page (feed, totals, optional list). Polled every ~5s by LiveProvider. */
+/**
+ * One request for everything live on a page (feed, totals, optional list). Polled every ~5s by LiveProvider. Every
+ * answer says whether BOOST is on (one boolean); the Boosted lane itself comes only with ?boost=1, which LiveProvider
+ * adds while a lane is on screen, so other pages never download its cards.
+ */
export async function GET(req: Request) {
const u = new URL(req.url);
const sort = parseSort(u.searchParams.get("sort"), null);
@@ -21,21 +26,24 @@ export async function GET(req: Request) {
const f = u.searchParams.get("filter");
const filter = isFilter(f) ? f : null;
const limit = clampLimit(u.searchParams.get("limit"), 40);
+ const wantsBoost = u.searchParams.get("boost") === "1";
try {
const usd = await ethUsd();
const listOpts = sort ? { sort, window, chain, filter, limit, offset: 0, ethUsd: usd } : null;
// the home list's first page is the strip's candidate set: rank it instead of running the live query a second time;
// any other view fetches the strip in the same batch as everything else
const deriveTrending = listOpts !== null && isTrendingSource(listOpts);
- const [feed, totals, page, posts, fetchedTrending] = await Promise.all([
+ const [feed, totals, page, posts, fetchedTrending, boost] = await Promise.all([
memo("feed", 2_000, () => getLaunchFeed(24, usd)),
memo("totals", 2_000, () => getLaunchTotals(usd)),
listOpts ? memo(`list:${chain ?? "all"}:${sort}:${window}:${filter ?? "-"}:${limit}`, 2_000, () => listLaunchesPage(listOpts)) : Promise.resolve(null),
memo(feedPostsKey(0), 2_000, () => listFeed(FEED_POSTS_LIMIT, 0)), // the same entry /api/posts?feed=1 serves
deriveTrending ? Promise.resolve(null) : memo("trending", 2_000, () => getTrending(usd)),
+ // the switch is read on every poll, so turning BOOST off reaches open tabs within one tick; a failed read sends nothing
+ wantsBoost ? boostLaneOrNull(usd) : Promise.resolve(null),
]);
const trending = fetchedTrending ?? trendingFrom(page?.items ?? []);
- return NextResponse.json({ at: Date.now(), feed, totals, ethUsd: usd, sort, window, chain, filter, limit, has_more: page?.hasMore ?? null, launches: page?.items ?? null, posts, trending }, { headers: { "cache-control": "no-store" } });
+ return NextResponse.json({ at: Date.now(), feed, totals, ethUsd: usd, sort, window, chain, filter, limit, has_more: page?.hasMore ?? null, launches: page?.items ?? null, posts, trending, boost_on: boostEnabled(), boost: boost ?? undefined }, { headers: { "cache-control": "no-store" } });
} catch (err) {
console.error("[launch] live failed:", err instanceof Error ? err.message : err);
return NextResponse.json({ error: "could not load live snapshot" }, { status: 502 });
diff --git a/app/src/app/api/launch/sync/route.ts b/app/src/app/api/launch/sync/route.ts
index 9d2b060b..6b6b5ef0 100644
--- a/app/src/app/api/launch/sync/route.ts
+++ b/app/src/app/api/launch/sync/route.ts
@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
import { DEFAULT_CHAIN, isChainKey } from "@/lib/chainPublic";
import { rateLimited } from "@/lib/launchpad/editServer";
import { applyLaunchTx, pollAll } from "@/lib/launchpad/indexer";
+import { forgetBoostLane } from "@/lib/launchpad/boostServer";
export const dynamic = "force-dynamic";
@@ -19,7 +20,10 @@ export async function POST(req: Request) {
if (!/^0x[0-9a-fA-F]{64}$/.test(tx)) return NextResponse.json({ error: "bad tx" }, { status: 400 });
if (!isChainKey(chain)) return NextResponse.json({ error: "bad chain" }, { status: 400 });
try {
- return NextResponse.json(await applyLaunchTx(chain, tx as `0x${string}`));
+ const r = await applyLaunchTx(chain, tx as `0x${string}`);
+ // a boost just indexed: this machine's next lane read is fresh, so the booster sees their place at once
+ if (r.boosts) forgetBoostLane();
+ return NextResponse.json(r);
} catch (err) {
return NextResponse.json({ error: err instanceof Error ? err.message : "sync failed" }, { status: 502 });
}
diff --git a/app/src/app/globals.css b/app/src/app/globals.css
index 14dbe376..4423f0bd 100644
--- a/app/src/app/globals.css
+++ b/app/src/app/globals.css
@@ -350,6 +350,15 @@ input[type="number"] { -moz-appearance: textfield; appearance: textfield; }
.bb-card-sell { animation: bb-card-sell 2.2s ease-out 1; }
@media (prefers-reduced-motion: reduce) { .bb-row-new, .bb-row-buy, .bb-row-sell, .bb-card-new, .bb-card-buy, .bb-card-sell { animation: none; } }
+/* Boosted lane (BoostedLane.tsx): a card lights up once when a boost lands on it. Decorative: the amounts carry the
+ facts. The ring is inset, so the lane's clipped corners never cut it. Reduced motion keeps the colour, drops the
+ embers and the pop. */
+@keyframes bb-boost-ring { 0% { box-shadow: inset 0 0 0 2px var(--color-warm), inset 0 0 36px -10px var(--color-warm); } 100% { box-shadow: inset 0 0 0 2px transparent, inset 0 0 36px -10px transparent; } }
+.bb-boost-ring { animation: bb-boost-ring 2.4s ease-out 1 both; }
+@keyframes bb-ember { 0% { opacity: 0; transform: translate(0, 0) scale(1); } 12% { opacity: 1; } 100% { opacity: 0; transform: translate(var(--dx), var(--dy)) scale(0.3); } }
+.bb-ember { animation: bb-ember 1.2s cubic-bezier(0.2, 0.7, 0.3, 1) 1 both; box-shadow: 0 0 6px var(--color-warm); }
+@media (prefers-reduced-motion: reduce) { .bb-ember { display: none; } }
+
/* ── loading system: route progress bar, skeleton shimmer, spinner ─────────── */
/* scaleX rather than width: the bar animates on the compositor instead of
re-running layout on every frame. transform-origin pins it to the left edge. */
diff --git a/app/src/app/layout.tsx b/app/src/app/layout.tsx
index 0571eeb9..5f927e71 100644
--- a/app/src/app/layout.tsx
+++ b/app/src/app/layout.tsx
@@ -7,6 +7,7 @@ import TxToasts from "@/components/launchpad/TxToasts";
import LiveProvider from "@/components/launchpad/LiveProvider";
import { getLaunchFeed, getLaunchTotalsForRequest } from "@/lib/launchpad/queries";
import { ethUsd } from "@/lib/launchpad/ethPrice";
+import { boostEnabled } from "@/lib/launchpad/boostSwitch";
import { SITE_URL } from "@/lib/chainPublic";
import { BRAND, BRAND_DOMAIN, BRAND_GITHUB, BRAND_X, SITE_DESCRIPTION, SITE_TITLE, SOCIAL_DESCRIPTION } from "@/lib/brand";
import { siteJsonLdHtml, siteVerification } from "@/lib/seo";
@@ -49,7 +50,7 @@ export default async function RootLayout({ children }: { children: React.ReactNo
-
+
diff --git a/app/src/app/llms.txt/route.ts b/app/src/app/llms.txt/route.ts
index b54d28aa..f0aacdb8 100644
--- a/app/src/app/llms.txt/route.ts
+++ b/app/src/app/llms.txt/route.ts
@@ -1,6 +1,24 @@
import { SITE_URL } from "@/lib/chainPublic";
import { launchpad } from "@/lib/launchpad/config";
import { BRAND_DOMAIN, BRAND_GITHUB } from "@/lib/brand";
+import { boostEnabled } from "@/lib/launchpad/boostServer";
+import { BOOST_FLOOR_TWIG, BOOST_TOKEN, BOOST_WINDOW_H } from "@/lib/launchpad/boost";
+
+/** The Boost section, only while the switch is on (boost.ts holds the rule). */
+function boostSection(): string {
+ if (!boostEnabled()) return "";
+ return `
+## Boost (Base, optional, paid in TWIG)
+A separate "Boosted" lane on the home page: the 5 tokens with the most TWIG sent to 0x000000000000000000000000000000000000dEaD for them in the last ${BOOST_WINDOW_H}h.
+It is not part of the ranking: sort=live and the Trending board count outside wallets only. Nothing is paid to openlaunch.
+To boost a launch: TWIG (${BOOST_TOKEN}).transfer(0x…dEaD, amount) with amount = whole * 10^18 + token_id
+(whole = a count of whole TWIG, at least ${BOOST_FLOOR_TWIG}; token_id = the launch's position id, the list API's token_id field,
+greater than 0 and less than 10^11). The last 12 digits name the launch; a transfer outside these bounds is not a boost.
+Then POST ${SITE_URL}/api/launch/sync?chain=base&tx=0x… to show it at once. Burns are final.
+- GET ${SITE_URL}/api/boost?chain=base (the lane: twig, boosts, last_at, expires_at, launch)
+- GET ${SITE_URL}/api/boost?chain=base&token=0x… (one token: twig in the window, place, hidden)
+`;
+}
export const dynamic = "force-dynamic";
@@ -67,6 +85,7 @@ Optional metadata: POST ${SITE_URL}/api/launch/meta {chain, launcher, salt, name
Recommended: buy a little right after launch (a Universal Router swap on the new pool; the site's form suggests ≈ $25). A token with no
holder and no price move reads as dead on screeners and sits under "quiet launches" on the home page until an outside wallet trades it.
+${boostSection()}
## API
- GET ${SITE_URL}/api/launch/list?chain=base|robinhood|arc&sort=live|new|mcap|volume|gainers|holders&window=1h|24h|all&limit=50
sort=live (the home page default; "trending" is an alias): tokens an outside wallet traded in the last 24h first, ranked by outside
diff --git a/app/src/app/rules/page.tsx b/app/src/app/rules/page.tsx
index fad98740..32edcf7a 100644
--- a/app/src/app/rules/page.tsx
+++ b/app/src/app/rules/page.tsx
@@ -10,6 +10,8 @@ import { CHAINS, CHAIN_KEYS, CHAIN_LABELS, explorerAddress } from "@/lib/chainPu
import { BRAND_GITHUB } from "@/lib/brand";
import LaunchMachine from "@/components/launchpad/LaunchMachine";
import { ChainLogo } from "@/components/launchpad/ChainLogo";
+import BoostRulesEntry from "@/components/launchpad/BoostRulesEntry";
+import { boostEnabled } from "@/lib/launchpad/boostServer";
import { RULES } from "@/lib/points/score";
export const metadata: Metadata = pageMetadata({ path: "/rules", title: "How it works", description: "What a launch does on-chain, what it costs (gas), and what can never happen to your liquidity." });
@@ -131,6 +133,7 @@ export default function RulesPage() {
How does the price move?
Price follows a single-sided Uniswap v4 curve: the first buyers get the most tokens per unit of the quote asset, and every buy moves the price up. Sells move it down.
There is no anti-snipe mechanism. Bots can buy in the first block like anyone else.
The launch form suggests a small first buy (about $25) so your token opens with a holder and a price; clear it and the launch stays free.
Why is my token under “quiet launches”?
The home page ranks by facts, not by launch order. A token is live once a wallet other than its launcher has traded it in the last 24 hours; trades in the launch block and the next three blocks (snipe bots) don't count, and neither do the launcher's own. Live tokens rank by outside wallets in the last hour, then today, then by their last outside trade. A wallet's newest launch gets its first hour on the board regardless; after that it sits under quiet launches, one row per wallet, until someone trades it.
Nothing is hidden: every launch stays in the New tab, in search and in the API. The only way up is a trade from an outside wallet.
+ {boostEnabled() ? : null}
What can change after launch?
Nothing on-chain can be edited after launch: not the name, not the fee, not the beneficiaries. Metadata (image, description, links) is stored by this site and can change; the token itself cannot.
What is a TWIG- or GITLAWB-quoted pool?
TWIG is Twigpine's token on Base: a 1:1 wrapper of GITLAWB. Anyone can wrap GITLAWB into TWIG, or unwrap it back, at any time with no fee, and every TWIG is backed by one GITLAWB held in its contract, which has no owner and no transfer restrictions. It is the quote the Base form offers: pick it and buyers pay in TWIG; any trading fee is paid in TWIG to the beneficiaries named at launch (by their shares) when it is collected, and a launch that names none has its TWIG fees burned when they are collected.
GITLAWB is Twigpine's token on Base, bridged 1:1 to Robinhood Chain over LayerZero (one supply, two chains): an ordinary ERC-20 with no transfer restrictions and no issuer switch. The Robinhood Chain form offers it; on Base, pools already paired with GITLAWB keep their badge and price. Fees work the same way: paid in GITLAWB when collected, and a launch that names no beneficiary has its GITLAWB fees burned when they are collected.
Dollar figures for both come from the Uniswap v4 WETH/GITLAWB pool price on Base, cross-checked against a 30-minute on-chain average, and ETH/USD; one TWIG counts as one GITLAWB, since it unwraps to one. They are for display and sorting only; nothing on-chain depends on them.
What should I know about stock-quoted pools?
Stock-quoted pools use tokenized stocks as the quote asset: Coinbase tokenized stocks (B20) on Base, recognised here only from Coinbase's official list and priced in dollars where Chainlink publishes an on-chain feed (the others show no dollar price); Robinhood Stock Tokens on Robinhood Chain, recognised only from Robinhood's own registry.
Both are securities issued by third parties under Regulation S and are not offered to US persons. Coinbase's also exclude the UK, Canada, Australia, Singapore and Switzerland. Their issuers can pause transfers or freeze wallets in restricted jurisdictions. Holding or trading them is subject to the issuer's terms, not ours.
diff --git a/app/src/app/t/[chain]/[token]/page.tsx b/app/src/app/t/[chain]/[token]/page.tsx
index 8df1728c..d40eebba 100644
--- a/app/src/app/t/[chain]/[token]/page.tsx
+++ b/app/src/app/t/[chain]/[token]/page.tsx
@@ -50,6 +50,11 @@ import WatchButton from "@/components/launchpad/WatchButton";
import { BorderBeam } from "@/components/vendor/border-beam";
import { Banner } from "@/components/launchpad/LaunchCard";
import { ChainLogo } from "@/components/launchpad/ChainLogo";
+import BoostPanel from "@/components/launchpad/BoostPanel";
+import { boostEnabled, getTokenBoost, type TokenBoost } from "@/lib/launchpad/boostServer";
+import { BOOST_CHAIN } from "@/lib/launchpad/boost";
+import { gitlawbUsd } from "@/lib/launchpad/gitlawbServer";
+import { twigUsdFromGitlawb } from "@/lib/launchpad/twig";
import type { ProofKey } from "@/lib/launchpad/proof";
/** Where GITLAWB lives, as said beside a GITLAWB-quoted pool. */
@@ -76,7 +81,7 @@ export async function generateMetadata({ params }: { params: Promise<{ chain: st
}
/** A token's page: market, chart, trades, holders and comments, with every wallet named by its profile where it has one. */
-export default async function TokenPage({ params }: { params: Promise<{ chain: string; token: string }> }) {
+export default async function TokenPage({ params, searchParams }: { params: Promise<{ chain: string; token: string }>; searchParams: Promise<{ boost?: string }> }) {
const { chain, token } = await params;
if (!isChainKey(chain) || !isAddress(token)) notFound();
const usd = await ethUsd();
@@ -93,7 +98,16 @@ export default async function TokenPage({ params }: { params: Promise<{ chain: s
};
const unlisted = quote.key === "other";
const stockQuote = quote.key === "stock" ? stockByAddress(chain, l.quote) : null;
- const [swaps, holders, tint] = await Promise.all([getSwaps(chain, l.token, quote.decimals, 40), memo(`holders:${chain}:${l.token}`, 5_000, () => getHolderPanel(chain, l.token)), tokenTint(l.image_url, l.token)]);
+ // Boost (Base only, while the switch is on): the token's line and TWIG's price for the dialog; a failed read shows no panel
+ const boostable = chain === BOOST_CHAIN && boostEnabled();
+ const [swaps, holders, tint, boost, twigUsd] = await Promise.all([
+ getSwaps(chain, l.token, quote.decimals, 40),
+ memo(`holders:${chain}:${l.token}`, 5_000, () => getHolderPanel(chain, l.token)),
+ tokenTint(l.image_url, l.token),
+ boostable ? getTokenBoost(l.token).catch((): TokenBoost | null => null) : null,
+ boostable ? gitlawbUsd().then(twigUsdFromGitlawb).catch(() => null) : null,
+ ]);
+ const boostOpen = (await searchParams).boost === "1";
// names for every wallet the server renders (trades, creator, fee recipients, top holders): the first paint shows them
const nameWallets = [l.launcher, ...swaps.map((s) => s.trader), ...l.recipients.map((r) => r.payout), ...(holders?.top ?? []).map((h) => h.address)].filter((w): w is string => Boolean(w));
// a failed lookup seeds nothing (the browser then asks itself); only an answer says "no profile" for a wallet
@@ -238,6 +252,8 @@ export default async function TokenPage({ params }: { params: Promise<{ chain: s
{/* the token at a glance beside the trade box, as other launchpads keep it; the full record is in the About tab */}
+ {/* Boost (Base, while the switch is on): under the About card, which stays right under the trade box */}
+ {boost ? : null}
diff --git a/app/src/components/CommandPalette.tsx b/app/src/components/CommandPalette.tsx
index 4d08d0a4..02768f65 100644
--- a/app/src/components/CommandPalette.tsx
+++ b/app/src/components/CommandPalette.tsx
@@ -13,6 +13,7 @@ import { setPendingToken } from "@/lib/launchpad/token-transition";
import { buildPaletteGroups, isSearchableQuery, paletteTokenFrom, type PaletteGroup, type PaletteItem, type PaletteToken } from "@/lib/command-palette";
import { useOpenBridge } from "./bridge/BridgeProvider";
import { useEarnInfo } from "./earn/earnInfo";
+import { useBoostOn } from "./launchpad/useBoostOn";
type LaunchesResponse = { launches?: Parameters[0][] };
@@ -67,7 +68,9 @@ export default function CommandPalette({ open, onOpenChange }: { open: boolean;
const theme = resolvedTheme === "dark" ? "dark" : "light";
// the Earn entry exists only while the feature is switched on; asked once, on the first open
const earn = useEarnInfo(open)?.enabled === true;
- const groups = useMemo(() => buildPaletteGroups({ query, tokens: current?.tokens ?? [], trending: trending ?? [], theme, earn }), [query, current, trending, theme, earn]);
+ // the Boosted entry follows the live poll's switch: no request of its own
+ const boost = useBoostOn();
+ const groups = useMemo(() => buildPaletteGroups({ query, tokens: current?.tokens ?? [], trending: trending ?? [], theme, earn, boost }), [query, current, trending, theme, earn, boost]);
const status = searching ? "Searching tokens…" : current?.failed ? "Token search is unavailable right now. Pages and actions still work." : "";
const close = () => {
diff --git a/app/src/components/launchpad/BoostAdmin.tsx b/app/src/components/launchpad/BoostAdmin.tsx
new file mode 100644
index 00000000..6bf2732b
--- /dev/null
+++ b/app/src/components/launchpad/BoostAdmin.tsx
@@ -0,0 +1,90 @@
+"use client";
+
+import Link from "next/link";
+import { useCallback, useEffect, useState } from "react";
+import { useConfig } from "wagmi";
+import { getWalletClient } from "wagmi/actions";
+import { isAddress } from "viem";
+import { useHydratedAccount } from "@/lib/useHydratedAccount";
+import { btn, card } from "@/components/ui";
+import type { BoostLane } from "@/lib/launchpad/boostServer";
+import { BOOST_CHAIN, buildBoostModMessage, fmtBoostTwig, type BoostModAction } from "@/lib/launchpad/boost";
+import { CHAINS } from "@/lib/chainPublic";
+import { nowMs } from "@/lib/launchpad/time";
+import { friendlyError } from "@/lib/errors";
+import { nonce } from "@/lib/nonce";
+
+/**
+ * The Boosted lane for moderators: what is in it now, Hide on each card, and Hide / Unhide by address (a hidden token is
+ * no longer listed anywhere, so showing it again takes its address). Each action is an admin-wallet signature. Hiding
+ * never refunds: the TWIG was burned on-chain.
+ */
+export default function BoostAdmin() {
+ const { address } = useHydratedAccount();
+ const config = useConfig();
+ const [lane, setLane] = useState(null);
+ const [target, setTarget] = useState("");
+ const [msg, setMsg] = useState<{ ok: boolean; text: string } | null>(null);
+ // a failed or unreadable answer (a proxy's HTML page) keeps the last list on screen; it never throws from the effect
+ const load = useCallback(async () => {
+ try {
+ const res = await fetch(`/api/boost?chain=${BOOST_CHAIN}`, { cache: "no-store" });
+ if (res.ok) setLane((await res.json()) as BoostLane);
+ } catch {
+ // keep the last lane
+ }
+ }, []);
+ useEffect(() => {
+ const id = setTimeout(() => void load(), 0);
+ return () => clearTimeout(id);
+ }, [load]);
+
+ async function act(token: string, action: BoostModAction) {
+ if (!address) return;
+ try {
+ const n = nonce();
+ const ts = nowMs();
+ const wallet = await getWalletClient(config, { chainId: CHAINS[BOOST_CHAIN].id });
+ const signature = await wallet.signMessage({ message: buildBoostModMessage({ action, token, wallet: address, nonce: n, ts }) });
+ const res = await fetch("/api/boost/mod", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ action, token, wallet: address, nonce: n, ts, signature }) });
+ // an error page that is not JSON (a 502 from the proxy) still reports the HTTP failure, not a parse error
+ const d = (await res.json().catch(() => ({}))) as { error?: string };
+ if (!res.ok) throw new Error(d.error ?? `request failed (HTTP ${res.status})`);
+ setMsg({ ok: true, text: `${action === "hide" ? "Hidden" : "Shown again"}: ${token}` });
+ // a hidden card leaves the list at once; the next read (fresh on the machine that took the write) confirms it
+ if (action === "hide") setLane((l) => (l?.enabled ? { ...l, items: l.items.filter((b) => b.token !== token.toLowerCase()) } : l));
+ await load();
+ } catch (e) {
+ setMsg({ ok: false, text: friendlyError(e) });
+ }
+ }
+
+ if (lane && !lane.enabled) return null;
+ return (
+
+
: null}
+
+ );
+}
diff --git a/app/src/components/launchpad/BoostDialog.tsx b/app/src/components/launchpad/BoostDialog.tsx
new file mode 100644
index 00000000..0d622e96
--- /dev/null
+++ b/app/src/components/launchpad/BoostDialog.tsx
@@ -0,0 +1,245 @@
+"use client";
+
+import Link from "next/link";
+import { useMemo, useRef, useState } from "react";
+import { useConfig, useReadContract, useSwitchChain } from "wagmi";
+import { getPublicClient, getWalletClient } from "wagmi/actions";
+import type { Hex } from "viem";
+import { ArrowUpRight } from "lucide-react";
+import Sheet from "@/components/Sheet";
+import ConnectWallet from "@/components/ConnectWallet";
+import { btn } from "@/components/ui";
+import { Spinner } from "@/components/Skeleton";
+import { useHydratedAccount } from "@/lib/useHydratedAccount";
+import { ERC20_MIN_ABI, ERC20_TRANSFER_ABI } from "@/lib/launchpad/abi";
+import { DEAD } from "@/lib/launchpad/config";
+import { TWIG_WRAP_URL } from "@/lib/launchpad/twig";
+import { fmtUsd } from "@/lib/launchpad/math";
+import { friendlyError } from "@/lib/errors";
+import { BUILDER_DATA_SUFFIX, CHAINS, explorerTx } from "@/lib/chainPublic";
+import {
+ BOOST_CHAIN,
+ BOOST_COPY,
+ BOOST_FLOOR_TWIG,
+ BOOST_PRESETS,
+ BOOST_TOKEN,
+ boostAmount,
+ boostAmountProblem,
+ boostConfirmLabel,
+ boostShowsNow,
+ fmtBoostTwig,
+ type LaneEntry,
+ groupWhole,
+ isLaunchTag,
+ maxBoostWhole,
+ parseBoostWhole,
+} from "@/lib/launchpad/boost";
+import { toast } from "./TxToasts";
+import { TwigMark } from "./TwigBadge";
+
+/** A boost the wallet has sent whose outcome is not known yet; the panel keeps it while the dialog is closed. */
+export type PendingBoost = { hash: Hex; whole: bigint };
+type Phase =
+ | { k: "idle" }
+ | { k: "preparing" }
+ | { k: "signing" }
+ | { k: "sent"; hash: Hex; whole: bigint }
+ | { k: "unconfirmed"; hash: Hex; whole: bigint; checking: boolean; note: string | null }
+ | { k: "done"; hash: Hex; whole: bigint; shows: boolean }
+ | { k: "error"; message: string };
+
+const BASE = CHAINS[BOOST_CHAIN];
+
+/**
+ * Send TWIG to 0x…dEaD for a token's place in the Boosted lane (boost.ts): one plain TWIG.transfer whose amount ends in
+ * the launch's position id. No approval, nothing to sign but the transfer. Whole TWIG only; the floor and the balance
+ * (tag included) are checked before the button wakes, and the transfer is simulated before the wallet is asked.
+ * Sent means sent: once the wallet returns a hash, only a receipt ends the action. A receipt that cannot be read leaves
+ * it unconfirmed and locked, with "Check again", so a slow node never invites a second burn; the panel holds the hash
+ * (`pending`) so closing and reopening the dialog keeps the lock.
+ */
+export default function BoostDialog({ token, tokenId, symbol, name, twigUsd, current, entry, place, pending, onPending, onClose, onBoosted }: { token: string; tokenId: number; symbol: string; name: string; twigUsd: number | null; current: bigint; entry: LaneEntry; place: number | null; pending: PendingBoost | null; onPending: (p: PendingBoost | null) => void; onClose: () => void; onBoosted?: () => void }) {
+ const config = useConfig();
+ const { address, isConnected, chainId } = useHydratedAccount();
+ const { switchChainAsync } = useSwitchChain();
+ const [amount, setAmount] = useState(groupWhole(BOOST_FLOOR_TWIG));
+ const [phase, setPhase] = useState(pending ? { k: "unconfirmed", ...pending, checking: false, note: null } : { k: "idle" });
+ const lock = useRef(false);
+ const tag = BigInt(tokenId);
+ const tagOk = isLaunchTag(tag);
+
+ const bal = useReadContract({ address: BOOST_TOKEN as `0x${string}`, abi: ERC20_MIN_ABI, functionName: "balanceOf", args: address ? [address] : undefined, chainId: BASE.id, query: { enabled: Boolean(address), refetchInterval: 15_000 } });
+ const balance = bal.data as bigint | undefined;
+ const whole = parseBoostWhole(amount);
+ const problem = tagOk ? boostAmountProblem(whole, balance, tag) : "This launch cannot be boosted.";
+ const raw = useMemo(() => (whole !== null && problem === null ? boostAmount(whole, tag) : null), [whole, problem, tag]);
+ const max = balance !== undefined && tagOk ? maxBoostWhole(balance, tag) : null;
+ const busy = phase.k === "preparing" || phase.k === "signing" || phase.k === "sent" || phase.k === "unconfirmed";
+ const usd = whole !== null && twigUsd ? fmtUsd(Number(whole) * twigUsd) : null;
+ // a full lane shows 5 tokens: say before the send whether this amount gets this one in, and what would
+ const inLane = place !== null;
+ const shows = raw === null || boostShowsNow(entry, current, raw, inLane);
+ /** Whether a sent boost of `w` whole TWIG brings the token into the lane: one rule for the done screen, however the receipt arrived. */
+ const showsAfter = (w: bigint): boolean => !tagOk || boostShowsNow(entry, current, boostAmount(w, tag), inLane);
+ const neededWhole = !inLane && entry.full && entry.cutoff !== null ? (() => {
+ const gap = BigInt(entry.cutoff) - current;
+ return gap > 0n ? (gap + 10n ** 18n - 1n) / 10n ** 18n : 0n;
+ })() : null;
+
+ async function send() {
+ if (!address || raw === null || whole === null || busy || lock.current) return;
+ lock.current = true; // before the first await
+ setPhase({ k: "preparing" });
+ try {
+ if (chainId !== BASE.id) await switchChainAsync({ chainId: BASE.id });
+ const pub = getPublicClient(config, { chainId: BASE.id })!;
+ const wallet = await getWalletClient(config, { chainId: BASE.id });
+ const { request } = await pub.simulateContract({ address: BOOST_TOKEN as `0x${string}`, abi: ERC20_TRANSFER_ABI, functionName: "transfer", args: [DEAD, raw], account: address, dataSuffix: BUILDER_DATA_SUFFIX });
+ setPhase({ k: "signing" });
+ const hash = await wallet.writeContract(request);
+ onPending({ hash, whole });
+ setPhase({ k: "sent", hash, whole });
+ let rc;
+ try {
+ rc = await pub.waitForTransactionReceipt({ hash });
+ } catch {
+ // sent, outcome unknown: never an error that would let the same TWIG be sent twice
+ setPhase({ k: "unconfirmed", hash, whole, checking: false, note: null });
+ return;
+ }
+ await settle(hash, whole, rc.status === "success", showsAfter(whole));
+ } catch (err) {
+ setPhase({ k: "error", message: friendlyError(err) });
+ } finally {
+ lock.current = false;
+ }
+ }
+
+ /** A final answer for a sent boost: indexed and done, or reverted (sending again is then safe). */
+ async function settle(hash: Hex, whole: bigint, ok: boolean, shows: boolean) {
+ onPending(null);
+ if (!ok) {
+ setPhase({ k: "error", message: "The transfer reverted on-chain. No TWIG was sent; you can try again." });
+ return;
+ }
+ // index it now rather than at the next poll: the lane and this page show it straight away
+ await fetch(`/api/launch/sync?chain=${BOOST_CHAIN}&tx=${hash}`, { method: "POST" }).catch(() => {});
+ setPhase({ k: "done", hash, whole, shows });
+ toast({ kind: "info", title: `${symbol} is boosted`, sub: `${groupWhole(whole)} TWIG sent to 0x…dEaD`, chain: BOOST_CHAIN, token, symbol });
+ void bal.refetch();
+ onBoosted?.();
+ }
+
+ async function checkAgain() {
+ if (phase.k !== "unconfirmed" || phase.checking) return;
+ const { hash, whole } = phase;
+ setPhase({ ...phase, checking: true, note: null });
+ try {
+ const rc = await getPublicClient(config, { chainId: BASE.id })!.getTransactionReceipt({ hash });
+ await settle(hash, whole, rc.status === "success", showsAfter(whole));
+ } catch {
+ setPhase({ k: "unconfirmed", hash, whole, checking: false, note: "Not confirmed yet. Check your wallet's activity before sending anything again." });
+ }
+ }
+
+ return (
+
+ {phase.k === "done" ? (
+
+
{place !== null ? `${name} is #${place} in the Boosted lane.` : phase.shows ? `${name} is in the Boosted lane.` : `${name} is not in the lane yet: the 5th place still holds more.`}
+
{fmtBoostTwig(boostAmount(phase.whole, tag))} went to 0x…dEaD. It counts for the next 24 hours and adds up with any other boost on {symbol}; the lane shows the 5 largest totals.
Your wallet sent {groupWhole(phase.whole)} TWIG, but Base has not confirmed it to this page yet. Sending is locked until it does, so the same boost is never paid twice.
+ )}
+
+ );
+}
diff --git a/app/src/components/launchpad/BoostPanel.tsx b/app/src/components/launchpad/BoostPanel.tsx
new file mode 100644
index 00000000..207e29cf
--- /dev/null
+++ b/app/src/components/launchpad/BoostPanel.tsx
@@ -0,0 +1,80 @@
+"use client";
+
+import dynamic from "next/dynamic";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ArrowUpRight } from "lucide-react";
+import { btn } from "@/components/ui";
+import { useLive } from "./LiveProvider";
+import { TwigMark } from "./TwigBadge";
+import type { TokenBoost } from "@/lib/launchpad/boostServer";
+import { BOOST_CHAIN, BOOST_COPY, boostTimeLeft, fmtBoostTwig } from "@/lib/launchpad/boost";
+import { explorerTx } from "@/lib/chainPublic";
+import type { PendingBoost } from "./BoostDialog";
+
+// the dialog (wallet reads, the send flow) loads on first use, not with the page
+const BoostDialog = dynamic(() => import("./BoostDialog"), { ssr: false });
+
+/**
+ * A Base token's boost line on its page: whether it is in the Boosted lane, with how much TWIG and for how long, and
+ * the button that opens the dialog. Nothing while BOOST is off. A token an admin hid says so and offers no button, so
+ * nobody sends TWIG for a place it cannot get. `autoOpen` comes from /me's "Boost" link (?boost=1).
+ */
+export default function BoostPanel({ token, tokenId, symbol, name, initial, twigUsd, serverNow, autoOpen = false }: { token: string; tokenId: number; symbol: string; name: string; initial: TokenBoost; twigUsd: number | null; serverNow: number; autoOpen?: boolean }) {
+ const { refresh } = useLive();
+ const [state, setState] = useState(initial);
+ const [open, setOpen] = useState(autoOpen && initial.enabled && !initial.hidden);
+ const [now, setNow] = useState(serverNow);
+ // a sent boost whose receipt is not read yet: kept here so a closed and reopened dialog stays locked on it
+ const [pending, setPending] = useState(null);
+ useEffect(() => {
+ const clock = setInterval(() => setNow(Date.now()), 30_000);
+ return () => clearInterval(clock);
+ }, []);
+ const again = useRef | null>(null);
+ useEffect(() => () => {
+ if (again.current) clearTimeout(again.current);
+ }, []);
+ const read = useCallback(() => {
+ fetch(`/api/boost?chain=${BOOST_CHAIN}&token=${token}`, { cache: "no-store" })
+ .then(async (r) => (r.ok ? setState((await r.json()) as TokenBoost) : undefined))
+ .catch(() => {});
+ }, [token]);
+ // after a boost: read now (the machine that indexed it answers fresh) and once more after the lane's 5 s cache, for
+ // a request that lands on the other machine
+ const reload = useCallback(() => {
+ read();
+ if (again.current) clearTimeout(again.current);
+ again.current = setTimeout(read, 6_000);
+ refresh(); // the hero's TWIG burned
+ }, [read, refresh]);
+
+ if (!state.enabled) return null;
+ const left = state.last_at ? boostTimeLeft(state.last_at, now) : null;
+ const active = left !== null && BigInt(state.twig) > 0n;
+ return (
+
+
+
Boost
+ {active && state.place ? #{state.place} in the lane : null}
+
+ {state.hidden ? (
+
{BOOST_COPY.hidden}
+ ) : (
+ <>
+
+ {active ? (
+ <>Boosted with {fmtBoostTwig(state.twig)} in the last 24 hours · {left}.
+ ) : (
+ <>Not boosted. Sending TWIG to 0x…dEaD puts {symbol} in the Boosted lane for 24 hours.
+ )}
+
+
+ )}
+ {open ? setOpen(false)} onBoosted={reload} /> : null}
+
+ );
+}
diff --git a/app/src/components/launchpad/BoostRulesEntry.tsx b/app/src/components/launchpad/BoostRulesEntry.tsx
new file mode 100644
index 00000000..44ee48f0
--- /dev/null
+++ b/app/src/components/launchpad/BoostRulesEntry.tsx
@@ -0,0 +1,16 @@
+import { ChevronDown } from "lucide-react";
+import { BOOST_COPY } from "@/lib/launchpad/boost";
+
+/** The rules page's Boost question; the page renders it only while the switch is on (boostEnabled, read per request). */
+export default function BoostRulesEntry() {
+ return (
+
+ What is the Boosted lane?
+
+
It is a separate, labelled row on the home page and the Base page. A place in it is paid for by sending TWIG to 0x…dEaD: the TWIG is gone, and nothing is paid to openlaunch or Twigpine. It is not part of the ranking above: the Live sort and the Trending board count outside wallets only, and no boost changes them.
+
{BOOST_COPY.what} {BOOST_COPY.how}
+
{BOOST_COPY.tag} {BOOST_COPY.final}
+
+
+ );
+}
diff --git a/app/src/components/launchpad/BoostedLane.tsx b/app/src/components/launchpad/BoostedLane.tsx
new file mode 100644
index 00000000..dde12f7d
--- /dev/null
+++ b/app/src/components/launchpad/BoostedLane.tsx
@@ -0,0 +1,168 @@
+"use client";
+
+import Link from "next/link";
+import { useEffect, useRef, useState, type CSSProperties } from "react";
+import { motion, useReducedMotion } from "motion/react";
+import { ArrowUpRight, ChevronDown } from "lucide-react";
+import TokenAvatar from "./TokenAvatar";
+import { TwigMark } from "./TwigBadge";
+import { useLive } from "./LiveProvider";
+import LiveNumber from "@/components/LiveNumber";
+import type { BoostLane } from "@/lib/launchpad/boostServer";
+import { BOOST_COPY, BOOST_LANE_SIZE, boostFuse, boostIgnitions, boostTimeLeft, boostWholeOf } from "@/lib/launchpad/boost";
+import { capDisplay } from "@/lib/launchpad/market-cap";
+import { explorerTx } from "@/lib/chainPublic";
+import { setPendingToken } from "@/lib/launchpad/token-transition";
+
+/** The rolling TWIG figure: "1.2M", "300K", like fmtBoostTwig (Intl rounds 999,999 up to "1M" by itself). */
+const TWIG_FORMAT = { notation: "compact", maximumFractionDigits: 2 } as const;
+
+/** Sparks that rise from the amount when a boost lands: offsets, delays and size. Decorative, a fixed set. */
+const EMBERS: readonly { dx: number; dy: number; delay: number; size: number; ink?: boolean }[] = [
+ { dx: -6, dy: -24, delay: 0, size: 4 },
+ { dx: 3, dy: -32, delay: 90, size: 3, ink: true },
+ { dx: 10, dy: -20, delay: 160, size: 3 },
+ { dx: -1, dy: -28, delay: 240, size: 4, ink: true },
+ { dx: 15, dy: -16, delay: 320, size: 3 },
+];
+/** An ignition is drawn for this long; older entries are dropped when the next one is recorded. */
+const IGNITE_KEEP_MS = 10_000;
+
+/**
+ * The Boosted lane: tokens someone sent TWIG to 0x…dEaD for, most TWIG in the last 24 hours first (boost.ts). A paid,
+ * labelled surface of its own, never mixed into the Live sort or the Trending board. Renders nothing while the BOOST
+ * switch is off. It asks the shared live poll for the lane while it is on screen (wantBoost); a poll without it is no
+ * news, so the cards stay as they are.
+ *
+ * Motion follows the board above it: nothing moves on its own. Each card carries a fuse (the share of its 24 hours
+ * left, stepped with the card's clock), and a card lights up once when a fresh boost lands on it: a warm ring, the
+ * amount rolling up, a few embers. Places change with a short slide.
+ */
+export default function BoostedLane({ initial, serverNow }: { initial: BoostLane; serverNow: number }) {
+ const { subscribe, wantBoost } = useLive();
+ const reduced = useReducedMotion();
+ const [lane, setLane] = useState(initial);
+ const [now, setNow] = useState(serverNow);
+ // what each card held at the last snapshot: a token with more TWIG than this, freshly boosted, lights up
+ const prev = useRef | null>(initial.enabled ? new Map(initial.items.map((i) => [i.token, i.twig])) : null);
+ const [ignited, setIgnited] = useState>({});
+
+ useEffect(() => wantBoost(), [wantBoost]);
+ useEffect(() => {
+ const unsubscribe = subscribe((snap) => {
+ const next = snap.boost;
+ if (!next) return;
+ if (next.enabled) {
+ const t = Date.now();
+ const lit = boostIgnitions(prev.current, next.items, t);
+ prev.current = new Map(next.items.map((i) => [i.token, i.twig]));
+ if (lit.size > 0) {
+ setIgnited((m) => {
+ const kept = Object.fromEntries(Object.entries(m).filter(([, at]) => t - at < IGNITE_KEEP_MS));
+ for (const token of lit) kept[token] = t;
+ return kept;
+ });
+ }
+ } else {
+ prev.current = null;
+ }
+ setLane(next);
+ });
+ const clock = setInterval(() => setNow(Date.now()), 30_000);
+ return () => {
+ unsubscribe();
+ clearInterval(clock);
+ };
+ }, [subscribe]);
+
+ if (!lane.enabled) return null;
+ // a boost that ran out between polls leaves at once rather than showing "0m left"
+ const items = lane.items.filter((b) => boostTimeLeft(b.last_at, now) !== null);
+ return (
+
+
+
+
+ {BOOST_COPY.laneTitle}
+
+
{BOOST_COPY.laneNote}
+
+ {/* the whole rule, in place: no page to keep in step with the switch */}
+
+ How boosts work
+
+
{BOOST_COPY.what}
+
{BOOST_COPY.how} {BOOST_COPY.tag}
+
{BOOST_COPY.final}
+
+
+ {items.length === 0 ? (
+
{BOOST_COPY.laneEmpty}
+ ) : (
+
+ {items.map((b, i) => {
+ const l = b.launch;
+ const cap = capDisplay(l.fdv_quote, l.quote_usd, { key: l.quote_key, symbol: l.quote_symbol, decimals: l.quote_decimals }).compact;
+ const left = boostTimeLeft(b.last_at, now);
+ const fuse = boostFuse(b.last_at, now);
+ const lit = ignited[l.token];
+ // two columns from 640px: an odd last card takes the whole row instead of leaving a hole
+ const lastOdd = i === items.length - 1 && items.length % 2 === 1;
+ return (
+
+ {/* one warm ring per ignition: a new key replays it */}
+ {lit ? : null}
+ setPendingToken({ chain: l.chain, token: l.token, name: l.name, symbol: l.symbol, image: l.image_url })}
+ className="group flex min-w-0 items-center gap-2.5"
+ >
+
+
+ {l.name}
+ {l.symbol} · , market cap {cap}
+
+
+
+
+ Latest burn
+
+ {/* the fuse: what is left of the 24 hours, burning down from the right; steps with the card's clock */}
+
+
+ {fuse > 0 ? : null}
+
+
+
+ );
+ })}
+ {/* five columns from 1024px: the free places read as open, never as a grey block */}
+ {Array.from({ length: Math.max(0, BOOST_LANE_SIZE - items.length) }, (_, i) => (
+
Open spot
+ ))}
+
+ )}
+
+ );
+}
diff --git a/app/src/components/launchpad/ChainLanding.tsx b/app/src/components/launchpad/ChainLanding.tsx
index a7da7a0d..563c0af5 100644
--- a/app/src/components/launchpad/ChainLanding.tsx
+++ b/app/src/components/launchpad/ChainLanding.tsx
@@ -4,6 +4,9 @@ import Link from "next/link";
import { notFound } from "next/navigation";
import { ArrowRight, ArrowUpRight } from "lucide-react";
import LaunchList from "@/components/launchpad/LaunchList";
+import BoostedLane from "@/components/launchpad/BoostedLane";
+import { boostLaneOrNull } from "@/lib/launchpad/boostServer";
+import { BOOST_CHAIN } from "@/lib/launchpad/boost";
import SectionIntro from "@/components/sections/SectionIntro";
import shell from "@/components/sections/SectionShell.module.css";
import { CHAIN_KEYS, CHAIN_LABELS, CHAINS, EXPLORERS, explorerAddress, type ChainKey } from "@/lib/chainPublic";
@@ -33,9 +36,10 @@ export default async function ChainLanding({ chain }: { chain: ChainKey }) {
const c = CHAIN_LANDING[chain];
const lp = launchpad(chain);
const usd = await ethUsd();
- const [page, totals] = await Promise.all([
+ const [page, totals, boost] = await Promise.all([
listLaunchesPage({ sort: "live", window: "all", chain, filter: null, limit: PAGE_SIZE, ethUsd: usd }),
getLaunchTotalsForRequest(usd), // the root layout already ran it this request: shared, not repeated
+ chain === BOOST_CHAIN ? boostLaneOrNull(usd) : null, // boosts exist on Base only
]);
const launches = totals.by_chain[chain].launches;
const now = nowMs();
@@ -66,6 +70,9 @@ export default async function ChainLanding({ chain }: { chain: ChainKey }) {
) : null}
+ {/* always mounted on Base, so a switch-on reaches an open tab; the margin goes with the lane (empty:hidden) */}
+ {chain === BOOST_CHAIN ?
: null}
+
Tokens on {CHAIN_LABELS[chain]}
diff --git a/app/src/components/launchpad/LaunchMechanism.tsx b/app/src/components/launchpad/LaunchMechanism.tsx
index 52edb0ab..f1f2a0c2 100644
--- a/app/src/components/launchpad/LaunchMechanism.tsx
+++ b/app/src/components/launchpad/LaunchMechanism.tsx
@@ -45,6 +45,13 @@ export default function LaunchMechanism() {
// TWIG burned: its own figure (the GITLAWB behind it stays in the TWIG contract), shown once there is any; null-safe for a poll from an older machine
const twigBurned = t.twig_burned ?? "0";
const twigBurnedExact = `${fmtUnitsExact(twigBurned, TWIG_DECIMALS)} ${TWIG_SYMBOL}`;
+ // boosts send TWIG to 0x…dEaD too: the label says where each part came from once there is any boost (null-safe for an older machine)
+ const twigBoosted = BigInt(t.twig_boost_burned ?? "0");
+ // never below zero: mid rolling deploy the two figures can come from machines a release apart
+ const twigFees = BigInt(twigBurned) > twigBoosted ? BigInt(twigBurned) - twigBoosted : 0n;
+ const twigBurnedWhy = twigBoosted > 0n
+ ? `Sent to 0x…dEaD on Base: ${fmtQuote(twigFees.toString(), TWIG_DECIMALS, TWIG_SYMBOL)} from the trading fees of TWIG-quoted launches, ${fmtQuote(twigBoosted.toString(), TWIG_DECIMALS, TWIG_SYMBOL)} by boosts`
+ : "Sent to 0x…dEaD by TWIG-quoted launches on Base";
return
{count(t.trades)}
@@ -63,7 +70,7 @@ export default function LaunchMechanism() {
{/* the "≈" explained in the open: a title alone cannot be reached by touch or keyboard */}
{usdNote ?
≈ {usdNote}
: null}
diff --git a/app/src/components/launchpad/LiveProvider.tsx b/app/src/components/launchpad/LiveProvider.tsx
index 2da444c0..d3cc5b72 100644
--- a/app/src/components/launchpad/LiveProvider.tsx
+++ b/app/src/components/launchpad/LiveProvider.tsx
@@ -5,6 +5,7 @@ import type { FeedItem, LaunchRow, LaunchSort, LaunchTotals, TrendingSnap, Volum
import type { ChainKey } from "@/lib/chainPublic";
import type { LaunchFilter } from "@/lib/launchpad/search";
import type { PostRow } from "@/lib/launchpad/postsServer";
+import type { BoostLane } from "@/lib/launchpad/boostServer";
/**
* One poller for the whole page. Everything live (toasts, tape, hero totals,
@@ -26,6 +27,10 @@ export type Live = {
has_more?: boolean | null;
posts?: PostRow[];
trending?: TrendingSnap;
+ /** Whether BOOST is on: every answer carries it (an older machine does not, and the last value stands). */
+ boost_on?: boolean;
+ /** The Boosted lane, only while a lane is on screen (wantBoost); absent when not asked for or not read this tick. */
+ boost?: BoostLane;
};
type ListParams = { sort: LaunchSort; window: VolumeWindow; chain: ChainKey | null; filter: LaunchFilter | null; limit: number };
type Listener = (live: Live) => void;
@@ -35,6 +40,8 @@ type Ctx = {
refresh: () => void;
/** Called after every successful tick with the fresh snapshot. Use for setState from a callback (never from an effect body). */
subscribe: (fn: Listener) => () => void;
+ /** A Boosted lane is on screen: polls ask for the lane until the returned function is called. */
+ wantBoost: () => () => void;
};
const LiveCtx = createContext(null);
const POLL_MS = 5_000;
@@ -44,6 +51,7 @@ export default function LiveProvider({ initial, children }: { initial: Omit(initial.sort ? { sort: initial.sort, window: initial.window ?? "all", chain: initial.chain ?? null, filter: initial.filter ?? null, limit: initial.limit ?? 40 } : null);
const inflight = useRef(false);
const listeners = useRef(new Set());
+ const boostWanted = useRef(0);
const last = useRef(live);
const tick = useCallback(async () => {
@@ -51,7 +59,9 @@ export default function LiveProvider({ initial, children }: { initial: Omit 0) parts.push("boost=1");
+ const q = parts.length ? `?${parts.join("&")}` : "";
const res = await fetch(`/api/launch/live${q}`, { cache: "no-store" });
if (!res.ok) return;
const data = (await res.json()) as Live;
@@ -60,7 +70,8 @@ export default function LiveProvider({ initial, children }: { initial: Omit fn(merged));
@@ -97,7 +108,14 @@ export default function LiveProvider({ initial, children }: { initial: Omit ({ live, setListParams, refresh: () => void tick(), subscribe }), [live, setListParams, tick, subscribe]);
+ const wantBoost = useCallback(() => {
+ boostWanted.current += 1;
+ return () => {
+ boostWanted.current = Math.max(0, boostWanted.current - 1);
+ };
+ }, []);
+
+ const value = useMemo(() => ({ live, setListParams, refresh: () => void tick(), subscribe, wantBoost }), [live, setListParams, tick, subscribe, wantBoost]);
return {children};
}
diff --git a/app/src/components/launchpad/MeDashboard.tsx b/app/src/components/launchpad/MeDashboard.tsx
index 1ef62aa5..617bcc97 100644
--- a/app/src/components/launchpad/MeDashboard.tsx
+++ b/app/src/components/launchpad/MeDashboard.tsx
@@ -2,7 +2,7 @@
import Link from "next/link";
import { useCallback, useEffect, useState } from "react";
-import { ArrowDownLeft, ArrowRight, ArrowUpRight, Coins, Hourglass, Layers3, LockKeyhole, PencilLine, RefreshCw, Wallet } from "lucide-react";
+import { ArrowDownLeft, ArrowRight, ArrowUpRight, Coins, Flame, Hourglass, Layers3, LockKeyhole, PencilLine, RefreshCw, Wallet } from "lucide-react";
import { useConfig } from "wagmi";
import { useHydratedAccount } from "@/lib/useHydratedAccount";
import { getPublicClient, getWalletClient } from "wagmi/actions";
@@ -30,6 +30,8 @@ import ConnectWallet from "@/components/ConnectWallet";
import ProfileIdentity from "@/components/profile/ProfileIdentity";
import SeasonCard from "@/components/points/SeasonCard";
import EarnCard from "@/components/earn/EarnCard";
+import { useBoostOn } from "./useBoostOn";
+import { BOOST_CHAIN } from "@/lib/launchpad/boost";
import styles from "./MeDashboard.module.css";
type Me = { wallet: string; ethUsd: number | null; launches: LaunchRow[]; tokens: (LaunchRow & { my_buys: number; my_sells: number; my_last_trade: string })[]; trades: WalletTrade[] };
@@ -53,6 +55,7 @@ export default function MeDashboard() {
/** The dashboard for one connected wallet: its profile card, figures, launches, holdings and trades. */
function WalletDashboard({ address, isConnected }: { address: Address | undefined; isConnected: boolean }) {
const config = useConfig();
+ const boostOn = useBoostOn();
const [me, setMe] = useState(null);
const [err, setErr] = useState(null);
const [pending, setPending] = useState({});
@@ -287,6 +290,12 @@ function WalletDashboard({ address, isConnected }: { address: Address | undefine
+ {/* Boost opens the dialog on the token's page (Base only, while the switch is on) */}
+ {boostOn && l.chain === BOOST_CHAIN ? (
+
+ Boost
+
+ ) : null}
);
diff --git a/app/src/components/launchpad/boost-ui.test.ts b/app/src/components/launchpad/boost-ui.test.ts
new file mode 100644
index 00000000..ce10f6d4
--- /dev/null
+++ b/app/src/components/launchpad/boost-ui.test.ts
@@ -0,0 +1,194 @@
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+
+// Source contracts for Boost (like earn-ui.test.ts): they hold the rules that keep a paid lane honest in place.
+const read = (p: string) => readFileSync(new URL(p, import.meta.url), "utf8");
+const dialog = read("./BoostDialog.tsx");
+const panel = read("./BoostPanel.tsx");
+const lane = read("./BoostedLane.tsx");
+const admin = read("./BoostAdmin.tsx");
+const rulesEntry = read("./BoostRulesEntry.tsx");
+const rules = read("../../app/rules/page.tsx");
+const dashboard = read("./MeDashboard.tsx");
+const server = read("../../lib/launchpad/boostServer.ts");
+const boostSwitch = read("../../lib/launchpad/boostSwitch.ts");
+const live = read("./LiveProvider.tsx");
+const layout = read("../../app/layout.tsx");
+const syncRoute = read("../../app/api/launch/sync/route.ts");
+const landing = read("./ChainLanding.tsx");
+const css = read("../../app/globals.css");
+const indexer = read("../../lib/launchpad/indexer.ts");
+const queries = read("../../lib/launchpad/queries.ts");
+const liveRoute = read("../../app/api/launch/live/route.ts");
+const boostRoute = read("../../app/api/boost/route.ts");
+const llms = read("../../app/llms.txt/route.ts");
+const home = read("../../app/(home)/page.tsx");
+const tokenPage = read("../../app/t/[chain]/[token]/page.tsx");
+
+test("the ranking never reads boosts: no paid row can enter the Live sort or the Trending board", () => {
+ // boost code, not the English word (the board's own copy says fresh tokens "get a boost" in score)
+ const BOOST_CODE = /from ["'][^"']*[bB]oost[^"']*["']|bb_boosts|BOOST_|[bB]oostLane|useBoostOn|getTokenBoost|live\.boost|snap\.boost/;
+ for (const f of ["../../lib/launchpad/ranking.ts", "../../lib/launchpad/trending-live.ts", "../../lib/launchpad/trending-board.ts", "./TrendingStrip.tsx", "./LaunchList.tsx"]) {
+ assert.doesNotMatch(read(f), BOOST_CODE, f);
+ }
+ // queries.ts names bb_boosts only inside getLaunchTotals (the TWIG burned figure), never in a list or ranking query
+ const start = queries.indexOf("export async function getLaunchTotals(");
+ const end = queries.indexOf("\n}\n", start);
+ assert.ok(start > 0 && end > start);
+ // the only imports it needs: the chain id the totals filter on, and the switch that gates them
+ const IMPORTS = ['import { BOOST_CHAIN_ID } from "./boost";\n', 'import { boostEnabled } from "./boostSwitch";\n'];
+ for (const imp of IMPORTS) assert.equal(queries.split(imp).length, 2, imp);
+ const outside = IMPORTS.reduce((acc, imp) => acc.replace(imp, ""), queries.slice(0, start) + queries.slice(end));
+ assert.doesNotMatch(outside, BOOST_CODE);
+ // the totals count only boosts that name a launch, and only while the switch is on
+ assert.match(queries.slice(start, end), /boostEnabled\(\)\n\s*\? db<\{ burned: string \}\[\]>`\n\s*SELECT COALESCE\(sum\(b\.amount\), 0\)::text AS burned FROM bb_boosts b\n\s*JOIN bb_launches l ON l\.chain_id = b\.chain_id AND l\.token_id = b\.tag/);
+});
+
+test("a boost is one plain TWIG transfer to 0x…dEaD: simulated, credited to the builder code, never an approval", () => {
+ assert.match(dialog, /simulateContract\(\{ address: BOOST_TOKEN as `0x\$\{string\}`, abi: ERC20_TRANSFER_ABI, functionName: "transfer", args: \[DEAD, raw\], account: address, dataSuffix: BUILDER_DATA_SUFFIX \}\)/);
+ assert.equal((dialog.match(/writeContract\(/g) ?? []).length, 1);
+ assert.match(dialog, /wallet\.writeContract\(request\)/);
+ assert.doesNotMatch(dialog, /approve|maxUint|sendTransaction|signMessage/);
+ // the amount is built from the launch's own position id, only once the checks pass
+ assert.match(dialog, /whole !== null && problem === null \? boostAmount\(whole, tag\) : null/);
+ assert.match(dialog, /const tag = BigInt\(tokenId\)/);
+ // the transfer ABI is reachable from the dialog alone
+ const users = walk(path.resolve(import.meta.dirname, "../..")).filter((f) => !f.endsWith(".test.ts") && readFileSync(f, "utf8").includes("ERC20_TRANSFER_ABI"));
+ assert.deepEqual(users.map((f) => path.basename(f)).sort(), ["BoostDialog.tsx", "abi.ts"]);
+});
+
+test("the send locks before its first await and simulates before the wallet is asked", () => {
+ const body = dialog.slice(dialog.indexOf("async function send()"));
+ const lockAt = body.indexOf("lock.current = true");
+ assert.ok(lockAt > 0 && lockAt < body.indexOf("await"), "lock before the first await");
+ assert.ok(body.indexOf("simulateContract") < body.indexOf("writeContract"), "simulate before write");
+ assert.match(body, /if \(chainId !== BASE\.id\) await switchChainAsync\(\{ chainId: BASE\.id \}\)/);
+});
+
+test("sent means sent: an unread receipt locks the dialog instead of inviting a second burn", () => {
+ const body = dialog.slice(dialog.indexOf("async function send()"), dialog.indexOf("async function settle("));
+ // the hash is handed to the panel before the receipt wait, and a failed wait is "unconfirmed", never "error"
+ assert.ok(body.indexOf("onPending({ hash, whole })") < body.indexOf("waitForTransactionReceipt"));
+ assert.match(body, /catch \{\n\s*\/\/ sent, outcome unknown[^\n]*\n\s*setPhase\(\{ k: "unconfirmed", hash, whole, checking: false, note: null \}\);\n\s*return;/);
+ assert.match(dialog, /const busy = phase\.k === "preparing" \|\| phase\.k === "signing" \|\| phase\.k === "sent" \|\| phase\.k === "unconfirmed";/);
+ assert.match(dialog, /useState\(pending \? \{ k: "unconfirmed", \.\.\.pending, checking: false, note: null \} : \{ k: "idle" \}\)/);
+ // the panel owns the pending hash, so closing and reopening keeps the lock
+ assert.match(panel, /pending=\{pending\} onPending=\{setPending\}/);
+ // only a receipt settles it, and the sync call indexes it at once
+ assert.match(dialog, /await fetch\(`\/api\/launch\/sync\?chain=\$\{BOOST_CHAIN\}&tx=\$\{hash\}`, \{ method: "POST" \}\)/);
+});
+
+test("the dialog says where the TWIG goes, that it is final, and that the ranking is untouched", () => {
+ for (const key of ["what", "tag", "final"]) assert.match(dialog, new RegExp(`BOOST_COPY\\.${key}`), key);
+ assert.match(dialog, /0x…dEaD \(burned\)/);
+ assert.match(dialog, /Platform fee<\/dt>]*>\$0/);
+});
+
+test("everything stays dark while BOOST is off", () => {
+ assert.match(boostSwitch, /return process\.env\.BOOST\?\.trim\(\)\.toLowerCase\(\) === "on";/);
+ assert.match(server, /export \{ boostEnabled \};/);
+ assert.match(lane, /if \(!lane\.enabled\) return null;/);
+ assert.match(panel, /if \(!state\.enabled\) return null;/);
+ assert.match(admin, /if \(lane && !lane\.enabled\) return null;/);
+ assert.match(rules, /\{boostEnabled\(\) \? : null\}/);
+ assert.doesNotMatch(rulesEntry, /"use client"/);
+ assert.match(dashboard, /boostOn && l\.chain === BOOST_CHAIN \?/);
+ assert.match(llms, /if \(!boostEnabled\(\)\) return "";/);
+ assert.match(boostRoute, /if \(!boostEnabled\(\)\) return NextResponse\.json\(\{ enabled: false \}/);
+ assert.match(tokenPage, /const boostable = chain === BOOST_CHAIN && boostEnabled\(\);/);
+});
+
+test("a failed lane read never breaks a page or blanks open tabs", () => {
+ assert.match(server, /\.catch\(\(err\) => \{\n\s*console\.warn\("\[boost\] lane read failed:"/);
+ assert.match(liveRoute, /boost: boost \?\? undefined/);
+ assert.match(home, //);
+ // a tick without the lane is no news: the cards stay as they are
+ assert.match(lane, /const next = snap\.boost;\n\s*if \(!next\) return;/);
+ // the lane sits after the facts-only board, never inside it
+ assert.ok(home.indexOf(" {
+ assert.match(indexer, /const twig = TWIG_ADDRESSES\[chain\];\n\s*if \(twig\) \{\n\s*const burnLogs = await fetchLogsSplit\(\(f, t\) => client\.getLogs\(\{ address: twig as Address, event: ERC20_TRANSFER_EVENT, args: \{ to: DEAD \}, fromBlock: f, toBlock: t \}\), from, to\);/);
+ assert.match(indexer, /applyBoost\(db, chain, l as Log & \{ args: TransferArgs \}, locker\.toLowerCase\(\)\)/);
+ assert.match(indexer, /applyBoost\(db, chain, l as unknown as Log & \{ args: TransferArgs \}, locker\)/);
+ assert.match(indexer, /INSERT INTO bb_boosts \(chain_id, tx_hash, log_index, booster, amount, tag, block_number, block_time\)[\s\S]*?ON CONFLICT DO NOTHING/);
+});
+
+test("moderation is admin-only, signed over its own message, with a single-use nonce", () => {
+ const body = server.slice(server.indexOf("export async function moderateBoost("));
+ const adminAt = body.indexOf("if (!adminWallets().has(wallet)) return fail(\"admin only\", 403);");
+ const verifyAt = body.indexOf("await verify(BOOST_CHAIN, wallet, message, p.signature)");
+ const nonceAt = body.indexOf("await consumeNonce(p.nonce, wallet)");
+ const writeAt = body.indexOf("INSERT INTO bb_token_settings");
+ assert.ok(adminAt > 0 && adminAt < verifyAt && verifyAt < nonceAt && nonceAt < writeAt);
+ assert.match(body, /const message = buildBoostModMessage\(/);
+ // a hidden token is out of the lane, and its page offers no button
+ assert.match(server, /AND NOT COALESCE\(s\.boost_hidden, false\)/);
+ assert.match(panel, /\{state\.hidden \? \(\n\s*]*>\{BOOST_COPY\.hidden\}<\/p>\n\s*\) : \(/);
+});
+
+function walk(dir: string, out: string[] = []): string[] {
+ for (const name of readdirSync(dir)) {
+ const p = path.join(dir, name);
+ if (statSync(p).isDirectory()) walk(p, out);
+ else if (/\.(ts|tsx)$/.test(p)) out.push(p);
+ }
+ return out;
+}
+
+test("only a lane on screen downloads the lane; every page gets the switch as one boolean", () => {
+ assert.match(lane, /useEffect\(\(\) => wantBoost\(\), \[wantBoost\]\);/);
+ assert.match(live, /if \(boostWanted\.current > 0\) parts\.push\("boost=1"\);/);
+ assert.match(liveRoute, /wantsBoost \? boostLaneOrNull\(usd\) : Promise\.resolve\(null\)/);
+ assert.match(liveRoute, /boost_on: boostEnabled\(\), boost: boost \?\? undefined/);
+ // the switch survives a tick from an older machine; the lane does not pretend to
+ assert.match(live, /boost_on: data\.boost_on \?\? last\.current\.boost_on/);
+ assert.doesNotMatch(live, /boost: data\.boost \?\?/);
+ assert.match(layout, /boost_on: boostEnabled\(\)/);
+ assert.match(read("./useBoostOn.ts"), /useState\(live\.boost_on === true\)/);
+ // /base keeps the lane mounted, so a switch-on reaches an open tab
+ assert.match(landing, /chain === BOOST_CHAIN \?
{
+ assert.match(syncRoute, /if \(r\.boosts\) forgetBoostLane\(\);/);
+ const mod = server.slice(server.indexOf("export async function moderateBoost("));
+ assert.ok(mod.indexOf("forgetBoostLane();") > mod.indexOf("INSERT INTO bb_token_settings"));
+ assert.match(panel, /again\.current = setTimeout\(read, 6_000\);/);
+});
+
+test("a boost that cannot enter a full lane is said so before anything is sent", () => {
+ assert.match(dialog, /const shows = raw === null \|\| boostShowsNow\(entry, current, raw, inLane\);/);
+ assert.match(dialog, /\{problem === null && !shows \? \(/);
+ assert.match(dialog, /BOOST_COPY\.short/);
+ // the done screen never claims a place the boost did not get
+ assert.match(dialog, /phase\.shows \? `\$\{name\} is in the Boosted lane\.` : `\$\{name\} is not in the lane yet/);
+});
+
+test("the lane moves only when something happens, and reduced motion keeps only colour", () => {
+ assert.match(lane, /const lit = boostIgnitions\(prev\.current, next\.items, t\);/);
+ assert.match(lane, / {
+ // both ways a receipt can arrive settle with the same rule: never a hard-coded "it shows"
+ assert.equal((dialog.match(/await settle\(hash, whole, rc\.status === "success", showsAfter\(whole\)\);/g) ?? []).length, 2);
+ assert.doesNotMatch(dialog, /settle\([^)]*, true\)/);
+ assert.match(dialog, /const showsAfter = \(w: bigint\): boolean => !tagOk \|\| boostShowsNow\(entry, current, boostAmount\(w, tag\), inLane\);/);
+ // an error page that is not JSON still reports the HTTP failure; a bad lane read never throws from the effect
+ assert.match(admin, /const d = \(await res\.json\(\)\.catch\(\(\) => \(\{\}\)\)\) as \{ error\?: string \};/);
+ assert.match(admin, /throw new Error\(d\.error \?\? `request failed \(HTTP \$\{res\.status\}\)`\);/);
+ assert.match(admin, /const load = useCallback\(async \(\) => \{\n\s*try \{/);
+ // agents get the bounds the decoder enforces (isLaunchTag: 0 < tag < 10^11; whole TWIG >= the floor)
+ assert.match(llms, /whole = a count of whole TWIG, at least \$\{BOOST_FLOOR_TWIG\}/);
+ assert.match(llms, /greater than 0 and less than 10\^11/);
+});
diff --git a/app/src/components/launchpad/useBoostOn.ts b/app/src/components/launchpad/useBoostOn.ts
new file mode 100644
index 00000000..2cf819c4
--- /dev/null
+++ b/app/src/components/launchpad/useBoostOn.ts
@@ -0,0 +1,22 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useLive } from "./LiveProvider";
+
+/**
+ * Whether the BOOST switch is on, as the shared live poll last said. No request of its own. The root layout seeds it
+ * from the server (so the first paint is right), every poll repeats it, and a poll from a machine that predates it
+ * changes nothing. Switching BOOST off reaches open tabs within one poll.
+ */
+export function useBoostOn(): boolean {
+ const { live, subscribe } = useLive();
+ const [on, setOn] = useState(live.boost_on === true);
+ useEffect(
+ () =>
+ subscribe((snap) => {
+ if (snap.boost_on !== undefined) setOn(snap.boost_on);
+ }),
+ [subscribe],
+ );
+ return on;
+}
diff --git a/app/src/lib/command-palette.ts b/app/src/lib/command-palette.ts
index 6c2dcdb4..c01a7fa9 100644
--- a/app/src/lib/command-palette.ts
+++ b/app/src/lib/command-palette.ts
@@ -58,15 +58,18 @@ export function paletteTokenFrom(l: LaunchLike): PaletteToken {
/** Listed only while the Earn switch is on (GET /api/earn); it lands on the /me card. */
export const EARN_PAGE = { id: "page:earn", label: "Earn on idle USDC", href: "/me#earn", keywords: "earn lend deposit usdc vault morpho interest savings withdraw" } as const;
+/** Listed only while the Boost switch is on (the live poll says so); it lands on the home page's Boosted lane. */
+export const BOOST_PAGE = { id: "page:boosted", label: "Boosted tokens", href: "/#boosted", keywords: "boost boosted twig burn lane dead" } as const;
+
/**
* Results in reading order: tokens first (search hits, or what is trending before anything is
* typed), then pages, then actions. Empty groups are dropped.
*/
-export function buildPaletteGroups({ query, tokens, trending, theme, earn = false }: { query: string; tokens: PaletteToken[]; trending: PaletteToken[]; theme: "light" | "dark"; earn?: boolean }): PaletteGroup[] {
+export function buildPaletteGroups({ query, tokens, trending, theme, earn = false, boost = false }: { query: string; tokens: PaletteToken[]; trending: PaletteToken[]; theme: "light" | "dark"; earn?: boolean; boost?: boolean }): PaletteGroup[] {
const q = query.trim();
const tokenList = q ? (isSearchableQuery(q) ? tokens : []) : trending;
const tokenItems: PaletteItem[] = tokenList.map((t) => ({ kind: "token", id: `token:${t.chain}:${t.token}`, label: t.name, token: t }));
- const pages: PaletteItem[] = [...PALETTE_PAGES, ...(earn ? [EARN_PAGE] : [])].filter((p) => !q || matchesQuery(q, `${p.label} ${p.keywords}`)).map((p) => ({ kind: "page", ...p }));
+ const pages: PaletteItem[] = [...PALETTE_PAGES, ...(earn ? [EARN_PAGE] : []), ...(boost ? [BOOST_PAGE] : [])].filter((p) => !q || matchesQuery(q, `${p.label} ${p.keywords}`)).map((p) => ({ kind: "page", ...p }));
const next = theme === "dark" ? "light" : "dark";
const actions: PaletteItem[] = [
{ kind: "action" as const, id: "action:bridge", label: "Bridge funds between chains", action: "bridge" as const, keywords: "bridge relay move deposit base robinhood arc" },
diff --git a/app/src/lib/launchpad/abi.ts b/app/src/lib/launchpad/abi.ts
index 2abaaea8..f0f728b6 100644
--- a/app/src/lib/launchpad/abi.ts
+++ b/app/src/lib/launchpad/abi.ts
@@ -357,6 +357,20 @@ export const ERC20_MIN_ABI = [
},
] as const;
+/** ERC-20 transfer, alone: the one call a boost makes (TWIG to 0x…dEaD, boost.ts). Kept apart so no other flow can reach it by accident. */
+export const ERC20_TRANSFER_ABI = [
+ {
+ type: "function",
+ name: "transfer",
+ stateMutability: "nonpayable",
+ inputs: [
+ { name: "to", type: "address" },
+ { name: "value", type: "uint256" },
+ ],
+ outputs: [{ name: "", type: "bool" }],
+ },
+] as const;
+
/** Typed event items (viem getLogs wants AbiEvent, not an ABI index). */
export const LAUNCHED_EVENT = LAUNCH_FACTORY_ABI.find((x) => x.type === "event" && x.name === "Launched")! as Extract<(typeof LAUNCH_FACTORY_ABI)[number], { type: "event" }>;
export const POOL_SWAP_EVENT = POOL_MANAGER_ABI[0];
diff --git a/app/src/lib/launchpad/boost.test.ts b/app/src/lib/launchpad/boost.test.ts
new file mode 100644
index 00000000..77c66118
--- /dev/null
+++ b/app/src/lib/launchpad/boost.test.ts
@@ -0,0 +1,229 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+ BOOST_COPY,
+ BOOST_DEAD,
+ BOOST_FLOOR_TWIG,
+ BOOST_LANE_SIZE,
+ BOOST_PRESETS,
+ BOOST_TOKEN,
+ BOOST_WINDOW_MS,
+ LAUNCH_TAG_MAX,
+ TAG_SPACE,
+ boostAmount,
+ boostAmountProblem,
+ boostConfirmLabel,
+ boostExpiresAt,
+ boostFromTransfer,
+ boostFuse,
+ boostIgnitions,
+ boostShowsNow,
+ compactWhole,
+ IGNITE_FRESH_MS,
+ boostTagOf,
+ boostTimeLeft,
+ boostWholeOf,
+ buildBoostModMessage,
+ fmtBoostTwig,
+ groupWhole,
+ isBoostModAction,
+ isLaunchTag,
+ maxBoostWhole,
+ parseBoostWhole,
+ rankLane,
+ type BoostTransfer,
+} from "./boost.ts";
+import { TWIG_ADDRESS, TWIG_ADDRESSES } from "./twig.ts";
+import { DEAD } from "./config.ts";
+
+const E18 = 10n ** 18n;
+const ID = 3_135_968n; // a real Base position id (the newest TWIG launch on 2026-10-14)
+
+test("boosts burn TWIG on Base, to the dead address the rest of the app uses", () => {
+ assert.equal(BOOST_TOKEN, TWIG_ADDRESS);
+ assert.equal(BOOST_TOKEN, TWIG_ADDRESSES.base);
+ assert.equal(BOOST_DEAD, DEAD.toLowerCase());
+ assert.equal(BOOST_WINDOW_MS, 24 * 3_600_000);
+ assert.equal(BOOST_LANE_SIZE, 5);
+});
+
+test("the amount carries the launch's position id in its last digits, and decodes back", () => {
+ const raw = boostAmount(300_000n, ID);
+ assert.equal(raw, 300_000n * E18 + ID);
+ assert.equal(boostTagOf(raw), ID);
+ assert.equal(boostWholeOf(raw), 300_000n);
+ // the tag is worth under a millionth of one TWIG
+ assert.ok(TAG_SPACE * 1_000_000n <= E18);
+});
+
+test("a tag must name a launch: positive and below the reserved range", () => {
+ assert.equal(isLaunchTag(0n), false);
+ assert.equal(isLaunchTag(1n), true);
+ assert.equal(isLaunchTag(LAUNCH_TAG_MAX - 1n), true);
+ assert.equal(isLaunchTag(LAUNCH_TAG_MAX), false);
+ assert.throws(() => boostAmount(100_000n, 0n));
+ assert.throws(() => boostAmount(100_000n, LAUNCH_TAG_MAX));
+ assert.throws(() => boostAmount(0n, ID));
+});
+
+test("Max never asks for more than the balance holds, tag included", () => {
+ assert.equal(maxBoostWhole(500_000n * E18 + ID, ID), 500_000n);
+ assert.equal(maxBoostWhole(500_000n * E18 + ID - 1n, ID), 499_999n);
+ assert.equal(maxBoostWhole(500_000n * E18, ID), 499_999n);
+ assert.equal(maxBoostWhole(0n, ID), 0n);
+ assert.equal(maxBoostWhole(E18 - 1n, ID), 0n);
+ for (const bal of [123n * E18 + 5n, 10n ** 24n, 7n * E18 + ID, 7n * E18 + ID + 1n]) {
+ const w = maxBoostWhole(bal, ID);
+ if (w > 0n) assert.ok(boostAmount(w, ID) <= bal, `${bal}`);
+ assert.ok(boostAmount(w + 1n, ID) > bal, `${bal}`);
+ }
+});
+
+test("the amount box takes whole TWIG only", () => {
+ assert.equal(parseBoostWhole("300000"), 300_000n);
+ assert.equal(parseBoostWhole("1,000,000"), 1_000_000n);
+ assert.equal(parseBoostWhole(" 5 000 000 "), 5_000_000n);
+ for (const bad of ["", "0", "1.5", "-3", "1e6", "abc", "0x10", "1000000000000"]) assert.equal(parseBoostWhole(bad), null, bad);
+ for (const p of BOOST_PRESETS) assert.ok((parseBoostWhole(p) ?? 0n) >= BOOST_FLOOR_TWIG, p);
+});
+
+test("the dialog names the one thing stopping a send", () => {
+ assert.equal(boostAmountProblem(null, undefined, ID), "Enter a whole number of TWIG.");
+ assert.equal(boostAmountProblem(99_999n, 10n ** 30n, ID), "A boost sends at least 100,000 TWIG.");
+ assert.equal(boostAmountProblem(100_000n, 100_000n * E18, ID), "Not enough TWIG in this wallet.");
+ assert.equal(boostAmountProblem(100_000n, 100_000n * E18 + ID, ID), null);
+ assert.equal(boostAmountProblem(100_000n, undefined, ID), null); // balance still loading: the wallet will refuse if short
+});
+
+const transfer = (o: Partial = {}): BoostTransfer => ({
+ address: "0x6AC18BCF4EDE02591D4917452700EA5EAAEA13C1",
+ from: "0xAbC0000000000000000000000000000000000001",
+ to: "0x000000000000000000000000000000000000dEaD",
+ value: 300_000n * E18 + ID,
+ txHash: "0xAA".padEnd(66, "0"),
+ logIndex: 7,
+ blockNumber: 52_000_000n,
+ ...o,
+});
+
+test("a TWIG transfer to 0x…dEaD with a launch tag becomes a boost row, lowercased", () => {
+ assert.deepEqual(boostFromTransfer(transfer()), {
+ tx_hash: "0xaa".padEnd(66, "0"),
+ log_index: 7,
+ booster: "0xabc0000000000000000000000000000000000001",
+ amount: (300_000n * E18 + ID).toString(),
+ tag: ID.toString(),
+ block_number: "52000000",
+ });
+});
+
+test("everything else is not a boost", () => {
+ const LOCKER = "0x1111111111111111111111111111111111111111";
+ assert.equal(boostFromTransfer(transfer({ address: "0x5f980dcfc4c0fa3911554cf5ab288ed0eb13dba3" })), null, "GITLAWB, not TWIG");
+ assert.equal(boostFromTransfer(transfer({ to: "0x0000000000000000000000000000000000000000" })), null, "unwrap burns go to zero");
+ assert.equal(boostFromTransfer(transfer({ to: "0xabc0000000000000000000000000000000000002" })), null, "a plain transfer");
+ assert.equal(boostFromTransfer(transfer({ from: LOCKER.toUpperCase().replace("0X", "0x") }), [LOCKER]), null, "the locker's own fee burn");
+ assert.equal(boostFromTransfer(transfer({ value: 300_000n * E18 })), null, "no tag");
+ assert.equal(boostFromTransfer(transfer({ value: 300_000n * E18 + LAUNCH_TAG_MAX + 5n })), null, "a reserved tag");
+ assert.equal(boostFromTransfer(transfer({ value: (BOOST_FLOOR_TWIG - 1n) * E18 + ID })), null, "under the floor");
+ assert.ok(boostFromTransfer(transfer({ value: BOOST_FLOOR_TWIG * E18 + ID })), "exactly the floor counts");
+});
+
+const row = (token: string, twig: bigint, lastAt: string) => ({ token, twig: (twig * E18).toString(), boosts: 1, boosters: 1, last_at: lastAt, last_tx: "0x" });
+
+test("the lane orders by TWIG in the window, then the newer boost, then the address", () => {
+ const ranked = rankLane([
+ row("0xc", 100_000n, "2026-10-15T01:00:00Z"),
+ row("0xa", 5_000_000n, "2026-10-15T00:00:00Z"),
+ row("0xb", 100_000n, "2026-10-15T02:00:00Z"),
+ row("0xe", 100_000n, "2026-10-15T01:00:00Z"),
+ row("0xd", 300_000n, "2026-10-14T23:00:00Z"),
+ row("0xf", 100_000n, "2026-10-14T00:00:00Z"),
+ ]);
+ assert.deepEqual(ranked.map((r) => r.token), ["0xa", "0xd", "0xb", "0xc", "0xe"]);
+ assert.equal(rankLane([row("0xa", 1n, "2026-10-15T00:00:00Z")], 0).length, 0);
+});
+
+test("a boost runs 24 hours from the newest one, and says so", () => {
+ const last = "2026-10-15T00:00:00.000Z";
+ const t0 = Date.parse(last);
+ assert.equal(boostExpiresAt(last), t0 + 24 * 3_600_000);
+ assert.equal(boostTimeLeft(last, t0), "24h left");
+ assert.equal(boostTimeLeft(last, t0 + 18.5 * 3_600_000), "5h left");
+ assert.equal(boostTimeLeft(last, t0 + 23.25 * 3_600_000), "45m left");
+ assert.equal(boostTimeLeft(last, t0 + 24 * 3_600_000 - 30_000), "under 1m left");
+ assert.equal(boostTimeLeft(last, t0 + 24 * 3_600_000), null);
+ assert.equal(boostTimeLeft("not a date", t0), null);
+});
+
+test("amounts read as people say them", () => {
+ assert.equal(groupWhole(1_000_000n), "1,000,000");
+ assert.equal(groupWhole(999n), "999");
+ assert.equal(fmtBoostTwig(1_200_000n * E18 + ID), "1.2M TWIG");
+ assert.equal(fmtBoostTwig(1_250_000n * E18), "1.25M TWIG");
+ assert.equal(fmtBoostTwig(10_000_000n * E18), "10M TWIG");
+ assert.equal(fmtBoostTwig((300_000n * E18 + ID).toString()), "300K TWIG");
+ assert.equal(fmtBoostTwig(500n * E18), "500 TWIG");
+ // never "1000K": a value that rounds up to the next unit takes it
+ assert.equal(compactWhole(999_999), "1M");
+ assert.equal(compactWhole(999_994), "999.99K");
+ assert.equal(compactWhole(999_995_000), "1B");
+ assert.equal(compactWhole(1_000), "1K");
+ assert.equal(compactWhole(999), "999");
+ assert.equal(fmtBoostTwig(999_999n * E18 + ID), "1M TWIG");
+ assert.equal(boostConfirmLabel(300_000n), "Send 300,000 TWIG to 0x…dEaD");
+});
+
+test("an admin signature names the action, the token and the admin, and cannot pass for a posts signature", () => {
+ assert.ok(isBoostModAction("hide") && isBoostModAction("unhide"));
+ assert.equal(isBoostModAction("mute"), false);
+ const m = buildBoostModMessage({ action: "hide", token: "0xABC", wallet: "0xDEF", nonce: "n1", ts: Date.parse("2026-10-15T00:00:00Z") });
+ assert.equal(m, ["openlaunch.lol boosted lane", "", "Action: hide", "Token: base:0xabc", "Admin: 0xdef", "Nonce: n1", "Issued: 2026-10-15T00:00:00.000Z"].join("\n"));
+ assert.ok(!m.includes("post:"));
+});
+
+test("the words keep to the rules: no value talk, the burn and its finality said plainly", () => {
+ const banned = /\b(moon|rally|buyback|guarantee[ds]?|pump|gem|100x|profit|invest(ment)?|returns?|yield|airdrop|reward)\b/i;
+ for (const [k, v] of Object.entries(BOOST_COPY)) assert.ok(!banned.test(v), `${k}: ${v}`);
+ assert.match(BOOST_COPY.final, /cannot be undone or refunded/);
+ assert.match(BOOST_COPY.laneNote, /Not a ranking/);
+ assert.match(BOOST_COPY.what, /not an endorsement/);
+});
+
+test("the fuse is the share of the 24 hours still left", () => {
+ const last = "2026-10-15T00:00:00.000Z";
+ const t0 = Date.parse(last);
+ assert.equal(boostFuse(last, t0), 1);
+ assert.equal(boostFuse(last, t0 + 6 * 3_600_000), 0.75);
+ assert.equal(boostFuse(last, t0 + 24 * 3_600_000), 0);
+ assert.equal(boostFuse(last, t0 + 30 * 3_600_000), 0);
+ assert.equal(boostFuse(last, t0 - 60_000), 1, "a clock behind the chain never overfills it");
+ assert.equal(boostFuse("not a date", t0), 0);
+});
+
+test("a card lights up only for a fresh boost that added TWIG", () => {
+ const now = Date.parse("2026-10-15T12:00:00Z");
+ const at = (msAgo: number) => new Date(now - msAgo).toISOString();
+ const item = (token: string, twig: bigint, msAgo: number) => ({ token, twig: (twig * E18).toString(), boosts: 1, boosters: 1, last_at: at(msAgo), last_tx: "0x" });
+ const prev = new Map([["0xa", (100_000n * E18).toString()], ["0xb", (500_000n * E18).toString()]]);
+ const lit = boostIgnitions(prev, [
+ item("0xa", 400_000n, 10_000), // grew, fresh
+ item("0xb", 500_000n, 10_000), // unchanged
+ item("0xc", 300_000n, 20_000), // new to the lane, fresh
+ item("0xd", 900_000n, 2 * 3_600_000), // new to the lane only because another expired: old boost
+ ], now);
+ assert.deepEqual([...lit].sort(), ["0xa", "0xc"]);
+ assert.equal(boostIgnitions(null, [item("0xa", 1n, 0)], now).size, 0, "the first snapshot lights nothing");
+ assert.equal(boostIgnitions(new Map(), [item("0xa", 1n, IGNITE_FRESH_MS + 1)], now).size, 0, "a tab back from sleep replays nothing");
+ // fewer TWIG (an old boost aged out) is never news
+ assert.equal(boostIgnitions(new Map([["0xa", (900_000n * E18).toString()]]), [item("0xa", 400_000n, 0)], now).size, 0);
+});
+
+test("the dialog knows whether a boost shows now", () => {
+ const full = { full: true, cutoff: (1_000_000n * E18).toString() };
+ assert.equal(boostShowsNow({ full: false, cutoff: null }, 0n, 100_000n * E18, false), true, "room in the lane");
+ assert.equal(boostShowsNow(full, 0n, 100_000n * E18, false), false, "under the 5th place");
+ assert.equal(boostShowsNow(full, 0n, 1_000_000n * E18, false), true, "a tie goes to the newer boost");
+ assert.equal(boostShowsNow(full, 900_000n * E18, 100_000n * E18, false), true, "it adds to what the token already has");
+ assert.equal(boostShowsNow(full, 0n, 1n, true), true, "already in the lane");
+});
diff --git a/app/src/lib/launchpad/boost.ts b/app/src/lib/launchpad/boost.ts
new file mode 100644
index 00000000..cca46bcf
--- /dev/null
+++ b/app/src/lib/launchpad/boost.ts
@@ -0,0 +1,237 @@
+/**
+ * Boost: TWIG sent to 0x…dEaD buys a token a place in the Boosted lane for 24 hours. Pure, node --test loads it directly.
+ *
+ * One rule, stated once:
+ * A boost is one plain TWIG.transfer(0x…dEaD, amount) on Base whose amount names the launch in its last digits:
+ * amount = whole TWIG × 10^18 + the launch's position id (bb_launches.token_id, unique on Base's PositionManager).
+ * The tag is worth less than 10^-6 TWIG, so wallets show the whole amount. It lives in the Transfer event itself:
+ * the indexer reads logs only, and a plain wallet, a smart wallet, a Safe and an agent all boost the same way.
+ *
+ * The Boosted lane is a separate, labelled surface. It is never read by the Live sort, the Trending board or
+ * ranking.ts (boost-ui.test.ts guards that): a token cannot buy its way into the facts-only ranking.
+ * Nothing reaches Twigpine: the TWIG is gone, and the GITLAWB behind it stays in the TWIG contract.
+ */
+import { TWIG_ADDRESS, TWIG_DECIMALS, TWIG_SYMBOL } from "./twig.ts";
+import { CHAIN_IDS } from "../chainKeys.ts";
+
+/** Boosts exist on Base only: TWIG has not been bridged anywhere. */
+export const BOOST_CHAIN = "base" as const;
+export const BOOST_CHAIN_ID = CHAIN_IDS[BOOST_CHAIN];
+/** Lowercase, like every address the indexer compares. */
+export const BOOST_DEAD = "0x000000000000000000000000000000000000dead";
+export const BOOST_TOKEN = TWIG_ADDRESS;
+/** The least a boost may send, in whole TWIG. In TWIG, not dollars, so a pushed TWIG price cannot move it. */
+export const BOOST_FLOOR_TWIG = 100_000n;
+export const BOOST_WINDOW_H = 24;
+export const BOOST_WINDOW_MS = BOOST_WINDOW_H * 3_600_000;
+/** Cards in the lane: the leader and four, like the Trending board. */
+export const BOOST_LANE_SIZE = 5;
+export const BOOST_PRESETS = ["100000", "300000", "1000000", "5000000"] as const;
+/** The largest whole amount the dialog accepts: more than every TWIG in existence, so it only stops typos. */
+export const BOOST_MAX_TWIG = 10n ** 11n;
+
+const UNIT = 10n ** BigInt(TWIG_DECIMALS);
+/** The last 12 digits of a boost's raw amount are its tag. */
+export const TAG_SPACE = 10n ** 12n;
+/** Tags below this name a launch by its position id; tags from here up are reserved for later kinds (pinned posts, names). */
+export const LAUNCH_TAG_MAX = 10n ** 11n;
+
+/** True for a position id a boost can carry in its last digits. */
+export function isLaunchTag(tag: bigint): boolean {
+ return tag > 0n && tag < LAUNCH_TAG_MAX;
+}
+
+/** The raw amount for a boost of `whole` TWIG on the launch with position id `tag`. */
+export function boostAmount(whole: bigint, tag: bigint): bigint {
+ if (whole < 1n) throw new Error("a boost sends at least 1 TWIG");
+ if (!isLaunchTag(tag)) throw new Error("not a launch tag");
+ return whole * UNIT + tag;
+}
+
+/** What a raw amount names: its tag (last 12 digits). */
+export function boostTagOf(raw: bigint): bigint {
+ return raw % TAG_SPACE;
+}
+
+/** Whole TWIG in a raw amount (the tag is far below one TWIG). */
+export function boostWholeOf(raw: bigint): bigint {
+ return raw / UNIT;
+}
+
+/** The most whole TWIG a balance can boost with, the tag included; 0 when it cannot pay one TWIG and the tag. */
+export function maxBoostWhole(balance: bigint, tag: bigint): bigint {
+ let w = balance / UNIT;
+ if (w > 0n && w * UNIT + tag > balance) w -= 1n;
+ return w;
+}
+
+/** The dialog's amount box: whole TWIG only, digits with optional grouping commas, at least 1, at most BOOST_MAX_TWIG. */
+export function parseBoostWhole(input: string): bigint | null {
+ const s = input.replace(/[,\s_]/g, "");
+ if (!/^\d{1,12}$/.test(s)) return null;
+ const n = BigInt(s);
+ return n >= 1n && n <= BOOST_MAX_TWIG ? n : null;
+}
+
+/** Why an amount cannot be sent yet, or null when it can. */
+export function boostAmountProblem(whole: bigint | null, balance: bigint | undefined, tag: bigint): string | null {
+ if (whole === null) return "Enter a whole number of TWIG.";
+ if (whole < BOOST_FLOOR_TWIG) return `A boost sends at least ${groupWhole(BOOST_FLOOR_TWIG)} TWIG.`;
+ if (balance !== undefined && boostAmount(whole, tag) > balance) return "Not enough TWIG in this wallet.";
+ return null;
+}
+
+/** "1,000,000": every digit, grouped (what the wallet will be asked to send, never rounded). */
+export function groupWhole(n: bigint): string {
+ return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+const UNITS: readonly [number, string][] = [[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]];
+
+/** "1.2M", "300K", "999.99K", "1M" (never "1000K": a value that rounds up to the next unit takes that unit). */
+export function compactWhole(whole: number): string {
+ for (const [u, s] of UNITS) {
+ if (whole >= u * 0.999995) return `${(whole / u).toFixed(2).replace(/\.?0+$/, "")}${s}`;
+ }
+ return Math.floor(whole).toString();
+}
+
+/** "1.2M TWIG", "300K TWIG" from a raw amount (lane cards, the token page line). */
+export function fmtBoostTwig(raw: bigint | string): string {
+ return `${compactWhole(Number(boostWholeOf(BigInt(raw))))} ${TWIG_SYMBOL}`;
+}
+
+/* ─────────────────────────────── the indexer's half ─────────────────────────────── */
+
+/** One ERC-20 Transfer log, as the indexer hands it over (addresses in any case). */
+export type BoostTransfer = { address: string; from: string; to: string; value: bigint; txHash: string; logIndex: number; blockNumber: bigint };
+/** The row a boost becomes: raw facts only. The launch is joined at read time, by tag. */
+export type BoostRow = { tx_hash: string; log_index: number; booster: string; amount: string; tag: string; block_number: string };
+
+/**
+ * A Transfer log → a boost row, or null when it is not one: not TWIG, not to 0x…dEaD, sent by an address in `skip`
+ * (the launch locker's own fee burns), a tag that names no launch, or less than the floor.
+ */
+export function boostFromTransfer(t: BoostTransfer, skip: readonly string[] = []): BoostRow | null {
+ if (t.address.toLowerCase() !== BOOST_TOKEN) return null;
+ if (t.to.toLowerCase() !== BOOST_DEAD) return null;
+ const booster = t.from.toLowerCase();
+ if (skip.some((s) => s.toLowerCase() === booster)) return null;
+ const tag = boostTagOf(t.value);
+ if (!isLaunchTag(tag)) return null;
+ if (boostWholeOf(t.value) < BOOST_FLOOR_TWIG) return null;
+ return { tx_hash: t.txHash.toLowerCase(), log_index: t.logIndex, booster, amount: t.value.toString(), tag: tag.toString(), block_number: t.blockNumber.toString() };
+}
+
+/* ─────────────────────────────── the lane ─────────────────────────────── */
+
+/** A token's boosts inside the window, summed (the database groups; this orders). */
+export type LaneTotals = { token: string; twig: string; boosts: number; boosters: number; last_at: string; last_tx: string };
+
+/** Most TWIG in the window first; a tie goes to the newer boost, then to the address, so the order never flickers. */
+export function rankLane(rows: readonly T[], size = BOOST_LANE_SIZE): T[] {
+ return [...rows]
+ .sort((a, b) => {
+ const d = BigInt(b.twig) - BigInt(a.twig);
+ if (d !== 0n) return d > 0n ? 1 : -1;
+ const t = Date.parse(b.last_at) - Date.parse(a.last_at);
+ if (t !== 0) return t;
+ return a.token < b.token ? -1 : a.token > b.token ? 1 : 0;
+ })
+ .slice(0, size);
+}
+
+/** When a token leaves the lane: 24 hours after its newest boost. */
+export function boostExpiresAt(lastAt: string): number {
+ return Date.parse(lastAt) + BOOST_WINDOW_MS;
+}
+
+/** "23h left", "45m left", "under 1m left"; null once the boost has run out. */
+export function boostTimeLeft(lastAt: string, nowMs: number): string | null {
+ const ms = boostExpiresAt(lastAt) - nowMs;
+ if (!(ms > 0)) return null;
+ const m = Math.floor(ms / 60_000);
+ if (m < 1) return "under 1m left";
+ if (m < 60) return `${m}m left`;
+ return `${Math.floor(m / 60)}h left`;
+}
+
+/** How much of a boost's 24 hours is left, 0 to 1: the length of the card's fuse. */
+export function boostFuse(lastAt: string, nowMs: number): number {
+ const left = (boostExpiresAt(lastAt) - nowMs) / BOOST_WINDOW_MS;
+ return Number.isFinite(left) ? Math.min(1, Math.max(0, left)) : 0;
+}
+
+/** A boost newer than this when a poll first shows it is news; older ones (a tab back from sleep) light nothing. */
+export const IGNITE_FRESH_MS = 180_000;
+
+/**
+ * Which cards light up on this poll: a token with more TWIG than the last snapshot showed (a new boost, or a token new
+ * to the lane), whose newest boost is still fresh. `prev` null = the first snapshot this view has seen: nothing lights.
+ * A token that only moved up because another expired has no fresh boost and stays still.
+ */
+export function boostIgnitions(prev: ReadonlyMap | null, items: readonly LaneTotals[], nowMs: number, freshMs = IGNITE_FRESH_MS): Set {
+ const out = new Set();
+ if (!prev) return out;
+ for (const it of items) {
+ const before = prev.get(it.token);
+ const grew = before === undefined || BigInt(it.twig) > BigInt(before);
+ const fresh = nowMs - Date.parse(it.last_at) <= freshMs;
+ if (grew && fresh) out.add(it.token);
+ }
+ return out;
+}
+
+/** The lane as the dialog needs it: is it full, and what does the last place hold (raw TWIG in the window). */
+export type LaneEntry = { full: boolean; cutoff: string | null };
+
+/**
+ * Whether a boost of `raw` brings a token with `current` TWIG in the window into the lane as it stands. A full lane
+ * needs at least the last place's total (a tie goes to the newer boost). A token already in the lane stays in it.
+ */
+export function boostShowsNow(entry: LaneEntry, current: bigint, raw: bigint, inLane: boolean): boolean {
+ if (inLane || !entry.full || entry.cutoff === null) return true;
+ return current + raw >= BigInt(entry.cutoff);
+}
+
+/* ─────────────────────────────── moderation ─────────────────────────────── */
+
+export const BOOST_MOD_ACTIONS = ["hide", "unhide"] as const;
+export type BoostModAction = (typeof BOOST_MOD_ACTIONS)[number];
+export function isBoostModAction(v: unknown): v is BoostModAction {
+ return typeof v === "string" && (BOOST_MOD_ACTIONS as readonly string[]).includes(v);
+}
+
+/** The text an admin wallet signs to hide a token from the lane or show it again. Its own wording, so a posts signature never replays here. */
+export function buildBoostModMessage(p: { action: BoostModAction; token: string; wallet: string; nonce: string; ts: number }): string {
+ return [
+ `openlaunch.lol boosted lane`,
+ ``,
+ `Action: ${p.action}`,
+ `Token: ${BOOST_CHAIN}:${p.token.toLowerCase()}`,
+ `Admin: ${p.wallet.toLowerCase()}`,
+ `Nonce: ${p.nonce}`,
+ `Issued: ${new Date(p.ts).toISOString()}`,
+ ].join("\n");
+}
+
+/* ─────────────────────────────── words ─────────────────────────────── */
+
+/** Every sentence the feature shows, in one place, so a test can hold them to the rules (no value talk). */
+export const BOOST_COPY = {
+ laneTitle: "Boosted",
+ laneNote: "Paid in TWIG sent to 0x…dEaD. Not a ranking: the Live sort and Trending count outside wallets only.",
+ laneEmpty: "Nothing is boosted right now. Any Base launch can be boosted with TWIG from its page.",
+ what: "The Boosted lane shows the 5 tokens with the most TWIG sent for them in the last 24 hours. A boost counts toward that total for 24 hours. It does not change the Live sort or the Trending board, and it is not an endorsement.",
+ tag: "The last digits of the amount name this token, so the transfer itself records what it boosted.",
+ final: "The TWIG goes to 0x…dEaD. It cannot be undone or refunded, and nothing is paid to openlaunch or Twigpine.",
+ hidden: "This token is not shown in the Boosted lane.",
+ baseOnly: "Boosts are on Base only: TWIG exists only there.",
+ how: "Anyone can boost any Base launch from its page, from 100,000 TWIG. Boosts on one token in the same 24 hours add up. When the lane is full, a token shows once its total passes the 5th place.",
+ short: "The lane is full. This boost alone will not bring this token into it yet: the 5th place holds more. It still counts for 24 hours and adds up with any other boost.",
+} as const;
+
+/** The confirm button's words for an amount. */
+export function boostConfirmLabel(whole: bigint): string {
+ return `Send ${groupWhole(whole)} TWIG to 0x…dEaD`;
+}
diff --git a/app/src/lib/launchpad/boostServer.ts b/app/src/lib/launchpad/boostServer.ts
new file mode 100644
index 00000000..0c9de140
--- /dev/null
+++ b/app/src/lib/launchpad/boostServer.ts
@@ -0,0 +1,176 @@
+import "server-only";
+import { isAddress } from "viem";
+import { maybeDb } from "@/lib/db";
+import { getLaunchesByRefs, type LaunchRow } from "./queries";
+import { forgetMemo, memo } from "./memo";
+import { boostEnabled } from "./boostSwitch";
+import { tsFresh } from "./posts";
+import { adminWallets, consumeNonce, isNonce, verify } from "./postsServer";
+import {
+ BOOST_CHAIN,
+ BOOST_CHAIN_ID,
+ BOOST_FLOOR_TWIG,
+ BOOST_LANE_SIZE,
+ BOOST_WINDOW_H,
+ boostExpiresAt,
+ buildBoostModMessage,
+ isBoostModAction,
+ rankLane,
+ type LaneEntry,
+ type LaneTotals,
+} from "./boost";
+
+export { boostEnabled };
+
+/**
+ * Server half of Boost (boost.ts holds the rule). The feature is OFF unless the runtime secret BOOST=on is set
+ * (`fly secrets set BOOST=on`, which restarts the app; no rebuild). Off, the API says only `{ enabled: false }` and no
+ * page shows the lane, the token page line or the dialog. The indexer records boosts either way: they are TWIG burns
+ * on-chain whatever the switch says, and turning it on then shows the last 24 hours as they were.
+ */
+export type BoostLaneItem = LaneTotals & { expires_at: string; launch: LaunchRow };
+export type BoostLane = { enabled: false } | { enabled: true; window_h: number; floor_twig: string; items: BoostLaneItem[] };
+export type TokenBoost =
+ | { enabled: false }
+ | { enabled: true; hidden: boolean; twig: string; boosts: number; boosters: number; last_at: string | null; last_tx: string | null; expires_at: string | null; place: number | null; entry: LaneEntry };
+
+const RAW_FLOOR = (BOOST_FLOOR_TWIG * 10n ** 18n).toString();
+const LANE_TTL_MS = 5_000;
+
+/**
+ * Every token's boosts inside the window, summed, for tokens not hidden from the lane, largest first. The launch is
+ * joined by position id (the tag), so a boost that names no launch is never shown. `limit` bounds the read.
+ */
+async function laneTotals(limit: number): Promise {
+ const db = maybeDb();
+ if (!db) return [];
+ return db`
+ SELECT l.token, sum(b.amount)::text AS twig, count(*)::int AS boosts, count(DISTINCT b.booster)::int AS boosters,
+ max(b.block_time) AS last_at,
+ (array_agg(b.tx_hash ORDER BY b.block_number DESC, b.log_index DESC))[1] AS last_tx
+ FROM bb_boosts b
+ JOIN bb_launches l ON l.chain_id = b.chain_id AND l.token_id = b.tag
+ LEFT JOIN bb_token_settings s ON s.chain_id = l.chain_id AND s.token = l.token
+ WHERE b.chain_id = ${BOOST_CHAIN_ID}
+ AND b.block_time > now() - make_interval(hours => ${BOOST_WINDOW_H})
+ AND b.amount >= ${RAW_FLOOR}::numeric
+ AND NOT COALESCE(s.boost_hidden, false)
+ GROUP BY l.token
+ ORDER BY sum(b.amount) DESC, max(b.block_time) DESC
+ LIMIT ${limit}`;
+}
+
+const TOTALS_KEY = "boost:lane-totals";
+const LANE_KEY = "boost:lane";
+
+/** The lane's order, shared for a few seconds by every page load and poll. */
+function rankedLane(): Promise {
+ return memo(TOTALS_KEY, LANE_TTL_MS, async () => rankLane(await laneTotals(BOOST_LANE_SIZE * 4), BOOST_LANE_SIZE * 4));
+}
+
+/**
+ * After a write that changes the lane (a boost just indexed, an admin hide): the next read on this machine is fresh,
+ * so the booster's page shows its place and the admin's list drops the card. Another machine catches up within LANE_TTL_MS.
+ */
+export function forgetBoostLane(): void {
+ forgetMemo(TOTALS_KEY);
+ forgetMemo(LANE_KEY);
+}
+
+/** Is the lane full, and what does its last place hold: what a boost has to reach to show now. */
+function laneEntry(ranked: readonly LaneTotals[]): LaneEntry {
+ const full = ranked.length >= BOOST_LANE_SIZE;
+ return { full, cutoff: full ? ranked[BOOST_LANE_SIZE - 1].twig : null };
+}
+
+/** The Boosted lane: the top BOOST_LANE_SIZE tokens with their market rows. `{ enabled: false }` while the switch is off. */
+export async function getBoostLane(ethUsd: number | null): Promise {
+ if (!boostEnabled()) return { enabled: false };
+ // a few spare candidates, so a token whose market row cannot be read leaves its place to the next one, not a hole
+ const top = (await rankedLane()).slice(0, BOOST_LANE_SIZE + 3);
+ const rows = top.length > 0 ? await getLaunchesByRefs(top.map((t) => ({ chain: BOOST_CHAIN, token: t.token })), ethUsd) : [];
+ const byToken = new Map(rows.map((r) => [r.launch.token, r.launch]));
+ const items = top
+ .flatMap((t) => {
+ const launch = byToken.get(t.token);
+ return launch ? [{ ...t, expires_at: new Date(boostExpiresAt(t.last_at)).toISOString(), launch }] : [];
+ })
+ .slice(0, BOOST_LANE_SIZE);
+ return { enabled: true, window_h: BOOST_WINDOW_H, floor_twig: BOOST_FLOOR_TWIG.toString(), items };
+}
+
+/**
+ * The lane for a page render or a live poll, shared for a few seconds; null when it could not be read. Never the reason
+ * a page fails: a page then shows no lane, and a poll sends none, so open tabs keep what they show until the next tick.
+ */
+export async function boostLaneOrNull(ethUsd: number | null): Promise {
+ if (!boostEnabled()) return { enabled: false };
+ return memo(LANE_KEY, LANE_TTL_MS, () => getBoostLane(ethUsd)).catch((err) => {
+ console.warn("[boost] lane read failed:", err instanceof Error ? err.message : err);
+ return null;
+ });
+}
+
+/** One token's boost state for its page: TWIG inside the window, its place in the lane (1-based) and whether an admin hid it. */
+export async function getTokenBoost(token: string): Promise {
+ if (!boostEnabled()) return { enabled: false };
+ const db = maybeDb();
+ const t = token.toLowerCase();
+ const none = { enabled: true as const, hidden: false, twig: "0", boosts: 0, boosters: 0, last_at: null, last_tx: null, expires_at: null, place: null, entry: { full: false, cutoff: null } };
+ if (!db) return none;
+ const [[row], [setting], ranked] = await Promise.all([
+ db<{ twig: string; boosts: number; boosters: number; last_at: string | null; last_tx: string | null }[]>`
+ SELECT COALESCE(sum(b.amount), 0)::text AS twig, count(*)::int AS boosts, count(DISTINCT b.booster)::int AS boosters,
+ max(b.block_time) AS last_at,
+ (array_agg(b.tx_hash ORDER BY b.block_number DESC, b.log_index DESC))[1] AS last_tx
+ FROM bb_boosts b
+ JOIN bb_launches l ON l.chain_id = b.chain_id AND l.token_id = b.tag
+ WHERE b.chain_id = ${BOOST_CHAIN_ID} AND l.token = ${t}
+ AND b.block_time > now() - make_interval(hours => ${BOOST_WINDOW_H})
+ AND b.amount >= ${RAW_FLOOR}::numeric`,
+ db<{ boost_hidden: boolean }[]>`SELECT boost_hidden FROM bb_token_settings WHERE chain_id = ${BOOST_CHAIN_ID} AND token = ${t}`,
+ rankedLane(),
+ ]);
+ const i = ranked.findIndex((r) => r.token === t);
+ return {
+ enabled: true,
+ hidden: setting?.boost_hidden === true,
+ twig: row?.twig ?? "0",
+ boosts: row?.boosts ?? 0,
+ boosters: row?.boosters ?? 0,
+ last_at: row?.last_at ?? null,
+ last_tx: row?.last_tx ?? null,
+ expires_at: row?.last_at ? new Date(boostExpiresAt(row.last_at)).toISOString() : null,
+ place: i >= 0 && i < BOOST_LANE_SIZE ? i + 1 : null,
+ entry: laneEntry(ranked),
+ };
+}
+
+type Fail = { ok: false; error: string; status: number };
+const fail = (error: string, status: number): Fail => ({ ok: false, error, status });
+
+/**
+ * Admin hide / unhide of one Base token in the Boosted lane: an ADMIN_WALLETS signature over buildBoostModMessage with
+ * a single-use nonce and a fresh timestamp. Boosts already sent stay recorded and are never refunded; a hidden token
+ * simply does not appear, and its page says so (so nobody burns TWIG for a place it cannot get).
+ */
+export async function moderateBoost(p: { action: unknown; token: unknown; wallet: unknown; nonce: unknown; ts: unknown; signature: unknown }): Promise<{ ok: true } | Fail> {
+ const db = maybeDb();
+ if (!db) return fail("db unconfigured", 503);
+ if (typeof p.wallet !== "string" || !isAddress(p.wallet)) return fail("bad address", 400);
+ const wallet = p.wallet.toLowerCase();
+ if (!isBoostModAction(p.action)) return fail("bad action", 400);
+ if (typeof p.token !== "string" || !isAddress(p.token)) return fail("bad token", 400);
+ const token = p.token.toLowerCase();
+ if (!isNonce(p.nonce) || !tsFresh(p.ts, Date.now())) return fail("stale or bad nonce", 400);
+ if (!adminWallets().has(wallet)) return fail("admin only", 403);
+ const [known] = await db<{ token: string }[]>`SELECT token FROM bb_launches WHERE chain_id = ${BOOST_CHAIN_ID} AND token = ${token}`;
+ if (!known) return fail("unknown token", 404);
+ const message = buildBoostModMessage({ action: p.action, token, wallet, nonce: p.nonce, ts: Number(p.ts) });
+ if (!(await verify(BOOST_CHAIN, wallet, message, p.signature))) return fail("signature does not match", 401);
+ if (!(await consumeNonce(p.nonce, wallet))) return fail("nonce already used", 401);
+ await db`INSERT INTO bb_token_settings (chain_id, token, boost_hidden) VALUES (${BOOST_CHAIN_ID}, ${token}, ${p.action === "hide"})
+ ON CONFLICT (chain_id, token) DO UPDATE SET boost_hidden = EXCLUDED.boost_hidden, updated_at = now()`;
+ forgetBoostLane();
+ return { ok: true };
+}
diff --git a/app/src/lib/launchpad/boostSwitch.ts b/app/src/lib/launchpad/boostSwitch.ts
new file mode 100644
index 00000000..8efc6b93
--- /dev/null
+++ b/app/src/lib/launchpad/boostSwitch.ts
@@ -0,0 +1,9 @@
+import "server-only";
+
+/**
+ * The BOOST runtime switch (`fly secrets set BOOST=on`, which restarts the app; no rebuild). Its own module so the
+ * totals query can ask it without importing the lane's server half. Anything else, or unset, is off.
+ */
+export function boostEnabled(): boolean {
+ return process.env.BOOST?.trim().toLowerCase() === "on";
+}
diff --git a/app/src/lib/launchpad/indexer.ts b/app/src/lib/launchpad/indexer.ts
index b9f41313..74a67fd0 100644
--- a/app/src/lib/launchpad/indexer.ts
+++ b/app/src/lib/launchpad/indexer.ts
@@ -4,13 +4,15 @@ import { publicClient } from "@/lib/chain";
import { chainIdOf, type ChainKey } from "@/lib/chainPublic";
import { maybeDb, errMessage, type Db } from "@/lib/db";
import { LAUNCH_FACTORY_ABI, LAUNCH_LOCKER_ABI, POOL_MANAGER_ABI, ERC20_MIN_ABI, ERC20_TRANSFER_EVENT, LAUNCHED_EVENT, POOL_SWAP_EVENT, LOCKER_EVENTS } from "./abi";
-import { CONFIGURED_CHAINS, launchpad, listedQuoteAddresses } from "./config";
+import { CONFIGURED_CHAINS, DEAD, launchpad, listedQuoteAddresses } from "./config";
import { validDecimals } from "./unlisted-quote";
import { DEAD_ADDR, ZERO_ADDR } from "./holders";
import { SYNC_CHUNK_BLOCKS, SYNC_MAX_CHUNKS_PER_CALL, syncOverlapBlocks } from "@/lib/config";
import { byChainOrder, fetchBySelectors, fetchLogsSplit, isRangeTooLarge } from "./log-range";
import { redactUrls } from "./redact";
import { ENTRY_POINTS, attributeSwap, type ReceiptLog } from "./attribution";
+import { TWIG_ADDRESSES } from "./twig";
+import { boostFromTransfer } from "./boost";
/**
* Launchpad chain → Postgres indexer.
@@ -22,6 +24,7 @@ import { ENTRY_POINTS, attributeSwap, type ReceiptLog } from "./attribution";
* LaunchFactory.Launched → bb_launches (+ name/symbol read from the token)
* PoolManager.Swap (id ∈ our pool ids) → bb_launch_swaps + rolling price / volume on bb_launches
* LaunchLocker.Collected/Burned/Credited/Claimed → bb_launch_fee_events + fee totals
+ * TWIG.Transfer to 0x…dEaD naming a launch (Base) → bb_boosts (boost.ts; the locker's own fee burns are skipped)
* Everything is idempotent on (tx_hash, log_index).
*/
export type LaunchSyncResult = {
@@ -33,6 +36,7 @@ export type LaunchSyncResult = {
launches?: number;
swaps?: number;
fees?: number;
+ boosts?: number;
caught_up?: boolean;
};
@@ -200,6 +204,24 @@ async function applySwap(db: Db, chain: ChainKey, log: Log & { args: Swap }, poo
}) as Promise;
}
+type TransferArgs = { from: Address; to: Address; value: bigint };
+
+/** Record one TWIG transfer to 0x…dEaD as a boost when its amount names a launch (boost.ts). The launch locker's own fee burns are never boosts. */
+async function applyBoost(db: Db, chain: ChainKey, log: Log & { args: TransferArgs }, locker: string): Promise {
+ const row = boostFromTransfer(
+ { address: log.address, from: log.args.from, to: log.args.to, value: log.args.value, txHash: log.transactionHash!, logIndex: Number(log.logIndex!), blockNumber: log.blockNumber! },
+ [locker],
+ );
+ if (!row) return false;
+ const time = await timeOf(chain, log.blockNumber!);
+ const rows = await db`
+ INSERT INTO bb_boosts (chain_id, tx_hash, log_index, booster, amount, tag, block_number, block_time)
+ VALUES (${chainIdOf(chain)}, ${row.tx_hash}, ${row.log_index}, ${row.booster}, ${row.amount}, ${row.tag}, ${row.block_number}, ${time})
+ ON CONFLICT DO NOTHING
+ RETURNING tx_hash`;
+ return rows.length > 0;
+}
+
type FeeLog = Log &
(
| { eventName: "Collected"; args: { tokenId: bigint; token: Address; quoteAmount: bigint; tokenAmount: bigint } }
@@ -280,7 +302,7 @@ async function poolMaps(db: Db, chain: ChainKey): Promise<{ poolToToken: Map([["robinhood", 1000]]);
/** Apply every launchpad-relevant log in one range. Launched first so same-range swaps resolve. */
-async function applyRange(db: Db, chain: ChainKey, from: bigint, to: bigint): Promise<{ launches: number; swaps: number; fees: number }> {
+async function applyRange(db: Db, chain: ChainKey, from: bigint, to: bigint): Promise<{ launches: number; swaps: number; fees: number; boosts: number }> {
const client = publicClient(chain);
const cfg = launchpad(chain);
const factory = cfg.factory!;
@@ -306,10 +328,17 @@ async function applyRange(db: Db, chain: ChainKey, from: bigint, to: bigint): Pr
}
const feeLogs = await fetchLogsSplit((f, t) => client.getLogs({ address: locker, events: LOCKER_EVENTS, fromBlock: f, toBlock: t }), from, to);
for (const l of feeLogs) if (await applyFee(db, chain, l as unknown as FeeLog, tokenIdToToken)) fees++;
+ // boosts: TWIG sent to 0x…dEaD, one filtered log query per range, only where TWIG exists (Base)
+ let boosts = 0;
+ const twig = TWIG_ADDRESSES[chain];
+ if (twig) {
+ const burnLogs = await fetchLogsSplit((f, t) => client.getLogs({ address: twig as Address, event: ERC20_TRANSFER_EVENT, args: { to: DEAD }, fromBlock: f, toBlock: t }), from, to);
+ for (const l of burnLogs) if (await applyBoost(db, chain, l as Log & { args: TransferArgs }, locker.toLowerCase())) boosts++;
+ }
// holder balances: every Transfer of every launched token (idempotent; backfill covers history)
const tokens = [...new Set([...poolToToken.values()])];
if (tokens.length > 0) await applyTransfers(db, chain, tokens, from, to);
- return { launches, swaps, fees };
+ return { launches, swaps, fees, boosts };
}
// ── swap attribution backlog ─────────────────────────────────────────────────
@@ -767,7 +796,7 @@ async function run(chain: ChainKey): Promise {
const deploy = launchDeployBlock(chain);
let from = cursor_block > 0n ? cursor_block - syncOverlapBlocks() : deploy;
if (from < deploy) from = deploy;
- const totals = { launches: 0, swaps: 0, fees: 0 };
+ const totals = { launches: 0, swaps: 0, fees: 0, boosts: 0 };
let chunks = 0;
let to = from;
while (from <= confirmed && chunks < SYNC_MAX_CHUNKS_PER_CALL) {
@@ -777,6 +806,7 @@ async function run(chain: ChainKey): Promise {
totals.launches += r.launches;
totals.swaps += r.swaps;
totals.fees += r.fees;
+ totals.boosts += r.boosts;
await db`UPDATE bb_launch_sync_cursor SET cursor_block = ${to}, head_block = ${head}, last_run_at = now(), last_error = NULL WHERE chain_id = ${cid}`;
from = to + 1n;
chunks++;
@@ -791,9 +821,9 @@ async function run(chain: ChainKey): Promise {
}
// ── receipt apply ────────────────────────────────────────────────────────────
-export type ApplyLaunchTxResult = { status: "applied" | "not_found" | "reverted" | "skipped"; reason?: string; launches?: number; swaps?: number; fees?: number; tokens?: string[] };
+export type ApplyLaunchTxResult = { status: "applied" | "not_found" | "reverted" | "skipped"; reason?: string; launches?: number; swaps?: number; fees?: number; boosts?: number; tokens?: string[] };
-/** Apply one transaction's launches, swaps and fee events straight from its receipt (right after a wallet returns). */
+/** Apply one transaction's launches, swaps, fee events and boosts straight from its receipt (right after a wallet returns). */
export async function applyLaunchTx(chain: ChainKey, hash: Hex): Promise {
const reason = skipReason(chain);
if (reason) return { status: "skipped", reason };
@@ -833,5 +863,11 @@ export async function applyLaunchTx(chain: ChainKey, hash: Hex): Promise l.address.toLowerCase() === locker) });
for (const l of feeLogs) if (await applyFee(db, chain, l as unknown as FeeLog, tokenIdToToken)) fees++;
- return { status: "applied", launches, swaps, fees, tokens };
+ let boosts = 0;
+ const twig = TWIG_ADDRESSES[chain];
+ if (twig) {
+ const burnLogs = parseEventLogs({ abi: [ERC20_TRANSFER_EVENT], eventName: "Transfer", logs: receipt.logs.filter((l) => l.address.toLowerCase() === twig) });
+ for (const l of burnLogs) if (await applyBoost(db, chain, l as unknown as Log & { args: TransferArgs }, locker)) boosts++;
+ }
+ return { status: "applied", launches, swaps, fees, boosts, tokens };
}
diff --git a/app/src/lib/launchpad/memo.ts b/app/src/lib/launchpad/memo.ts
index 78155bb7..94300718 100644
--- a/app/src/lib/launchpad/memo.ts
+++ b/app/src/lib/launchpad/memo.ts
@@ -20,6 +20,11 @@ export function clearMemo(): void {
store.clear();
}
+/** Drop one key, so the next read is fresh (after a write that changes what it holds). Other keys are untouched. */
+export function forgetMemo(key: string): void {
+ store.delete(key);
+}
+
/** Test-only: current entry count. */
export function memoSizeForTests(): number {
return store.size;
diff --git a/app/src/lib/launchpad/postsServer.ts b/app/src/lib/launchpad/postsServer.ts
index 68e98f3d..fd0f927a 100644
--- a/app/src/lib/launchpad/postsServer.ts
+++ b/app/src/lib/launchpad/postsServer.ts
@@ -25,11 +25,12 @@ export function adminWallets(): Set {
return new Set((process.env.ADMIN_WALLETS ?? "").split(",").map((s) => s.trim().toLowerCase()).filter((s) => isAddress(s)));
}
-function isNonce(v: unknown): v is string {
+export function isNonce(v: unknown): v is string {
return typeof v === "string" && /^[0-9a-f]{32}$/.test(v);
}
-async function consumeNonce(nonce: string, wallet: string): Promise {
+/** Spend a single-use signing nonce for `wallet`; false when it was already used (a replay). Shared with boost moderation. */
+export async function consumeNonce(nonce: string, wallet: string): Promise {
const db = maybeDb()!;
try {
await db`INSERT INTO bb_post_nonces (nonce, wallet) VALUES (${nonce}, ${wallet})`;
@@ -40,7 +41,8 @@ async function consumeNonce(nonce: string, wallet: string): Promise {
}
}
-async function verify(chain: ChainKey, wallet: string, message: string, signature: unknown): Promise {
+/** True when `signature` is `wallet`'s signature of `message` (EOAs and smart wallets). Shared with boost moderation. */
+export async function verify(chain: ChainKey, wallet: string, message: string, signature: unknown): Promise {
if (typeof signature !== "string" || !/^0x[0-9a-fA-F]+$/.test(signature)) return false;
try {
return await publicClient(chain).verifyMessage({ address: wallet as Address, message, signature: signature as Hex });
diff --git a/app/src/lib/launchpad/queries.ts b/app/src/lib/launchpad/queries.ts
index 2fd62b43..2b3f36ab 100644
--- a/app/src/lib/launchpad/queries.ts
+++ b/app/src/lib/launchpad/queries.ts
@@ -10,6 +10,8 @@ import { gitlawbUsd } from "./gitlawbServer";
import { GITLAWB_ADDRESS, reconcileGitlawbUsd } from "./gitlawb";
import { MUSEWORLD_ADDRESS, MUSEWORLD_TWAP_WINDOW_S, timeWeightedPrice } from "./museworld";
import { gitlawbLinkedUsd } from "./twig";
+import { BOOST_CHAIN_ID } from "./boost";
+import { boostEnabled } from "./boostSwitch";
import { canonicalImageUrl, pictureKey, reusedPictures, type PictureUse } from "./images";
import { GRACE_HOURS, LIVE_WINDOW_HOURS, STRIP_SIZE, rankTrending, type LiveTier } from "./ranking";
import { SNIPER_BLOCKS, SYNCED_FOREVER } from "./holders";
@@ -530,10 +532,13 @@ export type LaunchTotals = {
*/
gitlawb_burned: string;
/**
- * TWIG sent to 0x…dEaD by launches quoted in it, raw 18-dec (Base only). Kept apart from gitlawb_burned: the GITLAWB
- * behind burned TWIG stays in the TWIG contract, so it is TWIG that was burned, and it is shown as such.
+ * TWIG sent to 0x…dEaD, raw 18-dec (Base only): the trading fees of launches quoted in it, plus boosts (boost.ts).
+ * Kept apart from gitlawb_burned: the GITLAWB behind burned TWIG stays in the TWIG contract, so it is TWIG that was
+ * burned, and it is shown as such.
*/
twig_burned: string;
+ /** The boosts' part of twig_burned, raw 18-dec (the hero's tooltip splits the two). */
+ twig_boost_burned: string;
by_chain: Record;
};
@@ -548,16 +553,32 @@ export async function getLaunchTotals(ethUsd: number | null = null): Promise [k, { launches: 0, trades: 0, volume_quote_eth: "0", volume_quote_usdg: "0", volume_quote_usdc: "0", volume_quote_gitlawb: "0", volume_quote_twig: "0" }])) as LaunchTotals["by_chain"],
});
const db = maybeDb();
if (!db) return empty();
await withStocks();
- const rows = await db<{ chain_id: number; quote: string; launches: bigint; trades: bigint; volume: string; burned: string; creators: string }[]>`
+ const [rows, [boosted]] = await Promise.all([
+ db<{ chain_id: number; quote: string; launches: bigint; trades: bigint; volume: string; burned: string; creators: string }[]>`
SELECT chain_id, quote, count(*)::bigint AS launches, COALESCE(sum(buys + sells), 0)::bigint AS trades,
COALESCE(sum(volume_quote), 0)::text AS volume, COALESCE(sum(fees_quote_burned), 0)::text AS burned,
COALESCE(sum(fees_quote_collected - fees_quote_burned), 0)::text AS creators
- FROM bb_launches GROUP BY chain_id, quote`;
+ FROM bb_launches GROUP BY chain_id, quote`,
+ // boosts are TWIG sent to 0x…dEaD too (boost.ts): they join the TWIG burned figure while the switch is on, and
+ // nothing else reads them here. Only boosts that name a launch count (the lane's own join), so a stray burn whose
+ // last digits name nothing is never called a boost. Display only: a failed read counts none rather than taking
+ // every page's totals down with it.
+ boostEnabled()
+ ? db<{ burned: string }[]>`
+ SELECT COALESCE(sum(b.amount), 0)::text AS burned FROM bb_boosts b
+ JOIN bb_launches l ON l.chain_id = b.chain_id AND l.token_id = b.tag
+ WHERE b.chain_id = ${BOOST_CHAIN_ID}`.catch((err) => {
+ console.warn("[totals] boost burns unread:", err instanceof Error ? err.message : err);
+ return [{ burned: "0" }];
+ })
+ : Promise.resolve([{ burned: "0" }]),
+ ]);
const t = empty();
const add = (a: string, b: string) => (BigInt(a) + BigInt(b)).toString();
for (const r of rows) {
@@ -590,6 +611,8 @@ export async function getLaunchTotals(ethUsd: number | null = null): Promise`, the admin, a single-use nonce, a time within 5 minutes), so a posts signature can never be replayed here. Hidden is a flag in `bb_token_settings.boost_hidden`. Burns already sent stay recorded and are never refunded. A hidden token's page says it is not shown in the lane and offers no button, so nobody burns TWIG for a place it cannot get.
+
+## Copy rules
+
+Always "sent to 0x…dEaD". Never a price or value claim, never "boost your price", never moon, rally, buyback, guarantee, reward, airdrop or yield (`boost.test.ts` checks every sentence). The lane says "Not a ranking". Boosted is not endorsed, and the dialog says so.
+
+## Development and verification
+
+```
+cd app
+npx tsx --conditions=react-server --tsconfig tsconfig.test.json --test src/lib/launchpad/boost.test.ts src/components/launchpad/boost-ui.test.ts
+BOOST=on npm run dev
+```
+
+On an anvil fork of Base, a wallet with TWIG can boost any launch the local database knows; the receipt path and the indexer path both record it. Weekly figures:
+
+```sql
+SELECT date_trunc('week', block_time) AS wk, count(*) AS boosts, count(DISTINCT booster) AS boosters, sum(amount) / 1e18 AS twig
+ FROM bb_boosts WHERE chain_id = 8453 GROUP BY 1 ORDER BY 1 DESC;
+```