@forgedevv/shared 0.0.0-stage → 0.2.0

package/dist/api.d.ts

@@ -0,0 +1,464 @@
+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 launchpadRetry: {
+        readonly method: "POST";
+        readonly path: "/api/launchpads/:id/retry";
+    };
+    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;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, 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 LaunchpadRetryResponse: z.ZodObject<{
+    jobId: z.ZodUUID;
+}, z.core.$strip>;
+export type LaunchpadRetryResponse = z.infer<typeof LaunchpadRetryResponse>;
+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>;
+/** Lowercase 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";
+/**
+ * 16 random bytes as 32 lowercase hex characters, fresh for every request (and every retry). The
+ * signer accepts a nonce once within the clock-skew window.
+ */
+export declare const SIGNER_NONCE_HEADER = "X-Forge-Nonce";
+/** Requests whose timestamp differs from the signer clock by more than this are rejected. */
+export declare const SIGNER_MAX_CLOCK_SKEW_SECONDS = 60;
+/** First line of the signed string. Any change to its layout gets a new tag. */
+export declare const SIGNER_SIGNATURE_VERSION = "forge-signer-v2";
+/** The request fields covered by the signer HMAC. */
+export interface SignerSignedFields {
+    /** HTTP method, uppercase (`POST`). */
+    method: string;
+    /** Request target exactly as sent: the path plus the query string (`/v1/configs?a=1`). */
+    path: string;
+    /** Same value as the timestamp header. */
+    timestamp: string;
+    /** Same value as the nonce header. */
+    nonce: string;
+    /** Lowercase hex SHA-256 of the raw body bytes (an empty body hashes zero bytes). */
+    bodySha256: string;
+}
+/**
+ * Exact string fed to HMAC-SHA256, one field per line, in this order:
+ *
+ *   forge-signer-v2\n<METHOD>\n<path?query>\n<timestamp>\n<nonce>\n<body sha256>
+ *
+ * Every field has a strict format that excludes the line feed, and the field count is fixed, so
+ * the string decodes to exactly one tuple: a signature made for one method, route, query, time,
+ * nonce or body is worth nothing for any other. Throws on a field outside its format, so neither
+ * side can sign or check an ambiguous string.
+ */
+export declare function signerSignedPayload(fields: SignerSignedFields): 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>;