Integration kit
Index Nasdegen in an afternoon
For trading terminals and screeners (GMGN, Axiom, Photon, BullX, DexScreener, GeckoTerminal): the contracts, the event topics, the maths behind every price and progress bar, the metadata format, the JSON API and a real-time stream. Everything here is derived from the same configuration the site runs on. Machine-readable: /api/integrate/kit.json (version 1.0.0).
Every pool is plain Uniswap v4.Index the factory events, watch the pool ids, render from the API or the stream.
What a Nasdegen launch is
One transaction, one locked Uniswap v4 pool, a fee split written into the locker.
A launch deploys a fixed-supply ERC-20 (1,000,000,000 by default, no mint, no owner), opens a Uniswap v4 pool quoted in ETH, USDG, a tokenized stock or any ERC-20 the creator picked, and mints one single-sided position holding 100% of the supply to an ownerless LaunchLocker. Nothing can withdraw it. Trading happens on the pool like on any v4 pool: quote by the Universal Router, swap with a V4_SWAP command, read state through the StateView. There are three launch kinds and the API says which (kind): pool (a direct launch), listing (an existing token brought in by the ListingFactory) and curve (a bonding curve that graduates into a pool).
Currency order
On every LaunchFactory and ListingFactory pool the quote is currency0 and the launched token is currency1: the factory searches a CREATE2 salt until the token address sorts above the quote. A graduated bonding curve is the one exception: its pool is ordered by address and bb_launch_pools.token_is_currency0 (API: pools[].token_is_currency0) says so. The API already normalises every swap and price to the quote-first convention.
Hooks
Every pool carries a hook: the LiquidityGate on direct and listing pools (only the factories may add liquidity, so nobody can sandwich with just-in-time liquidity; it never touches a swap), the CurveHook on graduated curve pools (fee split and the 5-second snipe tax). Read the real hook from hooks on each row; pools indexed before the gate existed are hookless. Tick spacing is always 200; the LP fee is 1% to 3% in pips.
Fee split
Every collected trading fee is split by the locker: 30% to the protocol's FeeRouter, 70% to the beneficiaries the creator named, to the coin's holders (a reward coin) or burned. The router forwards its quote-side balance 50% to the cold treasury and 50% to its payee(), a second protocol wallet: of every fee, 15% reaches the payee and 15% funds the treasury.
Sell-side protocol share
Fees accrue in both currencies. The protocol's share of the coin leg (sell-side fees, in the launched token) is burned on the spot at collect time: LaunchLocker.ProtocolBurned on direct pools, FeeSplitter.ProtocolBurned on graduated curves. Only the quote leg reaches the router. Track supply as totalSupply minus the dead address.
Liquidity is locked forever: the locker has no withdraw, transfer or decrease path. A collect removes zero liquidity. Read the plain-language version on How it works.
Contracts per chain
From the deployed configuration. A blank means not deployed yet, never a placeholder.
- LaunchFactorydeploys the token, opens the pool, locks the position; emits Launched
0xFf66c00C1eE1079B425fEF4e5E6682ae6beb188E- LaunchLockerholds every launch position forever; collect() pays the fee split; emits Collected / Paid / Burned
0x52b459199c054A5503F72811Ee7C368956927c1F- FeeRouterthe protocol's fee sink and the first recipient of every launch; forward() splits its balance 50 / 50; emits Split
0xd06e0accc1EA626E98b8A8ad4D44ec405C2f1DB6- XVaultFactorysuperseded by SocialVaultFactory; X-only fee vaults
0x63306bD73F21fF707738ed383f20ad47757956fb- SocialVaultFactorydeterministic fee vaults for a handle on a registered platform (1 = X, 2 = TikTok, 3 = Instagram, 4 = GitHub); emits VaultDeployed / Claimed / HandleBound
0xcc976c58705673bd349E0d1A9f0812575c29bdA1- PosterPoolFactorypay-the-posters payrolls: one PosterPool per launch (poolOf(params), CREATE2), rounds the site's attester signs and anyone relays (payRound); the pool caps cadence, per-winner share and holder status; emits PoolDeployed / RoundPaid
0x35F94178A55dC9512f23fA52dfFbe557b4FA7F72- CurveFactorybonding-curve launches and their graduation into a v4 pool; emits CurveLaunched / Graduated / Abandoned
0xD8c5d2860abFE05705E412e7debb3d1Fd2d46dDB- CurveHookthe hook on every graduated curve pool: fee split, snipe tax; emits PoolFeesCollected
0xeA1A065e89611999bADfcBa24305d71Ac2fBa844- ListingFactorylists an existing ERC-20 into a locked pool (bring a coin); emits Listed
0x68dB27053AA61E226379060A7AAC33BfEd555d4e- LaunchLocker (listings)the ListingFactory's own locker: the same events as the launch locker
0xE722c1Ff8fE0a73A843c34181E4C53D49Db3179d- LiquidityGatethe hook on every direct and listing pool: only the factories may add liquidity; never touches a swap
0x5A56d12AdBD415021826B884ccFdF5a54cbD2800- Treasurythe cold wallet: every launch fee and half of every forward()
0x65308a5440D9e05289b5DAD6A865d52a7DF74F6b- Vestingthe platform token's (NASDEGEN) team vesting contract
- not deployed yet
- LaunchAndBuyatomic launch + first buy for direct launches; the factory records it as launcher, the creator is LaunchedVia.creator / creatorOf(token); emits LaunchedVia
0x7418B19a20E693377703325fe15b25599724E2D5- MultiLaunchRouterone signature, several chains: launches the home coin (like LaunchAndBuy) and sends a LayerZero V2 order per other chain; on each destination it launches that chain's SEPARATE coin for the same creator, with the same name, ticker and metadata. The factory records it as launcher; the creator is LaunchedVia.creator / creatorOf(token). Emits LaunchedVia, RemoteSent, RemoteLaunched, RemoteFailed. Null = not deployed here
0xb5290De2a45F7136193f29456710A07051700D7A- TwinBridgea twin coin's LayerZero endpoint: it burns on the chain the coin leaves and mints on the chain it arrives, so ONE supply is shared across every chain that coin reaches, at one address. Null = the twin engine is not deployed here and every coin launched on this chain has its own separate supply
- not deployed yet
- RulesLaunchFactoryV3launches a RulesTokenV3 (hooks enforced by the coin on every transfer, optional custom hook program) into a RulesGate pool, optionally with a FeeVault whose game modes the coin feeds; emits Launched (LaunchFactory's shape), RulesLaunched, FeeVaultCreated. Null = not deployed here
0xb936057CE0e50891655e559A196F007E6ac72B00- CustomRulesEnginethe stateless interpreter every RulesTokenV3 runs its custom hook program on (validate / runSection are pure views). Null = not deployed here
0xDf3C3A7eEe6d3FAE0646B2AFA54B15B9e4c7d520- RulesGovernorholder governance of a RulesTokenV3's governable knobs: deposit, propose, 3-day vote (3% quorum), 2-day timelock, execute. Null = not deployed here
0x455D4AbD35FD03765D110B9Ce8AF952727a71A99- FeeStyleLaunchFactoryplain launches into a dynamic-fee pool (fee 0x800000, tick spacing 200) whose FeeStyleHook sets every swap's LP fee (sniper decay, volatility, size); emits Launched (lpFee = 0x800000), FeeStyleLaunched. Null = not deployed here
0x99f05241BD59848080A54f3C9195AE186CA38e51- FeeStyleHookthe hook on every fee-style pool: LiquidityGate plus a per-swap LP fee; quoteFee(key, params) gives the fee a swap pays now; emits StyleRegistered. Null = not deployed here
0x65F562786542c2cd26Cfa0f7925Da472d6aF6880- CreatorFeeLaunchFactoryFeeStyleLaunchFactory's launch (same pool key on the FeeStyleHook, same Launched + FeeStyleLaunched events) with two creator-fee options fixed at launch: quoteOnly (creators paid only in the quote; the coin side of every fee is burned) and transferable (the current fee recipient can hand off future fees); emits CreatorFeeOptions(token, tokenId, quoteOnly, transferable). Null = not deployed here
0xCA39a6851AeCaA3221C8eEBF0EAD868AABb7383E- CreatorFeeLockerthe CreatorFeeLaunchFactory's locker: LaunchLocker's collect / claim and events, plus quoteOnlyOf / transferableOf, TokenLegBurned, and the two-step fee hand-off (proposeHandoff, acceptHandoff, cancelHandoff; HandoffProposed / HandedOff) that only a current creator recipient can start; recipientsOf(tokenId) is the live split. Null = not deployed here
0xBfF2A9f82F8Cb8E3D202B20b71Dd17c8fF1c6760- PegLaunchFactoryuPEG launches: a PegToken (every whole unit of the coin is a numbered object on its ERC-721 PegMirror) locked 100% in a LiquidityGate pool; emits Launched (LaunchFactory's shape) and PegLaunched(token, mirror, objects, unit, baseURI). Null = not deployed here
- not deployed yet
Uniswap v4 (canonical deployments, swap layout v1)
- poolManager
0x498581fF718922c3f8e6A244956aF099B2652b2b- positionManager
0x7C5f5A4bBd8fD63184577525326123B519429bDc- universalRouter
0x6fF5693b99212Da76ad316178A184AB56D299b43
Fixed quotes
- ETH18 decimals
0x0000000000000000000000000000000000000000
- LaunchFactorydeploys the token, opens the pool, locks the position; emits Launched
0xa987eD06C8d386C796c4E49AA09Aa83361fbECc9- LaunchLockerholds every launch position forever; collect() pays the fee split; emits Collected / Paid / Burned
0x943aa7E74De2C8A89296B2621a96c0947e490b53- FeeRouterthe protocol's fee sink and the first recipient of every launch; forward() splits its balance 50 / 50; emits Split
0xd06e0accc1EA626E98b8A8ad4D44ec405C2f1DB6- XVaultFactorysuperseded by SocialVaultFactory; X-only fee vaults
0x63306bD73F21fF707738ed383f20ad47757956fb- SocialVaultFactorydeterministic fee vaults for a handle on a registered platform (1 = X, 2 = TikTok, 3 = Instagram, 4 = GitHub); emits VaultDeployed / Claimed / HandleBound
0x614e413586c5D298C0A1aF03436e4Cfcd81af40C- PosterPoolFactorypay-the-posters payrolls: one PosterPool per launch (poolOf(params), CREATE2), rounds the site's attester signs and anyone relays (payRound); the pool caps cadence, per-winner share and holder status; emits PoolDeployed / RoundPaid
0x9985E72DD5800F7257C6aC841A0A981bf4f99ede- CurveFactorybonding-curve launches and their graduation into a v4 pool; emits CurveLaunched / Graduated / Abandoned
0xa93A9b7A38D36B8882878558B178720592A79A4E- CurveHookthe hook on every graduated curve pool: fee split, snipe tax; emits PoolFeesCollected
0x7779d6EddAbb17E8153b1d3e6dfb1379887D6844- ListingFactorylists an existing ERC-20 into a locked pool (bring a coin); emits Listed
0x68dB27053AA61E226379060A7AAC33BfEd555d4e- LaunchLocker (listings)the ListingFactory's own locker: the same events as the launch locker
0xE722c1Ff8fE0a73A843c34181E4C53D49Db3179d- LiquidityGatethe hook on every direct and listing pool: only the factories may add liquidity; never touches a swap
0xdac33249139E490DAFA09219e1EE125bf6f4a800- Treasurythe cold wallet: every launch fee and half of every forward()
0x65308a5440D9e05289b5DAD6A865d52a7DF74F6b- Vestingthe platform token's (NASDEGEN) team vesting contract
- not deployed yet
- LaunchAndBuyatomic launch + first buy for direct launches; the factory records it as launcher, the creator is LaunchedVia.creator / creatorOf(token); emits LaunchedVia
0x04D6cbA8b9b3B5A6D2D1F6f2F2C53e3EE65C720c- MultiLaunchRouterone signature, several chains: launches the home coin (like LaunchAndBuy) and sends a LayerZero V2 order per other chain; on each destination it launches that chain's SEPARATE coin for the same creator, with the same name, ticker and metadata. The factory records it as launcher; the creator is LaunchedVia.creator / creatorOf(token). Emits LaunchedVia, RemoteSent, RemoteLaunched, RemoteFailed. Null = not deployed here
0x60fb5BCa73F258C5969317a225c4B57b6fEDaa80- TwinBridgea twin coin's LayerZero endpoint: it burns on the chain the coin leaves and mints on the chain it arrives, so ONE supply is shared across every chain that coin reaches, at one address. Null = the twin engine is not deployed here and every coin launched on this chain has its own separate supply
- not deployed yet
- RulesLaunchFactoryV3launches a RulesTokenV3 (hooks enforced by the coin on every transfer, optional custom hook program) into a RulesGate pool, optionally with a FeeVault whose game modes the coin feeds; emits Launched (LaunchFactory's shape), RulesLaunched, FeeVaultCreated. Null = not deployed here
0xc03fc0f3D8Ba1Fe95D01212038721c5Ef7f8368a- CustomRulesEnginethe stateless interpreter every RulesTokenV3 runs its custom hook program on (validate / runSection are pure views). Null = not deployed here
0xDf3C3A7eEe6d3FAE0646B2AFA54B15B9e4c7d520- RulesGovernorholder governance of a RulesTokenV3's governable knobs: deposit, propose, 3-day vote (3% quorum), 2-day timelock, execute. Null = not deployed here
0x455D4AbD35FD03765D110B9Ce8AF952727a71A99- FeeStyleLaunchFactoryplain launches into a dynamic-fee pool (fee 0x800000, tick spacing 200) whose FeeStyleHook sets every swap's LP fee (sniper decay, volatility, size); emits Launched (lpFee = 0x800000), FeeStyleLaunched. Null = not deployed here
0x6ae0BD0ffdA8Db5930774EAC67525E0049832a9c- FeeStyleHookthe hook on every fee-style pool: LiquidityGate plus a per-swap LP fee; quoteFee(key, params) gives the fee a swap pays now; emits StyleRegistered. Null = not deployed here
0xFa0651e29D1690D2B32c5897AC6a175EAd5D2880- CreatorFeeLaunchFactoryFeeStyleLaunchFactory's launch (same pool key on the FeeStyleHook, same Launched + FeeStyleLaunched events) with two creator-fee options fixed at launch: quoteOnly (creators paid only in the quote; the coin side of every fee is burned) and transferable (the current fee recipient can hand off future fees); emits CreatorFeeOptions(token, tokenId, quoteOnly, transferable). Null = not deployed here
0x34967D54e4B45aeDeD25649741eA6188eBa20CaC- CreatorFeeLockerthe CreatorFeeLaunchFactory's locker: LaunchLocker's collect / claim and events, plus quoteOnlyOf / transferableOf, TokenLegBurned, and the two-step fee hand-off (proposeHandoff, acceptHandoff, cancelHandoff; HandoffProposed / HandedOff) that only a current creator recipient can start; recipientsOf(tokenId) is the live split. Null = not deployed here
0x775cC0e6bdA38CBa7430a5eF0b92cCA1e83B6801- PegLaunchFactoryuPEG launches: a PegToken (every whole unit of the coin is a numbered object on its ERC-721 PegMirror) locked 100% in a LiquidityGate pool; emits Launched (LaunchFactory's shape) and PegLaunched(token, mirror, objects, unit, baseURI). Null = not deployed here
- not deployed yet
Uniswap v4 (canonical deployments, swap layout v2)
- poolManager
0x8366a39CC670B4001A1121B8F6A443A643e40951- positionManager
0x58daec3116aae6D93017bAAea7749052E8a04fA7- universalRouter
0x8876789976decbfcbbbe364623c63652db8c0904
Fixed quotes
- USDG6 decimals
0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168- ETH18 decimals
0x0000000000000000000000000000000000000000
- LaunchFactorydeploys the token, opens the pool, locks the position; emits Launched
0xaB7FFC770fF5e7FeD0677c179e897A690ed4eBD9- LaunchLockerholds every launch position forever; collect() pays the fee split; emits Collected / Paid / Burned
0x324b59d4705d40527B3C64dA9803f7E80f120F43- FeeRouterthe protocol's fee sink and the first recipient of every launch; forward() splits its balance 50 / 50; emits Split
0xd06e0accc1EA626E98b8A8ad4D44ec405C2f1DB6- XVaultFactorysuperseded by SocialVaultFactory; X-only fee vaults
0x63306bD73F21fF707738ed383f20ad47757956fb- SocialVaultFactorydeterministic fee vaults for a handle on a registered platform (1 = X, 2 = TikTok, 3 = Instagram, 4 = GitHub); emits VaultDeployed / Claimed / HandleBound
0xCAe11577F88d7bF8E4fb1DDB241556f008C32F25- PosterPoolFactorypay-the-posters payrolls: one PosterPool per launch (poolOf(params), CREATE2), rounds the site's attester signs and anyone relays (payRound); the pool caps cadence, per-winner share and holder status; emits PoolDeployed / RoundPaid
0x7418B19a20E693377703325fe15b25599724E2D5- CurveFactorybonding-curve launches and their graduation into a v4 pool; emits CurveLaunched / Graduated / Abandoned
0x0e5676B609CE83DD299A1025D188548764A913e4- CurveHookthe hook on every graduated curve pool: fee split, snipe tax; emits PoolFeesCollected
0x5214be97Ac1D5F4d86a378A5B75B289f114ba844- ListingFactorylists an existing ERC-20 into a locked pool (bring a coin); emits Listed
0x68dB27053AA61E226379060A7AAC33BfEd555d4e- LaunchLocker (listings)the ListingFactory's own locker: the same events as the launch locker
0xE722c1Ff8fE0a73A843c34181E4C53D49Db3179d- LiquidityGatethe hook on every direct and listing pool: only the factories may add liquidity; never touches a swap
0xC210DE2457fBeC8a7A8C6D884cc2259E4C102800- Treasurythe cold wallet: every launch fee and half of every forward()
0x65308a5440D9e05289b5DAD6A865d52a7DF74F6b- Vestingthe platform token's (NASDEGEN) team vesting contract
- not deployed yet
- LaunchAndBuyatomic launch + first buy for direct launches; the factory records it as launcher, the creator is LaunchedVia.creator / creatorOf(token); emits LaunchedVia
0xcBEB49eE51706D6C169276f44F5A613594586Bf2- MultiLaunchRouterone signature, several chains: launches the home coin (like LaunchAndBuy) and sends a LayerZero V2 order per other chain; on each destination it launches that chain's SEPARATE coin for the same creator, with the same name, ticker and metadata. The factory records it as launcher; the creator is LaunchedVia.creator / creatorOf(token). Emits LaunchedVia, RemoteSent, RemoteLaunched, RemoteFailed. Null = not deployed here
0x71346E21004F8aa2157094996e073741Cb2eCC8F- TwinBridgea twin coin's LayerZero endpoint: it burns on the chain the coin leaves and mints on the chain it arrives, so ONE supply is shared across every chain that coin reaches, at one address. Null = the twin engine is not deployed here and every coin launched on this chain has its own separate supply
- not deployed yet
- RulesLaunchFactoryV3launches a RulesTokenV3 (hooks enforced by the coin on every transfer, optional custom hook program) into a RulesGate pool, optionally with a FeeVault whose game modes the coin feeds; emits Launched (LaunchFactory's shape), RulesLaunched, FeeVaultCreated. Null = not deployed here
0x6A92BfcFaa107ba8686D4285521f5C7d67F16f6B- CustomRulesEnginethe stateless interpreter every RulesTokenV3 runs its custom hook program on (validate / runSection are pure views). Null = not deployed here
0xDf3C3A7eEe6d3FAE0646B2AFA54B15B9e4c7d520- RulesGovernorholder governance of a RulesTokenV3's governable knobs: deposit, propose, 3-day vote (3% quorum), 2-day timelock, execute. Null = not deployed here
0x455D4AbD35FD03765D110B9Ce8AF952727a71A99- FeeStyleLaunchFactoryplain launches into a dynamic-fee pool (fee 0x800000, tick spacing 200) whose FeeStyleHook sets every swap's LP fee (sniper decay, volatility, size); emits Launched (lpFee = 0x800000), FeeStyleLaunched. Null = not deployed here
0x8AE2ea8Cbd61869f8dF32563ECC38AD62A8141a9- FeeStyleHookthe hook on every fee-style pool: LiquidityGate plus a per-swap LP fee; quoteFee(key, params) gives the fee a swap pays now; emits StyleRegistered. Null = not deployed here
0xC1cB0e098E709e9eB35989C200FDde5e6812e880- CreatorFeeLaunchFactoryFeeStyleLaunchFactory's launch (same pool key on the FeeStyleHook, same Launched + FeeStyleLaunched events) with two creator-fee options fixed at launch: quoteOnly (creators paid only in the quote; the coin side of every fee is burned) and transferable (the current fee recipient can hand off future fees); emits CreatorFeeOptions(token, tokenId, quoteOnly, transferable). Null = not deployed here
0x31637Eb0FaA1fE3EBFcF2939424979fB6aac8734- CreatorFeeLockerthe CreatorFeeLaunchFactory's locker: LaunchLocker's collect / claim and events, plus quoteOnlyOf / transferableOf, TokenLegBurned, and the two-step fee hand-off (proposeHandoff, acceptHandoff, cancelHandoff; HandoffProposed / HandedOff) that only a current creator recipient can start; recipientsOf(tokenId) is the live split. Null = not deployed here
0x8ea1A3F9CE26dEeAB8c349ef5cdCcdA67b2D7fe5- PegLaunchFactoryuPEG launches: a PegToken (every whole unit of the coin is a numbered object on its ERC-721 PegMirror) locked 100% in a LiquidityGate pool; emits Launched (LaunchFactory's shape) and PegLaunched(token, mirror, objects, unit, baseURI). Null = not deployed here
- not deployed yet
Uniswap v4 (canonical deployments, swap layout v1)
- poolManager
0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF- positionManager
0x7A4a5c919aE2541AeD11041A1AEeE68f1287f95b- universalRouter
0x1906c1d672b88cD1B9aC7593301cA990F94Eae07
Fixed quotes
- BNB18 decimals
0x0000000000000000000000000000000000000000
Tokenized stocks (Coinbase B20 on Base, Robinhood Stock Tokens on Robinhood Chain) are read from the issuer registries: GET /api/quotes?chain=&q= lists them with decimals and live prices. Source verification links are on How it works.
Events to index
Signatures and topic0 computed from the same ABI the indexer decodes with, so they cannot drift.
Watch the factory addresses above for launches, then filter PoolManager.Swap by the pool ids they announce (topic1 = poolId). Per-launch contracts (a BondingCurve, a RewardPool) are announced by the factory event that creates them. The last column says where each event lands in the read model (db/schema.sql); the JSON API exposes those tables.
| Event | Emitter | topic0 | Lands in |
|---|---|---|---|
| Launchedevent Launched(address indexed token, uint256 indexed tokenId, address indexed launcher, address quote, bytes32 poolId, int24 startTick, uint24 lpFee, uint256 supply, string metadataURI) | LaunchFactory | 0xda18b133e41a7fe4e3adc625c6eeaf9237558c875e411398a623cc9603aad0a9 | bb_launches (kind pool; one row per token, its first pool is the primary market) + bb_launch_pools (one row per pool)a multi-pair launch emits one Launched per pool with the same token |
| MultiPairLaunchedevent MultiPairLaunched(address indexed token, bytes32[] poolIds) | LaunchFactory | 0xa61112d06e0155d1f17b7bcef94fc48ca0406c6bc3152aca945cc8e835555479 | bb_launch_pools.pool_index (the pool set; factory.poolsOf(token) lists them with supply_bps) |
| RewardPoolCreatedevent RewardPoolCreated(address indexed token, address indexed pool, address indexed quote) | LaunchFactory | 0xcccf10613f67792eecfb9a80ab0ceb4928e43c66255e7a39e9dd5a2dad5bc103 | bb_launches.reward_pool (the holders fee mode: the creator share is paid to holders in the quote) |
| FeeVaultCreatedevent FeeVaultCreated(address indexed token, address indexed vault, address indexed quote, uint8 mode) | LaunchFactory | 0x255add866ba2eeef650e4e30a49e793bf95621d59796d33c2f5cfca46bc7300a | bb_launches.fee_vault / fee_mode (creator fee modules; every FeeVault event lands in bb_vault_events) |
| LaunchedViaevent LaunchedVia(address indexed creator, address indexed token, uint256 tokenId, uint256 quoteIn, uint256 tokensOut) | LaunchAndBuy | 0x5bf63f84755bf9de4570848428b2e7a8fff53eb980b51ae4c555467365a14630 | bb_launches.creator: the wallet that launched through the router (the same tx's Launched names the router as launcher)treat Launched.launcher == LaunchAndBuy as creator = LaunchedVia.creator (router.creatorOf(token) on-chain) for display, edit rights and holder exclusions; quoteIn / tokensOut = the first buy |
| LaunchedViaevent LaunchedVia(address indexed creator, address indexed token, uint256 tokenId, uint256 quoteIn, uint256 tokensOut) | MultiLaunchRouter | 0x5bf63f84755bf9de4570848428b2e7a8fff53eb980b51ae4c555467365a14630 | bb_launches.creator: the wallet that launched through the router, on the home chain AND on every remote chain (a remote launch lands in the LayerZero executor's transaction)same signature and hook as LaunchAndBuy.LaunchedVia |
| RemoteSentevent RemoteSent(bytes32 indexed guid, uint32 indexed dstEid, address indexed creator, address homeToken, uint256 lzFee, uint256 dstValue) | MultiLaunchRouter | 0x76b0046ac2032fe0cd04a9038e0d21cffc7a4f5d7c922311087c4a293f377ca2 | not indexed: the home side of a multi-chain launch (guid, dstEid, creator, homeToken, LayerZero fee, destination value) |
| RemoteLaunchedevent RemoteLaunched(bytes32 indexed guid, uint32 indexed srcEid, address indexed creator, address homeToken, address token) | MultiLaunchRouter | 0x9224beb90f1ddab99a57022f03146f14d3841f624324c9b68153aed607ef8db0 | not indexed: the remote side (guid, srcEid, creator, homeToken, token); the family query links the coins by creator + ticker + name |
| RemoteFailedevent RemoteFailed(bytes32 indexed guid, address indexed creator, uint256 value, bytes order, bytes reason) | MultiLaunchRouter | 0x1e357a98aa3d95a113341baacebd2faf9e4a89416eee24fb5b6d30fa56e54eef | not indexed: a remote launch that reverted; its value is held for the creator (retry / cancel on that chain) |
| Listedevent Listed(address indexed token, uint256 indexed tokenId, address indexed lister, address quote, bytes32 poolId, int24 startTick, uint24 lpFee, uint256 amount, string metadataURI) | ListingFactory | 0xad5a4aaa469875ff13658232c22a8ba97398205fa40bdf452cdbd83b1ee2d117 | bb_listings + bb_launches (kind listing, supply = the token's totalSupply) + bb_launch_pools |
| CurveLaunchedevent CurveLaunched(address indexed token, address indexed curve, address indexed launcher, address quote, address creatorFeeRecipient, uint256 supply, uint256 phantomQuote, uint256 graduationThreshold, uint16 feeBps, uint16 creatorTaxBps, string metadataURI) | CurveFactory | 0x41a83fcb07d214b946bf3ed8ff5921bef5a4459be08287b8fe86e3de08103c08 | bb_launches (kind curve, pool_id = the curve address, graduation_threshold, phantom_quote, creator_tax_bps) + bb_curve_launches (phase 1) |
| CurveLaunchOptionsevent CurveLaunchOptions(address indexed token, uint32 snipeWindow, uint16 snipeStartBps, uint16 airdropBps, uint256 airdropTokens) | CurveFactory | 0x718dd73f4177b643a4c4da4072fb4f3b3ca5d40c5714252c6b1a547aea4b8ecd | bb_curve_launches.snipe_window / snipe_start_bps / airdrop_bps (API: snipe_window, snipe_start_bps, airdrop_bps on the row)right after CurveLaunched; snipeWindow 5 / snipeStartBps 9900 = the legacy same-block shield, else a 600 / 1200 / 1800 s linear window from 5000 / 7500 / 9000 bps; airdropTokens = supply x airdropBps / 10000 is held off the curve and never sold |
| CurveBuyevent CurveBuy(address indexed buyer, address indexed recipient, uint256 quoteIn, uint256 tokensOut, uint256 fee, uint256 tax) | BondingCurvethe launch's BondingCurve (CurveLaunched.curve; bb_launches.curve) until it graduates | 0xec36bf571f136799e8dc0b0b8bea4b04d8bd3d43de838aab0d5fc21d4cbfc455 | bb_launch_swaps (pool_id = the curve, is_buy true, amount0 = -quoteIn, amount1 = tokensOut) + bb_launches.curve_raised += quoteIn - fee - tax |
| CurveSellevent CurveSell(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 quoteOut, uint256 fee, uint256 tax) | BondingCurvethe launch's BondingCurve (CurveLaunched.curve; bb_launches.curve) until it graduates | 0x8113d738abdcb6b38357e9d53a54a7157861a09031b453651f0fe7fe151f59df | bb_launch_swaps (is_buy false) + bb_launches.curve_raised -= quoteOut |
| CurveCompletedevent CurveCompleted(address indexed recipient, uint256 quoteOut, uint256 tokenOut) | BondingCurvethe launch's BondingCurve (CurveLaunched.curve; bb_launches.curve) until it graduates | 0xf8d37a90738ae063b8b8058b66f5880cf3cf7ab0c5d4fa78219696591dfbfb67 | not stored: the clearing trade; Graduated follows in the same transaction |
| Graduatedevent Graduated(address indexed token, bytes32 indexed poolId, uint256 indexed tokenId, address quote, uint256 quoteAmount, uint256 tokenAmount, uint256 tokensBurned, uint160 sqrtPriceX96) | CurveFactory | 0xd4df01b899fd11e56dd1988cc7505f0cb8fcbf6e06af3a4d3ee20936f3529072 | bb_launches.pool_id / token_id / graduated / hooks + bb_launch_pools (token_is_currency0 by address order) + bb_curve_launches.graduated (phase 3) |
| AirdropReservedevent AirdropReserved(address indexed token, address indexed pool, uint256 amount) | CurveFactory | 0xe55be1cdc3273dff1821789e780f247efc390b92c95703b8a1715aecc6435662 | bb_curve_launches.airdrop_pool (API: airdrop_pool): the reserve landed in its AirdropPool at createGraduatedPool, after Graduatedthe pool pays holders pro-rata in the token itself (Rewarded, in launch tokens); its burnTokenLeg is distributor-only and dust-only |
| PoolRegisteredevent PoolRegistered(bytes32 indexed poolId, address indexed token, address indexed quote, address creator, uint16 feeBps, uint16 creatorTaxBps, uint40 openedAt, uint32 snipeWindow, uint16 snipeStartBps) | CurveHook | 0xbac2eecacb7fe6eb2a802a459146a15156726c2bba844132bf4140f188cc788a | bb_curve_launches.pool_opened_at / snipe_window / snipe_start_bps (API: pool_opened_at): the shield's clock starts at openedAtlive: CurveHook.currentBuyChargeBps(poolId) = fee + creator tax + snipe tax on a buy right now; snipeShieldOf(poolId) = (openedAt, window, startBps, endsAt) |
| FeesSweptevent FeesSwept(uint256 protocolAmount, uint256 creatorAmount, uint256 creatorTax) | BondingCurvethe launch's BondingCurve (CurveLaunched.curve; bb_launches.curve) until it graduates | 0x9f4cd7c4ed99d08a797804560c9c5d71d2cf7e101f2e3b5e7d1ca8a24c370e4f | bb_launch_fee_events (kind collected) |
| Abandonedevent Abandoned(address indexed token, address indexed venue, uint256 refundQuote, uint256 refundSupply) | CurveFactory | 0x56189f752f9a4ea9b583fa556ef1d10e6993eaa22c72ade4f03c9a63c80a5fde | bb_curve_launches.phase = 4, refunding, refund_venue, refund_quote, refund_supply + bb_launches.refundingBondingCurve emits CurveAbandoned(refundQuote, refundSupply, tokensBurned) when the curve itself is the refund venue |
| Redeemedevent Redeemed(address indexed token, address indexed holder, uint256 tokensIn, uint256 quoteOut) | CurveFactory | 0x5cdf07ad0fc222442720b108e3ed4c4640f0fadc2ab2253e66f259a0fea83480 | bb_curve_redemptions + bb_curve_launches.redeemedBondingCurve emits Redeemed(holder, tokensIn, quoteOut) at the curve venue: same table |
| Swapevent Swap(bytes32 indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee) | PoolManager (Uniswap v4) | 0x40e9cecb9f5f1f1c5b9c97dec2917b7ee92e57ba5563708daca94dd84ad7112f | bb_launch_swaps (filtered by the launch pool ids: topic1 = poolId) + rolling price / volume / buys / sells on bb_launches and bb_launch_poolsstored in the quote = currency0 convention: a graduated curve pool whose token sorts first has its legs swapped and sqrtPrice inverted (2^192 / sqrtPriceX96) |
| PoolFeesCollectedevent PoolFeesCollected(bytes32 indexed poolId, address indexed currency, uint256 protocolAmount, uint256 creatorAmount, uint256 taxAmount) | CurveHook | 0x68319b9c14504932188cf18fd430081408f4e8cc877910e4772b09e73ba72821 | bb_launch_fee_events (kind collected) + bb_launches.fees_quote_collected / fees_token_collected |
| Collectedevent Collected(uint256 indexed tokenId, address indexed token, uint256 quoteAmount, uint256 tokenAmount) | LaunchLocker | 0xe985bb809569e1ab693b8d0a44015cb780fa698a4b16df55472d8eeffa185b39 | bb_launch_fee_events (kind collected) + bb_launches.fees_quote_collected / fees_token_collected |
| Paidevent Paid(uint256 indexed tokenId, address indexed account, address indexed currency, uint256 amount) | LaunchLocker | 0x2a156326ec22774ffa31f45f5f5990405e41eb6fe44e1d600934ab445cf3c0c1 | bb_launch_fee_events (kind paid; account = the recipient, currency, amount) |
| Burnedevent Burned(uint256 indexed tokenId, address indexed currency, uint256 amount) | LaunchLocker | 0x7a6396f9141e42bbd82eddb43e30077ef07aaafcd4ee3dfbd6adb1dca8f2445a | bb_launch_fee_events (kind burned) + bb_launches.fees_quote_burned / fees_token_burned |
| ProtocolBurnedevent ProtocolBurned(uint256 indexed tokenId, address indexed token, uint256 amount) | LaunchLocker | 0x6bae6d2d751347b78b8b6df28f4237035c84cb589fe6b90dabda8ba05bc1e7c5 | bb_launch_fee_events (kind protocol_burn): the coin leg of the protocol share, sent to the dead address at collect time |
| ProtocolBurnedevent ProtocolBurned(address indexed token, uint256 amount) | FeeSplitter (CurveHook, curve locker)the CurveHook and the CurveFactory's locker (both FeeSplitters) | 0xdd67fcf03eff90a877db609aef3742829b09597a5a304114ec25dc0f271fb14d | bb_launch_fee_events (kind protocol_burn) for graduated curve pools |
| Creditedevent Credited(address indexed account, address indexed currency, uint256 amount) | LaunchLocker | 0x4e45da441832cf53bdaa69235704fc0575e68210f459ee1562911024b12967d5 | bb_launch_fee_events (kind credited): a recipient that could not receive was credited; claim(currency) pays it later |
| Claimedevent Claimed(address indexed account, address indexed currency, uint256 amount) | LaunchLocker | 0xf7a40077ff7a04c7e61f6f26fb13774259ddf1b6bce9ecf26a8276cdd3992683 | bb_launch_fee_events (kind claimed) |
| Distributedevent Distributed(uint256 indexed round, uint256 holders, uint256 amount) | RewardPoolthe launch's RewardPool (RewardPoolCreated.pool; bb_launches.reward_pool) | 0xc5d35a65af09b3042394b742529d10f7fbf9a37294d6b13e4d63d06f9909a15b | not stored: the sum of a round's Rewarded rows |
| Rewardedevent Rewarded(uint256 indexed round, address indexed holder, uint256 amount) | RewardPoolthe launch's RewardPool (RewardPoolCreated.pool; bb_launches.reward_pool) | 0x6d46424d7308d93179bbc5c8c01e098e8353dad13aff9809fd8a881a69feaa3a | bb_rewards (holder, round, amount in the quote asset) |
| TokenLegBurnedevent TokenLegBurned(uint256 amount) | RewardPoolthe launch's RewardPool (RewardPoolCreated.pool; bb_launches.reward_pool) | 0x76a36c38271909275ee6eecb21d4449967c6cfcf8548fd5e1b5aeb5ed5952fe3 | bb_rewards (holder = 0x000000000000000000000000000000000000dead, round 0, amount in launch tokens) |
| Rewardedevent Rewarded(uint256 indexed round, address indexed holder, uint256 amount) | AirdropPoolthe launch's AirdropPool (AirdropReserved.pool; bb_curve_launches.airdrop_pool), a RewardPool quoted in the token itself | 0x6d46424d7308d93179bbc5c8c01e098e8353dad13aff9809fd8a881a69feaa3a | not stored: read totalDistributed() / rounds() on the pool; amounts are in the launch token (the pot IS the airdrop) |
| TokenLegBurnedevent TokenLegBurned(uint256 amount) | AirdropPoolthe launch's AirdropPool (AirdropReserved.pool; bb_curve_launches.airdrop_pool), a RewardPool quoted in the token itself | 0x76a36c38271909275ee6eecb21d4449967c6cfcf8548fd5e1b5aeb5ed5952fe3 | not stored: the dust the distributor burned once the pot was under BURN_DUST_BPS of what it had paid out |
| Splitevent Split(address indexed currency, uint256 treasuryAmount, uint256 payeeAmount) | FeeRouter | 0x5d95162205dc900555172b9649799b0334d5c456a8c9d875524229cd73416d4b | bb_fee_splits (treasury_amount to the cold wallet, payee_amount to the FeeRouter's payee); Forwarded fires once per leg and is not stored |
| VaultDeployedevent VaultDeployed(bytes32 indexed handleHash, address indexed vault, uint8 indexed platformId, string handle) | SocialVaultFactory | 0xe36f96a5cc2b2ec9aafd9e3a53a704b0f022615e6a1b1ecc1913f0f523199970 | bb_x_vaults (handle_hash, handle, vault; the hash is keccak256(abi.encode(platformId, handle))) |
| Claimedevent Claimed(bytes32 indexed handleHash, address indexed vault, address indexed to, address[] currencies, uint256[] amounts) | SocialVaultFactory | 0x95eecace84751e43183c30db83463452f4095af434d7128cb70691dd04fd7ef5 | bb_x_claims (vault, to_addr, currencies[], amounts[]) |
| HandleBoundevent HandleBound(bytes32 indexed handleHash, bytes32 indexed userId, uint8 indexed platformId) | SocialVaultFactory | 0x089eb62e5e28daea29ada5ebaf37a1ec65094320080f3d150db33213aec31438 | bb_x_events (kind handle_bound: handle_hash, x_user_id = the bound account id) |
| VaultDeployedevent VaultDeployed(bytes32 indexed handleHash, address indexed vault, string handle) | XVaultFactory | 0xc3d0e1e209e26cc94d58bd9d7cc2c68f49a275898e447d9034534ec19f265029 | bb_x_vaults (handle_hash, handle, vault) — v1, X only, superseded; nothing new pays these vaults |
| Claimedevent Claimed(bytes32 indexed handleHash, address indexed vault, address indexed to, address[] currencies, uint256[] amounts) | XVaultFactory | 0x95eecace84751e43183c30db83463452f4095af434d7128cb70691dd04fd7ef5 | bb_x_claims (vault, to_addr, currencies[], amounts[]) |
Amounts in events are raw integers in the quote's decimals (ETH 18, USDG 6, a stock or custom coin as its contract says); the launched token always has 18 decimals. Metadata URIs are the form described in section 05.
Prices and progress bars
The formulas the site uses, written for another codebase.
Direct pools: price comes from sqrtPriceX96 (the Swap event or StateView.getSlot0(poolId)) in the quote-first convention. Market cap equals fully diluted valuation: the entire supply is either in the pool or in wallets, nothing is reserved, so fdv = price x supply. Bonding curves: a constant-product curve that opens at an FDV of phantomQuote (a virtual quote reserve) and graduates into a locked full-range v4 pool at its terminal price once it has raised graduationThreshold of real quote. The API carries phantom_quote, graduation_threshold, curve_raised, graduated and refunding on every curve row.
- Direct pool, tokens per quote
- tokensPerQuote = (sqrtPriceX96 / 2^96)^2 * 10^(quoteDecimals - 18)Uniswap's raw price is token-wei per smallest quote unit; the power of ten converts to whole quote units.
- Direct pool, quote per token
- priceQuote = 1 / tokensPerQuote
- From a tick
- tokensPerQuote = 1.0001^tick * 10^(quoteDecimals - 18)The opening price is the start tick:
start_tickon every row. - Market cap
- fdvQuote = priceQuote * supply / 1e18 (market cap = FDV: the whole supply is in the pool or in wallets, nothing is reserved); usd = fdvQuote * quoteUsd
- Token as currency0
- when bb_launch_pools.token_is_currency0 (a graduated curve pool whose token sorts below its quote) use sqrtPriceX96' = 2^192 / sqrtPriceX96 and negate amounts; the API already returns the normalised form
- Curve reserves
- quoteReserve = phantomQuote + curveRaised; tokenReserve = supply - tokensSold (BondingCurve.getReserves())
- Curve price
- priceQuoteRaw = quoteReserve / tokenReserve (raw units); priceQuote = priceQuoteRaw * 10^(18 - quoteDecimals)
- Curve buy
- tokensOut = (quoteIn - fee - tax) * tokenReserve / (quoteReserve + quoteIn - fee - tax); fee = quoteIn * feeBps / 10000; tax = quoteIn * creatorTaxBps / 10000Fee 1% to 3% split 30 / 70 like every launch, plus an optional creator tax up to 10% that goes wholly to the creator recipient.
- Progress bar
- progress = min(1, curveRaised / graduationThreshold)
- Graduation rule
- graduates when curveRaised >= graduationThreshold, i.e. tokenReserve == reserved = supply * phantomQuote / (phantomQuote + graduationThreshold)The clearing buy that crosses the threshold graduates the curve in the same transaction (
CurveCompletedthenGraduated). - FDV at graduation
- fdvRawAtGraduation = (phantomQuote + graduationThreshold)^2 / phantomQuote
- Tokens into the pool
- poolTokens = reserved * graduationThreshold / (phantomQuote + graduationThreshold); the rest of the reserve is burned at graduation
- Snipe tax
- legacy shield (snipe_window 5, snipe_start_bps 9900): taxBps(t) = 9900 * e^(-1.75 * floor(t)) for t < 5 s after the graduated pool opened, 0 after; long shields (snipe_window 600 | 1200 | 1800 s, snipe_start_bps 5000 | 7500 | 9000): taxBps(t) = start * (window - floor(t)) / window; charged on buys only, on top of fee + creator tax, total capped at 9900; t counts from pool_opened_at (PoolRegistered.openedAt)Protects the graduation transaction from being sandwiched; nothing more. Buys only.
- Refund state
- quoteOut = refundQuote * tokensIn / refundSupply (rounded down) at refund_venue while phase == 4A curve stuck ready-but-not-graduated for 3 days (or one whose pool cannot be seeded) can be flipped to refunds by anyone; phases: none 0, trading 1, swept 2, graduated 3, refunding 4. Trading is closed while
refunding.
Snipe tax schedule (bps per second since the graduated pool opened, 9900 at t = 0)
- t = 0 s9900 bps
- t = 1 s1720 bps
- t = 2 s298 bps
- t = 3 s51 bps
- t = 4 s9 bps
- t = 5 s0 bps
Metadata and logos
Off-chain, on this domain, referenced from the launch event.
The metadataURI in Launched, CurveLaunched and Listed is https://nasdegen.fun/api/launch/meta/<launcher>/<key> (the launcher wallet and a 32-byte key chosen before the salt search, so the URI is stable). It answers the JSON below; /api/launch/meta/<token>?chain= answers the same by token address. Logos uploaded here are re-encoded to a 512 x 512 WebP at https://nasdegen.fun/api/launch/image/t/<48 hex>.webp (random immutable key, cache-control: immutable); a creator may also give any https URL. Every list and feed row already carries image_url, so the list endpoints are enough to render logos. Cache metadata for 5 minutes: the creator can edit it with a signed request; the token itself never changes.
{
"name": "My Token",
"symbol": "MYT",
"description": "…",
"image": "https://nasdegen.fun/api/launch/image/t/<48 hex>.webp",
"external_url": "https://…",
"x": "handle",
"token": "0x…",
"x_recipients": [{ "handle": "handle", "vault": "0x…", "bps": 10000 }]
}REST reference
Every public read endpoint. The same list, as OpenAPI 3.1: /api/openapi.json.
/api/launch/listBrowse launches. The list every tab of the home page reads. Raw amounts are decimal integer strings in the quote's decimals (`quote_decimals`); `price_quote` / `fdv_quote` are numbers in the quote asset; `*_usd` fields are null when the quote has no price.
chain=base|robinhood|bnb sort=live|new|mcap|volume|gainers|holders window=1h|24h|all filter=fee0|burn|usdg|gitlawb|today|stock|holders|platform|parasite|posters limit offset quote format=json|csvcache: public, s-maxage=2, stale-while-revalidate=10 example: /api/launch/list?chain=base&sort=new&limit=50/api/launch/liveOne call for a live page. The activity feed, the site totals, the trending strip and (with `sort`) one list page, in one response. The site polls it every ~5 s.
chain=base|robinhood|bnb sort=live|new|mcap|volume|gainers|holders window=1h|24h|all filter=fee0|burn|usdg|gitlawb|today|stock|holders|platform|parasite|posters limit offset quotecache: public, s-maxage=2, stale-while-revalidate=10 example: /api/launch/live?chain=base&sort=live&limit=40/api/launch/feedLatest launches and trades. The newest 24 launch and swap events across every chain, newest first.
format=json|csvcache: public, s-maxage=2, stale-while-revalidate=10 example: /api/launch/feed/api/launch/searchSearch by name, symbol or address. Substring match on name / symbol, exact match on a token address; at most 20 rows.
q* chain=base|robinhood|bnbcache: public, s-maxage=5, stale-while-revalidate=30 example: /api/launch/search?q=pepe&chain=base/api/launch/candlesOHLCV candles. Sparse whole buckets in quote per token (multiply by `quote.usd` for dollars), at most 2000 including the current bucket; fill gaps from `baseline.price`. `launch.price` is the opening price from the start tick.
chain*=base|robinhood|bnb token* interval=1m|5m|15m|1h|4h|1d from walletcache: public, s-maxage=5, stale-while-revalidate=30 example: /api/launch/candles?chain=base&token=0x...&interval=5m/api/launch/holdersHolder distribution. Top holders, concentration, the creator's position and sniper-window buyers. `synced` is false while the token's transfer history is still being backfilled.
chain*=base|robinhood|bnb token*cache: no-store (5 s server memo) example: /api/launch/holders?chain=base&token=0x.../api/launch/rewardsReward-coin payouts. For a launch in the holders fee mode: what its RewardPool has paid out, from the index of Rewarded / TokenLegBurned.
chain*=base|robinhood|bnb token* walletcache: no-store (5 s server memo) example: /api/launch/rewards?chain=base&token=0x.../api/launch/sistersSister-coin candidates. Launches on the chain quoted in the same asset that own a RewardPool or a FeeVault (the FeeVault sister mode picker).
chain*=base|robinhood|bnb quote* qcache: no-store example: /api/launch/sisters?chain=base"e=0x0000000000000000000000000000000000000000/api/public/v1/feesPublic fee data: totals and per coin. Fees every coin has generated and where they went, from indexed events only: creator wallets, holders (RewardPool), handles (social vaults), posters (PosterPool), fee modules (FeeVault), cross-chain routers, the protocol (FeeRouter), burned (0x…dEaD, the protocol's coin-leg share included), credited and awaiting claim, and curve rows indexed before their split was stored (unattributed). Totals per chain and quote asset across ALL coins (quote legs only: coin legs are different tokens); one page of coins with both legs. Every bucket: { amount | quote + coin, events, txs (its newest tx hashes) }. Solana: fee claims into the treasury multisig by source, in lamports. Raw integer strings, no USD. CORS open; unknown parameters are refused at the edge; a busy database answers 503 + retry-after.
chain=base|robinhood|bnb limit offsetcache: public, s-maxage=60, stale-while-revalidate=300 example: /api/public/v1/fees?chain=base&limit=50/api/public/v1/fees/{chain}/{token}Public fee data: one coin, event by event. One coin's fee breakdown (generated; to creator / holders / handles / posters / modules / xchain / protocol / burn / credited / unattributed; protocol_coin_burned; posters_paid_out; summary { creator_side, protocol, burned, pending_claim, unattributed }; reconciled per leg) and its fee events newest first, each with tx_hash and log_index. chain = solana takes a mint and returns that coin's treasury claims by source.
{chain}*=base|robinhood|bnb|solana {token}* limit offsetcache: public, s-maxage=60, stale-while-revalidate=300 example: /api/public/v1/fees/base/0x.../api/launch/meta/{token}Token metadata by address. Name, symbol, description, logo and links the creator registered. The logo is a 512x512 WebP on this domain when it was uploaded here, else the https URL the creator gave.
{token}* chain=base|robinhood|bnbcache: public, max-age=300 example: /api/launch/meta/0x...?chain=base/api/launch/meta/{launcher}/{key}Token metadata by its on-chain URI. The form of `metadataURI` written on-chain by Launched / CurveLaunched / Listed: the launcher address and a 32-byte key. Same JSON as the by-address form.
{launcher}* {key}*cache: public, max-age=300 example: /api/launch/meta/0x<launcher>/0x<key>/api/voteAdvisory holder votes. For a launch with a fee module: the proposals to switch its mode, their tallies (weight = min(balance when voting, balance at close), from the holder index) and, with `wallet`, that wallet's own vote. Advisory only: the creator decides; nothing here changes the fee split.
chain*=base|robinhood|bnb token* walletcache: no-store example: /api/vote?chain=base&token=0x.../api/quotesQuote assets on a chain. The fixed quotes (ETH; USDG on Robinhood Chain) and the chain's tokenized-stock registry with live USD prices. Only registry addresses are ever labelled stocks.
chain*=base|robinhood|bnb qcache: no-store (30 s server memo) example: /api/quotes?chain=base&q=AAPL/api/quotes/inspectCan this ERC-20 be a quote?. On-chain reads, DexScreener depth and (Base) a GoPlus scan for an arbitrary quote coin. Per-IP limit: 30 per minute.
chain*=base|robinhood|bnb address*cache: no-store (10 min server cache) example: /api/quotes/inspect?chain=base&address=0x.../api/healthIndex freshness. Database reachability and the indexer cursor per chain (block lag, last run, last error).
cache: no-store example: /api/health/api/integrate/kit.jsonThis kit, machine-readable. Contracts, Uniswap v4 addresses, event signatures and topics, constants, the REST reference and the stream description; versioned.
cache: public, s-maxage=60, stale-while-revalidate=300 example: /api/integrate/kit.json/api/openapi.jsonOpenAPI 3.1. The public read API, this kit and the stream as an OpenAPI 3.1 document.
cache: public, s-maxage=300, stale-while-revalidate=3600 example: /api/openapi.json/api/streamReal-time events (SSE). Server-sent events: new launches, swaps, curve state changes, holder-reward payouts and fee splits as the indexer writes them. Resume with `Last-Event-ID` or `since=`.
chain=base|robinhood|bnb sincecache: no-store example: /api/stream?chain=baseCSV. /api/launch/list and /api/launch/feed also answer ?format=csv: the same rows as text/csv, RFC 4180 with CRLF line endings, one header line then one line per row. Amounts stay decimal integer strings in the same units as the JSON. Coin names and symbols are written by whoever launched the coin, so a field that starts with =, +, - or @ is prefixed with a single quote: a spreadsheet must not treat a coin name as a formula.
Raw token and quote amounts are decimal integer strings; use quote_decimals, never a blanket 18. price_quote and fdv_quote are numbers in the quote asset; price_usd, fdv_usd and volume_usd are dollars and null when the quote has no price (a stock outside market hours keeps its last price; an unknown coin has none).
Caching: s-maxage is the CDN window per endpoint (2 s on the hot lists, 5 s on candles, burns and search, 300 s on metadata); responses with no-store are memoised a few seconds server-side. When the database is busy a cached read answers 503 with retry-after: 2: keep your last data and retry. Unknown query parameters are refused with 400 at the edge on the cached endpoints. /api/quotes/inspect allows 30 calls per IP per minute. Poll modestly; for anything real-time use the stream below.
curl -s "https://nasdegen.fun/api/integrate/kit.json" | jq '.chains.base.events[] | {name, contract, topic0}'
curl -s "https://nasdegen.fun/api/openapi.json" | jq '.paths | keys'# every launch on Base, newest first, as CSV
curl -s "https://nasdegen.fun/api/launch/list?chain=base&sort=new&limit=200&format=csv" > launches.csv
# the latest launches and trades
curl -s "https://nasdegen.fun/api/launch/feed?format=csv" > trades.csvReal-time stream
Server-sent events over plain HTTP. No socket library, no key.
GET /api/stream emits new launches, swaps, curve state changes, holder-reward payouts and fee splits as the indexer writes them, polling the index every 2 s and sending a : ping comment every 15 s. A connection closes cleanly after about 290 s; every event's id is a cursor, so reconnecting with Last-Event-ID (which EventSource does on its own) resumes exactly after the last event you saw. Optional chain= narrows to one chain; optional since= takes a cursor or a moment (unix seconds, unix ms or an ISO date, at most 24 h back) to replay before following; absent, the stream starts at the head.
# follow every chain from now on
curl -N "https://nasdegen.fun/api/stream"
# one chain, resuming from the last id you processed (what EventSource sends on its own)
curl -N -H "Last-Event-ID: v1.120.5531.7.40.12.9" "https://nasdegen.fun/api/stream?chain=base"
# or from a moment (unix seconds, unix ms or an ISO date; at most 24 h back)
curl -N "https://nasdegen.fun/api/stream?since=2026-09-14T00:00:00Z"event: ready
id: v1.120.5531.7.40.12.9
retry: 3000
data: {"cursor":"v1.120.5531.7.40.12.9","chain":"base","poll_ms":2000,"publish_lag_s":3,"lifetime_s":290,"page_limit":200}
event: swap
id: v1.120.5532.7.40.12.9
data: {"chain":"base","chain_id":8453,"token":"0x…","pool_id":"0x…","trader":"0x…","is_buy":true,"amount0":"-50000000000000000","amount1":"1234567000000000000000000","sqrt_price_x96":"…","tick":183800,"block_number":37000000,"block_time":"2026-09-14T12:00:02.000Z","tx_hash":"0x…","log_index":12}
: ping| event | data |
|---|---|
| ready | { cursor, chain, poll_ms, publish_lag_s, lifetime_s, page_limit } once per connection; its id is the resolved start cursor |
| launch | a new bb_launches row: { chain, chain_id, token, token_id, launcher, creator, quote, pool_id, kind, curve, hooks, start_tick, lp_fee, supply, name, symbol, metadata_uri, reward_pool, fee_vault, block_number, block_time, tx_hash, log_index } |
| swap | a new bb_launch_swaps row (quote = currency0 convention): { chain, chain_id, token, pool_id, trader, is_buy, amount0, amount1, sqrt_price_x96, tick, block_number, block_time, tx_hash, log_index } |
| curve | a bb_curve_launches row was inserted or changed (graduation, sweep, refund, redemption): { chain, chain_id, token, curve, pool_id, phase, graduated, refunding, refund_venue, refund_quote, refund_supply, redeemed, abandoned_at, updated_at } |
| reward | a bb_rewards row: { chain, chain_id, token, pool, round, holder, amount, block_number, block_time, tx_hash, log_index } |
| burn | a bb_burns row: { chain, chain_id, kind, round, currency, amount_in, burned, to, block_number, block_time, tx_hash, log_index } |
| split | a bb_fee_splits row: { chain, chain_id, currency, treasury_amount, payee_amount, block_number, block_time, tx_hash, log_index } |
| unavailable | { reason } then the server closes (no database, or the database is busy): reconnect after `retry` |
Cursor design: v1.<launch>.<swap>.<curve>.<reward>.<burn>.<split>, one insertion-sequence position per table. A row is published only once its insert is 3 s old, so an insert whose transaction commits late is never skipped past; a block number or a block time would not work as a cursor because the chains' indexers lag differently and the reorg re-scan writes old blocks late. Each poll reads at most 200 rows per table and polls again at once when a page was full, so a reconnect catches up quickly. Delivery is at-least-once within a connection and exactly-once across reconnects when you resume from the last id you processed.
Latency is the indexer's: the cron polls the chains about once a minute, and POST /api/launch/sync?chain=&tx= indexes one transaction at once. Without a database the stream sends one event: unavailable and closes; the retry hint makes clients reconnect.
const es = new EventSource("https://nasdegen.fun/api/stream?chain=base");
es.addEventListener("launch", (e) => index(JSON.parse(e.data)));
es.addEventListener("swap", (e) => trade(JSON.parse(e.data)));
es.addEventListener("curve", (e) => curveState(JSON.parse(e.data)));
// the browser reconnects with Last-Event-ID = the last id it saw; nothing is missedBrand assets and contact
The chrome bull, one render at every size listings ask for.
- /brand/mark.svgthe same bull with rounded corners, for anything that asks for an SVG
- 64x64 raster in an SVG wrapper · svg+xml
Platform name: nasdegen.fun. Chrome bull on black #07060B; accent purple #BF5AFF, up lime #C8FF00.Contact: @nasdegen on X
Solana
Runs on Meteora, not on these contracts.
Solana launches go through Meteora's Dynamic Bonding Curve (DBC) under a Nasdegen partner config per (quote, curve size): a terminal that already indexes DBC pools picks them up automatically, keyed by those configs. partnerConfigs lists the pre-funded quotes; any other Solana coin with a real market can be paired too (the launcher creates the config and the site verifies it, so a new config appears per such launch) (SOL, ZEC and the Backpack Securities stocks and ETFs issued through Sunrise), with the config public key each pool is created under.
The EVM contracts above are live on Base, Robinhood Chain and BNB Chain. Solana launches run on Meteora's Dynamic Bonding Curve under the partner configs the kit lists; there is no Solidity there to verify.