@b3dotfun/sdk 0.1.68 → 0.1.69-alpha.0

package/dist/types/anyspend/react/hooks/useKycStatus.d.ts

@@ -0,0 +1,47 @@
+export interface KycStatusResponse {
+    kycRequired: boolean;
+    status: "not_verified" | "pending" | "completed" | "approved" | "declined" | "needs_review" | "expired";
+    inquiry?: {
+        inquiryId: string;
+        sessionToken: string;
+    };
+    config?: {
+        templateId: string;
+        environment: string;
+    };
+}
+interface KycInquiryResponse {
+    inquiryId: string;
+    sessionToken: string;
+}
+interface KycVerifyResponse {
+    status: string;
+}
+/**
+ * Returns cached wallet auth headers without triggering a wallet signature prompt.
+ * Returns undefined if no valid cache exists for the given address.
+ */
+export declare function getCachedWalletHeaders(address: string): Record<string, string> | undefined;
+/**
+ * Returns a function that builds the wallet-signature auth headers.
+ * Caches signatures for 4 minutes (server allows 5-minute window).
+ */
+export declare function useWalletAuthHeaders(): {
+    address: `0x${string}` | undefined;
+    getHeaders: () => Promise<Record<string, string>>;
+};
+export declare function useKycStatus(enabled?: boolean): {
+    kycStatus: KycStatusResponse | null;
+    isLoadingKycStatus: boolean;
+    kycStatusError: Error | null;
+    refetchKycStatus: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<KycStatusResponse, Error>>;
+};
+export declare function useCreateKycInquiry(): {
+    createInquiry: import("@tanstack/react-query").UseMutateAsyncFunction<KycInquiryResponse, Error, void, unknown>;
+    isCreatingInquiry: boolean;
+};
+export declare function useVerifyKyc(): {
+    verifyKyc: import("@tanstack/react-query").UseMutateAsyncFunction<KycVerifyResponse, Error, string, unknown>;
+    isVerifying: boolean;
+};
+export {};

package/dist/types/anyspend/services/anyspend.d.ts

@@ -6,7 +6,7 @@ export declare const anyspendService: {
     getTokenList: (chainId: number, query: string) => Promise<components["schemas"]["Token"][]>;
     getToken: (chainId: number, tokenAddress: string) => Promise<components["schemas"]["Token"]>;
     getQuote: (req: GetQuoteRequest, partnerId?: string) => Promise<GetQuoteResponse>;
-    createOrder: ({ recipientAddress, type, srcChain, dstChain, srcTokenAddress, dstTokenAddress, srcAmount, payload, onramp, metadata, creatorAddress, partnerId, clientReferenceId, visitorData, callbackMetadata, }: {
+    createOrder: ({ recipientAddress, type, srcChain, dstChain, srcTokenAddress, dstTokenAddress, srcAmount, payload, onramp, metadata, creatorAddress, partnerId, clientReferenceId, visitorData, callbackMetadata, feeOnTop, kycWalletHeaders, }: {
         recipientAddress: string;
         type: string;
         srcChain: number;
@@ -22,6 +22,9 @@ export declare const anyspendService: {
         clientReferenceId?: string;
         visitorData?: VisitorData;
         callbackMetadata?: Record<string, unknown>;
+        feeOnTop?: boolean;
+        /** Wallet signature auth headers for KYC lookup (stripe-web2 orders only). */
+        kycWalletHeaders?: Record<string, string>;
     }) => Promise<{
         success: boolean;
         message: string;

package/dist/types/global-account/react/components/SignInWithB3/steps/LoginStep.d.ts

@@ -19,5 +19,5 @@ interface LoginStepContainerProps {
     partnerId?: string;
 }
 export declare function LoginStepContainer({ children, partnerId }: LoginStepContainerProps): import("react/jsx-runtime").JSX.Element;
-export declare function LoginStep({ onSuccess, chain }: LoginStepProps): import("react/jsx-runtime").JSX.Element;
+export declare function LoginStep({ onSuccess, chain }: LoginStepProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/types/global-account/react/hooks/useAuthentication.d.ts

@@ -1,6 +1,8 @@
 import { Wallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
-export declare function useAuthentication(partnerId: string): {
+export declare function useAuthentication(partnerId: string, { skipAutoConnect }?: {
+    skipAutoConnect?: boolean;
+}): {
     logout: (callback?: () => void) => Promise<void>;
     isAuthenticated: boolean;
     isReady: boolean;

package/dist/types/global-account/react/stores/useModalStore.d.ts

@@ -657,6 +657,10 @@ interface ModalState {
     setLinkingState: (isLinking: boolean, method?: string | null) => void;
     /** Function to update closable property of current content without adding to history */
     setClosable: (closable: boolean) => void;
+    /** Whether a third-party iframe (e.g. Persona KYC) is currently active over the modal */
+    personaActive: boolean;
+    /** Function to mark a third-party iframe as active/inactive */
+    setPersonaActive: (active: boolean) => void;
 }
 /**
  * Zustand store for managing modal state

package/dist/types/global-account/react/utils/createWagmiConfig.d.ts

@@ -25,3 +25,21 @@ export declare function createWagmiConfig(options: CreateWagmiConfigOptions): im
 }, {
     "thirdweb:lastChainId": number;
 }>)[]>;
+/**
+ * Returns a cached wagmi config for the given partnerId.
+ * Use this instead of calling createWagmiConfig() directly inside React components or hooks
+ * to avoid registering duplicate EventEmitter listeners on every render.
+ */
+export declare function getCachedWagmiConfig(options: CreateWagmiConfigOptions): import("wagmi").Config<readonly [import("viem").Chain, ...import("viem").Chain[]], {
+    [k: string]: import("viem").HttpTransport<undefined, false>;
+}, (CreateConnectorFn | CreateConnectorFn<import("thirdweb/dist/types/adapters/eip1193").EIP1193Provider | undefined, {
+    connect<withCapabilities extends boolean = false>(parameters?: import("@thirdweb-dev/wagmi-adapter").ConnectionOptions<withCapabilities> | undefined): Promise<{
+        accounts: withCapabilities extends true ? readonly {
+            address: `0x${string}`;
+            capabilities: Record<string, unknown>;
+        }[] : readonly `0x${string}`[];
+        chainId: number;
+    }>;
+}, {
+    "thirdweb:lastChainId": number;
+}>)[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.1.68",
+  "version": "0.1.69-alpha.0",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",
@@ -55,6 +55,11 @@
       "import": "./dist/esm/anyspend/constants.js",
       "require": "./dist/cjs/anyspend/constants.js"
     },
+    "./anyspend/platform": {
+      "types": "./dist/types/anyspend/platform/index.d.ts",
+      "import": "./dist/esm/anyspend/platform/index.js",
+      "require": "./dist/cjs/anyspend/platform/index.js"
+    },
     "./anyspend/services/*": {
       "types": "./dist/types/anyspend/services/*.d.ts",
       "import": "./dist/esm/anyspend/services/*.js",
@@ -324,6 +329,7 @@
     "js-cookie": "3.0.5",
     "lucide-react": "0.424.0",
     "motion": "^12.23.11",
+    "persona": "^5.7.0",
     "qrcode.react": "4.2.0",
     "react-easy-crop": "^5.5.3",
     "react-intersection-observer": "9.16.0",

package/src/anyspend/docs/checkout-sessions.md

@@ -29,7 +29,7 @@ Session creation is instant (DB-only, no external calls). The order is created s
 ## Session Status Lifecycle
 
 ```
-open --> processing --> complete
+open --> processing --> complete (verified)
   |
   └--> expired
 ```
@@ -37,10 +37,27 @@ open --> processing --> complete
 | Status | When |
 |--------|------|
 | `open` | Created, waiting for order/payment |
-| `processing` | Payment received, order executing |
-| `complete` | Order executed successfully |
+| `processing` | Client reported payment, waiting for server-side verification |
+| `complete` | Order verified on-chain by the anyspend-service callback |
 | `expired` | TTL expired, payment failed, or manually expired |
 
+## Server-Side Payment Verification
+
+Checkout sessions use server-side verification to prevent spoofed completions. The client `/complete` endpoint only transitions a session to `processing` — it does **not** trigger side effects (webhooks, customer creation, discount usage, etc.).
+
+The anyspend-service verifies the payment on-chain and sends a callback to the platform's internal endpoint, which finalizes the session to `complete` and runs all side effects. This ensures that webhooks and merchant integrations are only triggered by verified payments.
+
+```
+Client calls /complete  -->  session: "processing"
+                                  |
+anyspend-service verifies  -->  internal callback  -->  session: "complete" + side effects
+on-chain (order.executed)
+```
+
+Verified sessions include `verified_at` and `verified_by` fields in the session object, providing an audit trail of server-verified completions.
+
+**No SDK changes required** — the SDK already passes `checkoutSessionId` in `callbackMetadata` when creating orders, so the verification pipeline works automatically.
+
 ## API
 
 ### `POST /checkout-sessions` — Create Session

package/src/anyspend/platform/client.ts

@@ -0,0 +1,198 @@
+/**
+ * Core HTTP client for the AnySpend Platform API.
+ * Handles authentication, retries, error parsing, and idempotency.
+ */
+
+import { parseApiError, type ApiErrorResponse } from "./errors";
+import { generateIdempotencyKey } from "./utils/idempotency";
+
+export interface ClientConfig {
+  baseUrl?: string;
+  timeout?: number;
+  maxRetries?: number;
+  idempotencyKeyGenerator?: () => string;
+}
+
+export const DEFAULT_BASE_URL = "https://platform-api.anyspend.com/api/v1";
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_MAX_RETRIES = 3;
+
+export class HttpClient {
+  private apiKey: string;
+  private baseUrl: string;
+  private timeout: number;
+  private maxRetries: number;
+  private generateIdempotencyKey: () => string;
+
+  constructor(apiKey: string, config: ClientConfig = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries || DEFAULT_MAX_RETRIES;
+    this.generateIdempotencyKey = config.idempotencyKeyGenerator || generateIdempotencyKey;
+  }
+
+  async get<T>(path: string, params?: object): Promise<T> {
+    const url = this.buildUrl(path, params);
+    return this.request<T>("GET", url);
+  }
+
+  async post<T>(path: string, body?: object): Promise<T> {
+    const url = this.buildUrl(path);
+    return this.request<T>("POST", url, body);
+  }
+
+  async patch<T>(path: string, body: object): Promise<T> {
+    const url = this.buildUrl(path);
+    return this.request<T>("PATCH", url, body);
+  }
+
+  async delete<T>(path: string, body?: object): Promise<T> {
+    const url = this.buildUrl(path);
+    return this.request<T>("DELETE", url, body);
+  }
+
+  async postFormData<T>(path: string, formData: FormData): Promise<T> {
+    const url = this.buildUrl(path);
+    return this.requestRaw<T>("POST", url, formData);
+  }
+
+  private buildUrl(path: string, params?: object): string {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params as Record<string, unknown>)) {
+        if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+
+  private async request<T>(method: string, url: string, body?: object): Promise<T> {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+    };
+
+    // Auto-generate idempotency key for POST/PATCH
+    if (method === "POST" || method === "PATCH") {
+      headers["Idempotency-Key"] = this.generateIdempotencyKey();
+    }
+
+    return this.executeWithRetry<T>(method, url, headers, body ? JSON.stringify(body) : undefined);
+  }
+
+  private async requestRaw<T>(method: string, url: string, body: FormData): Promise<T> {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+    };
+
+    return this.executeWithRetry<T>(method, url, headers, body);
+  }
+
+  private async executeWithRetry<T>(
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    body?: string | FormData,
+  ): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+        const response = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (response.ok) {
+          // Handle CSV/text responses
+          const contentType = response.headers.get("Content-Type") || "";
+          if (contentType.includes("text/csv")) {
+            return (await response.text()) as unknown as T;
+          }
+          return (await response.json()) as T;
+        }
+
+        // Parse error response
+        const errorBody = (await response.json().catch(() => ({
+          error: { type: "api_error", code: "internal_error", message: "Unknown error" },
+        }))) as ApiErrorResponse;
+
+        const error = parseApiError(response.status, errorBody, response.headers);
+
+        // Don't retry 4xx errors (except 429 rate limits)
+        if (response.status < 500 && response.status !== 429) {
+          throw error;
+        }
+
+        // For 429, wait the specified retry-after time
+        if (response.status === 429) {
+          const retryAfter = parseInt(response.headers.get("Retry-After") || "1", 10);
+          await this.sleep(retryAfter * 1000);
+          lastError = error;
+          continue;
+        }
+
+        // For 5xx, retry with exponential backoff
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1000);
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          lastError = new Error(`Request timed out after ${this.timeout}ms`);
+        } else if (err instanceof Error && "type" in err) {
+          // Already a parsed ApiError, re-throw
+          throw err;
+        } else {
+          lastError = err instanceof Error ? err : new Error(String(err));
+        }
+
+        if (attempt < this.maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1000);
+        }
+      }
+    }
+
+    throw lastError || new Error("Request failed after retries");
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Static HTTP client for unauthenticated requests (quick-pay).
+ */
+export class StaticHttpClient {
+  static async post<T>(baseUrl: string, path: string, body: Record<string, unknown>): Promise<T> {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (response.ok) {
+      return (await response.json()) as T;
+    }
+
+    const errorBody = (await response.json().catch(() => ({
+      error: { type: "api_error", code: "internal_error", message: "Unknown error" },
+    }))) as ApiErrorResponse;
+
+    throw parseApiError(response.status, errorBody, response.headers);
+  }
+}

package/src/anyspend/platform/errors.ts

@@ -0,0 +1,92 @@
+/**
+ * Typed error classes for the AnySpend Platform API client.
+ */
+
+export interface ApiErrorResponse {
+  error: {
+    type: string;
+    code: string;
+    message: string;
+    param?: string;
+  };
+}
+
+export class ApiError extends Error {
+  readonly type: string;
+  readonly code: string;
+  readonly status: number;
+  readonly param?: string;
+
+  constructor(status: number, body: ApiErrorResponse) {
+    super(body.error.message);
+    this.name = "ApiError";
+    this.type = body.error.type;
+    this.code = body.error.code;
+    this.status = status;
+    this.param = body.error.param;
+  }
+}
+
+export class AuthenticationError extends ApiError {
+  constructor(status: number, body: ApiErrorResponse) {
+    super(status, body);
+    this.name = "AuthenticationError";
+  }
+}
+
+export class PermissionError extends ApiError {
+  constructor(status: number, body: ApiErrorResponse) {
+    super(status, body);
+    this.name = "PermissionError";
+  }
+}
+
+export class RateLimitError extends ApiError {
+  readonly retryAfter: number;
+
+  constructor(status: number, body: ApiErrorResponse, retryAfter: number) {
+    super(status, body);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+}
+
+export class NotFoundError extends ApiError {
+  constructor(status: number, body: ApiErrorResponse) {
+    super(status, body);
+    this.name = "NotFoundError";
+  }
+}
+
+export class IdempotencyError extends ApiError {
+  constructor(status: number, body: ApiErrorResponse) {
+    super(status, body);
+    this.name = "IdempotencyError";
+  }
+}
+
+/**
+ * Parse an API error response into the appropriate typed error class.
+ */
+export function parseApiError(status: number, body: ApiErrorResponse, headers?: Headers): ApiError {
+  const type = body.error?.type;
+
+  if (status === 401 || type === "authentication_error") {
+    return new AuthenticationError(status, body);
+  }
+  if (status === 403 || type === "permission_error") {
+    return new PermissionError(status, body);
+  }
+  if (status === 429 || type === "rate_limit_error") {
+    const retryAfter = parseInt(headers?.get("Retry-After") || "60", 10);
+    return new RateLimitError(status, body, retryAfter);
+  }
+  if (status === 404 || type === "not_found_error") {
+    return new NotFoundError(status, body);
+  }
+  if (type === "idempotency_error") {
+    return new IdempotencyError(status, body);
+  }
+
+  return new ApiError(status, body);
+}

package/src/anyspend/platform/index.ts

@@ -0,0 +1,129 @@
+/**
+ * AnySpend Platform API Client
+ *
+ * A headless TypeScript client for the AnySpend Platform REST API.
+ * Works in any runtime with `fetch` (Node.js, browsers, Cloudflare Workers, Deno, Bun).
+ *
+ * @example
+ * ```typescript
+ * import { AnySpendPlatformClient } from '@b3dotfun/sdk/anyspend/platform';
+ *
+ * const platform = new AnySpendPlatformClient('asp_your_api_key_here');
+ *
+ * // Create a payment link
+ * const link = await platform.paymentLinks.create({
+ *   name: 'Summer Sale',
+ *   amount: '10000000',
+ *   token_address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+ *   chain_id: 8453,
+ *   recipient_address: '0x...',
+ * });
+ *
+ * // Quick pay (no API key needed)
+ * const quickLink = await AnySpendPlatformClient.quickPay({
+ *   recipient_address: '0x...',
+ *   amount: '5000000',
+ * });
+ * ```
+ */
+
+import { HttpClient, StaticHttpClient, DEFAULT_BASE_URL, type ClientConfig } from "./client";
+import { PaymentLinksResource } from "./resources/payment-links";
+import { ProductsResource } from "./resources/products";
+import { CustomersResource } from "./resources/customers";
+import { TransactionsResource } from "./resources/transactions";
+import { CheckoutSessionsResource } from "./resources/checkout-sessions";
+import { WebhooksResource } from "./resources/webhooks";
+import { DiscountCodesResource } from "./resources/discount-codes";
+import { NotificationsResource } from "./resources/notifications";
+import { WidgetsResource } from "./resources/widgets";
+import { OrganizationResource } from "./resources/organization";
+import { AnalyticsResource } from "./resources/analytics";
+import { EventsResource } from "./resources/events";
+import type { QuickPayParams, PaymentLink } from "./types";
+
+export class AnySpendPlatformClient {
+  private client: HttpClient;
+
+  /** Payment Links - Create, manage, and track payment links */
+  readonly paymentLinks: PaymentLinksResource;
+
+  /** Products - Manage your product catalog */
+  readonly products: ProductsResource;
+
+  /** Customers - Manage customer records */
+  readonly customers: CustomersResource;
+
+  /** Transactions - View transaction history and stats */
+  readonly transactions: TransactionsResource;
+
+  /** Checkout Sessions - Server-side checkout management */
+  readonly checkoutSessions: CheckoutSessionsResource;
+
+  /** Webhooks - Configure webhook endpoints */
+  readonly webhooks: WebhooksResource;
+
+  /** Discount Codes - Create and validate discounts */
+  readonly discountCodes: DiscountCodesResource;
+
+  /** Notifications - Email and Telegram settings */
+  readonly notifications: NotificationsResource;
+
+  /** Widgets - Embeddable widget configurations */
+  readonly widgets: WidgetsResource;
+
+  /** Organization - Org settings and defaults */
+  readonly organization: OrganizationResource;
+
+  /** Analytics - Revenue and conversion analytics */
+  readonly analytics: AnalyticsResource;
+
+  /** Events - API audit trail */
+  readonly events: EventsResource;
+
+  /**
+   * Create a new AnySpend Platform API client.
+   *
+   * @param apiKey - Your API key (starts with `asp_`)
+   * @param config - Optional configuration
+   */
+  constructor(apiKey: string, config?: ClientConfig) {
+    this.client = new HttpClient(apiKey, config);
+
+    this.paymentLinks = new PaymentLinksResource(this.client);
+    this.products = new ProductsResource(this.client);
+    this.customers = new CustomersResource(this.client);
+    this.transactions = new TransactionsResource(this.client);
+    this.checkoutSessions = new CheckoutSessionsResource(this.client);
+    this.webhooks = new WebhooksResource(this.client);
+    this.discountCodes = new DiscountCodesResource(this.client);
+    this.notifications = new NotificationsResource(this.client);
+    this.widgets = new WidgetsResource(this.client);
+    this.organization = new OrganizationResource(this.client);
+    this.analytics = new AnalyticsResource(this.client);
+    this.events = new EventsResource(this.client);
+  }
+
+  /**
+   * Create a quick payment link without authentication.
+   * Rate limited to 5 requests per minute per IP.
+   *
+   * @param params - Quick pay parameters
+   * @param baseUrl - Optional API base URL (defaults to production)
+   */
+  static async quickPay(params: QuickPayParams, baseUrl: string = DEFAULT_BASE_URL): Promise<PaymentLink> {
+    return StaticHttpClient.post<PaymentLink>(baseUrl, "/quick-pay", params as unknown as Record<string, unknown>);
+  }
+}
+
+// Re-export types and errors
+export type { ClientConfig } from "./client";
+export {
+  ApiError,
+  AuthenticationError,
+  PermissionError,
+  RateLimitError,
+  NotFoundError,
+  IdempotencyError,
+} from "./errors";
+export type * from "./types";

package/src/anyspend/platform/resources/analytics.ts

@@ -0,0 +1,10 @@
+import type { HttpClient } from "../client";
+import type { AnalyticsOverview } from "../types";
+
+export class AnalyticsResource {
+  constructor(private client: HttpClient) {}
+
+  async overview(period?: "7d" | "30d" | "90d" | "all"): Promise<AnalyticsOverview> {
+    return this.client.get<AnalyticsOverview>("/analytics/overview", period !== undefined ? { period } : undefined);
+  }
+}

package/src/anyspend/platform/resources/checkout-sessions.ts

@@ -0,0 +1,36 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type { CheckoutSession, ListResponse, CreateCheckoutSessionParams, PaginationParams } from "../types";
+
+export interface ListCheckoutSessionsParams extends PaginationParams {
+  status?: "open" | "processing" | "completed" | "expired" | "failed";
+  payment_link_id?: string;
+  from?: number;
+  to?: number;
+}
+
+export class CheckoutSessionsResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListCheckoutSessionsParams): Promise<ListResponse<CheckoutSession>> {
+    return this.client.get<ListResponse<CheckoutSession>>("/checkout-sessions", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListCheckoutSessionsParams, "page">): AsyncGenerator<CheckoutSession> {
+    yield* autoPaginate<CheckoutSession>((page, limit) => this.list({ ...params, page, limit }), {
+      limit: params?.limit,
+    });
+  }
+
+  async create(params: CreateCheckoutSessionParams): Promise<CheckoutSession> {
+    return this.client.post<CheckoutSession>("/checkout-sessions", params);
+  }
+
+  async get(id: string): Promise<CheckoutSession> {
+    return this.client.get<CheckoutSession>(`/checkout-sessions/${id}`);
+  }
+
+  async expire(id: string): Promise<CheckoutSession> {
+    return this.client.post<CheckoutSession>(`/checkout-sessions/${id}/expire`);
+  }
+}