How DreamPad works

DreamPad launches tokens on a bonding curve, graduates them into a locked Uniswap pool, and routes every fee the coin ever earns back to its holders and its creator. Curve fees, the graduation fee, post-launch trading taxes and the pool's own swap fees all go through one split on the token.

The rule that never changes: at least 90% of every stream goes to holders and the creator, at most 10% to the platform, and everyone can claim whenever they like, before or after graduation.

• Ethereum mainnet: graduation into Uniswap V2, optional buy / sell taxes, rewards in the pair asset.
• Robinhood Chain: graduation into a full-range Uniswap V3 position in the 1% tier, tax-free tokens, rewards from the pool fee. Any coin on the chain, including Uniswap V4 pools, can be a pair asset.
• Pair assets: WETH, USDC, or a tokenized stock. Rewards are paid in that asset; trading is always in ETH.

The app is a Next.js front end over the contracts. Nothing is custodial: your wallet signs every launch, trade and claim. The one exception is optional fast trading, which uses a key kept in your own browser.

• Accept the risk disclosure. New browsers and new wallets see it once. It can be reopened from the footer.
• Pick a network in the header: Ethereum, Robinhood Chain, or a testnet when one is configured. Every read, launch and trade is scoped to that network, and the app switches your wallet when a transaction needs it.
• Connect a wallet (any injected wallet, or WalletConnect when configured). The chip shows your ETH balance on the chosen network and links to your profile.
• Explore lists every coin with market cap, 24h volume, holders and fees. Launch creates a coin. Rewards claims everything you are owed. Profile shows your holdings, coins created, fees claimed and trades.
• USD / Pair toggle: show values in USD (via price feeds) or in each coin's pair asset. Price / Mcap on the chart switches between price per token and market cap.

A launch deploys three minimal-proxy clones in one transaction: the token (1,000,000,000 fixed supply), its bonding curve and its rewards distributor. The form previews every setting before your wallet opens.

Launch fee: $2, paid in ETH at the current ETH price (a Chainlink feed on Ethereum, the DreamPad oracle on Robinhood Chain). Anything sent above the exact fee is refunded.

Your launch wallet earns the creator share only. It is excluded from holder rewards, so a creator cannot double-dip by holding their own coin in the same wallet.

struct LaunchParams {
    string  name;
    string  symbol;
    string  metadataURI;      // logo, description, socials (data: URI or ipfs://)
    address quoteAsset;       // WETH, USDC, a stock: must be enabled on the factory
    uint16  buyTaxBps;        // <= feeConfig.maxTaxBps (1000 = 10%); 0 on V3 chains
    uint16  sellTaxBps;
    uint16  holderShareBps;   // holder + creator must sum to 10_000
    uint16  creatorShareBps;
    uint16  maxWalletBps;     // 0 = disabled
    uint32  maxWalletDuration;
    uint256 minHoldForRewards;
    uint256 initialBuyQuote;  // optional first buy, in quote units
}

// factory.launch{value: launchFee + initialBuy (WETH pairs only)}(params)
// zap.launchWithETH{value: launchFee + ethForFirstBuy}(params, minQuoteOut)

import { createWalletClient, http, parseEther } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { dreamPadFactoryAbi } from "./abi";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({ account, chain, transport: http(RPC) });

const fee = await publicClient.readContract({ address: FACTORY, abi: dreamPadFactoryAbi, functionName: "launchFee" });
const hash = await wallet.writeContract({
  address: FACTORY,
  abi: dreamPadFactoryAbi,
  functionName: "launch",
  args: [{
    name: "Dream Cat", symbol: "DCAT", metadataURI: "data:application/json;base64,…",
    quoteAsset: WETH, buyTaxBps: 200, sellTaxBps: 400,
    holderShareBps: 8000, creatorShareBps: 2000,
    maxWalletBps: 0, maxWalletDuration: 0, minHoldForRewards: 0n,
    initialBuyQuote: parseEther("0.5"),
  }],
  value: fee + parseEther("0.5"),
});

Launching $ABC reserves the ticker for the launching wallet for 24 hours. Nobody else can launch the same symbol in that window, so a bundler cannot clone your ticker next to yours, while you can relaunch it yourself to fix a misconfigured first attempt. Every launch by the holder refreshes the window.

Matching ignores case and a leading $: abc, ABC and $ABC are one ticker. The display symbol stays exactly as typed. A reservation can be handed to another wallet with transferTicker.

cast call $FACTORY "tickerStatus(string)(address,uint256)" "ABC" --rpc-url $RPC
cast call $FACTORY "canLaunchTicker(string,address)(bool)" "ABC" $MY_WALLET --rpc-url $RPC

Of the 1B supply, 800,000,000 tokens are sold on the curve and 200,000,000 are reserved for the pool. The curve is constant-product (x · y = k) with a virtual token reserve of 1.06B and a virtual quote reserve set per pair asset. With those constants a curve always raises about 3.08× its virtual quote reserve before it sells out.

The virtual reserve is sized so that every coin raises roughly the same $30,000 whatever it is paired with: 8 WETH, about 30,769 USDC, or the equivalent in a stock at its live price. refreshQuoteAsset re-sizes a pair asset after a big price move (once an hour, 25% per step) and is also the call that confirms a newly registered asset.

• 2% fee on every curve trade, taken on the quote side, split 90% holders + creator, 10% platform. Holders on the curve earn from every later curve trade.
• No minimum buy. Buy as little or as much as you like; the last buy that sells the curve out is refunded for the part it cannot fill.
• Transfers are locked until graduation. Tokens can only move to and from the curve, so nobody can seed a competing pool or dump over the counter before liquidity is live.
• Previews are exact: quoteToTokens, tokensToQuoteOut and the zap's previewBuyCurve / previewSellCurve return what the trade would fill right now.

# buy with 100 USDC (approve the curve once first)
cast send $USDC "approve(address,uint256)" $CURVE $(cast max-uint) --private-key $PK --rpc-url $RPC
cast send $CURVE "buy(uint256,uint256,address)" 100000000 0 $ME --private-key $PK --rpc-url $RPC

# WETH-paired coins accept native ETH
cast send $CURVE "buyWithETH(uint256,address)" 0 $ME --value 0.1ether --private-key $PK --rpc-url $RPC

# sell 1M tokens; unwrap=true pays ETH on WETH pairs
cast send $CURVE "sell(uint256,uint256,address,bool)" 1000000ether 0 $ME true --private-key $PK --rpc-url $RPC

When the last curve token sells, in the same transaction:

• A 3% graduation fee on the raise goes through the usual split. Curve holders and the creator can claim their share immediately.
• The remaining quote plus exactly enough of the 200M reserve to match the curve's closing price are put into the pool. Reserve tokens not needed at that price are burned, so the pool opens where the curve closed and there is no price gap.
• On Ethereum the Uniswap V2 pair is minted directly (not via the router, so a griefer cannot block it by pre-creating the pair) and the LP tokens go to the LiquidityVault, which can never withdraw them.
• On Robinhood Chain the adapter mints one full-range Uniswap V3 position in the 1% fee tier owned by LiquidityVaultV3, which can only ever collect fees.
• The token flips to open trading and registers the pool as a taxed AMM (Ethereum only).

Graduation is automatic on the buy that sells out the curve. If it ever needs a nudge, graduate() on the curve is permissionless.

DreamZap is the ETH router. On a buy it swaps your ETH into the pair asset on Uniswap (V2 pair, then the best V3 pool, then a V4 pool) and buys on the curve or the pool for you in one transaction. On a sell it does the reverse and pays you ETH. A buyer of a TSLAx-paired coin never holds TSLAx.

• Pay-with toggle: the trade panel defaults to ETH; you can also pay in the pair asset directly.
• One approval, ever: the curve is the only spender pre-graduation (the zap sells through sellFor), and the app approves the maximum once.
• 10 / 25 / 50 / 75 / MAX buttons size a trade from your balance.
• Slippage: presets 0.5 / 1 / 3% or any custom value under 50%. The minimum output is enforced on-chain.
• Route impact guard: when swapping ETH into the pair asset would move that pool by more than 25%, the app blocks the trade and says so, instead of filling badly.
• Previews show what you receive, the curve fee, the route and the price impact before you sign.

# buy on the curve with 0.1 ETH (minTokensOut from previewBuyCurve minus slippage)
cast call $ZAP "previewBuyCurve(address,uint256)(uint256,uint256)" $TOKEN 100000000000000000 --rpc-url $RPC
cast send $ZAP "buyCurve(address,uint256)" $TOKEN $MIN_OUT --value 0.1ether --private-key $PK --rpc-url $RPC

# sell 1M tokens for ETH (approve the curve once first)
cast send $ZAP "sellCurve(address,uint256,uint256)" $TOKEN 1000000ether $MIN_ETH --private-key $PK --rpc-url $RPC

# after graduation: buyPool / sellPool (approve the zap for sells)

interface IDreamZap {
    function buyCurve(address token, uint256 minTokensOut) external payable returns (uint256);
    function buyPool(address token, uint256 minTokensOut) external payable returns (uint256);
    function previewBuyCurve(address token, uint256 ethIn) external view returns (uint256 tokensOut, uint256 quoteIn);
}

contract Buyer {
    IDreamZap constant ZAP = IDreamZap(0x...);
    function buy(address token) external payable {
        (uint256 expected,) = ZAP.previewBuyCurve(token, msg.value);
        ZAP.buyCurve{value: msg.value}(token, expected * 97 / 100); // 3% slippage
        // tokens are credited to msg.sender of the zap call: this contract
    }
}

The Buy button on every explore card buys with the ETH amount and slippage configured in the Fast panel in the header (default 0.05 ETH at 3%). There is no amount prompt: the app quotes at click time, applies your slippage, and sends. The button shows the amount, then Bought or Failed; hover a failure for the reason.

In wallet mode you still confirm in your wallet. With fast trading on, the buy signs instantly.

A browser extension cannot be told to approve transactions automatically, so fast trading creates a separate trading wallet whose private key is stored in this browser. While the switch is on, buys, sells and approvals sign with it instantly. Launching, claiming rewards and admin actions always use your main wallet.

• Deposit ETH from your main wallet into the trading wallet from the Fast panel. Keep only what you are actively trading.
• Withdraw all ETH sends the balance back to your main wallet, minus gas (estimated per network; Robinhood Chain needs more than 21,000 gas for a plain transfer).
• Coins bought in fast mode are held by the trading wallet. The coin page, Rewards and Profile follow it while fast is on. Graduated coins offer Move all to my main wallet; curve coins cannot be transferred until graduation, so sell from there instead.
• Export key shows the private key so you can import it into a wallet app. Reset forgets it (only enabled when the balance is zero).
• The key is stored unencrypted in localStorage. Anyone with access to this browser profile controls that wallet. Export the key before clearing site data.

• Top by market cap shows the four largest coins; All coins lists the rest with sorts by latest trade, market cap, 24h volume and age, a pair filter, search by name, ticker or address, and a Graduated switch that flips between coins on the curve and coins that graduated.
• Cards show market cap, 24h volume, holders, buy / sell tax and the creator's share. A tax above 5% or a creator share above 25% gets an amber outline and a high tax / high creator fee badge.
• Coin page header: copyable contract address, creator, launch time. Stats: price, market cap, liquidity, 24h change and volume, holder rewards paid, and the fee share bar.
• Chart: candles built from every curve and pool trade since launch, in 1m / 5m / 15m / 1h, as price or market cap, in USD or the pair asset. Volume bars underneath.
• Trades and holders: live tables; trader addresses link to profiles, and trades made by the coin's creator (including the launch buy) are marked creator and tinted, so a creator selling is never hidden in the list. Wallets below the minimum reward balance are not listed as holders.
• Header search finds a coin by name, ticker or contract address on the current network.

Every revenue stream is deposited into the token and split by one formula. The holder share goes to the RewardsDistributor, which credits it pro rata to balances at that moment. Rewards accrue in the pair asset: ETH for WETH launches, USDC for stable launches, the stock itself for stock pairs.

• Claims are pull-based: Claim on the coin page or the Rewards page, Claim as ETH on WETH pairs, and Claim all on the Rewards page walks every pending claim in order.
• claimFor(account) lets anyone push rewards to a holder; processBatch lets keepers sweep.
• Excluded from rewards: the creator's launch wallet, the curve, the pool, the token, the router, the zap and 0xdead. The creator can exclude more (a CEX wallet, a vesting contract) and set a minimum balance to qualify.

cast call $DISTRIBUTOR "withdrawableOf(address)(uint256)" $ME --rpc-url $RPC
cast send $DISTRIBUTOR "claim()" --private-key $PK --rpc-url $RPC
cast send $DISTRIBUTOR "claimAsETH()" --private-key $PK --rpc-url $RPC   # WETH pairs

The creator's share of every curve fee, the graduation fee, every tax swap-back and every LP harvest accrues as creatorRewardsClaimable on the token, in the pair asset. Nothing is pushed; claim whenever you like with Claim or Claim as ETH in the Creator panel.

Fixed for the life of the coin: buy / sell tax, the holder / creator split, the platform share, the pair asset. There is no setter for any of them, so the Creator panel has no tax controls because there is nothing to change.

On Ethereum, swaps against the registered pool pay the buy or sell tax in the coin itself, which the token contract holds. Wallet-to-wallet transfers are free. On the next sell that finds at least swapThreshold (0.05% of supply) waiting, the token sells up to maxSwapAmount (0.5% of supply, and never more than 0.2% of the pool's token reserve as it was when the window started) into the pool for the pair asset and runs the split. The seller whose transaction triggers it pays the extra gas; if that swap fails, the sell still goes through and the retry happens on a later sell.

A swap-back runs at most once every ten minutes and never sells below the pool's time-weighted average price over that window (a 0.3% tolerance, with the pool fee and the sale's own impact already priced in). Anyone may trigger it once the pot is above the threshold, so a floor taken from the spot price would be no floor at all: a caller who dumps first and triggers the swap-back only gets it deferred (SwapBackDeferred), and the pot waits for the next window.

On Robinhood Chain tokens are tax-free: Uniswap V3 pools reject fee-on-transfer tokens, so rewards there come from the 1% pool fee via harvests instead.

The explore cards flag a buy or sell tax above 5% as *high tax* and a creator share above 25% as *high creator fee*.

At launch the creator can route a buyback and burn share of every fee stream (curve trades, the graduation fee, taxes and harvested pool fees) to the BuybackVault. The share comes out of the creator's part of the split, so holders are never diluted by it: the launch form shows holders / creator / buyback / platform side by side.

The vault holds that share in the pair asset until someone runs a buyback. Anyone can run it; the caller pays gas and receives nothing. A run buys the coin on its bonding curve before graduation and on its Uniswap pool after, then sends what it bought to the dead address until the coin's burn cap is reached. The cap is chosen at launch as the share of the supply the buybacks may burn: everything, nothing (a pure buyback into the vault), or for example half. Coins bought past the cap stay in the vault, where only the creator can withdraw them, and only after graduation.

• Once every ten minutes, at most 0.2% of the pool's pair-asset reserve as it was when the window started (or 0.5% of the curve's virtual quote) per run, so a single run cannot move the price much, and a reserve somebody inflated during the window never raises the cap.
• Never above the average price. On a V2 pool the buy is floored at the tokens a fair pool would give at the pool's time-weighted average price since the previous run (0.3% tolerance); on a V3 pool the swap is limited to 1% above the average sqrt price. If somebody pushed the price up first, the run is deferred (Deferred) and the pair asset waits. The first pool run after graduation only records the price window.
• On the curve the price cannot be flashed, only traded, and a round trip costs the curve fee twice, so a capped buy of 0.5% of the virtual quote cannot be sandwiched for profit.
• The vault's exemptions (tax, max wallet, holder rewards) are fixed: the creator cannot tax it, cap it or make it earn.

The coin page shows what is waiting to be spent, what was burned, what is held, and a Run buyback button that greys out until the next window. The protocol's own $DREAM uses this with a 50% burn cap: it burns until half the supply is gone, then keeps buying into the vault.

cast call $VAULT "positions(address)(uint16,uint256,uint256,uint256,uint256,uint256,uint32,uint32)" $TOKEN --rpc-url $RPC
cast send $VAULT "run(address)" $TOKEN --private-key $PK --rpc-url $RPC

Liquidity is locked forever, but the fees it earns are not. LiquidityVault.harvest(token) (Ethereum) burns only the LP that represents fee growth since the last harvest, measured as growth of sqrt(k) per LP share so price moves never count, sells the token half into the pool and deposits the whole harvest as the pair asset. LiquidityVaultV3.harvest(token) (Robinhood Chain) collects the position's accrued fees without touching liquidity.

• Anyone can harvest. The caller pays gas and receives nothing extra; the proceeds are split between holders, creator and platform like every other fee. Fees keep accruing in the pool until someone harvests.
• Sales are floored at the average price. The token half is sold at most once every ten minutes and never below the pool's time-weighted average price over that window: at most 0.2% of the pool's reserve as it was when the window started, no more than 0.3% under the average (V2), or a swap limited to 0.5% below the average sqrt price (V3, using the pool's own price history from graduation on, which the adapter switches on at graduation). The moves stay under what a round trip through the pool costs, so pushing the price and holding it for a window does not pay either. If the price was just pushed down, or the pool has less than five minutes of history, the token half waits in the vault (TokenSaleDeferred) and only the pair-asset half is paid out. A front-run therefore either fits inside the tolerance and loses two pool fees, or defers the sale; a harvest cannot be sandwiched for profit.
• A creator can run a 0% tax coin and still pay holders from pool fees.
• The coin page shows the harvestable amount and a Harvest LP fees button.

cast call $VAULT "pendingFees(address)(uint256,uint256)" $TOKEN --rpc-url $RPC
cast send $VAULT "harvest(address)" $TOKEN --private-key $PK --rpc-url $RPC

The platform share is capped at 10% on-chain (MAX_PLATFORM_SHARE_BPS). Fee settings are snapshotted into each curve and token at launch, so a later change to the factory never touches a live coin.

The pair asset is what rewards are paid in and what the pool is seeded with, nothing else: trading is always in ETH. The launch form shows WETH and the stablecoin as tiles and puts every stock and other registered token in one searchable dropdown.

• Ethereum: Ondo Global Markets tokens (TSLAon, AAPLon, …) and Backed xStocks (TSLAx, SPYx, …), several hundred in total, from the issuers' official token lists.
• Robinhood Chain: Robinhood Stock Tokens (TSLA, AAPL, …) from Robinhood's asset API.
• Anything else: paste an address. Any ERC-20 with a Uniswap V3 pool, a V2 pair (Ethereum) or a V4 pool against ETH, USDC or USDG can be registered by anyone in one transaction. On Robinhood Chain that includes coins launched through Pons.

Picking a stock that is not registered yet shows a one-click Register. Registration asks the price oracle for a USD price and sizes the raise to about $30,000 worth of that asset. A token with no pool fails with NotPriceable. The asset is then pending: it opens for launches once refreshQuoteAsset, at least an hour later, sizes it again within 25% of the first sizing (QuoteAssetActivated). A sizing further away replaces the first and the hour restarts. Anyone can run the confirming call; the launch form lists pending assets with a Confirm price button. For an asset priced from a V2 pair the confirming call sizes it from the pair's average price over that hour, and the instant's price must agree with the average, so a pushed price really does have to hold for the whole hour against arbitrage. Active assets are re-sized from the same average.

Prices come from a 10-minute time-weighted average where the pool keeps history (V3), from the hour-long average of a V2 pair for community assets, and from spot for V4 pools (which keep no history; the owner can switch such an asset off). Re-sizing an active asset later is limited to once an hour and 25% per step, so a launch in flight cannot be sandwiched into a wrong raise target. Assets the owner switched off cannot be re-registered.

Community registrations go through the pair-asset guard (PairAssetGuard): the token must take no fee on transfer (a probe amount of 0.001 is moved from the registrant to the guard and straight back, and both balance changes must be exact), must not answer the standard paused() getter, and must not expose a blocklist getter (isBlacklisted, isBlackListed, blacklisted, isBlocked, blocked, isFrozen, frozen, isBanned). Any of these would let a third party freeze every coin paired with the token. The registrant therefore needs a little of the token and an approval to the guard; the launch form asks for both. The stablecoin and the issuers' stock tokens are regulated and do have pause and blocklist controls: DreamPad lists those itself, and owner listings do not go through the guard. A launch on any pair asset that is paused at that moment is refused.

The guard finds controls through their standard names, so a token that hides a pause behind another name still passes. The launch form keeps flagging community-registered assets for that reason: read the contract before pairing with one. Tokens with transfer allow-lists must allow the curve, pool, token, tax vault and distributor.

cast send $FACTORY "registerQuoteAsset(address)" $STOCK --private-key $PK --rpc-url $RPC
cast call $FACTORY "activatableAt(address)(uint256)" $STOCK --rpc-url $RPC   # unix time of the earliest confirmation
# an hour or more later, from any wallet:
cast send $FACTORY "refreshQuoteAsset(address)" $STOCK --private-key $PK --rpc-url $RPC
cast call $FACTORY "quoteAsset(address)" $STOCK --rpc-url $RPC

Each network has its own factory, implementations, zap and liquidity vault. Coin URLs carry the network: /token/eth/0x… and /token/robinhood/0x…. Robinhood Chain is an Arbitrum-style L2 (chain id 4663, testnet 46630) with sub-second blocks; DreamPad never deploys Uniswap V2 there.

Uniswap V4 pools are read through the StateView lens. The oracle probes owner-set pool-key templates (the Pons dynamic-fee shape and the hookless tiers); for any other pool, registerV4Pool(key) is permissionless and the launch form has a small panel for it.

/profile/<address> works for any wallet; Profile in the header opens yours (the fast-trading wallet while fast mode is on, with a link to the main one).

• Portfolio: ETH balance plus every DreamPad coin at its current price, in USD.
• Holdings: balance, price, value, share of supply and unclaimed rewards per coin.
• Coins created: market cap, holders, lifetime creator fees and what is claimable.
• Fees claimed: every holder and creator claim, with lifetime totals per asset.
• Trading history: every buy and sell through DreamPad, on the curve or through the ETH router, with the ETH or pair-asset amount and a transaction link.

/analytics shows how the launchpad is doing on the network you are browsing, straight from the contracts' own counters, so every figure is exact and live.

• Coins: launched, graduated and on the curve, the graduation rate, and a per-day chart of launches over the last 30 days.
• Revenue: curve fees, trading taxes, harvested LP fees and ETH launch fees, per pair asset and in USD at today's prices.
• Where it went: paid to holders, paid to creators, platform revenue (launch fees plus the platform's fee share) and the buyback share.
• Buybacks: spent, burned, held and waiting to run, per coin.
• Market: eligible holders, 24h volume and trades, total market cap, the most traded and the biggest coins.
• Site traffic: page views and visitors for the whole site, from Vercel Web Analytics.

A pair asset without a USD price is shown in its own units only and the page says so.

The platform's 10% accrues on each token as protocolRewardsClaimable. Only the treasury wallet set on the factory can open /admin and claim it, per token or in one batch with DreamPadFactory.claimProtocolRewards(tokens). Launch fees go straight to the treasury.

The page shows revenue per pair asset (claimable, claimed, paid to holders, paid to creators), launch fees collected, and per-coin rows.

Pause launches is the emergency switch. Only the treasury wallet can flip it (not the owner key). While paused nobody can launch; existing coins keep trading, graduating and paying rewards. The same wallet, or the owner, can release a squatted ticker early.

Terminals and bots: the HTTP API. No ABI needed. GET /api/v1/{chain}/quote?token=…&side=buy|sell&amount=…&slippageBps=100&trader=… returns the trade at the current state and the exact transaction to send (tx.to, tx.data, tx.value), plus the approval a sell needs first, in both the curve and the pool phase. /api/v1/{chain}/tokens lists launches newest first and /api/v1/{chain}/token/{address} gives phase, price, curve progress, taxes and max wallet. /api/v1/{chain} lists the contracts. {chain} is eth or robinhood. Amounts are base units (wei) as strings. A DEX Screener adapter for the curve phase lives at /api/dexscreener/{chain}/…. The full guide is docs/INTEGRATIONS.md in the repository.

ABIs are exported to web/src/abi by tools/export-abis.mjs. Every launch is discoverable on-chain: launchCount() then launches(i) and getLaunch(token) return the token, curve, distributor, pair asset, creator, pool and timestamps.

const n = await client.readContract({ address: FACTORY, abi: dreamPadFactoryAbi, functionName: "launchCount" });
for (let i = 0n; i < n; i++) {
  const token = await client.readContract({ address: FACTORY, abi: dreamPadFactoryAbi, functionName: "launches", args: [i] });
  const l = await client.readContract({ address: FACTORY, abi: dreamPadFactoryAbi, functionName: "getLaunch", args: [token] });
  console.log(l.token, l.curve, l.distributor, l.quoteAsset, l.creator, l.pair, l.createdAt, l.graduatedAt);
}

• New contracts. They are tested (Foundry suite with real Uniswap V2, V3 and V4 bytecode) and reviewed in-house over five audit rounds; every finding, its fix and the security score are on the public audit sheet at /audit. An independent review is still ahead. Trade amounts you can afford to lose.
• Anyone can launch anything. A coin's name and logo prove nothing. Check the contract address, the creator, the fee share and the tax on the card before buying.
• Price impact. Curve prices move with every trade; small pools move a lot. Use the previews and keep slippage tight.
• Fast trading keys are stored unencrypted in the browser. Keep small balances, withdraw when done, export the key before clearing site data.
• Pair-asset tokens are third-party assets with their own rules (allow-lists, corporate actions, pauses). DreamPad cannot control them.
• Testnets are not mainnet, even though DreamPad's testnet deployments are built to behave identically; mainnet coins do not exist on a testnet and cannot be used there.

The full risk disclosure is linked in the footer and must be accepted once per wallet before using the app.