@tuwaio/quasar-sdk 0.1.12 → 0.2.0

package/dist/index.d.ts

@@ -3,79 +3,84 @@ import { Transaction } from '@tuwaio/pulsar-core';
 export { Transaction, TransactionStatus, TransactionTracker, UpdatableTransactionFields } from '@tuwaio/pulsar-core';
 
 /**
- * @module types
- * @description Shared type definitions for the Quasar SDK.
- * Contains configuration interfaces, query parameters, and authentication structures.
+ * @file Default URL and endpoint paths of the Quasar API.
  */
+/** Base URL of Quasar Cloud, the default `baseUrl` of the `Quasar` client. */
+declare const BASE_API_URL = "https://api.tuwa.io";
+/** Path of the endpoint that `PulsarModule.syncCreate` calls (`POST`). */
+declare const PULSAR_SYNC_ENDPOINT = "/v1/engine/pulsar/sync";
+/** Path of the endpoint that `PulsarModule.getHistory` calls (`GET`). */
+declare const PULSAR_HISTORY_ENDPOINT = "/v1/engine/pulsar/history";
+
 /**
- * Configuration options for initializing the {@link Quasar} SDK client.
- *
- * @public
+ * @file Configuration, query and response types of the Quasar client, and the Pulsar transaction types it syncs.
+ */
+/**
+ * Options of the {@link Quasar} client.
  */
 interface QuasarConfig {
-    /** Your secret API key starting with `sk_live_`. */
+    /**
+     * Secret key of your Quasar app (`sk_live_...` for a live app, `sk_test_...` for a test app), sent in the
+     * `x-tuwa-secret-key` header of every request. Keep it on the server.
+     */
     secretKey: string;
-    /** Optional internal secret for system-to-system communication. */
+    /**
+     * Secret of the internal endpoints of a Quasar deployment, sent in the `x-internal-secret` header when set. The
+     * Quasar dashboard uses it to call its own server; apps leave it unset.
+     */
     internalSecret?: string;
-    /** The base URL of the Quasar Cloud API. Defaults to 'https://api.tuwa.io'. */
+    /** Base URL of the Quasar API: Quasar Cloud or your self-hosted server. Defaults to {@link BASE_API_URL}. */
     baseUrl?: string;
-    /** Request timeout in milliseconds. Defaults to 10000. */
+    /** Request timeout in milliseconds. Defaults to `10000`. */
     timeout?: number;
 }
 /**
- * Query parameters for filtering and paginating transaction history.
- *
- * @public
+ * Filters and pagination of {@link PulsarModule.getHistory}. Every filter is optional; the API returns the
+ * transactions of your app that match all given filters.
  */
 interface HistoryQuery {
-    /** Page number for pagination (1-indexed). */
+    /** Page number, starting at 1. Defaults to `1`. */
     page?: number;
-    /** Maximum number of results to return per page. */
+    /** Number of transactions per page. Defaults to `10`. */
     limit?: number;
-    /** Filter by blockchain chain ID (e.g., 1, 'solana'). */
+    /** Chain of the transactions: an EVM chain ID (`1`) or a Solana cluster (`'mainnet'`). */
     chainId?: string | number;
-    /** Filter by transaction status (e.g., 'Success', 'Failed'). */
+    /** Final status of the transactions (`'Success'`, `'Failed'` or `'Replaced'`, see `TransactionStatus`). */
     status?: string;
-    /** Filter by a specific Quasar transaction key. */
+    /** Key of one transaction (`txKey` of the Pulsar transaction). */
     txKey?: string;
-    /** Filter by the application name. */
+    /** Application name that was passed to {@link PulsarModule.syncCreate}. */
     appName?: string;
-    /** Filter by the sender's wallet address. */
+    /** Address of the wallet that sent the transactions. */
     walletAddress?: string;
 }
 /**
- * Generic wrapper for paginated API responses.
+ * One page of results.
  *
- * @typeParam T - The type of the documents contained in the result set.
- * @public
+ * @typeParam T - Type of the documents on the page.
  */
 interface PaginatedResult<T> {
-    /** Array of documents for the current page. */
+    /** Documents of the current page. */
     docs: T[];
-    /** Total number of documents matching the query. */
+    /** Number of documents that match the query. */
     totalDocs: number;
-    /** Total number of available pages. */
+    /** Number of pages. */
     totalPages: number;
-    /** The current page number (1-indexed). */
+    /** Current page number, starting at 1. */
     page: number;
-    /** Indicates if a subsequent page is available. */
+    /** Whether a next page exists. */
     hasNextPage: boolean;
-    /** Indicates if a preceding page is available. */
+    /** Whether a previous page exists. */
     hasPrevPage: boolean;
 }
 
 /**
- * @module core/client
- * @description Core HTTP client for the Quasar SDK.
- * Handles authenticated requests through the Iron Dome security perimeter
- * and provides structured error handling for all API interactions.
+ * @file HTTP client of the Quasar SDK: authentication headers, timeout and errors.
  */
 
 /**
- * Custom error class for all Quasar SDK API failures.
- *
- * Wraps the underlying HTTP error with a structured format including
- * status code, human-readable message, and the original error reference.
+ * Error thrown by the methods of the {@link Quasar} client when a request fails: an HTTP error status, a timeout or a
+ * network error.
  *
  * @example
  * ```typescript
@@ -84,36 +89,30 @@ interface PaginatedResult<T> {
  * } catch (err) {
  *   if (err instanceof QuasarSDKError) {
  *     console.error(err.status);        // e.g. 401
- *     console.error(err.message);       // "[Quasar SDK] Request Failed (401): Unauthorized"
- *     console.error(err.originalError); // Raw FetchError from ofetch
+ *     console.error(err.message);       // "[Quasar SDK] Request Failed (401): <error of the API>"
+ *     console.error(err.originalError); // FetchError from ofetch
  *   }
  * }
  * ```
  */
 declare class QuasarSDKError extends Error {
-    /** HTTP status code returned by the API, if available. */
+    /** HTTP status code of the response, or `undefined` when no response was received. */
     readonly status: number | undefined;
-    /** The original error thrown by the HTTP client. */
+    /** The error thrown by `ofetch`. */
     readonly originalError: Error;
     /**
-     * Creates a new QuasarSDKError instance.
+     * Creates the error.
      *
-     * @param message - Formatted error message with SDK prefix and status.
-     * @param status - HTTP status code, or `undefined` if unavailable.
-     * @param originalError - The raw error from the HTTP layer.
+     * @param message - Message: `[Quasar SDK] Request Failed (<status>): <error>`, where `<error>` is the `error` field of
+     *   the response body or the message of the fetch error.
+     * @param status - HTTP status code, or `undefined` when no response was received.
+     * @param originalError - The error thrown by `ofetch`.
      */
     constructor(message: string, status: number | undefined, originalError: Error);
 }
 /**
- * Internal HTTP client for the Quasar Cloud API.
- *
- * Manages authenticated requests by injecting the `x-tuwa-secret-key` header
- * into every outgoing request. Optionally injects `x-internal-secret`
- * when it is provided in the SDK config. Uses `ofetch` as the transport layer.
- *
- * @remarks
- * This class is not exported from the public API surface.
- * Consumers interact with it indirectly through the {@link Quasar} entry point.
+ * HTTP client shared by the modules of the {@link Quasar} client. Sends every request with the `x-tuwa-secret-key`
+ * header (and `x-internal-secret` when configured) through `ofetch`.
  *
  * @internal
  */
@@ -127,217 +126,129 @@ declare class QuasarClient {
     /** Request timeout in milliseconds. */
     private readonly timeout;
     /**
-     * Creates a new QuasarClient instance.
+     * Creates the client.
      *
-     * @param config - SDK configuration containing the secret key and optional overrides.
-     * @throws {Error} If `config.secretKey` is missing or empty.
+     * @param config - Secret key and optional overrides.
+     * @throws {Error} If `config.secretKey` is empty.
      */
     constructor(config: QuasarConfig);
     /**
-     * Sends an authenticated request to the Quasar Cloud API.
-     *
-     * Automatically injects Iron Dome headers (`x-tuwa-secret-key`, `Content-Type`)
-     * and optionally injects `x-internal-secret` when the SDK was configured with it.
-     * Wraps all transport errors into {@link QuasarSDKError}.
-     *
-     * @typeParam T - Expected response body type.
-     * @param path - API endpoint path (e.g. `/api/v1/engine/tx-sync`).
-     * @param options - Fetch options (method, body, query, headers, etc.).
-     *                  `baseURL` and `timeout` are managed internally and cannot be overridden.
-     * @returns The parsed JSON response body typed as `T`.
-     * @throws {QuasarSDKError} On any HTTP or network error.
+     * Sends a request with the `Content-Type: application/json` and `x-tuwa-secret-key` headers (and
+     * `x-internal-secret` when configured).
+     *
+     * @typeParam T - Type of the response body.
+     * @param path - Endpoint path, for example `/v1/engine/pulsar/sync`.
+     * @param options - `ofetch` options (method, body, query, headers). `baseURL` and `timeout` come from the config.
+     * @returns The parsed JSON response body.
+     * @throws {QuasarSDKError} On an HTTP error status, a timeout or a network error.
      */
     request<T>(path: string, options?: Omit<FetchOptions<'json'>, 'baseURL' | 'timeout'>): Promise<T>;
     /**
-     * Transforms a raw fetch error into a structured {@link QuasarSDKError}.
+     * Wraps an `ofetch` error in a {@link QuasarSDKError}. Side effect: logs a `console.error` on a 401 or 403 status.
      *
-     * Extracts status code and error message from the response body or fallback fields.
-     * Logs a console warning for authentication failures (401/403).
-     *
-     * @param error - The raw error caught from `ofetch`.
-     * @returns A formatted QuasarSDKError instance.
+     * @param error - The error thrown by `ofetch`.
+     * @returns The wrapped error.
      */
     private buildError;
 }
 
 /**
- * @module modules/pulsar
- * @description Pulsar Transaction Engine module.
- * Provides methods for syncing transaction states to the Quasar Cloud
- * and retrieving paginated transaction history.
+ * @file Pulsar module of the Quasar client: transaction sync and history.
  */
 
 /**
- * Pulsar module — the transaction engine interface for Quasar Cloud.
- *
- * The `PulsarModule` handles the lifecycle of blockchain transactions within the Quasar ecosystem.
- * It allows developers to sync transaction states (EVM, Solana, Starknet) to the cloud for
- * persistent tracking and to retrieve comprehensive transaction histories.
- *
- * @remarks
- * Access this module via `quasar.pulsar` after initializing the {@link Quasar} SDK.
- * All methods are authenticated automatically using the configured secret key.
+ * Transaction sync and history of the Quasar API, available as `quasar.pulsar` on a {@link Quasar} client. Quasar
+ * tracks every synced transaction on the server until it reaches a final status, so the status survives a closed tab,
+ * and returns the history of your app for any device.
  *
  * @example
- * ```typescript
- * const quasar = new Quasar({ secretKey: 'sk_live_...' });
+ * ```ts
+ * import { Quasar, type Transaction } from '@tuwaio/quasar-sdk';
  *
- * // Sync a new transaction to start tracking
- * const { txKey } = await quasar.pulsar.syncCreate(transaction);
+ * const quasar = new Quasar({ secretKey: process.env.QUASAR_SECRET_KEY ?? '' });
  *
- * // Retrieve transaction history with filters
- * const history = await quasar.pulsar.getHistory({
- *   chainId: 1,
- *   status: 'Success',
- * });
+ * // Called by the `onRemoteCreate` callback of the Pulsar store (through a Server Action) with the new transaction.
+ * export async function syncTransaction(tx: Transaction) {
+ *   const { txKey } = await quasar.pulsar.syncCreate(tx, 'my-app');
+ *   return txKey;
+ * }
  * ```
  */
 declare class PulsarModule {
     private readonly client;
     /**
-     * Creates a new PulsarModule instance.
+     * Creates the module. The {@link Quasar} client creates it for you.
      *
-     * @param client - The internal {@link QuasarClient} instance for making authenticated API calls.
+     * @param client - The HTTP client of the Quasar client.
      * @internal
      */
     constructor(client: QuasarClient);
     /**
-     * Syncs a newly created or pending transaction to the Quasar Cloud.
-     *
-     * This method sends the full transaction object to the Pulsar sync engine.
-     * Once synced, the transaction is indexed and tracked through the Iron Dome infrastructure.
-     *
-     * @param tx - The complete transaction object to sync. Must conform to the {@link Transaction} type.
-     * @param appName - Optional application name to associate with this transaction for filtering purposes.
-     * @returns A promise that resolves to an object containing the assigned `txKey`.
-     * @throws {QuasarSDKError} If the request fails due to authentication, validation, or network issues.
-     *
-     * @example
-     * ```typescript
-     * const result = await quasar.pulsar.syncCreate({
-     *   hash: '0xabc...',
-     *   chainId: 1,
-     *   status: 'pending',
-     *   from: '0x123...',
-     *   to: '0x456...',
-     *   // ... other transaction fields
-     * }, 'My Dashboard');
-     *
-     * console.log(result.txKey); // The unique key for this transaction
-     * ```
+     * Sends a new Pulsar transaction to Quasar, which starts tracking it on the server (`POST /v1/engine/pulsar/sync`).
+     * Sending a transaction with a `txKey` that Quasar already has does not create a second record: the response has
+     * `duplicate: true`.
+     *
+     * @param tx - The transaction created by Pulsar, as passed to `onRemoteCreate` of `createPulsarStore`.
+     * @param appName - Application name saved with the transaction; filter the history by it with `appName`.
+     * @returns `txKey` of the transaction and the tracking `mode`: `fast` (tracked right away) or `lazy` (queued, for
+     *   example when the quota of the organization is used up).
+     * @throws {QuasarSDKError} On an invalid transaction (400), an invalid key (401, 403), a timeout or a network error.
      */
     syncCreate(tx: Transaction, appName?: string): Promise<{
         success: true;
         txKey: string;
+        mode: 'fast' | 'lazy';
+        duplicate?: true;
     }>;
     /**
-     * Retrieves a paginated list of transactions from the Quasar Cloud.
-     *
-     * Supports advanced filtering by chain, status, wallet address, and more.
-     * Results are returned in a typed {@link PaginatedResult} wrapper.
+     * Reads the transactions of your app, newest first (`GET /v1/engine/pulsar/history`).
      *
-     * @param query - Optional query parameters for filtering and pagination. See {@link HistoryQuery}.
-     * @returns A promise that resolves to a {@link PaginatedResult} containing an array of {@link Transaction} documents.
-     * @throws {QuasarSDKError} If the request fails (e.g., 401 Unauthorized, 404 Not Found).
+     * @param query - Filters and pagination. `walletAddress` is compared with the sender address exactly as it was
+     *   synced; the API returns at most 100 transactions per page.
+     * @returns One page of transactions.
+     * @throws {QuasarSDKError} On an invalid key (401, 403), a timeout or a network error.
      *
      * @example
-     * ```typescript
-     * const result = await quasar.pulsar.getHistory({
-     *   page: 1,
-     *   limit: 20,
-     *   walletAddress: '6x...',
-     * });
-     *
-     * result.docs.forEach(tx => console.log(tx.txKey, tx.status));
+     * ```ts
+     * const page = await quasar.pulsar.getHistory({ walletAddress: '0x...', page: 1, limit: 20 });
+     * page.docs.forEach((tx) => console.log(tx.txKey, tx.status));
      * ```
      */
     getHistory(query?: HistoryQuery): Promise<PaginatedResult<Transaction>>;
 }
 
-declare const BASE_API_URL = "https://api.tuwa.io";
-declare const PULSAR_SYNC_ENDPOINT = "/v1/engine/pulsar/sync";
-declare const PULSAR_HISTORY_ENDPOINT = "/v1/engine/pulsar/history";
-
 /**
- * @module @tuwaio/quasar-sdk
- * The official server-side Node.js & Edge SDK for the TUWA Quasar Cloud.
- *
- * Provides a type-safe client for interacting with the Quasar API,
- * including transaction syncing, status tracking, and history retrieval
- * through the Iron Dome security perimeter.
- *
- * @example
- * ```typescript
- * import { Quasar } from '@tuwaio/quasar-sdk';
- *
- * const quasar = new Quasar({ secretKey: 'sk_live_...' });
- * const history = await quasar.pulsar.getHistory({ chainId: 1 });
- * ```
- *
- * @packageDocumentation
+ * @file The `Quasar` client, the entry point of the Quasar API.
  */
 
 /**
- * Pre-flight check before initiating a transaction.
- * Ensures the local SIWX Session is valid and verifies Quasar Engine health.
- *
- * @param customApiUrl - Optional custom API URL to override the default.
- * @throws {Error} If the session check fails or Quasar is unreachable.
- *
- * @public
- */
-declare function preFlightTxCheck(customApiUrl?: string): Promise<void>;
-/**
- * Main entry point for the Quasar SDK.
- *
- * The `Quasar` class provides a unified interface for interacting with the Quasar Cloud API.
- * It handles authentication, base URL configuration, and exposes domain-specific modules
- * like {@link PulsarModule} for transaction management.
+ * Client of the Quasar API (Quasar Cloud at `https://api.tuwa.io`, or a self-hosted Quasar server). Create it on the
+ * server: it sends the secret key of your Quasar app with every request.
  *
  * @example
- * ```typescript
+ * ```ts
  * import { Quasar } from '@tuwaio/quasar-sdk';
  *
- * // Initialize with your secret API key
- * const quasar = new Quasar({
- *   secretKey: 'sk_live_your_secret_key',
- *   baseUrl: 'https://api.tuwa.io', // Optional
- *   timeout: 10000,                // Optional, default is 10s
- * });
- *
- * // Access domain-specific modules
- * const history = await quasar.pulsar.getHistory({ chainId: 1 });
+ * const quasar = new Quasar({ secretKey: process.env.QUASAR_SECRET_KEY ?? '' });
+ * const history = await quasar.pulsar.getHistory({ walletAddress: '0x...', limit: 20 });
  * ```
- *
- * @public
  */
 declare class Quasar {
     /**
-     * The internal HTTP client used for authenticated requests.
+     * The HTTP client shared by the modules.
+     *
      * @internal
      */
     private readonly client;
-    /**
-     * The Pulsar Transaction Engine module.
-     *
-     * This module provides methods to sync transaction states to the Quasar Cloud
-     * and retrieve indexed transaction history across multiple blockchain networks.
-     *
-     * @see {@link PulsarModule}
-     */
+    /** Syncs Pulsar transactions to Quasar and reads their history. */
     readonly pulsar: PulsarModule;
     /**
-     * Creates a new instance of the Quasar SDK.
+     * Creates the client. Sends no request.
      *
-     * @param config - Configuration options for the SDK.
-     * @throws {Error} If the `secretKey` is missing or invalid.
-     *
-     * @example
-     * ```typescript
-     * const quasar = new Quasar({ secretKey: process.env.QUASAR_SECRET_KEY! });
-     * ```
+     * @param config - The secret key of the Quasar app and optional overrides.
+     * @throws {Error} If `config.secretKey` is empty.
      */
     constructor(config: QuasarConfig);
 }
 
-export { BASE_API_URL, type HistoryQuery, PULSAR_HISTORY_ENDPOINT, PULSAR_SYNC_ENDPOINT, type PaginatedResult, PulsarModule, Quasar, type QuasarConfig, QuasarSDKError, preFlightTxCheck };
+export { BASE_API_URL, type HistoryQuery, PULSAR_HISTORY_ENDPOINT, PULSAR_SYNC_ENDPOINT, type PaginatedResult, PulsarModule, Quasar, type QuasarConfig, QuasarSDKError };

package/dist/index.js

@@ -1,2 +1 @@
-import {useSiwxSessionStore}from'@tuwaio/siwx-react';import {ofetch}from'ofetch';export{TransactionStatus,TransactionTracker}from'@tuwaio/pulsar-core';var o="https://api.tuwa.io",c="/v1/engine/pulsar/sync",u="/v1/engine/pulsar/history";var n=class extends Error{status;originalError;constructor(r,e,t){super(r),this.name="QuasarSDKError",this.status=e,this.originalError=t;}},i=class{secretKey;internalSecret;baseUrl;timeout;constructor(r){if(!r.secretKey)throw new Error("[Quasar SDK] Missing API Key. Provide a secretKey starting with sk_live_.");this.secretKey=r.secretKey,this.internalSecret=r.internalSecret,this.baseUrl=r.baseUrl||o,this.timeout=r.timeout||1e4;}async request(r,e={}){try{return await ofetch(r,{baseURL:this.baseUrl,timeout:this.timeout,...e,headers:{"Content-Type":"application/json","x-tuwa-secret-key":this.secretKey,...this.internalSecret?{"x-internal-secret":this.internalSecret}:{},...e.headers}})}catch(t){throw this.buildError(t)}}buildError(r){let e=r,t=e.statusCode??e.response?.status,p=(e.data??e.response?._data)?.error??e.message??"Unknown Error";return (t===401||t===403)&&console.error("\u{1F6A8} [Quasar SDK] Auth Error. Check your Secret Key and scopes."),new n(`[Quasar SDK] Request Failed (${t}): ${p}`,t,e)}};var a=class{constructor(r){this.client=r;}async syncCreate(r,e){return this.client.request(c,{method:"POST",body:{...r,appName:e}})}async getHistory(r={}){return this.client.request(u,{method:"GET",query:{page:r.page??1,limit:r.limit??10,chainId:r.chainId,status:r.status,txKey:r.txKey,appName:r.appName,walletAddress:r.walletAddress}})}};async function A(s){if(!useSiwxSessionStore.getState().session)throw new Error("[QuasarSDK] No SIWX Session found. User must be signed in.");let e=s||o;try{let t=await fetch(`${e}/v1/engine/monitoring/health`,{method:"GET",cache:"no-store"});if(!t.ok)throw new Error(`[QuasarSDK] API Health check failed with status: ${t.status}`)}catch(t){throw new Error("[QuasarSDK] Quasar Cloud Engine is currently unreachable.",{cause:t})}}var l=class{client;pulsar;constructor(r){this.client=new i(r),this.pulsar=new a(this.client);}};
-export{o as BASE_API_URL,u as PULSAR_HISTORY_ENDPOINT,c as PULSAR_SYNC_ENDPOINT,a as PulsarModule,l as Quasar,n as QuasarSDKError,A as preFlightTxCheck};
+import {b,c,a as a$1}from'./chunk-YPUBFZPR.js';export{a as BASE_API_URL,c as PULSAR_HISTORY_ENDPOINT,b as PULSAR_SYNC_ENDPOINT}from'./chunk-YPUBFZPR.js';import {ofetch}from'ofetch';export{TransactionStatus,TransactionTracker}from'@tuwaio/pulsar-core';var a=class extends Error{status;originalError;constructor(r,e,t){super(r),this.name="QuasarSDKError",this.status=e,this.originalError=t;}},o=class{secretKey;internalSecret;baseUrl;timeout;constructor(r){if(!r.secretKey)throw new Error("[Quasar SDK] Missing API Key. Provide the secretKey of your Quasar app (sk_live_ or sk_test_).");this.secretKey=r.secretKey,this.internalSecret=r.internalSecret,this.baseUrl=r.baseUrl||a$1,this.timeout=r.timeout||1e4;}async request(r,e={}){try{return await ofetch(r,{baseURL:this.baseUrl,timeout:this.timeout,...e,headers:{"Content-Type":"application/json","x-tuwa-secret-key":this.secretKey,...this.internalSecret?{"x-internal-secret":this.internalSecret}:{},...e.headers}})}catch(t){throw this.buildError(t)}}buildError(r){let e=r,t=e.statusCode??e.response?.status,p=(e.data??e.response?._data)?.error??e.message??"Unknown Error";return (t===401||t===403)&&console.error("\u{1F6A8} [Quasar SDK] Auth Error. Check your Secret Key and scopes."),new a(`[Quasar SDK] Request Failed (${t}): ${p}`,t,e)}};var s=class{constructor(r){this.client=r;}async syncCreate(r,e){return this.client.request(b,{method:"POST",body:{...r,appName:e}})}async getHistory(r={}){return this.client.request(c,{method:"GET",query:{page:r.page??1,limit:r.limit??10,chainId:r.chainId,status:r.status,txKey:r.txKey,appName:r.appName,walletAddress:r.walletAddress}})}};var n=class{client;pulsar;constructor(r){this.client=new o(r),this.pulsar=new s(this.client);}};export{s as PulsarModule,n as Quasar,a as QuasarSDKError};

package/dist/react.cjs

@@ -0,0 +1 @@
+'use strict';var chunkNJH5FYLU_cjs=require('./chunk-NJH5FYLU.cjs'),siwxReact=require('@tuwaio/siwx-react');var i="/v1/engine/monitoring/health";async function u(s){if(!siwxReact.useSiwxSessionStore.getState().session)throw new Error("[QuasarSDK] No SIWX Session found. User must be signed in.");let o=(s||chunkNJH5FYLU_cjs.a).replace(/\/+$/,""),e;try{e=await fetch(`${o}${i}`,{method:"GET",cache:"no-store"});}catch(t){throw new Error("[QuasarSDK] Quasar Cloud Engine is currently unreachable.",{cause:t})}if(!e.ok)throw new Error(`[QuasarSDK] API Health check failed with status: ${e.status}`)}exports.preFlightTxCheck=u;

package/dist/react.d.cts

@@ -0,0 +1,28 @@
+/**
+ * The browser helper for React apps that sign users in with SIWX, imported from `@tuwaio/quasar-sdk/react`. This entry
+ * point needs `@tuwaio/siwx-react` (an optional peer dependency of the package); the root entry point does not.
+ *
+ * @module react
+ */
+/**
+ * Checks, before a transaction starts, that the user is signed in with SIWX and that the Quasar API responds. Use it
+ * as the `beforeTxProcess` callback of `createPulsarStore` from `@tuwaio/pulsar-core`: with the default
+ * `abortOnTxError: true`, an error aborts the transaction before the wallet is asked to sign it.
+ *
+ * The session check reads the client state of `useSiwxSessionStore` from `@tuwaio/siwx-react`. It is not proof of
+ * identity: the server that syncs the transaction must verify the session itself (for example with
+ * `getSiwxServerSession` from `@tuwaio/siwx-server`).
+ *
+ * Side effects: reads `useSiwxSessionStore` and sends `GET <apiUrl>/v1/engine/monitoring/health` without credentials
+ * and without the HTTP cache.
+ *
+ * @param customApiUrl - Base URL of the Quasar API. Defaults to {@link BASE_API_URL}.
+ * @returns Resolves when a session exists and the API answers with a 2xx status.
+ * @throws {Error} `[QuasarSDK] No SIWX Session found. User must be signed in.` when the store has no session.
+ * @throws {Error} `[QuasarSDK] Quasar Cloud Engine is currently unreachable.` when the request fails (network error,
+ *   CORS); the original error is its `cause`.
+ * @throws {Error} `[QuasarSDK] API Health check failed with status: <status>` when the API answers with another status.
+ */
+declare function preFlightTxCheck(customApiUrl?: string): Promise<void>;
+
+export { preFlightTxCheck };

package/dist/react.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The browser helper for React apps that sign users in with SIWX, imported from `@tuwaio/quasar-sdk/react`. This entry
+ * point needs `@tuwaio/siwx-react` (an optional peer dependency of the package); the root entry point does not.
+ *
+ * @module react
+ */
+/**
+ * Checks, before a transaction starts, that the user is signed in with SIWX and that the Quasar API responds. Use it
+ * as the `beforeTxProcess` callback of `createPulsarStore` from `@tuwaio/pulsar-core`: with the default
+ * `abortOnTxError: true`, an error aborts the transaction before the wallet is asked to sign it.
+ *
+ * The session check reads the client state of `useSiwxSessionStore` from `@tuwaio/siwx-react`. It is not proof of
+ * identity: the server that syncs the transaction must verify the session itself (for example with
+ * `getSiwxServerSession` from `@tuwaio/siwx-server`).
+ *
+ * Side effects: reads `useSiwxSessionStore` and sends `GET <apiUrl>/v1/engine/monitoring/health` without credentials
+ * and without the HTTP cache.
+ *
+ * @param customApiUrl - Base URL of the Quasar API. Defaults to {@link BASE_API_URL}.
+ * @returns Resolves when a session exists and the API answers with a 2xx status.
+ * @throws {Error} `[QuasarSDK] No SIWX Session found. User must be signed in.` when the store has no session.
+ * @throws {Error} `[QuasarSDK] Quasar Cloud Engine is currently unreachable.` when the request fails (network error,
+ *   CORS); the original error is its `cause`.
+ * @throws {Error} `[QuasarSDK] API Health check failed with status: <status>` when the API answers with another status.
+ */
+declare function preFlightTxCheck(customApiUrl?: string): Promise<void>;
+
+export { preFlightTxCheck };

package/dist/react.js

@@ -0,0 +1 @@
+import {a}from'./chunk-YPUBFZPR.js';import {useSiwxSessionStore}from'@tuwaio/siwx-react';var i="/v1/engine/monitoring/health";async function u(s){if(!useSiwxSessionStore.getState().session)throw new Error("[QuasarSDK] No SIWX Session found. User must be signed in.");let o=(s||a).replace(/\/+$/,""),e;try{e=await fetch(`${o}${i}`,{method:"GET",cache:"no-store"});}catch(t){throw new Error("[QuasarSDK] Quasar Cloud Engine is currently unreachable.",{cause:t})}if(!e.ok)throw new Error(`[QuasarSDK] API Health check failed with status: ${e.status}`)}export{u as preFlightTxCheck};