@invonetwork/web-sdk 0.2.1 → 0.4.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ClientConfig, A as ApproveResult, a as ConfirmReceiptResult, L as LinkDeviceResult } from './errors-DV5QsftP.js';
-export { I as InvoError, R as Rail, V as VerificationMethod } from './errors-DV5QsftP.js';
+import { C as ClientConfig, a as CallOptions, A as ApproveResult, b as ConfirmReceiptResult, L as LinkDeviceResult } from './types-CBMLNwbe.js';
+export { I as InvoError, c as InvoErrorInfo, d as InvoHooks, e as InvoRequestInfo, f as InvoResponseInfo, R as Rail, V as VerificationMethod } from './types-CBMLNwbe.js';
 
 declare class InvoClient {
     private readonly http;
@@ -10,19 +10,19 @@ declare class InvoClient {
     constructor(config: ClientConfig);
     private assertWebAuthn;
     /** Enroll a passkey for the token's identity (register/begin -> create() -> register/complete). */
-    enrollPasskey(): Promise<{
+    enrollPasskey(opts?: CallOptions): Promise<{
         status: string;
         device: unknown;
         raw: Record<string, unknown>;
     }>;
     /** Approve a SEND with the player's passkey. */
-    approveSend(transactionId: string): Promise<ApproveResult>;
+    approveSend(transactionId: string, opts?: CallOptions): Promise<ApproveResult>;
     /** Approve a TRANSFER with the player's passkey (returns the sender's claim code). */
-    approveTransfer(transactionId: string): Promise<ApproveResult>;
+    approveTransfer(transactionId: string, opts?: CallOptions): Promise<ApproveResult>;
     /** Recipient self-claims a SEND with their passkey. */
-    confirmReceiptSend(transactionId: string): Promise<ConfirmReceiptResult>;
+    confirmReceiptSend(transactionId: string, opts?: CallOptions): Promise<ConfirmReceiptResult>;
     /** Recipient self-claims a TRANSFER with their passkey. */
-    confirmReceiptTransfer(transactionId: string): Promise<ConfirmReceiptResult>;
+    confirmReceiptTransfer(transactionId: string, opts?: CallOptions): Promise<ConfirmReceiptResult>;
     /**
      * Interchangeable methods (§4.6): prove an *already-enrolled* method (e.g. the
      * INVO app device key) to authorize adding a new partner passkey. The returned
@@ -31,7 +31,7 @@ declare class InvoClient {
      *
      * begin -> navigator.credentials.get() -> complete with { link_id, webauthn_assertion }.
      */
-    linkDevice(linkId: string): Promise<LinkDeviceResult>;
+    linkDevice(linkId: string, opts?: CallOptions): Promise<LinkDeviceResult>;
     /** POST with the current player token. Token-expiry retry is handled one level
      *  up by withTokenRetry (which re-runs the whole ceremony, not a single call). */
     private post;
@@ -49,4 +49,4 @@ declare class InvoClient {
     private confirmReceipt;
 }
 
-export { ApproveResult, ClientConfig, ConfirmReceiptResult, InvoClient, LinkDeviceResult };
+export { ApproveResult, CallOptions, ClientConfig, ConfirmReceiptResult, InvoClient, LinkDeviceResult };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { assertSecureBaseUrl, Http, InvoError } from './chunk-A44O4KC3.js';
-export { InvoError } from './chunk-A44O4KC3.js';
+import { assertSecureBaseUrl, Http, InvoError } from './chunk-EEWOAUXO.js';
+export { InvoError } from './chunk-EEWOAUXO.js';
 
 // src/shared/webauthn.ts
 function b64urlToBuffer(value) {
@@ -91,7 +91,10 @@ var InvoClient = class {
     this.http = new Http({
       baseUrl: config.baseUrl,
       timeoutMs: config.timeoutMs,
-      fetchImpl: config.fetch
+      fetchImpl: config.fetch,
+      maxRetries: config.maxRetries,
+      retryBaseDelayMs: config.retryBaseDelayMs,
+      hooks: config.hooks
       // Browser: do NOT set User-Agent (forbidden header); the browser's own UA is fine.
     });
     this.auth = { kind: "bearer", token: config.token };
@@ -103,38 +106,43 @@ var InvoClient = class {
     }
   }
   /** Enroll a passkey for the token's identity (register/begin -> create() -> register/complete). */
-  async enrollPasskey() {
+  async enrollPasskey(opts) {
     this.assertWebAuthn();
+    const signal = opts?.signal;
     return this.withTokenRetry(async () => {
       const options = await this.post(
-        "/api/sdk/webauthn/register/begin"
+        "/api/sdk/webauthn/register/begin",
+        void 0,
+        signal
       );
       const cred = await navigator.credentials.create({
-        publicKey: toCreationOptions(options)
+        publicKey: toCreationOptions(options),
+        signal
       });
       if (!cred) throw new Error("Passkey creation was cancelled or returned no credential.");
       const raw = await this.post(
         "/api/sdk/webauthn/register/complete",
-        { credential: registrationToJSON(cred) }
+        { credential: registrationToJSON(cred) },
+        signal
       );
       return { status: String(raw["status"] ?? ""), device: raw["device"] ?? null, raw };
     });
   }
   /** Approve a SEND with the player's passkey. */
-  async approveSend(transactionId) {
-    return this.approve("send", transactionId);
+  async approveSend(transactionId, opts) {
+    return this.approve("send", transactionId, opts);
   }
   /** Approve a TRANSFER with the player's passkey (returns the sender's claim code). */
-  async approveTransfer(transactionId) {
-    return this.approve("transfers", transactionId);
+  async approveTransfer(transactionId, opts) {
+    return this.approve("transfers", transactionId, opts);
   }
   /** Recipient self-claims a SEND with their passkey. */
-  async confirmReceiptSend(transactionId) {
-    return this.confirmReceipt("send", transactionId);
+  async confirmReceiptSend(transactionId, opts) {
+    return this.confirmReceipt("send", transactionId, opts);
   }
   /** Recipient self-claims a TRANSFER with their passkey. */
-  async confirmReceiptTransfer(transactionId) {
-    return this.confirmReceipt("transfers", transactionId);
+  async confirmReceiptTransfer(transactionId, opts) {
+    return this.confirmReceipt("transfers", transactionId, opts);
   }
   /**
    * Interchangeable methods (§4.6): prove an *already-enrolled* method (e.g. the
@@ -144,15 +152,19 @@ var InvoClient = class {
    *
    * begin -> navigator.credentials.get() -> complete with { link_id, webauthn_assertion }.
    */
-  async linkDevice(linkId) {
+  async linkDevice(linkId, opts) {
     if (!linkId) throw new Error("linkDevice requires a `linkId`.");
+    const signal = opts?.signal;
     return this.withTokenRetry(async () => {
-      const assertion = await this.runAssertion("/api/sdk/device/link/webauthn/begin", {
-        link_id: linkId
-      });
+      const assertion = await this.runAssertion(
+        "/api/sdk/device/link/webauthn/begin",
+        { link_id: linkId },
+        signal
+      );
       const raw = await this.post(
         "/api/sdk/device/link/webauthn/complete",
-        { link_id: linkId, webauthn_assertion: assertion }
+        { link_id: linkId, webauthn_assertion: assertion },
+        signal
       );
       return { status: String(raw["status"] ?? ""), raw };
     });
@@ -160,8 +172,8 @@ var InvoClient = class {
   // --- internals ---
   /** POST with the current player token. Token-expiry retry is handled one level
    *  up by withTokenRetry (which re-runs the whole ceremony, not a single call). */
-  async post(path, body) {
-    return this.http.post(path, body, this.auth);
+  async post(path, body, signal) {
+    return this.http.post(path, body, this.auth, { signal });
   }
   /**
    * Run a whole flow, retrying it ONCE if any call fails with SDK_TOKEN_EXPIRED
@@ -192,22 +204,29 @@ var InvoClient = class {
     this.auth = { kind: "bearer", token: fresh };
     return true;
   }
-  async runAssertion(beginPath, beginBody) {
+  async runAssertion(beginPath, beginBody, signal) {
     this.assertWebAuthn();
-    const options = await this.post(beginPath, beginBody);
+    const options = await this.post(beginPath, beginBody, signal);
     const cred = await navigator.credentials.get({
-      publicKey: toRequestOptions(options)
+      publicKey: toRequestOptions(options),
+      signal
     });
     if (!cred) throw new Error("Passkey assertion was cancelled or returned no credential.");
     return assertionToJSON(cred);
   }
-  async approve(flow, transactionId) {
+  async approve(flow, transactionId, opts) {
     const id = encodeURIComponent(transactionId);
+    const signal = opts?.signal;
     return this.withTokenRetry(async () => {
-      const assertion = await this.runAssertion(`/api/sdk/${flow}/${id}/approve/webauthn/begin`);
+      const assertion = await this.runAssertion(
+        `/api/sdk/${flow}/${id}/approve/webauthn/begin`,
+        void 0,
+        signal
+      );
       const raw = await this.post(
         `/api/sdk/${flow}/${id}/approve`,
-        { webauthn_assertion: assertion }
+        { webauthn_assertion: assertion },
+        signal
       );
       return {
         status: String(raw["status"] ?? ""),
@@ -219,15 +238,19 @@ var InvoClient = class {
       };
     });
   }
-  async confirmReceipt(flow, transactionId) {
+  async confirmReceipt(flow, transactionId, opts) {
     const id = encodeURIComponent(transactionId);
+    const signal = opts?.signal;
     return this.withTokenRetry(async () => {
       const assertion = await this.runAssertion(
-        `/api/sdk/${flow}/${id}/confirm-receipt/webauthn/begin`
+        `/api/sdk/${flow}/${id}/confirm-receipt/webauthn/begin`,
+        void 0,
+        signal
       );
       const raw = await this.post(
         `/api/sdk/${flow}/${id}/confirm-receipt`,
-        { webauthn_assertion: assertion }
+        { webauthn_assertion: assertion },
+        signal
       );
       return { status: String(raw["status"] ?? ""), raw };
     });