@peddles/sdk 0.2.0

package/src/launch/wethCall.ts

@@ -0,0 +1,240 @@
+import type { ReadClient } from '../client.js';
+import { encodeAbiParameters, encodeFunctionData } from 'viem';
+import type { Address, ContractFunctionArgs, Hex } from 'viem';
+import { launchOrchestratorAbi, tokenMetadataAbi } from './abi.generated.js';
+import { validateFeeTerms, type FeeTerms } from './feeTerms.js';
+import { LAUNCH_COIN_DECIMALS, type WethLaunchPlan } from './wethPlan.js';
+
+/**
+ * The WETH-type launch call — `PeddlesLaunchOrchestratorV20.launch(LaunchInput)`,
+ * or `launchAndBuy(LaunchInput, devBuyValue, minTokensOut)` with a first buy.
+ * A pure port of the web app's `buildWethLaunchInput` / `buildWethLaunchCall`
+ * (`features/launch/useWethLaunch.ts`), held identical by test.
+ *
+ * ONE builder, every consumer: the web form, the REST API's `/prepare`, the CLI
+ * and the widget all sign exactly these bytes. Assembling the struct twice is how
+ * a form ends up simulating one transaction and sending another.
+ *
+ * `msg.value` is the orchestrator's `launchFee()` plus the first buy. The fee is read LIVE by the
+ * caller (it is owner-tunable beneath an immutable cap) and passed in as `launchFeeWei`; the
+ * orchestrator takes it off the top and reverts `LAUNCH_FEE_REQUIRED` when the value is short.
+ */
+
+/** The components of the `AssetParamsV1` struct `LaunchInput.params` carries — encoded as ONE tuple. */
+export const assetParamsV1Components = [
+  { name: 'version', type: 'uint8' },
+  { name: 'name', type: 'string' },
+  { name: 'symbol', type: 'string' },
+  { name: 'initialAdmin', type: 'address' },
+  { name: 'decimals', type: 'uint8' },
+] as const;
+
+/** On-chain metadata carried by `initCalls`. Only these writes are permitted. */
+export interface WethMetadata {
+  readonly contractUri: string;
+  readonly image: string;
+  readonly website: string;
+  readonly x: string;
+  readonly telegram: string;
+}
+
+export const EMPTY_WETH_METADATA: WethMetadata = { contractUri: '', image: '', website: '', x: '', telegram: '' };
+
+export interface WethLaunchArgs {
+  readonly name: string;
+  readonly symbol: string;
+  readonly salt: `0x${string}`;
+  /** The wallet that will sign. The orchestrator requires `vaultInput.creator == msg.sender`. */
+  readonly creator: `0x${string}`;
+  /** The creator's permanent fee terms. `null` is refused, never defaulted. */
+  readonly feeTerms: FeeTerms | null;
+  readonly metadata: WethMetadata;
+  readonly plan: WethLaunchPlan;
+  /** Native wei spent on the first buy. 0n launches without one. */
+  readonly devBuyWei: bigint;
+  /** Slippage floor for the first buy, in the launched token's base units. 0n with no first buy. */
+  readonly minTokensOut: bigint;
+  /** The orchestrator's `launchFee()`, read from the chain. Never assumed. */
+  readonly launchFeeWei: bigint;
+}
+
+/**
+ * The metadata writes, in `initCalls` order. Empty fields are OMITTED rather than
+ * written as empty strings — an `extraMetadata("x", "")` entry is a permanent
+ * on-chain claim, and clearing it later costs another transaction.
+ */
+export function buildInitCalls(metadata: WethMetadata): readonly Hex[] {
+  const calls: Hex[] = [];
+  if (metadata.contractUri.trim().length > 0) {
+    calls.push(encodeFunctionData({ abi: tokenMetadataAbi, functionName: 'updateContractURI', args: [metadata.contractUri.trim()] }));
+  }
+  const entries: readonly [string, string][] = [
+    ['image', metadata.image],
+    ['website', metadata.website],
+    ['x', metadata.x],
+    ['telegram', metadata.telegram],
+  ];
+  for (const [key, value] of entries) {
+    if (value.trim().length === 0) continue;
+    calls.push(encodeFunctionData({ abi: tokenMetadataAbi, functionName: 'updateExtraMetadata', args: [key, value.trim()] }));
+  }
+  return calls;
+}
+
+/** The `LaunchInput` struct, as the generated ABI types it. */
+export type WethLaunchInput = ContractFunctionArgs<typeof launchOrchestratorAbi, 'payable' | 'nonpayable', 'launch'>[0];
+
+export type WethLaunchCall =
+  | {
+      readonly functionName: 'launch';
+      readonly input: WethLaunchInput;
+      readonly args: readonly [WethLaunchInput];
+      readonly value: bigint;
+    }
+  | {
+      readonly functionName: 'launchAndBuy';
+      readonly input: WethLaunchInput;
+      readonly args: readonly [WethLaunchInput, bigint, bigint];
+      readonly value: bigint;
+    };
+
+/** Why these terms cannot ride in a launch, or null when they can. */
+export function wethLaunchTermsIssue(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;
+}
+
+/** The `LaunchInput` itself. Throws when the terms are missing or out of range. */
+export function buildWethLaunchInput(args: WethLaunchArgs, orchestrator: `0x${string}`): WethLaunchInput {
+  const { plan, feeTerms } = args;
+  const issue = wethLaunchTermsIssue(feeTerms);
+  if (issue !== null) throw new Error(issue);
+  if (feeTerms === null) throw new Error('Choose the trading fee for this token before launching.');
+
+  return {
+    variant: plan.variant,
+    salt: args.salt,
+    // AssetParamsV1 is a DYNAMIC STRUCT, so it must be encoded as a single tuple (with the leading
+    // offset word), never as a flat parameter list — the flat form reverts with EMPTY data.
+    params: encodeAbiParameters(
+      [{ type: 'tuple', components: assetParamsV1Components }],
+      [{ version: 1, name: args.name, symbol: args.symbol, initialAdmin: orchestrator, decimals: LAUNCH_COIN_DECIMALS }],
+    ),
+    initCalls: [...buildInitCalls(args.metadata)],
+    vaultInput: {
+      // The orchestrator sets this itself and REJECTS a pre-set one, so it goes in as zero.
+      token: '0x0000000000000000000000000000000000000000',
+      creator: args.creator,
+      // MIRRORS THE LAUNCH TYPE the plan read from the chain; the orchestrator refuses any mismatch.
+      liquidityBps: plan.allocationBps.liquidity,
+      airdropBps: 0,
+      vestingBps: 0,
+      burnBps: 0,
+      vaultBps: 0,
+      clogBps: plan.allocationBps.clog,
+      airdropEnabled: false,
+      liquidityAmount: plan.pooledSupply,
+      airdropAmount: 0n,
+      vestingAmount: 0n,
+      burnAmount: 0n,
+      vestingStart: 0n,
+      vestingCliff: 5_184_000n,
+      vestingDuration: 46_656_000n,
+      airdropStartsAt: 0n,
+      airdropEpochLength: 864_000,
+      airdropEpochCount: 10,
+      burnStartsAt: 0n,
+      burnEpochLength: 864_000,
+      firstBurnBps: 1_000,
+      minVoteBps: 0,
+      maxVoteBps: 2_000,
+      defaultVoteBps: 1_000,
+      quoteToken: plan.quoteToken,
+      poolManager: plan.poolManager,
+      positionManager: plan.positionManager,
+      hook: plan.hook,
+      liquidityManager: plan.liquidityManager,
+      airdropPublisher: plan.airdropPublisher,
+      fee: plan.poolFeePpm,
+      tickSpacing: plan.tickSpacing,
+    },
+    // uint16 on-chain, bounded by `validateFeeTerms` above, so `Number` is exact.
+    creatorTaxBps: Number(feeTerms.taxBps),
+    excessToCreatorBps: Number(feeTerms.excessToCreatorBps),
+    factoryValue: 0n,
+    amountPeddles: plan.pooledSupply,
+    sqrtPriceX96: plan.sqrtPriceX96,
+    tickLower: plan.tickLower,
+    tickUpper: plan.tickUpper,
+    liquidity: plan.liquidity,
+  };
+}
+
+/** Assemble the exact call for a launch. `launch` without a first buy, `launchAndBuy` with one. */
+export function buildWethLaunchCall(args: WethLaunchArgs, orchestrator: `0x${string}`): WethLaunchCall {
+  const input = buildWethLaunchInput(args, orchestrator);
+  if (args.devBuyWei < 0n || args.minTokensOut < 0n) throw new Error('A first-buy amount cannot be negative.');
+  if (args.launchFeeWei < 0n) throw new Error('The launch fee cannot be negative.');
+  if (args.devBuyWei === 0n) {
+    // A floor with nothing to spend is `NO_DEV_BUY` on-chain; refused here, never dropped.
+    if (args.minTokensOut !== 0n) throw new Error('Set a first-buy amount, or clear the minimum.');
+    return { functionName: 'launch', input, args: [input], value: args.launchFeeWei };
+  }
+  return {
+    functionName: 'launchAndBuy',
+    input,
+    args: [input, args.devBuyWei, args.minTokensOut],
+    value: args.launchFeeWei + args.devBuyWei,
+  };
+}
+
+/** An unsigned transaction: the bytes a wallet, the CLI or an agent signs. */
+export interface UnsignedLaunchTx {
+  readonly to: `0x${string}`;
+  readonly data: Hex;
+  /** Native wei to attach. */
+  readonly value: bigint;
+}
+
+/** The calldata of a WETH-type launch call. */
+export function encodeWethLaunchCall(call: WethLaunchCall, orchestrator: `0x${string}`): UnsignedLaunchTx {
+  const data =
+    call.functionName === 'launchAndBuy'
+      ? encodeFunctionData({ abi: launchOrchestratorAbi, functionName: 'launchAndBuy', args: call.args })
+      : encodeFunctionData({ abi: launchOrchestratorAbi, functionName: 'launch', args: call.args });
+  return { to: orchestrator, data, value: call.value };
+}
+
+/**
+ * The two launch-fee reads every V20 orchestrator (`PeddlesLaunchOrchestratorV20`,
+ * `PeddlesNFTBondingGraduationOrchestratorV20`) exposes since 2026-09-19. Hand-written because it
+ * MIRRORS `PeddlesAtomicBaseV20` in `contracts/src/PeddlesV20.sol` ahead of the next ABI
+ * regeneration; the signatures are the same ones the stock launchpad has always had.
+ */
+export const orchestratorLaunchFeeAbi = [
+  { type: 'function', name: 'launchFee', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'uint256' }] },
+  { type: 'function', name: 'maxLaunchFee', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'uint256' }] },
+] as const;
+
+export interface OrchestratorLaunchFee {
+  /** Exact wei the orchestrator takes off the top of `msg.value`. */
+  readonly launchFee: bigint;
+  /** Immutable per-deployment ceiling — disclosure, not something to send. */
+  readonly maxLaunchFee: bigint;
+}
+
+/**
+ * A V20 orchestrator's launch fee, READ FROM THE CHAIN. Owner-tunable storage under an immutable
+ * cap, so never a constant; a failed read throws rather than falling back to zero.
+ */
+export async function readOrchestratorLaunchFee(client: ReadClient, orchestrator: Address): Promise<OrchestratorLaunchFee> {
+  const [launchFee, maxLaunchFee] = (await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { address: orchestrator, abi: orchestratorLaunchFeeAbi, functionName: 'launchFee' },
+      { address: orchestrator, abi: orchestratorLaunchFeeAbi, functionName: 'maxLaunchFee' },
+    ],
+  })) as readonly [bigint, bigint];
+  return { launchFee, maxLaunchFee };
+}

package/src/launch/wethPlan.ts

@@ -0,0 +1,257 @@
+import type { ReadClient } from '../client.js';
+import { factoryAbi } from '../abis.js';
+import { launchOrchestratorAbi, liquidityExecutorLaunchAbi } from './abi.generated.js';
+import type { LaunchAddresses } from './addresses.js';
+import { liquidityForAmount, getSqrtPriceAtTick } from './tickMath.js';
+import { VARIANT_ASSET } from './variants.js';
+
+/**
+ * The WETH-type launch plan — everything `PeddlesLaunchOrchestratorV20.launch`
+ * needs, derived from LIVE chain reads. A pure port of the web app's
+ * `buildWethLaunchPlan` (`features/launch/useWethLaunch.ts`).
+ *
+ * The orchestrator takes `sqrtPriceX96`, `tickLower`, `tickUpper` and
+ * `liquidity` as INPUTS and mints exactly the position they describe, so every
+ * one of them is derived from reads:
+ *   - fee tier, tick spacing, pool manager, position manager, hook and quote
+ *     token come from `PeddlesV4LiquidityExecutor`
+ *   - the tick range comes from the executor's `defaultSingleSidedTicks` for THIS
+ *     token's predicted address
+ *   - the start tick is recovered from that range and the spacing
+ *   - the liquidity is the largest that fits the POOLED share of the 1e9 supply
+ *   - the allocation is the launch type's own (orchestrator defaults for type 0,
+ *     the registered split for any other)
+ *
+ * Any failed read throws. There is no fallback: a launch assembled from stale
+ * pool parameters is a launch that burns a creator's gas.
+ */
+
+/** Every Peddles launch is exactly one billion tokens; the orchestrator enforces it. */
+export const SUPPLY_UNITS = 1_000_000_000n;
+/** Every Peddles token launches at 18 decimals. Not a creator choice. */
+export const LAUNCH_COIN_DECIMALS = 18;
+
+export interface WethLaunchPlan {
+  readonly predictedToken: `0x${string}`;
+  readonly quoteToken: `0x${string}`;
+  readonly tokenIsCurrency0: boolean;
+  readonly tickLower: number;
+  readonly tickUpper: number;
+  readonly startTick: number;
+  readonly sqrtPriceX96: bigint;
+  readonly liquidity: bigint;
+  /** Total supply in base units — 1e9 × 10^18. */
+  readonly totalSupply: bigint;
+  /** The liquidity share of it, in base units — what the position is sized to hold. */
+  readonly pooledSupply: bigint;
+  readonly poolFeePpm: number;
+  readonly tickSpacing: number;
+  readonly hook: `0x${string}`;
+  readonly poolManager: `0x${string}`;
+  readonly positionManager: `0x${string}`;
+  readonly liquidityManager: `0x${string}`;
+  readonly airdropPublisher: `0x${string}`;
+  readonly allocationBps: {
+    readonly liquidity: number;
+    readonly airdrop: number;
+    readonly vesting: number;
+    readonly burn: number;
+    readonly clog: number;
+  };
+  /** The clog terms, when this launch type has one. `null` on a plain launch. */
+  readonly clog: {
+    readonly bps: number;
+    readonly sliceBps: number;
+    readonly minIntervalSeconds: number;
+  } | null;
+  /** The launch TYPE this plan was built for; the input builder cannot assemble another. */
+  readonly variant: number;
+}
+
+export interface WethPlanArgs {
+  readonly salt: `0x${string}`;
+  /** The locally mined address this salt must produce; the factory must agree or the plan fails closed. */
+  readonly expectedToken?: `0x${string}` | null;
+  /** The factory's variant id, as the creator chose it. REQUIRED — there is no default type. */
+  readonly variant: number;
+}
+
+export async function buildWethLaunchPlan(
+  client: ReadClient,
+  addresses: LaunchAddresses,
+  args: WethPlanArgs,
+): Promise<WethLaunchPlan> {
+  const { orchestrator, factory, liquidityExecutor } = addresses;
+  const variant = args.variant;
+
+  const config = await client.multicall({
+    allowFailure: false,
+    contracts: [
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'quoteToken' },
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'poolManager' },
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'positionManager' },
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'hook' },
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'fee' },
+      { address: liquidityExecutor, abi: liquidityExecutorLaunchAbi, functionName: 'tickSpacing' },
+      { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'airdropPublisher' },
+      { 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: factory, abi: factoryAbi, functionName: 'getPeddlesAddress', args: [variant, orchestrator, args.salt] },
+      { address: factory, abi: factoryAbi, functionName: 'isVariantSupported', args: [variant] },
+      { address: orchestrator, abi: launchOrchestratorAbi, functionName: 'feeHook' },
+    ],
+  });
+
+  const [
+    quoteToken,
+    poolManager,
+    positionManager,
+    hook,
+    fee,
+    tickSpacing,
+    airdropPublisher,
+    liquidityBps,
+    airdropBps,
+    vestingBps,
+    burnBps,
+    predictedToken,
+    variantSupported,
+    orchestratorHook,
+  ] = config as unknown as [
+    `0x${string}`,
+    `0x${string}`,
+    `0x${string}`,
+    `0x${string}`,
+    number,
+    number,
+    `0x${string}`,
+    number,
+    number,
+    number,
+    number,
+    `0x${string}`,
+    boolean,
+    `0x${string}`,
+  ];
+
+  if (!variantSupported) {
+    throw new Error('This launch type is not open for new launches, so launching is disabled.');
+  }
+  // Every launch pool is hooked by the fee hook, and the orchestrator refuses an executor pointed
+  // anywhere else. Checked here so a repointed contract refuses with a reason instead of reverting.
+  const expected = addresses.feeHook.toLowerCase();
+  if (hook.toLowerCase() !== expected || orchestratorHook.toLowerCase() !== expected) {
+    throw new Error(
+      'The launch contracts on this network are not wired to the trading-fee contract this build expects, so launching is disabled.',
+    );
+  }
+  if (args.expectedToken && predictedToken.toLowerCase() !== args.expectedToken.toLowerCase()) {
+    throw new Error(
+      'The factory predicts a different address for this launch than the one reserved for it. Launching is disabled rather than sending it somewhere else.',
+    );
+  }
+
+  let alloc = {
+    liquidity: Number(liquidityBps),
+    airdrop: Number(airdropBps),
+    vesting: Number(vestingBps),
+    burn: Number(burnBps),
+    clog: 0,
+  };
+  let clogTerms: WethLaunchPlan['clog'] = null;
+
+  if (variant !== VARIANT_ASSET) {
+    const declared = (await client.readContract({
+      address: factory,
+      abi: factoryAbi,
+      functionName: 'variantAllocation',
+      args: [variant],
+    })) as {
+      liquidityBps: number;
+      airdropBps: number;
+      vestingBps: number;
+      burnBps: number;
+      clogBps: number;
+      clogSliceBps: number;
+      clogMinInterval: bigint;
+    };
+    alloc = {
+      liquidity: Number(declared.liquidityBps),
+      airdrop: Number(declared.airdropBps),
+      vesting: Number(declared.vestingBps),
+      burn: Number(declared.burnBps),
+      clog: Number(declared.clogBps),
+    };
+    if (alloc.clog > 0) {
+      clogTerms = {
+        bps: Number(declared.clogBps),
+        sliceBps: Number(declared.clogSliceBps),
+        minIntervalSeconds: Number(declared.clogMinInterval),
+      };
+      if (!addresses.clogVaultFactory) {
+        throw new Error(
+          'This launch type withholds supply into a clog vault, and no clog vault factory is deployed on this chain. Launching is disabled rather than launching without it.',
+        );
+      }
+    }
+  }
+
+  if (alloc.airdrop !== 0 || alloc.burn !== 0 || alloc.vesting !== 0) {
+    throw new Error(
+      `This launch type allocates ${alloc.liquidity}/${alloc.airdrop}/${alloc.vesting}/${alloc.burn}/${alloc.clog} bps (liquidity/airdrop/vesting/burn/clog). Launching is disabled until it matches what this build would state.`,
+    );
+  }
+  if (alloc.liquidity + alloc.clog !== 10_000) {
+    throw new Error(`This launch type's allocation sums to ${alloc.liquidity + alloc.clog} bps, not 10000. Launching is disabled.`);
+  }
+
+  const [tickLower, tickUpper] = (await client.readContract({
+    address: liquidityExecutor,
+    abi: liquidityExecutorLaunchAbi,
+    functionName: 'defaultSingleSidedTicks',
+    args: [predictedToken],
+  })) as readonly [number, number];
+
+  const tokenIsCurrency0 = BigInt(predictedToken) < BigInt(quoteToken);
+  const spacing = Number(tickSpacing);
+  // Exactly the harness's derivation: the start price sits one spacing outside the single-sided
+  // range, on the side the token does not occupy.
+  const startTick = tokenIsCurrency0 ? Number(tickLower) - spacing : Number(tickUpper) + spacing;
+  const sqrtPriceX96 = getSqrtPriceAtTick(startTick);
+
+  const totalSupply = SUPPLY_UNITS * 10n ** BigInt(LAUNCH_COIN_DECIMALS);
+  // The position holds the LIQUIDITY share, not the whole supply: on a clog type the rest is minted
+  // to the clog vault, and a position sized to the whole supply reverts every clog launch.
+  const pooledSupply = (totalSupply * BigInt(alloc.liquidity)) / 10_000n;
+  const quote = liquidityForAmount(tokenIsCurrency0, Number(tickLower), Number(tickUpper), pooledSupply);
+  if (!quote) {
+    throw new Error(
+      'No single-sided position fits the pooled supply at the executor’s current tick range, so the pool parameters for this launch cannot be derived.',
+    );
+  }
+
+  return {
+    predictedToken,
+    quoteToken,
+    tokenIsCurrency0,
+    tickLower: Number(tickLower),
+    tickUpper: Number(tickUpper),
+    startTick,
+    sqrtPriceX96,
+    liquidity: quote.liquidity,
+    totalSupply,
+    pooledSupply,
+    poolFeePpm: Number(fee),
+    tickSpacing: spacing,
+    hook,
+    poolManager,
+    positionManager,
+    liquidityManager: liquidityExecutor,
+    airdropPublisher,
+    allocationBps: { ...alloc },
+    clog: clogTerms,
+    variant,
+  };
+}