@peddles/sdk 0.2.0

package/src/launch/stockCall.ts

@@ -0,0 +1,223 @@
+import type { ReadClient } from '../client.js';
+import { encodeFunctionData } from 'viem';
+import type { Abi, Address, Hex } from 'viem';
+import { erc20Abi } from '../abis.js';
+import { stockLaunchpadLaunchAbi } from './abi.generated.js';
+import { validateFeeTerms, type FeeTerms } from './feeTerms.js';
+import type { UnsignedLaunchTx } from './wethCall.js';
+
+/**
+ * The stock-paired launch call — `PeddlesStockLaunchpad.createCoin` (two
+ * overloads) or `createCoinAndBuy`. A pure port of the web app's
+ * `buildStockLaunchCall` (`features/launch/useStockLaunch.ts`), held identical by test.
+ *
+ *   dev buy, any salt         → createCoinAndBuy(name, symbol, quote, tax, excess, salt, quoteIn, minOut)
+ *   no dev buy, vanity salt   → createCoin(name, symbol, quote, tax, excess, salt)
+ *   no dev buy, no salt       → createCoin(name, symbol, quote, tax, excess)      (auto-salt)
+ *
+ * Every entrypoint is payable and requires `msg.value >= launchFee`. The fee is
+ * READ LIVE (`readStockLaunchFee`) and attached exactly; a dev buy pulls the
+ * quote asset through `transferFrom`, so the launchpad must be approved first.
+ */
+
+export interface StockLaunchArgs {
+  readonly name: string;
+  readonly symbol: string;
+  readonly quote: `0x${string}`;
+  /** null → the auto-salt overload. */
+  readonly salt: `0x${string}` | null;
+  /** Quote base units to spend on the dev buy. 0n → no dev buy. */
+  readonly quoteIn: bigint;
+  /** Slippage floor for the dev buy, in the launched token's base units. */
+  readonly minTokensOut: bigint;
+  /** The creator's permanent fee terms. `null` is refused, never defaulted. */
+  readonly feeTerms: FeeTerms | null;
+}
+
+export type StockLaunchCall =
+  | {
+      readonly kind: 'buy';
+      readonly functionName: 'createCoinAndBuy';
+      readonly args: readonly [string, string, `0x${string}`, number, number, `0x${string}`, bigint, bigint];
+    }
+  | {
+      readonly kind: 'salt';
+      readonly functionName: 'createCoin';
+      readonly args: readonly [string, string, `0x${string}`, number, number, `0x${string}`];
+    }
+  | {
+      readonly kind: 'auto';
+      readonly functionName: 'createCoin';
+      readonly args: readonly [string, string, `0x${string}`, number, number];
+    };
+
+/** Why these terms cannot ride in a launch, or null when they can. */
+export function stockLaunchTermsIssue(feeTerms: FeeTerms | null): string | null {
+  if (feeTerms === null) return 'Choose the trading fee for this token before launching.';
+  if (validateFeeTerms(feeTerms) !== null) return 'The trading fee or its split is outside the range a launch can set.';
+  return null;
+}
+
+export function buildStockLaunchCall({ name, symbol, quote, salt, quoteIn, minTokensOut, feeTerms }: StockLaunchArgs): StockLaunchCall {
+  const issue = stockLaunchTermsIssue(feeTerms);
+  if (issue !== null) throw new Error(issue);
+  if (feeTerms === null) throw new Error('Choose the trading fee for this token before launching.');
+  if (quoteIn < 0n || minTokensOut < 0n) throw new Error('A dev-buy amount cannot be negative.');
+
+  // uint16 on-chain; both are bounded (at most 10000) by `validateFeeTerms`, so the conversion is exact.
+  const tax = Number(feeTerms.taxBps);
+  const excess = Number(feeTerms.excessToCreatorBps);
+  if (quoteIn > 0n) {
+    return { kind: 'buy', functionName: 'createCoinAndBuy', args: [name, symbol, quote, tax, excess, salt ?? `0x${'00'.repeat(32)}`, quoteIn, minTokensOut] };
+  }
+  if (minTokensOut !== 0n) throw new Error('Set a dev-buy amount, or clear the minimum.');
+  if (salt !== null) {
+    return { kind: 'salt', functionName: 'createCoin', args: [name, symbol, quote, tax, excess, salt] };
+  }
+  return { kind: 'auto', functionName: 'createCoin', args: [name, symbol, quote, tax, excess] };
+}
+
+/** The calldata of a stock launch call. `launchFeeWei` is the live `launchFee()`, attached exactly. */
+export function encodeStockLaunchCall(call: StockLaunchCall, launchpad: `0x${string}`, launchFeeWei: bigint): UnsignedLaunchTx {
+  // viem selects the `createCoin` overload by argument count (5 or 6).
+  const data = encodeFunctionData({ abi: stockLaunchpadLaunchAbi as Abi, functionName: call.functionName, args: call.args as unknown as unknown[] });
+  return { to: launchpad, data, value: launchFeeWei };
+}
+
+/** ERC-20 `approve` / `allowance` — the standard shapes; the SDK's read-only `erc20Abi` carries neither. */
+export const erc20ApprovalAbi = [
+  {
+    type: 'function',
+    name: 'approve',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'value', type: 'uint256' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
+  {
+    type: 'function',
+    name: 'allowance',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'owner', type: 'address' },
+      { name: 'spender', type: 'address' },
+    ],
+    outputs: [{ type: 'uint256' }],
+  },
+] as const;
+
+/** The ERC-20 approval a dev buy needs: EXACTLY `quoteIn`, never unlimited. */
+export function encodeStockApproval(quote: `0x${string}`, launchpad: `0x${string}`, quoteIn: bigint): UnsignedLaunchTx {
+  return { to: quote, data: encodeFunctionData({ abi: erc20ApprovalAbi, functionName: 'approve', args: [launchpad, quoteIn] }), value: 0n };
+}
+
+/** The launchpad's current allowance on `quote` from `owner`. */
+export async function readStockAllowance(client: ReadClient, quote: Address, owner: Address, launchpad: Address): Promise<bigint> {
+  return (await client.readContract({ address: quote, abi: erc20ApprovalAbi, functionName: 'allowance', args: [owner, launchpad] })) as bigint;
+}
+
+export interface StockLaunchFee {
+  /** Exact wei to attach to the launch call. */
+  readonly launchFee: bigint;
+  /** Immutable per-deployment ceiling — disclosure, not something to send. */
+  readonly maxLaunchFee: bigint;
+}
+
+/** The launch fee, READ FROM THE CHAIN. Owner-tunable storage under an immutable cap; never a constant. */
+export async function readStockLaunchFee(client: ReadClient, launchpad: Address): Promise<StockLaunchFee> {
+  const [launchFee, maxLaunchFee] = (await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'launchFee' },
+      { address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'maxLaunchFee' },
+    ],
+  })) as readonly [bigint, bigint];
+  return { launchFee, maxLaunchFee };
+}
+
+export interface StockMiningInputs {
+  /** `COIN_VARIANT()` — the variant byte the launchpad binds into the salt. */
+  readonly variant: number;
+  /** `coinInitCodeHash(name, symbol)` — depends on the name and symbol, so a rename re-mines. */
+  readonly initCodeHash: Hex;
+}
+
+/** What `mineSalt` needs for a stock coin: the variant and the name/symbol-dependent init code hash. */
+export async function readStockMiningInputs(client: ReadClient, launchpad: Address, name: string, symbol: string): Promise<StockMiningInputs> {
+  const [variant, initCodeHash] = (await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'COIN_VARIANT' },
+      { address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'coinInitCodeHash', args: [name, symbol] },
+    ],
+  })) as readonly [number, Hex];
+  return { variant: Number(variant), initCodeHash };
+}
+
+/** The launchpad's own prediction for (creator, salt, name, symbol) — the confirmation a mined salt needs. */
+export async function predictStockCoin(client: ReadClient, launchpad: Address, creator: Address, salt: Hex, name: string, symbol: string): Promise<Address> {
+  return (await client.readContract({ address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'predictCoin', args: [creator, salt, name, symbol] })) as Address;
+}
+
+/** One whitelisted quote leg, as the launchpad and its own ERC-20 describe it. */
+export interface StockQuote {
+  readonly address: Address;
+  /** Position in `allQuotes` — append-ordered, the only recency signal the chain offers. */
+  readonly registryIndex: number;
+  /** On-chain symbol; `null` when the ERC-20 did not answer. Never defaulted. */
+  readonly symbol: string | null;
+  readonly name: string | null;
+  /** On-chain decimals; `null` when unreadable. Never defaulted. */
+  readonly decimals: number | null;
+  /** `quoteConfig.startTick` — the launch price, set by the launchpad owner. */
+  readonly startTick: number;
+}
+
+/**
+ * The stock-paired launch whitelist — READ FROM THE CHAIN (`quoteCount` / `allQuotes`,
+ * each gated on `quoteConfig(quote).allowed`), identity read off each ERC-20. An entry whose
+ * identity cannot be read is kept and marked unresolved, never dropped or defaulted.
+ */
+export async function readStockQuotes(client: ReadClient, launchpad: Address): Promise<readonly StockQuote[]> {
+  const count = Number(await client.readContract({ address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'quoteCount' }));
+  if (count === 0) return [];
+  const addresses = (await client.multicall({
+    allowFailure: false,
+    contracts: Array.from({ length: count }, (_, i) => ({ address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'allQuotes' as const, args: [BigInt(i)] as const })),
+  })) as readonly Address[];
+  const configs = (await client.multicall({
+    allowFailure: false,
+    contracts: addresses.map((quote) => ({ address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'quoteConfig' as const, args: [quote] as const })),
+  })) as readonly (readonly [boolean, boolean, number])[];
+  const allowed = addresses.map((address, i) => ({ address, i, config: configs[i]! })).filter(({ config }) => config[0]);
+  if (allowed.length === 0) return [];
+  const identity = await client.multicall({
+    allowFailure: true,
+    contracts: allowed.flatMap(({ address }) => [
+      { address, abi: erc20Abi, functionName: 'symbol' as const },
+      { address, abi: erc20Abi, functionName: 'name' as const },
+      { address, abi: erc20Abi, functionName: 'decimals' as const },
+    ]),
+  });
+  return allowed.map(({ address, i, config }, k) => {
+    const sym = identity[k * 3]!;
+    const nm = identity[k * 3 + 1]!;
+    const dec = identity[k * 3 + 2]!;
+    return {
+      address,
+      registryIndex: i,
+      symbol: sym.status === 'success' ? String(sym.result) : null,
+      name: nm.status === 'success' ? String(nm.result) : null,
+      decimals: dec.status === 'success' ? Number(dec.result) : null,
+      startTick: Number(config[2]),
+    };
+  });
+}
+
+/** Whether the launchpad allows `quote` right now. */
+export async function isQuoteAllowed(client: ReadClient, launchpad: Address, quote: Address): Promise<boolean> {
+  const [allowed] = (await client.readContract({ address: launchpad, abi: stockLaunchpadLaunchAbi, functionName: 'quoteConfig', args: [quote] })) as readonly [boolean, boolean, number];
+  return allowed;
+}

package/src/launch/tickMath.ts

@@ -0,0 +1,139 @@
+/**
+ * Uniswap v4 tick maths, in `bigint` — a pure port of the web app's
+ * `features/launch/tickMath.ts`.
+ *
+ * The WETH-type launch (`PeddlesLaunchOrchestratorV20.launch`) makes the CALLER do
+ * the pool maths: `LaunchInput` carries `sqrtPriceX96`, `tickLower`, `tickUpper`
+ * and `liquidity`, and the executor mints exactly the position those describe.
+ * Get `liquidity` one wei too high and `modifyLiquidities` reverts.
+ *
+ *   - `getSqrtPriceAtTick`  ← `StockTickMath.getSqrtPriceAtTick`
+ *   - `liquidityForAmount`  ← `_liquidityFor` / `_amountForLiquidity` (VerifyLive.s.sol),
+ *                             Uniswap's `getLiquidityForAmount0/1` plus the round-down
+ *                             shave the mint's round-UP demands.
+ *
+ * `number` appears nowhere below the tick index itself (`int24`). Every price and
+ * amount is `bigint`.
+ */
+
+export const MIN_TICK = -887272;
+export const MAX_TICK = 887272;
+export const Q96 = 1n << 96n;
+
+const UINT256_MAX = (1n << 256n) - 1n;
+const UINT160_MAX = (1n << 160n) - 1n;
+const UINT128_MAX = (1n << 128n) - 1n;
+
+/** The exact magic-constant ladder from `StockTickMath`, in bit order. */
+const RATIOS: readonly [bigint, bigint][] = [
+  [0x2n, 0xfff97272373d413259a46990580e213an],
+  [0x4n, 0xfff2e50f5f656932ef12357cf3c7fdccn],
+  [0x8n, 0xffe5caca7e10e4e61c3624eaa0941cd0n],
+  [0x10n, 0xffcb9843d60f6159c9db58835c926644n],
+  [0x20n, 0xff973b41fa98c081472e6896dfb254c0n],
+  [0x40n, 0xff2ea16466c96a3843ec78b326b52861n],
+  [0x80n, 0xfe5dee046a99a2a811c461f1969c3053n],
+  [0x100n, 0xfcbe86c7900a88aedcffc83b479aa3a4n],
+  [0x200n, 0xf987a7253ac413176f2b074cf7815e54n],
+  [0x400n, 0xf3392b0822b70005940c7a398e4b70f3n],
+  [0x800n, 0xe7159475a2c29b7443b29c7fa6e889d9n],
+  [0x1000n, 0xd097f3bdfd2022b8845ad8f792aa5825n],
+  [0x2000n, 0xa9f746462d870fdf8a65dc1f90e061e5n],
+  [0x4000n, 0x70d869a156d2a1b890bb3df62baf32f7n],
+  [0x8000n, 0x31be135f97d08fd981231505542fcfa6n],
+  [0x10000n, 0x9aa508b5b7a84e1c677de54f3e99bc9n],
+  [0x20000n, 0x5d6af8dedb81196699c329225ee604n],
+  [0x40000n, 0x2216e584f5fa1ea926041bedfe98n],
+  [0x80000n, 0x48a170391f7dc42444e8fa2n],
+];
+
+/** `sqrt(1.0001^tick) * 2^96`, identical to the on-chain implementation. Throws on an out-of-range tick. */
+export function getSqrtPriceAtTick(tick: number): bigint {
+  if (!Number.isInteger(tick)) throw new Error(`tick must be an integer, got ${tick}`);
+  const absTick = BigInt(Math.abs(tick));
+  if (absTick > BigInt(MAX_TICK)) throw new Error(`tick ${tick} is outside the v4 range`);
+
+  let price =
+    (absTick & 0x1n) !== 0n
+      ? 0xfffcb933bd6fad37aa2d162d1a594001n
+      : 0x100000000000000000000000000000000n;
+
+  for (const [bit, ratio] of RATIOS) {
+    if ((absTick & bit) !== 0n) price = (price * ratio) >> 128n;
+  }
+
+  if (tick > 0) price = UINT256_MAX / price;
+
+  const sqrtPriceX96 = (price >> 32n) + ((price & 0xffffffffn) === 0n ? 0n : 1n);
+  if (sqrtPriceX96 > UINT160_MAX) throw new Error('sqrtPriceX96 overflowed uint160');
+  return sqrtPriceX96;
+}
+
+function mulDivUp(a: bigint, b: bigint, denominator: bigint): bigint {
+  const product = a * b;
+  return product / denominator + (product % denominator === 0n ? 0n : 1n);
+}
+
+/** Token amount a position of `liquidity` over [sqrtA, sqrtB] costs, rounded UP — how the mint charges. */
+export function amountForLiquidity(
+  tokenIsCurrency0: boolean,
+  sqrtA: bigint,
+  sqrtB: bigint,
+  liquidity: bigint,
+): bigint {
+  if (tokenIsCurrency0) {
+    const numerator = mulDivUp(liquidity << 96n, sqrtB - sqrtA, sqrtB);
+    return numerator / sqrtA + (numerator % sqrtA === 0n ? 0n : 1n);
+  }
+  return mulDivUp(liquidity, sqrtB - sqrtA, Q96);
+}
+
+export interface LiquidityQuote {
+  readonly liquidity: bigint;
+  readonly sqrtLower: bigint;
+  readonly sqrtUpper: bigint;
+  /** What the mint will actually pull, rounded up. Always <= the allocation. */
+  readonly amountUsed: bigint;
+}
+
+/**
+ * The largest liquidity whose rounded-up token requirement still fits `amount`.
+ * Returns `null` when no liquidity fits — the caller must then refuse the launch, never guess.
+ */
+export function liquidityForAmount(
+  tokenIsCurrency0: boolean,
+  tickLower: number,
+  tickUpper: number,
+  amount: bigint,
+): LiquidityQuote | null {
+  if (amount <= 0n) return null;
+
+  const sqrtLower = getSqrtPriceAtTick(tickLower);
+  const sqrtUpper = getSqrtPriceAtTick(tickUpper);
+  if (sqrtUpper <= sqrtLower) return null;
+
+  let liquidity = tokenIsCurrency0
+    ? (amount * ((sqrtLower * sqrtUpper) / Q96)) / (sqrtUpper - sqrtLower)
+    : (amount * Q96) / (sqrtUpper - sqrtLower);
+
+  if (liquidity > UINT128_MAX) liquidity = UINT128_MAX;
+
+  for (
+    let i = 0;
+    i < 512 && liquidity > 0n && amountForLiquidity(tokenIsCurrency0, sqrtLower, sqrtUpper, liquidity) > amount;
+    i += 1
+  ) {
+    liquidity -= 1n;
+  }
+
+  if (liquidity === 0n) return null;
+  const amountUsed = amountForLiquidity(tokenIsCurrency0, sqrtLower, sqrtUpper, liquidity);
+  if (amountUsed > amount) return null;
+
+  return { liquidity, sqrtLower, sqrtUpper, amountUsed };
+}
+
+/** `sqrtPriceX96` for a token/quote pair at `startTick`, mirroring `startSqrtPriceFor`. */
+export function startSqrtPrice(startTick: number, tokenIsCurrency0: boolean): bigint {
+  return getSqrtPriceAtTick(tokenIsCurrency0 ? startTick : -startTick);
+}

package/src/launch/variants.ts

@@ -0,0 +1,183 @@
+import type { ReadClient } from '../client.js';
+import { factoryAbi } from '../abis.js';
+import { launchOrchestratorAbi } from './abi.generated.js';
+import type { LaunchAddresses } from './addresses.js';
+
+/**
+ * The launch types the factory will take a WETH-type launch for, READ FROM THE
+ * CHAIN. A port of the web's `useLaunchVariants` + `variantTerms`.
+ *
+ * The factory's registry is keyed by a uint8 with no enumerator, so the whole
+ * id space is read in ONE multicall (`variantInfo(1..255)`, batching off). Type 0
+ * is the built-in type; it is never registered and launches against the
+ * orchestrator's own owner-set defaults, so that is what is read for it.
+ *
+ * FAIL CLOSED: any failed read makes the whole list unavailable (the multicall
+ * throws). A partial list is not offered.
+ */
+
+/** The factory's permanently reserved asset variant. */
+export const VARIANT_ASSET = 0;
+
+export const BPS_DENOMINATOR = 10_000n;
+
+export interface VariantAllocation {
+  readonly liquidityBps: bigint;
+  readonly airdropBps: bigint;
+  readonly vestingBps: bigint;
+  readonly burnBps: bigint;
+  readonly clogBps: bigint;
+  /** Per-release cap, in bps of TOTAL supply. */
+  readonly clogSliceBps: bigint;
+  readonly clogMinIntervalSeconds: bigint;
+}
+
+export type LaunchTypeShape = 'full-liquidity' | 'clog';
+
+export type ResolvedTerms =
+  | { readonly ok: true; readonly shape: LaunchTypeShape; readonly allocation: VariantAllocation }
+  | { readonly ok: false; readonly reason: string };
+
+/** Can this split be launched and described? Mirrors what the contracts refuse. */
+export function resolveTerms(allocation: VariantAllocation): ResolvedTerms {
+  const { liquidityBps, airdropBps, vestingBps, burnBps, clogBps, clogSliceBps, clogMinIntervalSeconds } = allocation;
+  const sum = liquidityBps + airdropBps + vestingBps + burnBps + clogBps;
+  if (sum !== BPS_DENOMINATOR) {
+    return { ok: false, reason: 'This launch type’s split does not add up to the whole supply, so it cannot launch.' };
+  }
+  if (liquidityBps <= 0n) {
+    return { ok: false, reason: 'This launch type puts nothing into the pool, so it cannot launch.' };
+  }
+  if (airdropBps !== 0n || vestingBps !== 0n || burnBps !== 0n) {
+    return { ok: false, reason: 'This launch type airdrops, vests or burns supply, which Peddles does not offer.' };
+  }
+  if (clogBps > 0n && (clogSliceBps <= 0n || clogMinIntervalSeconds <= 0n)) {
+    return { ok: false, reason: 'This launch type holds supply back with no limit on how it is sold, so it cannot launch.' };
+  }
+  return { ok: true, shape: clogBps > 0n ? 'clog' : 'full-liquidity', allocation };
+}
+
+/** A launch type, as the chain describes it. */
+export interface LaunchVariant {
+  /** The factory's uint8 id. Carried into the launch; never shown as a name. */
+  readonly id: number;
+  /** Retired types stay registered but take no new launches. */
+  readonly enabled: boolean;
+  readonly allocation: VariantAllocation;
+  readonly terms: ResolvedTerms;
+  /** Null when this type can be launched on this chain right now. */
+  readonly refusal: string | null;
+}
+
+const ZERO = '0x0000000000000000000000000000000000000000';
+/** Registrable ids are 1..255; 0 is reserved for the built-in type. */
+const REGISTRABLE_IDS = Array.from({ length: 255 }, (_, i) => i + 1);
+
+interface RawAllocation {
+  readonly liquidityBps: number;
+  readonly airdropBps: number;
+  readonly vestingBps: number;
+  readonly burnBps: number;
+  readonly clogBps: number;
+  readonly clogSliceBps: number;
+  readonly clogMinInterval: bigint;
+}
+
+function toAllocation(raw: RawAllocation): VariantAllocation {
+  return {
+    liquidityBps: BigInt(raw.liquidityBps),
+    airdropBps: BigInt(raw.airdropBps),
+    vestingBps: BigInt(raw.vestingBps),
+    burnBps: BigInt(raw.burnBps),
+    clogBps: BigInt(raw.clogBps),
+    clogSliceBps: BigInt(raw.clogSliceBps),
+    clogMinIntervalSeconds: BigInt(raw.clogMinInterval),
+  };
+}
+
+function refusalFor(enabled: boolean, terms: ResolvedTerms, clogVaultReady: boolean): string | null {
+  if (!enabled) return 'This launch type is not open for new launches.';
+  if (!terms.ok) return terms.reason;
+  if (terms.shape === 'clog' && !clogVaultReady) {
+    return 'This launch type withholds supply into a clog vault, and no clog vault factory is deployed on this chain.';
+  }
+  return null;
+}
+
+/** Every launch type on this chain, type 0 first, then registered ids ascending. */
+export async function readLaunchVariants(client: ReadClient, addresses: LaunchAddresses): Promise<readonly LaunchVariant[]> {
+  const { factory, orchestrator } = addresses;
+  const infos = (await client.multicall({
+    allowFailure: false,
+    batchSize: 0,
+    contracts: REGISTRABLE_IDS.map((id) => ({ address: factory, abi: factoryAbi, functionName: 'variantInfo' as const, args: [id] as const })),
+  })) as readonly (readonly [`0x${string}`, `0x${string}`, boolean])[];
+
+  const registered = REGISTRABLE_IDS.map((id, i) => ({ id, info: infos[i]! })).filter(({ info }) => info[0] !== ZERO);
+
+  const [defaults, allocations] = await Promise.all([
+    client.multicall({
+      allowFailure: false,
+      contracts: [
+        { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'defaultLiquidityBps' },
+        { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'defaultAirdropBps' },
+        { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'defaultVestingBps' },
+        { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'defaultBurnBps' },
+        { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'clogVaultFactory' },
+      ],
+    }) as Promise<readonly [number, number, number, number, `0x${string}`]>,
+    registered.length === 0
+      ? Promise.resolve([] as readonly RawAllocation[])
+      : (client.multicall({
+          allowFailure: false,
+          batchSize: 0,
+          contracts: registered.map(({ id }) => ({ address: factory, abi: factoryAbi, functionName: 'variantAllocation' as const, args: [id] as const })),
+        }) as Promise<readonly RawAllocation[]>),
+  ]);
+
+  const [liquidityBps, airdropBps, vestingBps, burnBps, clogVaultFactory] = defaults;
+  const clogVaultReady = clogVaultFactory !== ZERO && addresses.clogVaultFactory !== null;
+
+  const rows = [
+    {
+      id: VARIANT_ASSET,
+      enabled: true,
+      allocation: {
+        liquidityBps: BigInt(liquidityBps),
+        airdropBps: BigInt(airdropBps),
+        vestingBps: BigInt(vestingBps),
+        burnBps: BigInt(burnBps),
+        clogBps: 0n,
+        clogSliceBps: 0n,
+        clogMinIntervalSeconds: 0n,
+      },
+    },
+    ...registered.map(({ id, info }, i) => ({ id, enabled: info[2], allocation: toAllocation(allocations[i]!) })),
+  ];
+
+  return rows.map((row) => {
+    const terms = resolveTerms(row.allocation);
+    return { id: row.id, enabled: row.enabled, allocation: row.allocation, terms, refusal: refusalFor(row.enabled, terms, clogVaultReady) };
+  });
+}
+
+/** The public launch type names the REST API, the CLI and the widget speak. */
+export type LaunchTypeName = 'standard' | 'clog' | 'stock';
+
+/**
+ * The variant a public type name resolves to on this chain, or a refusal.
+ * `standard` is always type 0; `clog` is the ONE enabled registered clog-shaped
+ * type — two of them is ambiguous and is refused rather than picked between.
+ */
+export function variantForType(variants: readonly LaunchVariant[], type: 'standard' | 'clog'): { variant: LaunchVariant } | { refusal: string } {
+  if (type === 'standard') {
+    const v = variants.find((x) => x.id === VARIANT_ASSET);
+    if (!v) return { refusal: 'The built-in launch type is not available on this chain.' };
+    return v.refusal ? { refusal: v.refusal } : { variant: v };
+  }
+  const clogs = variants.filter((x) => x.id !== VARIANT_ASSET && x.terms.ok && x.terms.shape === 'clog' && x.enabled);
+  if (clogs.length === 0) return { refusal: 'No Drip launch type is open on this chain.' };
+  if (clogs.length > 1) return { refusal: 'More than one Drip launch type is open on this chain; pass the variant id explicitly.' };
+  const v = clogs[0]!;
+  return v.refusal ? { refusal: v.refusal } : { variant: v };
+}