@forgedevv/shared 0.0.0-stage → 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,429 @@
+import { z } from 'zod';
+/** Lamports serialized as a decimal string (bigint). 1 SOL = 1_000_000_000 lamports. */
+export declare const Lamports: z.ZodString;
+export type Lamports = z.infer<typeof Lamports>;
+/** Raw token amount (smallest units) serialized as a decimal string. */
+export declare const RawTokenAmount: z.ZodString;
+/** Base58 ed25519 signature (transaction signature or signed message). */
+export declare const Base58Signature: z.ZodString;
+/** Serialized transaction, base64 encoded. */
+export declare const Base64Transaction: z.ZodBase64;
+export declare const Uuid: z.ZodUUID;
+/** ISO 8601 date-time (UTC `Z` or with an offset). */
+export declare const IsoDateTime: z.ZodISODateTime;
+/** Path params of routes with `:id`. */
+export declare const RouteIdParams: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strict>;
+export type RouteIdParams = z.infer<typeof RouteIdParams>;
+export declare const WEB_API_ROUTES: {
+    readonly authNonce: {
+        readonly method: "POST";
+        readonly path: "/api/auth/nonce";
+    };
+    readonly authVerify: {
+        readonly method: "POST";
+        readonly path: "/api/auth/verify";
+    };
+    readonly authSession: {
+        readonly method: "GET";
+        readonly path: "/api/auth/session";
+    };
+    readonly authLogout: {
+        readonly method: "POST";
+        readonly path: "/api/auth/logout";
+    };
+    readonly authSupabaseToken: {
+        readonly method: "GET";
+        readonly path: "/api/auth/supabase-token";
+    };
+    readonly gating: {
+        readonly method: "GET";
+        readonly path: "/api/gating";
+    };
+    readonly flags: {
+        readonly method: "GET";
+        readonly path: "/api/flags";
+    };
+    readonly chat: {
+        readonly method: "POST";
+        readonly path: "/api/chat";
+    };
+    readonly specConfirm: {
+        readonly method: "POST";
+        readonly path: "/api/spec/confirm";
+    };
+    readonly launchpadModifications: {
+        readonly method: "POST";
+        readonly path: "/api/launchpads/:id/modifications";
+    };
+    readonly paymentsQuote: {
+        readonly method: "POST";
+        readonly path: "/api/payments/quote";
+    };
+    readonly paymentsConfirm: {
+        readonly method: "POST";
+        readonly path: "/api/payments/confirm";
+    };
+    readonly jobApprove: {
+        readonly method: "POST";
+        readonly path: "/api/jobs/:id/approve";
+    };
+    readonly ownerTransactionGet: {
+        readonly method: "GET";
+        readonly path: "/api/jobs/:id/owner-transaction";
+    };
+    readonly ownerTransactionSubmit: {
+        readonly method: "POST";
+        readonly path: "/api/jobs/:id/owner-transaction";
+    };
+    readonly jobGet: {
+        readonly method: "GET";
+        readonly path: "/api/jobs/:id";
+    };
+    readonly launchpadsList: {
+        readonly method: "GET";
+        readonly path: "/api/launchpads";
+    };
+    readonly launchpadGet: {
+        readonly method: "GET";
+        readonly path: "/api/launchpads/:id";
+    };
+    readonly claimTransaction: {
+        readonly method: "GET";
+        readonly path: "/api/launchpads/:id/claim-transaction";
+    };
+    readonly launchpadReactivate: {
+        readonly method: "POST";
+        readonly path: "/api/launchpads/:id/reactivate";
+    };
+    readonly rpc: {
+        readonly method: "POST";
+        readonly path: "/api/rpc";
+    };
+};
+export declare const AuthNonceRequest: z.ZodObject<{
+    wallet: z.ZodString;
+}, z.core.$strict>;
+export type AuthNonceRequest = z.infer<typeof AuthNonceRequest>;
+/**
+ * `nonce` is an opaque server-signed token (stateless). `message` is the exact text the wallet
+ * must sign; the client never builds it. The token is also set as an HttpOnly cookie.
+ */
+export declare const AuthNonceResponse: z.ZodObject<{
+    nonce: z.ZodString;
+    message: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export type AuthNonceResponse = z.infer<typeof AuthNonceResponse>;
+export declare const AuthVerifyRequest: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AuthVerifyRequest = z.infer<typeof AuthVerifyRequest>;
+/** The session. */
+export declare const AuthVerifyResponse: z.ZodObject<{
+    wallet: z.ZodString;
+}, z.core.$strip>;
+export type AuthVerifyResponse = z.infer<typeof AuthVerifyResponse>;
+export declare const AuthLogoutResponse: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type AuthLogoutResponse = z.infer<typeof AuthLogoutResponse>;
+export declare const SupabaseTokenResponse: z.ZodObject<{
+    accessToken: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export type SupabaseTokenResponse = z.infer<typeof SupabaseTokenResponse>;
+export declare const Session: z.ZodObject<{
+    wallet: z.ZodString;
+}, z.core.$strip>;
+export type Session = AuthVerifyResponse;
+export declare const GatingResponse: z.ZodObject<{
+    ok: z.ZodBoolean;
+    required: z.ZodString;
+    balance: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type GatingResponse = z.infer<typeof GatingResponse>;
+export declare const FlagsResponse: z.ZodObject<{
+    signupsPaused: z.ZodBoolean;
+}, z.core.$strip>;
+export type FlagsResponse = z.infer<typeof FlagsResponse>;
+export declare const ChatRequest: z.ZodObject<{
+    conversationId: z.ZodOptional<z.ZodUUID>;
+    launchpadId: z.ZodOptional<z.ZodUUID>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type ChatRequest = z.infer<typeof ChatRequest>;
+/** Payload of the first stream event. */
+export declare const ChatResponse: z.ZodObject<{
+    conversationId: z.ZodUUID;
+}, z.core.$strip>;
+export type ChatResponse = z.infer<typeof ChatResponse>;
+export declare const SpecConfirmRequest: z.ZodObject<{
+    conversationId: z.ZodUUID;
+    spec: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        ownerWallet: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        quote: z.ZodLiteral<"SOL">;
+        tradingFeeBps: z.ZodNumber;
+        coinCreatorSharePct: z.ZodDefault<z.ZodNumber>;
+        poolCreationFeeSol: z.ZodNumber;
+        antiSniper: z.ZodDefault<z.ZodBoolean>;
+        theme: z.ZodObject<{
+            primaryColor: z.ZodString;
+            accentColor: z.ZodString;
+            darkMode: z.ZodBoolean;
+            tagline: z.ZodString;
+            logoUrl: z.ZodOptional<z.ZodURL>;
+            designNotes: z.ZodString;
+        }, z.core.$strip>;
+        launchpadCoin: z.ZodObject<{
+            name: z.ZodString;
+            symbol: z.ZodString;
+            description: z.ZodString;
+            imageUrl: z.ZodURL;
+            firstBuySol: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type SpecConfirmRequest = z.input<typeof SpecConfirmRequest>;
+export declare const SpecConfirmResponse: z.ZodObject<{
+    launchpadId: z.ZodUUID;
+    jobId: z.ZodUUID;
+}, z.core.$strip>;
+export type SpecConfirmResponse = z.infer<typeof SpecConfirmResponse>;
+export declare const LaunchpadModificationRequest: z.ZodObject<{
+    conversationId: z.ZodUUID;
+    request: z.ZodString;
+}, z.core.$strict>;
+export type LaunchpadModificationRequest = z.infer<typeof LaunchpadModificationRequest>;
+export declare const LaunchpadModificationResponse: z.ZodObject<{
+    jobId: z.ZodUUID;
+}, z.core.$strip>;
+export type LaunchpadModificationResponse = z.infer<typeof LaunchpadModificationResponse>;
+export declare const PaymentsQuoteRequest: z.ZodObject<{
+    jobId: z.ZodUUID;
+    kind: z.ZodEnum<{
+        creation: "creation";
+        modification: "modification";
+    }>;
+}, z.core.$strict>;
+export type PaymentsQuoteRequest = z.infer<typeof PaymentsQuoteRequest>;
+/** Quote as seen by the UI (docs/frontend/CONTRACT.md). */
+export declare const Quote: z.ZodObject<{
+    paymentId: z.ZodUUID;
+    kind: z.ZodEnum<{
+        creation: "creation";
+        modification: "modification";
+    }>;
+    lamports: z.ZodString;
+    usdAmount: z.ZodNumber;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type Quote = z.infer<typeof Quote>;
+/**
+ * `transaction` is the unsigned payment transaction (base64). It is null when lamports = "0"
+ * (an included modification remains and the job goes straight to `paid`).
+ */
+export declare const PaymentsQuoteResponse: z.ZodObject<{
+    paymentId: z.ZodUUID;
+    kind: z.ZodEnum<{
+        creation: "creation";
+        modification: "modification";
+    }>;
+    lamports: z.ZodString;
+    usdAmount: z.ZodNumber;
+    expiresAt: z.ZodISODateTime;
+    transaction: z.ZodNullable<z.ZodBase64>;
+}, z.core.$strip>;
+export type PaymentsQuoteResponse = z.infer<typeof PaymentsQuoteResponse>;
+export declare const PaymentsConfirmRequest: z.ZodObject<{
+    paymentId: z.ZodUUID;
+    signature: z.ZodString;
+}, z.core.$strict>;
+export type PaymentsConfirmRequest = z.infer<typeof PaymentsConfirmRequest>;
+export declare const PaymentsConfirmResponse: z.ZodObject<{
+    status: z.ZodEnum<{
+        refunded: "refunded";
+        quoted: "quoted";
+        confirmed: "confirmed";
+        expired: "expired";
+    }>;
+}, z.core.$strip>;
+export type PaymentsConfirmResponse = z.infer<typeof PaymentsConfirmResponse>;
+export declare const JobApproveResponse: z.ZodObject<{
+    status: z.ZodEnum<{
+        spec_ready: "spec_ready";
+        paid: "paid";
+        building: "building";
+        preview_ready: "preview_ready";
+        approved: "approved";
+        onchain_setup: "onchain_setup";
+        awaiting_owner_signature: "awaiting_owner_signature";
+        owner_signed: "owner_signed";
+        deploying: "deploying";
+        live: "live";
+        failed: "failed";
+        refunded: "refunded";
+    }>;
+}, z.core.$strip>;
+export type JobApproveResponse = z.infer<typeof JobApproveResponse>;
+/** Summary shown before the client signs the launch transaction. */
+export declare const OwnerTransactionSummary: z.ZodObject<{
+    coinName: z.ZodString;
+    coinSymbol: z.ZodString;
+    firstBuyLamports: z.ZodString;
+    estimatedNetworkFeeLamports: z.ZodString;
+    ownerWallet: z.ZodString;
+    ownerRequiredBalanceLamports: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OwnerTransactionSummary = z.infer<typeof OwnerTransactionSummary>;
+/** Absolute https URL (the launchpad coin metadata URI). Kept exactly as sent (no normalization). */
+export declare const HttpsUrl: z.ZodURL;
+/**
+ * The accounts of the launch transaction, pinned by the browser (`verifyLaunchCoinTransaction` of
+ * @forge/core) before the owner signs: the launchpad coin config and mint (launchpad row), the
+ * FORGE creator wallet that creates the pool and holds the durable nonce, the durable nonce
+ * account, and the coin metadata URI written by the pool creation.
+ */
+export declare const OwnerTransactionLaunch: z.ZodObject<{
+    config: z.ZodString;
+    mint: z.ZodString;
+    creator: z.ZodString;
+    nonceAccount: z.ZodString;
+    metadataUri: z.ZodURL;
+}, z.core.$strip>;
+export type OwnerTransactionLaunch = z.infer<typeof OwnerTransactionLaunch>;
+export declare const OwnerTransactionGetResponse: z.ZodObject<{
+    transaction: z.ZodBase64;
+    summary: z.ZodObject<{
+        coinName: z.ZodString;
+        coinSymbol: z.ZodString;
+        firstBuyLamports: z.ZodString;
+        estimatedNetworkFeeLamports: z.ZodString;
+        ownerWallet: z.ZodString;
+        ownerRequiredBalanceLamports: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    simulation: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        ok: "ok";
+        unavailable: "unavailable";
+    }>>;
+    launch: z.ZodOptional<z.ZodObject<{
+        config: z.ZodString;
+        mint: z.ZodString;
+        creator: z.ZodString;
+        nonceAccount: z.ZodString;
+        metadataUri: z.ZodURL;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OwnerTransactionGetResponse = z.infer<typeof OwnerTransactionGetResponse>;
+export declare const OwnerTransactionSubmitRequest: z.ZodObject<{
+    signedTransaction: z.ZodBase64;
+}, z.core.$strict>;
+export type OwnerTransactionSubmitRequest = z.infer<typeof OwnerTransactionSubmitRequest>;
+export declare const OwnerTransactionSubmitResponse: z.ZodObject<{
+    signature: z.ZodString;
+}, z.core.$strip>;
+export type OwnerTransactionSubmitResponse = z.infer<typeof OwnerTransactionSubmitResponse>;
+export declare const ClaimTransactionSummary: z.ZodObject<{
+    pool: z.ZodString;
+    tradingFeesLamports: z.ZodString;
+    poolCreationFeeLamports: z.ZodString;
+    ownerCostLamports: z.ZodString;
+    remainingPools: z.ZodNumber;
+}, z.core.$strip>;
+export type ClaimTransactionSummary = z.infer<typeof ClaimTransactionSummary>;
+export declare const ClaimTransactionResponse: z.ZodObject<{
+    transaction: z.ZodBase64;
+    summary: z.ZodOptional<z.ZodObject<{
+        pool: z.ZodString;
+        tradingFeesLamports: z.ZodString;
+        poolCreationFeeLamports: z.ZodString;
+        ownerCostLamports: z.ZodString;
+        remainingPools: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClaimTransactionResponse = z.infer<typeof ClaimTransactionResponse>;
+export declare const RpcRequest: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+}, z.core.$strict>;
+export type RpcRequest = z.infer<typeof RpcRequest>;
+export declare const RpcResponse: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RpcResponse = z.infer<typeof RpcResponse>;
+/** Hex HMAC-SHA256 computed with SIGNER_HMAC_SECRET over `signerSignedPayload(...)`. */
+export declare const SIGNER_SIGNATURE_HEADER = "X-Forge-Signature";
+/** Unix time in seconds, as a decimal string. */
+export declare const SIGNER_TIMESTAMP_HEADER = "X-Forge-Timestamp";
+/** Requests whose timestamp differs from the signer clock by more than this are rejected. */
+export declare const SIGNER_MAX_CLOCK_SKEW_SECONDS = 60;
+/**
+ * Exact string fed to HMAC-SHA256: `<timestamp>.<raw body>`. The timestamp is covered by the MAC
+ * so that a captured request cannot be replayed with a fresh timestamp.
+ */
+export declare function signerSignedPayload(timestamp: string, rawBody: string): string;
+export declare const SIGNER_ROUTES: {
+    readonly configs: {
+        readonly method: "POST";
+        readonly path: "/v1/configs";
+    };
+    readonly launchCoinPrepare: {
+        readonly method: "POST";
+        readonly path: "/v1/launch-coin/prepare";
+    };
+    readonly health: {
+        readonly method: "GET";
+        readonly path: "/v1/health";
+    };
+};
+export declare const SignerConfigsRequest: z.ZodObject<{
+    jobId: z.ZodUUID;
+}, z.core.$strict>;
+export type SignerConfigsRequest = z.infer<typeof SignerConfigsRequest>;
+export declare const SignerConfigsResponse: z.ZodObject<{
+    launchpadConfig: z.ZodString;
+    launchpadCoinConfig: z.ZodString;
+}, z.core.$strip>;
+export type SignerConfigsResponse = z.infer<typeof SignerConfigsResponse>;
+export declare const SignerLaunchPrepareRequest: z.ZodObject<{
+    jobId: z.ZodUUID;
+}, z.core.$strict>;
+export type SignerLaunchPrepareRequest = z.infer<typeof SignerLaunchPrepareRequest>;
+export declare const SignerLaunchPrepareResponse: z.ZodObject<{
+    partiallySignedTx: z.ZodBase64;
+    mint: z.ZodString;
+    summary: z.ZodOptional<z.ZodObject<{
+        coinName: z.ZodString;
+        coinSymbol: z.ZodString;
+        firstBuyLamports: z.ZodString;
+        estimatedNetworkFeeLamports: z.ZodString;
+        ownerWallet: z.ZodString;
+        ownerRequiredBalanceLamports: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SignerLaunchPrepareResponse = z.infer<typeof SignerLaunchPrepareResponse>;
+export declare const SignerHealthResponse: z.ZodObject<{
+    ok: z.ZodBoolean;
+    cluster: z.ZodOptional<z.ZodString>;
+    uptimeSeconds: z.ZodOptional<z.ZodNumber>;
+    jobs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SignerHealthResponse = z.infer<typeof SignerHealthResponse>;

package/dist/api.js

@@ -0,0 +1,264 @@
+import { z } from 'zod';
+import { JobStatus } from './jobs.js';
+import { PaymentKind, PaymentStatus } from './db.js';
+import { LaunchpadSpec, SolanaAddress } from './spec.js';
+/*
+ * Request/response schemas of the apps/web API (docs/INTERFACES.md §6) and of the internal
+ * builder -> signer API (§7). Request bodies are strict (unknown keys are rejected); responses
+ * strip unknown keys.
+ */
+// ---------------------------------------------------------------------------
+// Primitives
+// ---------------------------------------------------------------------------
+/** Lamports serialized as a decimal string (bigint). 1 SOL = 1_000_000_000 lamports. */
+export const Lamports = z
+    .string()
+    .regex(/^\d+$/, { error: 'Lamports must be a decimal integer string' });
+/** Raw token amount (smallest units) serialized as a decimal string. */
+export const RawTokenAmount = z.string().regex(/^\d+$/);
+/** Base58 ed25519 signature (transaction signature or signed message). */
+export const Base58Signature = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{64,88}$/, {
+    error: 'Invalid base58 signature',
+});
+/** Serialized transaction, base64 encoded. */
+export const Base64Transaction = z.base64().min(1);
+export const Uuid = z.uuid();
+/** ISO 8601 date-time (UTC `Z` or with an offset). */
+export const IsoDateTime = z.iso.datetime({ offset: true });
+/** Path params of routes with `:id`. */
+export const RouteIdParams = z.strictObject({ id: Uuid });
+// ---------------------------------------------------------------------------
+// apps/web routes (§6)
+// ---------------------------------------------------------------------------
+export const WEB_API_ROUTES = {
+    authNonce: { method: 'POST', path: '/api/auth/nonce' },
+    authVerify: { method: 'POST', path: '/api/auth/verify' },
+    authSession: { method: 'GET', path: '/api/auth/session' },
+    authLogout: { method: 'POST', path: '/api/auth/logout' },
+    authSupabaseToken: { method: 'GET', path: '/api/auth/supabase-token' },
+    gating: { method: 'GET', path: '/api/gating' },
+    flags: { method: 'GET', path: '/api/flags' },
+    chat: { method: 'POST', path: '/api/chat' },
+    specConfirm: { method: 'POST', path: '/api/spec/confirm' },
+    launchpadModifications: { method: 'POST', path: '/api/launchpads/:id/modifications' },
+    paymentsQuote: { method: 'POST', path: '/api/payments/quote' },
+    paymentsConfirm: { method: 'POST', path: '/api/payments/confirm' },
+    jobApprove: { method: 'POST', path: '/api/jobs/:id/approve' },
+    ownerTransactionGet: { method: 'GET', path: '/api/jobs/:id/owner-transaction' },
+    ownerTransactionSubmit: { method: 'POST', path: '/api/jobs/:id/owner-transaction' },
+    jobGet: { method: 'GET', path: '/api/jobs/:id' },
+    launchpadsList: { method: 'GET', path: '/api/launchpads' },
+    launchpadGet: { method: 'GET', path: '/api/launchpads/:id' },
+    claimTransaction: { method: 'GET', path: '/api/launchpads/:id/claim-transaction' },
+    launchpadReactivate: { method: 'POST', path: '/api/launchpads/:id/reactivate' },
+    rpc: { method: 'POST', path: '/api/rpc' },
+};
+// POST /api/auth/nonce
+export const AuthNonceRequest = z.strictObject({ wallet: SolanaAddress });
+/**
+ * `nonce` is an opaque server-signed token (stateless). `message` is the exact text the wallet
+ * must sign; the client never builds it. The token is also set as an HttpOnly cookie.
+ */
+export const AuthNonceResponse = z.object({
+    nonce: z.string().min(1),
+    message: z.string().min(1),
+    expiresAt: z.string().min(1),
+});
+// POST /api/auth/verify — signature of the message containing the nonce
+export const AuthVerifyRequest = z.strictObject({
+    wallet: SolanaAddress,
+    signature: Base58Signature,
+    /** The token returned by /api/auth/nonce; optional because it is also sent as a cookie. */
+    nonce: z.string().min(1).optional(),
+});
+/** The session. */
+export const AuthVerifyResponse = z.object({ wallet: SolanaAddress });
+// POST /api/auth/logout
+export const AuthLogoutResponse = z.object({ ok: z.literal(true) });
+// GET /api/auth/supabase-token — short-lived JWT for Supabase RLS / Realtime (claim `wallet`)
+export const SupabaseTokenResponse = z.object({
+    accessToken: z.string().min(1),
+    expiresAt: z.string().min(1),
+});
+export const Session = AuthVerifyResponse;
+// GET /api/gating — FORGE_GATING_AMOUNT of mint FORGE_MINT. Without FORGE_MINT, gating is
+// disabled: `enabled: false` and `ok: true`.
+export const GatingResponse = z.object({
+    ok: z.boolean(),
+    /** Required raw amount (smallest units). */
+    required: RawTokenAmount,
+    /** Wallet raw balance (smallest units). */
+    balance: RawTokenAmount,
+    enabled: z.boolean(),
+});
+// GET /api/flags — public kill-switch state needed by the UI
+export const FlagsResponse = z.object({ signupsPaused: z.boolean() });
+// POST /api/chat — text/event-stream of ChatStreamEvent (web-client.ts); always starts with
+// { type: 'conversation', conversationId } and ends with { type: 'done' }.
+export const ChatRequest = z.strictObject({
+    conversationId: Uuid.optional(),
+    /** Set for a modification of an existing launchpad. */
+    launchpadId: Uuid.optional(),
+    message: z.string().min(1),
+});
+/** Payload of the first stream event. */
+export const ChatResponse = z.object({ conversationId: Uuid });
+// POST /api/spec/confirm
+export const SpecConfirmRequest = z.strictObject({ conversationId: Uuid, spec: LaunchpadSpec });
+export const SpecConfirmResponse = z.object({ launchpadId: Uuid, jobId: Uuid });
+// POST /api/launchpads/:id/modifications
+export const LaunchpadModificationRequest = z.strictObject({
+    conversationId: Uuid,
+    request: z.string().min(1),
+});
+export const LaunchpadModificationResponse = z.object({ jobId: Uuid });
+// POST /api/payments/quote
+export const PaymentsQuoteRequest = z.strictObject({ jobId: Uuid, kind: PaymentKind });
+/** Quote as seen by the UI (docs/frontend/CONTRACT.md). */
+export const Quote = z.object({
+    paymentId: Uuid,
+    kind: PaymentKind,
+    lamports: Lamports,
+    usdAmount: z.number().nonnegative(),
+    expiresAt: IsoDateTime,
+});
+/**
+ * `transaction` is the unsigned payment transaction (base64). It is null when lamports = "0"
+ * (an included modification remains and the job goes straight to `paid`).
+ */
+export const PaymentsQuoteResponse = Quote.extend({ transaction: Base64Transaction.nullable() });
+// POST /api/payments/confirm
+export const PaymentsConfirmRequest = z.strictObject({
+    paymentId: Uuid,
+    signature: Base58Signature,
+});
+export const PaymentsConfirmResponse = z.object({ status: PaymentStatus });
+// POST /api/jobs/:id/approve (no body)
+export const JobApproveResponse = z.object({ status: JobStatus });
+/** Summary shown before the client signs the launch transaction. */
+export const OwnerTransactionSummary = z.object({
+    coinName: z.string(),
+    coinSymbol: z.string(),
+    firstBuyLamports: Lamports,
+    /** Everything the owner pays besides the first buy: network fee, rents, Metaplex fee, pool creation fee. */
+    estimatedNetworkFeeLamports: Lamports,
+    ownerWallet: SolanaAddress,
+    /**
+     * Balance the owner's wallet must hold before signing: first buy + everything above + the rent
+     * of the temporary WSOL account (created and closed within the transaction, so refunded, but
+     * held while it runs). Optional: absent when the server cannot compute it; older readers ignore it.
+     */
+    ownerRequiredBalanceLamports: Lamports.optional(),
+});
+/** Absolute https URL (the launchpad coin metadata URI). Kept exactly as sent (no normalization). */
+export const HttpsUrl = z.url({ protocol: /^https$/, error: 'Must be an https URL' });
+/**
+ * The accounts of the launch transaction, pinned by the browser (`verifyLaunchCoinTransaction` of
+ * @forge/core) before the owner signs: the launchpad coin config and mint (launchpad row), the
+ * FORGE creator wallet that creates the pool and holds the durable nonce, the durable nonce
+ * account, and the coin metadata URI written by the pool creation.
+ */
+export const OwnerTransactionLaunch = z.object({
+    config: SolanaAddress,
+    mint: SolanaAddress,
+    creator: SolanaAddress,
+    nonceAccount: SolanaAddress,
+    metadataUri: HttpsUrl,
+});
+// GET /api/jobs/:id/owner-transaction — launch transaction partially signed by FORGE
+export const OwnerTransactionGetResponse = z.object({
+    transaction: Base64Transaction,
+    /** Shown to the client before signing (INTERFACES §6). */
+    summary: OwnerTransactionSummary,
+    /** Whether the summary comes from a simulation of the exact message; when not `ok`, it is a lower bound. */
+    simulation: z.enum(['ok', 'failed', 'unavailable']).optional(),
+    /**
+     * The launch accounts the transaction must use. Optional in the schema so that older readers and
+     * writers still parse; the browser client refuses to sign a launch without it (fail closed).
+     */
+    launch: OwnerTransactionLaunch.optional(),
+});
+// POST /api/jobs/:id/owner-transaction
+export const OwnerTransactionSubmitRequest = z.strictObject({
+    signedTransaction: Base64Transaction,
+});
+export const OwnerTransactionSubmitResponse = z.object({ signature: Base58Signature });
+// GET /api/launchpads/:id/claim-transaction — client partner fee claim
+export const ClaimTransactionSummary = z.object({
+    /** The pool this transaction claims (one pool per transaction). */
+    pool: SolanaAddress,
+    /** Partner trading fees claimed by this transaction. */
+    tradingFeesLamports: Lamports,
+    /** Partner pool creation fee claimed by this transaction (0 when none). */
+    poolCreationFeeLamports: Lamports,
+    /** What the owner pays to claim: network fee and any account rent. */
+    ownerCostLamports: Lamports,
+    /** Pools still holding claimable fees after this one. */
+    remainingPools: z.number().int().nonnegative(),
+});
+export const ClaimTransactionResponse = z.object({
+    transaction: Base64Transaction,
+    summary: ClaimTransactionSummary.optional(),
+});
+// POST /api/rpc — Helius relay (method allow-list and per-IP rate limit enforced by apps/web)
+const JsonRpcId = z.union([z.string(), z.number(), z.null()]);
+export const RpcRequest = z.strictObject({
+    jsonrpc: z.literal('2.0'),
+    id: JsonRpcId,
+    method: z.string().min(1),
+    params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
+});
+export const RpcResponse = z.object({
+    jsonrpc: z.literal('2.0'),
+    id: JsonRpcId,
+    result: z.unknown().optional(),
+    error: z
+        .object({ code: z.number().int(), message: z.string(), data: z.unknown().optional() })
+        .optional(),
+});
+// ---------------------------------------------------------------------------
+// Internal builder -> signer API (§7)
+// ---------------------------------------------------------------------------
+/** Hex HMAC-SHA256 computed with SIGNER_HMAC_SECRET over `signerSignedPayload(...)`. */
+export const SIGNER_SIGNATURE_HEADER = 'X-Forge-Signature';
+/** Unix time in seconds, as a decimal string. */
+export const SIGNER_TIMESTAMP_HEADER = 'X-Forge-Timestamp';
+/** Requests whose timestamp differs from the signer clock by more than this are rejected. */
+export const SIGNER_MAX_CLOCK_SKEW_SECONDS = 60;
+/**
+ * Exact string fed to HMAC-SHA256: `<timestamp>.<raw body>`. The timestamp is covered by the MAC
+ * so that a captured request cannot be replayed with a fresh timestamp.
+ */
+export function signerSignedPayload(timestamp, rawBody) {
+    return `${timestamp}.${rawBody}`;
+}
+export const SIGNER_ROUTES = {
+    configs: { method: 'POST', path: '/v1/configs' },
+    launchCoinPrepare: { method: 'POST', path: '/v1/launch-coin/prepare' },
+    health: { method: 'GET', path: '/v1/health' },
+};
+/*
+ * The signer never takes an address or an amount from the request: it re-reads everything in
+ * Supabase. Requests are therefore strict and carry only the job id. Both routes are idempotent.
+ */
+// POST /v1/configs
+export const SignerConfigsRequest = z.strictObject({ jobId: Uuid });
+export const SignerConfigsResponse = z.object({
+    launchpadConfig: SolanaAddress,
+    launchpadCoinConfig: SolanaAddress,
+});
+// POST /v1/launch-coin/prepare — durable-nonce transaction signed by the creator wallet
+export const SignerLaunchPrepareRequest = z.strictObject({ jobId: Uuid });
+export const SignerLaunchPrepareResponse = z.object({
+    partiallySignedTx: Base64Transaction,
+    mint: SolanaAddress,
+    summary: OwnerTransactionSummary.optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+});
+// GET /v1/health
+export const SignerHealthResponse = z.object({
+    ok: z.boolean(),
+    cluster: z.string().optional(),
+    uptimeSeconds: z.number().optional(),
+    jobs: z.record(z.string(), z.unknown()).optional(),
+});