Build on wdyt

wdyt.fun is a permissionless Solana launchpad that replaces the bonding curve with a self-resolving prediction market. Every launch opens a market on one question (will this coin launch?) and both answers trade:

• Yes (buy_yes) buys YES along a buy-only curve. It buys the coin before it exists: 1 YES becomes 1 coin if the launch succeeds.
• No (buy_no) buys NO shares of a fund that is paid from both pots if the launch fails, priced at the fund's current value so buying late gives no edge.

The market resolves itself on-chain, with no oracle. If the YES pot reaches the threshold before the deadline, it resolves Yes: the coin graduates into a Meteora pool seeded by both sides, with the liquidity locked forever, and YES turns into the coin one for one; NO pays nothing. If time runs out first, it resolves No: NO holders get their SOL back plus a share of every YES buy after theirs, and YES holders get back the rest.

Any app, bot or wallet can list launches and route trades through one program. Name your own fee account on each trade and you keep 0.25% of every trade you route, paid in SOL in the same transaction. There is nothing to apply for and no API key.

At a glance

How a launch works

1. OPEN for the launch's window (params.window: 30 minutes in the option enabled today). buy_yes takes SOL and adds YES along a rising curve to the buyer's holding. buy_no takes SOL and adds NO shares priced at the fund's current value to it, once the YES pot holds no_unlock_bps of the threshold (30% by default); before that it fails with NoSideClosed. Nobody can sell back to the curve; early exits go through the order book. A private launch (launch.approver set) takes buys only from the wallets it approved, so the public buy instructions fail on it with PrivateLaunch; its order book is open to everyone.
2. RESOLVED_YES the moment the YES pot reaches the threshold (75 SOL in the option enabled today). The buy that crosses it is filled up to the threshold and the rest of its SOL is refunded in the same transaction.
3. LIVE once the graduation crank has created the Meteora DAMM v2 pool from the YES pot and the NO fund, less the No refund (no_refund_bps, 25% of the NO fund, kept for NO holders and paid by share), the migration fee and the launch fee (grad_fee_bps, 1% of the pool's SOL, to the treasury; the pool gets proportionally fewer coins, so the opening price is unchanged), with its liquidity locked forever. Every YES holder is paid the coin one for one, automatically: the keeper settles every holding and position right away, aiming to finish before pool trading opens claim_delay seconds later (default 60). From then on the coin trades wherever Meteora is routed: Jupiter, wallets, terminals.
4. RESOLVED_NO if the deadline passes first. The resolve_no crank closes it, and every YES and NO holder is paid SOL automatically.

Holdings and positions: users never claim. A buy adds YES or NO to the buyer's holding, an account of this program at PDA ["holding", launch, owner] that records what they bought without minting it, so a buy writes no token account. Fills and bids put YES and NO in the user's position, a token account at PDA ["position", mint, owner] that the launch PDA controls, and realize mints one side of the holding into it. Once the launch resolves, the permissionless settle_position pays the owner for both (coins in LIVE, SOL in RESOLVED_NO) and closes them, returning their rent. Only the owner's own instructions can move tokens out of a position or realize a holding. Read balances with positionBalances in the SDK (totals, the part still held, and which accounts exist) or GET /api/positions/{wallet}. Aggregators that need the output in the user's own token account (Jupiter's AMM interface does) use buy_yes_to_wallet / buy_no_to_wallet; those wallet tokens settle by the holder's claim_tokens / claim_sol.

A creator opens a launch with create_launch, whose preset argument picks one of the config's launch options: 0 is 15 minutes and 10 SOL, 1 (recommended) 30 minutes and 75 SOL, 2 60 minutes and 40 SOL. Only option 1 is enabled today; picking a disabled option fails with PresetUnavailable. The launch copies that option's terms into its params, so always read a launch's own params rather than assuming one. /api/config lists the options with the ones currently enabled.

The cranks (resolve No, graduate, settle positions and open orders, pay creators, claim pool fees) are permissionless and our keeper runs all of them, so an integration only has to send user trades.

Earn fees

buy_yes, buy_no and fill_order take an optional frontend account. Put your fee wallet there.

• The trade fee is fee_bps (default 1.25%): 0.70% protocol, 0.25% frontend, 0.30% creator. The creator's part is escrowed and paid only if the launch graduates.
• Your share moves to your account in the same transaction, in SOL.
• Leave frontend out and the protocol keeps that 0.25%.
• The account must already exist with at least 0.00089088 SOL (rent-exempt). A funded wallet works. A brand-new empty address makes the trade fail.

Read launches

The read API mirrors the chain and adds images, socials and history. Amounts are strings in lamports or token base units.

Or read the chain directly. Launches are Launch accounts at PDA ["launch", id as u64 little-endian]; decode them with the IDL. For live updates, subscribe to the program's logs for new signatures and read each transaction: its Anchor events (YesBought, NoBought, OrderFilled, Migrated, LaunchResolvedNo and the rest below) are not in the logs but in its inner instructions (see Events below); WdytClient.eventsFromTransaction decodes them.

Set up a client

import { AnchorProvider, Program } from "@anchor-lang/core"; // or @coral-xyz/anchor 0.30+
import BN from "bn.js";
import { Connection, PublicKey, Transaction } from "@solana/web3.js";

const idl = await (await fetch("https://wdyt.fun/idl/wdyt.json")).json();
const connection = new Connection(RPC_URL, "confirmed");
const provider = new AnchorProvider(connection, wallet, { commitment: "confirmed" });
const program = new Program(idl, provider);

const [configPda] = PublicKey.findProgramAddressSync([Buffer.from("config")], program.programId);
const { treasury } = await program.account.config.fetch(configPda);

Quote

Quotes are integer math on the Launch account and match the program to the lamport. All amounts are lamports or base units, and division rounds down unless it says ceil.

const BPS = 10_000n;
const SHARE_UNIT = 1_000_000_000n;
const ceilDiv = (a: bigint, b: bigint) => (a === 0n ? 0n : (a - 1n) / b + 1n);
const big = (x: { toString(): string }) => BigInt(x.toString()); // Anchor returns BN

/** YES out for `spend` lamports. `charged` is what the buyer pays; the rest is refunded. */
function quoteYes(l: any, spend: bigint) {
  const p = l.params;
  let fee = ceilDiv(spend * big(p.feeBps), BPS);
  let net = spend - fee;
  const room = big(p.threshold) - big(l.rYes);
  if (net > room) {
    // this buy completes the launch
    net = room;
    fee = ceilDiv(net * big(p.feeBps), BPS - big(p.feeBps));
  }
  const newVt = ceilDiv(big(l.k), big(l.vs) + net);
  return { yesOut: big(l.vt) - newVt, charged: net + fee, fee, graduates: net === room };
}

/** NO shares for `spend` lamports at unix time `now`. */
function quoteNo(l: any, spend: bigint, now: bigint) {
  const p = l.params;
  const fee = ceilDiv(spend * big(p.feeBps), BPS);
  const net = spend - fee;
  if (big(l.rYes) * BPS < big(p.threshold) * big(p.noUnlockBps)) throw new Error("NoSideClosed: the No side is not open yet");
  let t = now - big(l.openTs);
  if (t < 0n) t = 0n;
  if (t > big(p.window)) t = big(p.window);
  const bondAccrued = (big(p.bond) * t) / big(p.window);
  const v0 = (big(p.s0) * big(p.pMin)) / SHARE_UNIT;
  const value = big(l.rYes) + big(l.rNo) + bondAccrued + v0;
  return { shares: (net * (big(p.s0) + big(l.sNo))) / value, fee };
}

/** SOL paid by claim_sol for `f` NO shares and `a` YES once a launch has RESOLVED_NO. */
function payoutIfNo(l: any, f: bigint, a: bigint) {
  const p = l.params;
  const v0 = (big(p.s0) * big(p.pMin)) / SHARE_UNIT;
  let out = (f * (big(l.rYes) + big(l.rNo) + big(p.bond) + v0)) / (big(p.s0) + big(l.sNo));
  if (a > 0n && big(l.sold) > 0n) out += (big(l.s0YesGain) * a) / big(l.sold);
  return out;
}

A NO buy fails with NoSideClosed until rYes * 10000 >= threshold * noUnlockBps (the quote throws; show when No opens instead). If params.kNoBps is above zero, a NO buy fails when rNo + net would exceed (threshold - rYes) * kNoBps / 10000. Protect users with min_out / min_shares: the program rejects a trade that would deliver less with Slippage.

Trade

const launch = new PublicKey(address); // from /api/launches
const l = await program.account.launch.fetch(launch);
const spend = 500_000_000n; // 0.5 SOL
const { yesOut } = quoteYes(l, spend);
const minOut = (yesOut * 99n) / 100n; // 1% slippage

const ix = await program.methods
  .buyYes(new BN(spend.toString()), new BN(minOut.toString()))
  .accountsPartial({ buyer: wallet.publicKey, launch, frontend: YOUR_FEE_WALLET })
  .instruction();
await provider.sendAndConfirm(new Transaction().add(ix));

Anchor derives the other accounts (the vault, and the buyer's holding, which the first buy creates) from the IDL. A NO buy is the same call with buyNo(spend, minShares). Pass frontend: null to route without a fee account.

Exit early: the order book

While a market is open, holders can trade YES (Yes) and NO (No) with each other. The book trades between positions: an ask comes out of the maker's position, a bid's tokens land in it, and a taker buys into or sells from their own. What a user bought waits in their holding until realize mints it into their position, so an ask or a sale into a bid of bought shares sends realize first, in the same transaction.

• place_order(token, side, price, size): token 0 = YES, 1 = NO; side 0 = ask (sell), 1 = bid (buy); price in lamports per whole token (10^6 base units of YES, 10^9 of NO); size in base units. Asks escrow the tokens, bids escrow ceil(size * price / unit) lamports. The notional must be at least params.min_order (default 0.01 SOL).
• fill_order(qty): any qty from 1 base unit up to the order's left. The taker pays the maker ceil(qty * price / unit) for an ask, or receives floor(qty * price / unit) from a bid, plus or minus the trade fee (rounded up), split the same way as buys (including your frontend cut). A fill whose SOL rounds to zero, or a bid fill worth no more than its fee, is rejected. Makers pay no fee. Filling your own order is rejected.
• cancel_order(): maker only, while the market is open. Once it resolves, the keeper settles every open order with close_expired: a bid gets its SOL back, an ask's tokens are paid out like a position.
• realize(token): while the market is open, mints all of the signer's held YES (token 0) or NO (1) into their position, creating it if needed (the owner pays its rent, returned when it settles). Fails with NothingHeld when that side of the holding is empty.
• deposit(token, amount) / withdraw(token, amount): while the market is open, move YES or NO between the user's own token account and their position. Wallet tokens must be deposited to trade on the book, and held shares realized to trade or withdraw them.

Orders live at PDA ["order", launch, id as u64 little-endian]. List them from GET /api/launches/{address} or with getProgramAccounts on the Order account filtered by the launch at offset 8.

Settlement

Every payout below is pushed by our keeper; each instruction is permissionless, so anyone can send it sooner. Only wallet tokens need their holder.

After graduation

The coin is a normal SPL token with Metaplex metadata, trading in a Meteora DAMM v2 pool whose position is locked forever and whose fees are paid in SOL (split by claim_pool_fees between the creator, or the creator's fee split, the coin's holders through the rewards wallet, and the protocol). Its total supply is sold + pool_tok: graduation mints coins to match No-side SOL, or burns unsold reserve when the launch fee is larger than the matched share, and then revokes the mint authority. The Migrated event reports minted, burned and launch_fee. Jupiter routes Meteora DAMM v2 automatically, so any app that swaps through Jupiter can trade graduated coins with no extra work.

Cranks

All are permissionless and idempotent. Our keeper runs them within seconds; you never need to.

Creator fee splits and community takeovers

A coin's metadata never changes. Its creator fees can: the creator may split them across up to 10 wallets, once (create_fee_shares, then update_fee_shares), and in a community takeover approved by the team, config.takeover_authority hands a live coin's creator fees to a new lead with set_fee_admin, after which the lead may split them once. Coins without a split pay their creator exactly as above. Instructions that pay a split (update_fee_shares, set_fee_admin, distribute_creator_fees) take its current recipients, in order and writable, as remaining accounts. FeeSharesChanged reports every change (takeover is set for takeovers) and CreatorFeesDistributed every payout.