@chaindaddy/js 0.3.0 → 0.3.2

package/dist/api.d.ts

@@ -15,8 +15,8 @@ export interface paths {
          * @description A verified coin page by chain and ticker: its name, token address, registration ID, logo, price,
          *     market cap, 24-hour volume, liquidity, 24-hour price change and holder count. A figure Chain Daddy
          *     does not have is `null`, never `0`. The logo is `null` for a page marked NSFW. Answers 404 for a
-         *     ticker with no verified page on that chain. Keyless, the same for every caller, and cached for
-         *     about a minute.
+         *     ticker with no verified page on that chain, and for a page Chain Daddy removed. Keyless, the same
+         *     for every caller, and cached for about a minute.
          */
         get: operations["getPublicCoin"];
         put?: never;
@@ -38,9 +38,11 @@ export interface paths {
          * List the apps on a verified coin's page
          * @description The apps a verified coin's page shows, in page order: each app's ID, name, description, version,
          *     category, icon and whether it is a built-in. It names the apps; it does not include what the owner
-         *     set up inside them. Apps turned off are left out, and so is every app rated NSFW. Answers 404 for
-         *     a ticker with no verified page on that chain. Keyless, the same for every caller, and cached for
-         *     about a minute.
+         *     set up inside them. Apps turned off are left out, and so is every app rated NSFW, every app the
+         *     page itself no longer shows (not reviewed yet, suspended or removed) and the built-in parts of
+         *     the page that are not apps (its header, its market panel). Answers 404 for a ticker
+         *     with no verified page on that chain, and for a page Chain Daddy removed. Keyless, the same for
+         *     every caller, and cached for about a minute.
          */
         get: operations["listPublicCoinApps"];
         put?: never;
@@ -64,7 +66,8 @@ export interface paths {
          *     smallest unit as a decimal string, and `holds` (whether it is above zero). Use it to re-check a
          *     holding after someone signed in to your site with Chain Daddy, without an API key. Works for any
          *     token on a chain Chain Daddy serves. Each caller gets 60 requests a minute; past that it
-         *     answers 429. Cached for about 30 seconds.
+         *     answers 429. Cached for about 30 seconds. All callers together share a limit on chain reads:
+         *     in a busy moment it answers 503 with `Retry-After`.
          */
         get: operations["getPublicHolding"];
         put?: never;
@@ -86,10 +89,11 @@ export interface paths {
          * List a registration's verified sites
          * @description The websites a coin's registration has verified with a DNS record. `badgeHosts` show the coin's
          *     verified badge on the Chain Daddy sign-in page. `embedHosts` may also run the coin's apps and take
-         *     its checkout. A host covers its subdomains. `interactive` is `false` when there are no
+         *     its checkout. A host covers its subdomains, except one Chain Daddy has blocked. `interactive` is `false` when there are no
          *     `embedHosts` or Chain Daddy has turned the coin's embeds off. A registration with no verified
-         *     sites answers 200 with empty lists. Keyless, the same for every caller, and cached for about a
-         *     minute.
+         *     sites answers 200 with empty lists. Only the registration a verified coin page shows answers
+         *     (the `crownId` the coin read gives); any other ID answers 404. Keyless, the same for every
+         *     caller, and cached for about a minute.
          */
         get: operations["getPublicCrownSites"];
         put?: never;
@@ -100,6 +104,30 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v2/iap/config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Store configuration
+         * @description How creator stores work right now: whether they are switched on, the chains a store can run
+         *     on, what an item on each chain can be priced in besides the store's own token (the chain's
+         *     coin, a dollar stablecoin), and where the receipt signing keys are published. It also says
+         *     whether test stores are available here (`testMode`) and whether checkout sessions are
+         *     (`checkoutSessions`, with the limits on how long one may stay open).
+         */
+        get: operations["getIapConfig"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v2/iap/jwks": {
         parameters: {
             query?: never;
@@ -136,6 +164,10 @@ export interface paths {
          *     amount paid, when) with its current status. A refunded order's receipt reads `revoked`: offline
          *     verification proves a receipt was issued, this proves it still stands. The receipt is the compact JWS
          *     exactly as issued (three base64url parts joined by dots).
+         *
+         *     The answer is `200` whatever the receipt is. Act on `valid`, which is true only for status `valid`.
+         *     A string that is not a receipt Chain Daddy signed (a bad signature, a changed payload, an unknown
+         *     key, not a JWS at all) answers `{"valid": false, "status": "invalid", "error": "…"}` with no `payload`.
          */
         post: operations["verifyIapReceipt"];
         delete?: never;
@@ -164,6 +196,43 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v2/iap/stores/{storeId}/test-store": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The store's ID (a UUID) */
+                storeId: components["parameters"]["IapStoreId"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Get a store's test store
+         * @description The test store that stands beside a live store: the same coin page and payout, its own
+         *     catalog, keys, orders and webhook, and `mode: test`. Its orders are paid with
+         *     `POST /api/v2/iap/orders/{orderId}/test-pay`; nothing is sent on chain and no fee is taken. Pass the
+         *     live store's id (a test store's own id returns that test store). Your account credentials, as a wallet
+         *     that manages the coin's page; a store key is refused (403 `SESSION_REQUIRED`).
+         *     Guide: https://docs.chaindaddy.io/developer/test-your-integration#test-store
+         */
+        get: operations["getIapTestStore"];
+        put?: never;
+        /**
+         * Create a store's test store
+         * @description Creates the live store's test store with a copy of its catalog as it is now, drafts included and
+         *     nothing sold (201), or returns the one it already has (200). Safe to call again. From then on the
+         *     two catalogs are separate. Make its keys with `POST /api/v2/iap/stores/{storeId}/keys` on the test
+         *     store's id: they start with `cd_iap_test_` and work only on it. It takes no body. Your account
+         *     credentials, as a wallet that manages the coin's page and has the plan a store needs.
+         *     Guide: https://docs.chaindaddy.io/developer/test-your-integration#test-store
+         */
+        post: operations["openIapTestStore"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v2/iap/stores/{storeId}/skus": {
         parameters: {
             query?: never;
@@ -711,9 +780,8 @@ export interface paths {
          *     (200, secret unchanged; also turns back on a webhook turned off after repeated failures). Events default
          *     to every `iap.*` type there is at the time of the save (a type added later needs another save); names
          *     may omit the `iap.` prefix. The URL must be https and must not resolve to a
-         *     private address. Needs the store's own plan (a Developer plan or developer program membership), not
-         *     the Developer plan the general `/api/v2/webhooks` routes need. Account credentials, or a store key
-         *     with `webhooks:write`.
+         *     private address. Needs only the plan the store itself needs (any paid plan), not the Developer plan the
+         *     general `/api/v2/webhooks` routes need. Account credentials, or a store key with `webhooks:write`.
          */
         put: operations["setIapStoreWebhook"];
         post?: never;
@@ -833,6 +901,12 @@ export interface paths {
          *     A buyer paying a checkout session sends `checkoutSessionId` from their own session on chaindaddy.io. The
          *     session then fixes the store, the SKU, the quantity and `appAccountToken`, so `storeId` and `sku` may be
          *     left out. The amount and the fee are quoted exactly as for any other order of that item.
+         *
+         *     When the session's item belongs to an installed app, the order is that app's order: it pays the page, the
+         *     fee and the app's developer, needs `acknowledgeFinalSale: true`, and stays inside the app's limits. The app
+         *     is the item's own; an `appId` sent with a session is ignored. Everything is checked again when the order is
+         *     made, so a session opened while the item could be sold answers 409 `APP_ITEM_NOT_SOLD_HERE` once its
+         *     developer turns that off, pauses, or changes the item's terms.
          */
         post: operations["createIapOrder"];
         delete?: never;
@@ -864,6 +938,36 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v2/iap/orders/{orderId}/test-pay": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description `0x` followed by 64 hex characters */
+                orderId: components["parameters"]["IapOrderId"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pay a test order
+         * @description Pays a pending order of a test store with a simulated payment and confirms it at once: the items
+         *     are granted, the receipt is signed and `order.confirmed` is written, exactly as for a real payment.
+         *     No chain is read or written and no money moves. Where a transaction hash would be, the order carries
+         *     `test:` and an id. Calling it again on a confirmed order returns that order and changes nothing.
+         *
+         *     Call it with a key of the order's test store (`cd_iap_test_…`, scope `orders:write`), or signed in as
+         *     a wallet that manages the coin's page. It takes no body. A live store's order is only ever paid on
+         *     chain (409 `LIVE_ORDER`). Guide: https://docs.chaindaddy.io/developer/test-your-integration#test-store
+         */
+        post: operations["testPayIapOrder"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v2/iap/checkout/sessions": {
         parameters: {
             query?: never;
@@ -884,8 +988,12 @@ export interface paths {
          *
          *     `successUrl` and `cancelUrl` must be `https` pages on one of the coin's verified sites, or a subdomain of
          *     one (400 `RETURN_URL_NOT_VERIFIED`, which lists the sites that pass). The wallet that opened the store
-         *     must have signed the Seller Terms (403 `SELLER_TERMS_REQUIRED`). An item that belongs to an installed app
-         *     cannot be sold through a session (409 `SKU_NOT_FOR_SALE`).
+         *     must have signed the Seller Terms (403 `SELLER_TERMS_REQUIRED`).
+         *
+         *     An item of an app installed on the coin's page (its `sku` starts with `app.`) is sold through a session
+         *     only when the app's developer has allowed that item to be sold outside the app; otherwise the call answers
+         *     409 `APP_ITEM_NOT_SOLD_HERE`, with a `reason`. The sale pays the same wallets as inside the app: the page,
+         *     the fee and the developer's share. Such a session takes at most the app's per-order quantity.
          *
          *     Send an `Idempotency-Key`. A retry of the same request returns the session it opened, with status 200
          *     and the header `Idempotent-Replayed: true`.
@@ -946,6 +1054,10 @@ export interface paths {
          *     needs no credential (the session id in the buyer's link is enough) and never carries the session's
          *     `metadata` or `clientReferenceId`. The answer is never cached.
          *
+         *     When the item belongs to an app installed on the coin's page, `sku` names the app (`appId`) and carries
+         *     nothing else of the app's: no `appBps`, `appTermsVersion`, `appItemKey` or `appRole`, and an empty
+         *     `metadata`.
+         *
          *     Pass `origin` to learn whether a page on that origin may open this checkout in a popup
          *     (`openerAllowed`): it must be `https` on one of the coin's verified sites.
          *
@@ -1019,7 +1131,8 @@ export interface paths {
          * List the event types a webhook can subscribe to
          * @description Returns every subscribable event type with a one-line description: registration, heartbeat, holder, trade
          *     and alert events, API quota events, deal lifecycle events (`deal.created`, `deal.accepted`,
-         *     `deal.rejected`, `deal.cancelled`, `deal.completed`, `deal.failed`) and creator-store events (`iap.*`).
+         *     `deal.rejected`, `deal.cancelled`, `deal.completed`, `deal.failed`), creator-store events (`iap.*`) and
+         *     `app.order.confirmed`, which tells a paid app's developer of each confirmed order made through the app.
          *     This list is exactly what create and update accept. Read it before creating a webhook rather than
          *     guessing names: a misspelled type is refused with 400.
          *
@@ -1343,6 +1456,18 @@ export interface components {
             error: string;
             /** @description Machine-readable error code (e.g. `IAP_PLAN_REQUIRED`, `INSUFFICIENT_QUANTITY`) */
             code?: string;
+            /**
+             * @description Which of a code's causes this is, where a code has several. Sent with `APP_NOT_SELLING`:
+             *     `app_not_published`, `selling_switched_off` (stopped by Chain Daddy), `developer_paused`
+             *     (paused by the app's developer), `developer_unavailable` (the developer cannot sell right
+             *     now; why is between them and Chain Daddy, and their own portal tells them), `no_payout_on_chain`
+             *     or `payout_contract_missing` (the developer is not paid on this chain). Sent with
+             *     `APP_ITEM_NOT_SOLD_HERE` (an app's item and a checkout session): any of those, or
+             *     `not_allowed_outside_app` (the app's developer has not allowed the item to be sold outside the app),
+             *     `app_not_installed`, `terms_changed` or `item_not_for_sale`. Absent on every other error. Expect new
+             *     values.
+             */
+            reason?: string;
         };
         /** @description One token prize. Amounts are base units, as strings. */
         IapAirdropAward: {
@@ -1416,6 +1541,112 @@ export interface components {
             award?: components["schemas"]["IapAirdropAward"];
             campaign?: components["schemas"]["IapAwardAirdrop"];
         };
+        IapChain: {
+            /**
+             * @description CAIP-2 chain id
+             * @example eip155:8453
+             */
+            chainId?: string;
+            /** @example base */
+            chainKey?: string;
+            /**
+             * @description The checkout contract an order with a fee is paid through. Absent on Solana. A hint only: the
+             *     contract to pay is always the one in the order's own `payment` block.
+             */
+            checkout?: string;
+            /**
+             * @description The checkout contract an order with no fee is paid through (a store whose `feeBps` is 0). Absent on
+             *     Solana and where the chain has none. A hint only, like `checkout`.
+             */
+            checkoutNoFee?: string;
+            /** @description Confirmations an order waits for before it is `confirmed` */
+            confirmations?: number;
+            /**
+             * @description What a SKU on this chain may be paid in besides the store's own token (always allowed, and the
+             *     default): the chain's coin and, where the chain has one, its dollar stable.
+             */
+            currencies?: components["schemas"]["IapCurrency"][];
+        };
+        IapCurrency: {
+            /** @enum {string} */
+            currency?: "native" | "usdc";
+            /**
+             * @description The zero address for an EVM chain's coin, `11111111111111111111111111111111` for SOL, otherwise
+             *     the stable's contract or mint
+             */
+            address?: string;
+            /** @example USDC */
+            symbol?: string;
+            /** @example 6 */
+            decimals?: number;
+        };
+        IapConfig: {
+            enabled?: boolean;
+            /**
+             * @description Whether test stores are available here: a store's test store, its `cd_iap_test_` keys, and paying a
+             *     test order with no money
+             */
+            testMode?: boolean;
+            chains?: components["schemas"]["IapChain"][];
+            /** @description The read-only account every Solana store payment references */
+            solanaStaticKey?: string;
+            /** @example https://api.chaindaddy.io/api/v2/iap/jwks */
+            jwksUrl?: string;
+            /**
+             * @description The limits on what an app can make a buyer pay (paid apps). Chain Daddy may change them at any time.
+             *     Amounts are in millionths of a dollar.
+             */
+            paidApps?: {
+                /**
+                 * Format: int64
+                 * @description The most one purchase through an app may cost; an app item priced above it cannot be saved
+                 * @example 250000000
+                 */
+                maxOrderUsdMicros?: number;
+                /**
+                 * Format: int64
+                 * @description The most one buyer wallet may pay one app in any 24 hours
+                 * @example 1000000000
+                 */
+                walletAppDayUsdMicros?: number;
+                /**
+                 * Format: int64
+                 * @description Above this, the purchase sheet asks the buyer to press and hold
+                 * @example 50000000
+                 */
+                confirmAboveUsdMicros?: number;
+                /**
+                 * @description The most units in one order through an app
+                 * @example 10
+                 */
+                maxQuantity?: number;
+                /**
+                 * @description The most orders one buyer wallet may open through one app in a minute
+                 * @example 5
+                 */
+                ordersPerMinute?: number;
+            };
+            /** @description Present only where checkout sessions are switched on */
+            checkoutSessions?: {
+                /** @description When true, only a test store's key can open a checkout session here */
+                testOnly?: boolean;
+                /**
+                 * @description The least `expiresInSeconds` a session may ask for
+                 * @example 900
+                 */
+                minExpiresInSeconds?: number;
+                /**
+                 * @description The most `expiresInSeconds` a session may ask for
+                 * @example 86400
+                 */
+                maxExpiresInSeconds?: number;
+                /**
+                 * @description How long a session stays open when it does not say
+                 * @example 3600
+                 */
+                defaultExpiresInSeconds?: number;
+            };
+        };
         IapStore: {
             /** Format: uuid */
             id?: string;
@@ -1453,6 +1684,12 @@ export interface components {
              *     for its own items; items from apps installed on the page keep selling.
              */
             live?: boolean;
+            /**
+             * @description `test` for a test store: its orders are paid by the test-pay call instead of a wallet, nothing is sent
+             *     on chain and no fee is taken. Unrelated to `live` above.
+             * @enum {string}
+             */
+            mode?: "live" | "test";
             /** Format: date-time */
             createdAt?: string;
             /**
@@ -1857,13 +2094,24 @@ export interface components {
             refundedAt?: string | null;
             /** @description Signed receipt (JWS) once confirmed */
             receipt?: string | null;
-            /** @description Present while pending; how to pay */
-            payment?: components["schemas"]["IapEvmPayment"] | components["schemas"]["IapSolanaPayment"];
+            /**
+             * @description Present while pending; how to pay. A test store's order carries `{"kind": "test"}`: nothing is signed,
+             *     and it is paid with `POST /api/v2/iap/orders/{orderId}/test-pay`.
+             */
+            payment?: components["schemas"]["IapEvmPayment"] | components["schemas"]["IapSolanaPayment"] | components["schemas"]["IapTestPayment"];
             /** @description How to check this order's payment on chain without trusting the API. EVM: call hashOrder(order) on `checkout`, then paidBy(hash) at a block `confirmations` deep; `checkout` is the contract the order was (or will be) paid through, which hashOrder is bound to. Solana: find the transfer by its `reference` key and `memo`. Absent on test orders, and on EVM orders paid before the contract was recorded. */
             verification?: components["schemas"]["IapEvmVerification"] | components["schemas"]["IapSolanaVerification"];
             /** Format: date-time */
             createdAt?: string;
         };
+        /** @description The payment block of a test store's pending order. There is nothing to sign or send */
+        IapTestPayment: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            kind: "test";
+        };
         IapEvmVerification: {
             /**
              * @description discriminator enum property added by openapi-typescript
@@ -2119,12 +2367,18 @@ export interface components {
             deliveredAt?: string | null;
         };
         IapReceiptVerification: {
+            /** @description True only when `status` is `valid`. Deliver on this */
+            valid?: boolean;
             /**
-             * @description `revoked` once the order is refunded
+             * @description `valid`: the receipt is ours and its order stands. `revoked`: a refund was recorded since.
+             *     `invalid`: not a receipt Chain Daddy signed; `error` says why and there is no `payload`.
+             *     `unknown`: the signature is ours, but this API has no record of the receipt.
              * @enum {string}
              */
-            status?: "valid" | "revoked";
-            /** @description The receipt's decoded claims */
+            status?: "valid" | "revoked" | "invalid" | "unknown";
+            /** @description Why the receipt is `invalid`. Absent otherwise */
+            error?: string;
+            /** @description The receipt's decoded claims. Absent when `status` is `invalid` */
             payload?: {
                 /** @example https://chaindaddy.io */
                 iss?: string;
@@ -2460,8 +2714,8 @@ export interface components {
             iat: number;
             /** @description Five minutes after `iat` */
             exp: number;
-            /** @description When the Chain Daddy session this sign-in rides on began */
-            auth_time: number;
+            /** @description When the Chain Daddy session this sign-in rides on began. Only for a client whose `sub` is the wallet; a client with a per-site `sub` gets none, because the same value at every site would link its ids */
+            auth_time?: number;
             /** @description Your `nonce`, when you sent one */
             nonce?: string;
             jti: string;
@@ -2533,8 +2787,9 @@ export interface components {
         };
         /**
          * @description Not allowed. `IAP_PLAN_REQUIRED` when the wallet (for a store key, the wallet that opened the store)
-         *     has neither a Developer plan nor Developer Beta program membership in good standing. Otherwise the
-         *     caller does not manage this token page, or the store key lacks the scope.
+         *     cannot run a store. That takes any paid plan with the Seller Terms signed, or Developer Beta Program
+         *     membership in good standing. Otherwise the caller does not manage this token page, or the store key
+         *     lacks the scope.
          */
         IapForbidden: {
             headers: {
@@ -2543,13 +2798,28 @@ export interface components {
             content: {
                 /**
                  * @example {
-                 *       "error": "a Developer plan is required to run a store",
+                 *       "error": "running a store needs a paid plan or Developer Beta Program membership (the Developer plan is in beta and free while it is): https://chaindaddy.io/_developer",
                  *       "code": "IAP_PLAN_REQUIRED"
                  *     }
                  */
                 "application/json": components["schemas"]["IapError"];
             };
         };
+        /** @description No wallet session */
+        IapUnauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "error": "sign in first",
+                 *       "code": "UNAUTHORIZED"
+                 *     }
+                 */
+                "application/json": components["schemas"]["IapError"];
+            };
+        };
         /** @description `AIRDROPS_DISABLED` or `IAP_DISABLED`: the feature is switched off */
         IapAirdropsUnavailable: {
             headers: {
@@ -2665,6 +2935,12 @@ export interface components {
          *     and never sells, grants or consumes twice.
          */
         IdempotencyKey: string;
+        /**
+         * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+         *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+         *     and the same request returns the first result and never sells, grants or consumes twice.
+         */
+        IdempotencyKeyRequired: string;
         /** @description The store's ID (a UUID) */
         IapStoreId: string;
         /** @description The SKU key, e.g. `badge.gold` */
@@ -2740,7 +3016,7 @@ export interface operations {
                         /** @description The registration's ID on that chain */
                         crownId: number;
                         tokenAddress: string;
-                        /** @description The page's logo; `null` when it has none or the page is marked NSFW */
+                        /** @description The page's logo; `null` when it has none, the page is marked NSFW, or Chain Daddy removed the image */
                         logoUrl: string | null;
                         /** @description Whether the page carries the NSFW label */
                         nsfw: boolean;
@@ -2758,6 +3034,21 @@ export interface operations {
                     };
                 };
             };
+            /** @description The request came with the user agent of an AI or LLM crawler, and no cached answer was there to serve instead. Never sent to a browser or to a server using its own user agent. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "ai_bot_blocked",
+                     *       "message": "AI/LLM scraping is not permitted. Use our API with a developer-tier API key for programmatic access."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description No verified page for that ticker on that chain, or an unknown chain */
             404: {
                 headers: {
@@ -2774,6 +3065,24 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description More than 400 requests in a minute from one IP address, across the whole API. Never cached. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before trying again */
+                    "Retry-After"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Too many requests. Please try again later.",
+                     *       "code": "rate_limit_exceeded",
+                     *       "message": "Too many requests. Please try again later."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description The read could not be answered right now. Never cached; try again. */
             503: {
                 headers: {
@@ -2852,6 +3161,21 @@ export interface operations {
                     };
                 };
             };
+            /** @description The request came with the user agent of an AI or LLM crawler, and no cached answer was there to serve instead. Never sent to a browser or to a server using its own user agent. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "ai_bot_blocked",
+                     *       "message": "AI/LLM scraping is not permitted. Use our API with a developer-tier API key for programmatic access."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description No verified page for that ticker on that chain, or an unknown chain */
             404: {
                 headers: {
@@ -2868,6 +3192,24 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description More than 400 requests in a minute from one IP address, across the whole API. Never cached. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before trying again */
+                    "Retry-After"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Too many requests. Please try again later.",
+                     *       "code": "rate_limit_exceeded",
+                     *       "message": "Too many requests. Please try again later."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description The read could not be answered right now. Never cached; try again. */
             503: {
                 headers: {
@@ -2932,6 +3274,21 @@ export interface operations {
                     };
                 };
             };
+            /** @description The request came with the user agent of an AI or LLM crawler, and no cached answer was there to serve instead. Never sent to a browser or to a server using its own user agent. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "ai_bot_blocked",
+                     *       "message": "AI/LLM scraping is not permitted. Use our API with a developer-tier API key for programmatic access."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description An unknown chain, or an address that is not one on that chain */
             404: {
                 headers: {
@@ -2966,9 +3323,15 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The read could not be answered right now. Never cached; try again. */
+            /**
+             * @description The read could not be answered right now. Never cached; try again. It never means the wallet
+             *     holds nothing. In a busy moment, when Chain Daddy is making as many chain reads as it allows,
+             *     it carries `Retry-After`.
+             */
             503: {
                 headers: {
+                    /** @description Seconds to wait before trying again. Sent only in a busy moment */
+                    "Retry-After"?: number;
                     [name: string]: unknown;
                 };
                 content: {
@@ -3023,7 +3386,7 @@ export interface operations {
                         chain: string;
                         chainId: string;
                         crownId: number;
-                        /** @description The coin's ticker; empty when the registration could not be read */
+                        /** @description The coin's ticker */
                         symbol: string;
                         badgeHosts: string[];
                         embedHosts: string[];
@@ -3031,7 +3394,22 @@ export interface operations {
                     };
                 };
             };
-            /** @description An unknown chain, or an ID that is not a positive whole number */
+            /** @description The request came with the user agent of an AI or LLM crawler, and no cached answer was there to serve instead. Never sent to a browser or to a server using its own user agent. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "ai_bot_blocked",
+                     *       "message": "AI/LLM scraping is not permitted. Use our API with a developer-tier API key for programmatic access."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description An unknown chain, an ID that is not a positive whole number, or a registration that is not a verified coin page's */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -3047,6 +3425,24 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description More than 400 requests in a minute from one IP address, across the whole API. Never cached. */
+            429: {
+                headers: {
+                    /** @description Seconds to wait before trying again */
+                    "Retry-After"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "Too many requests. Please try again later.",
+                     *       "code": "rate_limit_exceeded",
+                     *       "message": "Too many requests. Please try again later."
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description The read could not be answered right now. Never cached; try again. */
             503: {
                 headers: {
@@ -3065,6 +3461,26 @@ export interface operations {
             };
         };
     };
+    getIapConfig: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Configuration */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapConfig"];
+                };
+            };
+        };
+    };
     getIapJwks: {
         parameters: {
             query?: never;
@@ -3121,7 +3537,7 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Verified receipt */
+            /** @description The check's answer, also for a receipt that is not valid (read `valid` and `status`) */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -3158,6 +3574,89 @@ export interface operations {
             404: components["responses"]["IapNotFound"];
         };
     };
+    getIapTestStore: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The store's ID (a UUID) */
+                storeId: components["parameters"]["IapStoreId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The test store */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapStore"];
+                };
+            };
+            401: components["responses"]["IapUnauthorized"];
+            403: components["responses"]["IapForbidden"];
+            /**
+             * @description `NOT_FOUND`: no such store, or it has no test store yet (POST here to create it).
+             *     `TEST_MODE_DISABLED`: test stores are not available here (`testMode` in `GET /api/v2/iap/config`).
+             */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapError"];
+                };
+            };
+        };
+    };
+    openIapTestStore: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The store's ID (a UUID) */
+                storeId: components["parameters"]["IapStoreId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The test store the live store already had */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapStore"];
+                };
+            };
+            /** @description The test store, just created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapStore"];
+                };
+            };
+            401: components["responses"]["IapUnauthorized"];
+            403: components["responses"]["IapForbidden"];
+            /**
+             * @description `NOT_FOUND`: no such store. `TEST_MODE_DISABLED`: test stores are not available here (`testMode` in
+             *     `GET /api/v2/iap/config`).
+             */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapError"];
+                };
+            };
+        };
+    };
     listIapSkus: {
         parameters: {
             query?: never;
@@ -3427,12 +3926,13 @@ export interface operations {
     grantIapItems: {
         parameters: {
             query?: never;
-            header?: {
+            header: {
                 /**
-                 * @description Send a unique value (a UUID) with every POST. Retrying with the same key returns the first result
-                 *     and never sells, grants or consumes twice.
+                 * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+                 *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+                 *     and the same request returns the first result and never sells, grants or consumes twice.
                  */
-                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                "Idempotency-Key": components["parameters"]["IdempotencyKeyRequired"];
             };
             path: {
                 /** @description The store's ID (a UUID) */
@@ -3467,12 +3967,13 @@ export interface operations {
     consumeIapItems: {
         parameters: {
             query?: never;
-            header?: {
+            header: {
                 /**
-                 * @description Send a unique value (a UUID) with every POST. Retrying with the same key returns the first result
-                 *     and never sells, grants or consumes twice.
+                 * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+                 *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+                 *     and the same request returns the first result and never sells, grants or consumes twice.
                  */
-                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                "Idempotency-Key": components["parameters"]["IdempotencyKeyRequired"];
             };
             path: {
                 /** @description The store's ID (a UUID) */
@@ -3790,12 +4291,13 @@ export interface operations {
     awardIapDrop: {
         parameters: {
             query?: never;
-            header?: {
+            header: {
                 /**
-                 * @description Send a unique value (a UUID) with every POST. Retrying with the same key returns the first result
-                 *     and never sells, grants or consumes twice.
+                 * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+                 *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+                 *     and the same request returns the first result and never sells, grants or consumes twice.
                  */
-                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                "Idempotency-Key": components["parameters"]["IdempotencyKeyRequired"];
             };
             path: {
                 /** @description The store's ID (a UUID) */
@@ -4347,12 +4849,13 @@ export interface operations {
     createIapOrder: {
         parameters: {
             query?: never;
-            header?: {
+            header: {
                 /**
-                 * @description Send a unique value (a UUID) with every POST. Retrying with the same key returns the first result
-                 *     and never sells, grants or consumes twice.
+                 * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+                 *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+                 *     and the same request returns the first result and never sells, grants or consumes twice.
                  */
-                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                "Idempotency-Key": components["parameters"]["IdempotencyKeyRequired"];
             };
             path?: never;
             cookie?: never;
@@ -4412,7 +4915,8 @@ export interface operations {
              * @description Sold out, or the wallet has reached the SKU's per-wallet limit. For an app's item: `APP_TERMS_CHANGED`
              *     (its developer changed its terms and the page's owner has not accepted them yet), `APP_NOT_INSTALLED`,
              *     `APP_NOT_SELLING`, `APP_ORDER_LIMIT` (above the per-purchase limit) or `APP_DAILY_LIMIT` (the wallet
-             *     reached what it may pay that app in 24 hours)
+             *     reached what it may pay that app in 24 hours). For an app's item paid through a checkout session:
+             *     `APP_ITEM_NOT_SOLD_HERE`, with a `reason`
              */
             409: {
                 headers: {
@@ -4484,15 +4988,79 @@ export interface operations {
             404: components["responses"]["IapNotFound"];
         };
     };
+    testPayIapOrder: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description `0x` followed by 64 hex characters */
+                orderId: components["parameters"]["IapOrderId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The order, confirmed, with its receipt */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapOrder"];
+                };
+            };
+            /** @description No credential, or a store key that is unknown or revoked (`INVALID_STORE_KEY`) */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapError"];
+                };
+            };
+            403: components["responses"]["IapForbidden"];
+            /**
+             * @description `NOT_FOUND`: no such order, or it is not an order of the caller's store or coin page.
+             *     `TEST_MODE_DISABLED`: test stores are not available here (`testMode` in `GET /api/v2/iap/config`).
+             */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["IapError"];
+                };
+            };
+            /**
+             * @description `LIVE_ORDER`: the order belongs to a live store. `ORDER_EXPIRED`: the order's deadline has passed;
+             *     create a new one.
+             */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "error": "this is a live order: it is paid on chain, and test-pay pays test orders only",
+                     *       "code": "LIVE_ORDER"
+                     *     }
+                     */
+                    "application/json": components["schemas"]["IapError"];
+                };
+            };
+        };
+    };
     createIapCheckoutSession: {
         parameters: {
             query?: never;
-            header?: {
+            header: {
                 /**
-                 * @description Send a unique value (a UUID) with every POST. Retrying with the same key returns the first result
-                 *     and never sells, grants or consumes twice.
+                 * @description Required: a call without it answers 400 `IDEMPOTENCY_KEY_REQUIRED`. Send one value per attempt (a UUID,
+                 *     or an id of your own such as `cart-8842-attempt-1`), up to 255 characters. Retrying with the same key
+                 *     and the same request returns the first result and never sells, grants or consumes twice.
                  */
-                "Idempotency-Key"?: components["parameters"]["IdempotencyKey"];
+                "Idempotency-Key": components["parameters"]["IdempotencyKeyRequired"];
             };
             path?: never;
             cookie?: never;
@@ -4599,7 +5167,13 @@ export interface operations {
                     "application/json": components["schemas"]["IapError"];
                 };
             };
-            /** @description `SKU_NOT_FOR_SALE`: the item is archived, has no price, is an unlock, or belongs to an installed app */
+            /**
+             * @description `SKU_NOT_FOR_SALE`: the item is archived, has no price or is an unlock. `APP_ITEM_NOT_SOLD_HERE`: the
+             *     item belongs to an app installed on the coin's page and cannot be sold from the coin's own site now.
+             *     `reason` says why: `not_allowed_outside_app` (the app's developer has not turned it on for this item),
+             *     `app_not_installed`, `terms_changed` (the coin's owner must accept the app's new terms on the coin's
+             *     page), `item_not_for_sale` (the app no longer sells it), or one of the `APP_NOT_SELLING` reasons
+             */
             409: {
                 headers: {
                     [name: string]: unknown;