Fornum

Launch a token with one WhatsApp message and keep the creator fees.

Live at fornum-exed.vercel.app

You text Fornum a name, a ticker and a picture. A person reads it, deploys the token on pump.fun from a Fornum launch wallet, and replies with the mint address. The creator fees that token earns are recorded against your number, and you claim them here to any Solana address. You can also hand the fees of a token to somebody else's number.

There is no bot, no form and no phone calls. The launch is a conversation, the site is where the money is.

Stack

Layer	Choice
Framework	Next.js 16, App Router, RSC, Turbopack
Styling	Tailwind CSS v4, tokens declared in CSS
Motion	CSS keyframes only, no animation library
Fonts	Geist Sans and Geist Mono through next/font
Chain	Solana, program in progress

Running it

npm install
npm run dev

Production build is npm run build, serve it with npm start.

Routes

/                 the number, the thread it runs through, live counters
/launch           how to launch, the number and the rules
/tokens           everything launched here, fees and who they belong to
/token/[id]       one token: fees, claim, hand over, claim history
/payouts          claims, every one with a transaction
/signin           sign in with a phone number by writing to it, link a wallet
/s/[token]        one time sign in link from the chat
/docs             how it works, including the money flow
/admin            sign ins, launches, fees and the counters shown on the site
/legal/*          terms and privacy

Only four are in the navigation: home, launch, tokens, claims. The rest are reached from the footer or from a card.

The number

Every launch, confirmation and payout goes through one WhatsApp thread, so the number is the largest element on the home page rather than a footnote. It is +1 (631) 660-1838, and it lives in content/site-config.json under whatsapp. display is what the site prints, e164 is what wa.me links are built from, digits only and no plus. Change one and you have to change the other, or the number on screen stops matching the thread it opens.

Database

Schema is db/schema.sql, run it once against DATABASE_URL. Tables: tokens, claims and launch requests. Amounts are lamports, stored as bigint.

Without DATABASE_URL the whole app falls back to an in memory store, so every page renders before anything is provisioned. That store resets on restart, which is the point: it is not a database. lib/db/store.ts is the only file that knows which one is in use.

Claiming

Creator fees accrue to the launch wallet that deployed the mint. pump.fun holds them until the creator collects, so a claim first sweeps and collects them into the launch wallet (one transaction built from pump.fun's published IDL, lib/pump/collect.ts), then sends a plain SOL transfer to the address the recipient gives us. Fees are never typed in: what a token earned is read off the chain, pump.fun's creator vaults plus the wallet above its funding line plus what was claimed (lib/tokens.ts).

POST /api/claim checks the session against the token's recipient hash, reads the wallet balance on chain, sends the transfer, then writes the claim and moves the claimed total in one transaction, so the same fees cannot go out twice. The wallet keeps a small reserve so it can always pay for the next transaction.

POST /api/assign hands the fees of a token to another number. One way on purpose: the new holder can pass them on again, the sender cannot pull them back.

POST /api/admin/launch launches a coin from /admin: the picture and the metadata are pinned to IPFS (PINATA_JWT), the coin is created on pump.fun through PumpPortal from the first funded, unused launch wallet, and the mint is recorded by itself. A JSON body with mint still records a coin deployed some other way.

Fee split at launch

Every coin launched from /admin is created in one transaction with its fee split locked by pump.fun's own fee sharing (lib/pump/shares.ts): create_v2 with the launch wallet as creator, create_fee_sharing_config, then update_fee_shares_v2 with the launch wallet at 8000 bps and the treasury at 2000 bps, which also revokes the admin. If any of the three fails none happens. Before signing, the policy is checked (two distinct valid addresses, neither the funding wallet, 10 000 bps) and stored in launch_fee_policies; the transaction is simulated and refused unless the simulated accounts already show the split; after sending, the split is read back from the finalized chain (programs, PDA, version 2, admin revoked, the curve's and, once graduated, the pool's creator pointing at the config, the two shareholders). Only then is the coin fee_sharing = 'native'; until then its fees are not paid out.

The three instructions need an address lookup table, which the treasury creates once from /admin (Fee split) and which is checked before every use: authority, active, complete, final. npm run launch:dry-run -- <creator> <treasury> <table> simulates a launch against mainnet without sending it.

A native coin is claimed through pump.fun's distribution (lib/pump/distribute.ts): 80% lands on its launch wallet and goes to the owner whole, 20% lands on the treasury, and the site does not split it again. Distributions are permissionless, so the worker reads every finalized one from each coin's sharing config into the treasury ledger, once per signature, and sends anything that is not a plain distribution to manual review. Coins launched before this keep the old path: collected by the site and split 80/20 at each claim.

This is the beginning of the README. Read the rest at the original. Read the full README ↗