vesant-sdk 1.7.0 → 1.7.1-dev.301c6df

package/dist/index.js

@@ -1,5 +1,61 @@
 'use strict';
 
+// src/core/auth.ts
+var StaticApiKeyProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async getCredential() {
+    return this.apiKey ? { scheme: "Bearer", token: this.apiKey } : null;
+  }
+  canRefresh() {
+    return false;
+  }
+};
+var RefreshingTokenProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.cached = null;
+    this.inFlight = null;
+    this.skewMs = opts.skewMs ?? 3e4;
+    this.scheme = opts.scheme ?? "Bearer";
+    this.now = opts.now ?? (() => Date.now());
+  }
+  canRefresh() {
+    return true;
+  }
+  async getCredential(ctx) {
+    const forceRefresh = ctx?.forceRefresh ?? false;
+    if (!forceRefresh && this.cached && !this.isExpiring(this.cached)) {
+      return { scheme: this.scheme, token: this.cached.token };
+    }
+    const fresh = await this.refresh();
+    return { scheme: this.scheme, token: fresh.token };
+  }
+  isExpiring(token) {
+    if (token.expiresAt === void 0) {
+      return false;
+    }
+    return this.now() >= token.expiresAt - this.skewMs;
+  }
+  refresh() {
+    if (this.inFlight) {
+      return this.inFlight;
+    }
+    this.inFlight = (async () => {
+      try {
+        const fresh = await this.opts.fetchToken();
+        this.cached = fresh;
+        this.opts.onRotate?.({ expiresAt: fresh.expiresAt });
+        return fresh;
+      } finally {
+        this.inFlight = null;
+      }
+    })();
+    return this.inFlight;
+  }
+};
+
 // src/core/errors.ts
 var VesantError = class _VesantError extends Error {
   constructor(message, code, statusCode, details) {
@@ -242,7 +298,7 @@ var noopLogger = {
 };
 
 // src/core/version.ts
-var SDK_VERSION = "1.7.0";
+var SDK_VERSION = "1.7.1";
 
 // src/shared/browser-utils.ts
 function generateUUID() {
@@ -324,6 +380,12 @@ var BaseClient = class {
     if (!config.tenantId?.trim()) {
       throw new ValidationError("tenantId is required and must be a non-empty string", ["tenantId"]);
     }
+    if (typeof fetch === "undefined") {
+      throw new VesantError(
+        "The Vesant SDK requires a global fetch (Node.js >= 18). Upgrade Node or provide a fetch polyfill.",
+        "RUNTIME_UNSUPPORTED"
+      );
+    }
     this.interceptors = config.interceptors || [];
     this.logger = config.logger || createConsoleLogger();
     let environment = config.environment;
@@ -342,11 +404,12 @@ var BaseClient = class {
       environment,
       headers: config.headers || {},
       timeout: config.timeout || 1e4,
-      retries: config.retries || 3,
+      retries: config.retries ?? 3,
       debug: config.debug || false,
       interceptors: this.interceptors,
       logger: this.logger
     };
+    this.authProvider = config.authProvider ?? (apiKey ? new StaticApiKeyProvider(apiKey) : void 0);
     if (config.circuitBreaker) {
       this.circuitBreaker = new CircuitBreaker(config.circuitBreaker);
     }
@@ -354,6 +417,19 @@ var BaseClient = class {
       this.rateLimitTracker = new RateLimitTracker();
     }
   }
+  /**
+   * Resolve the Idempotency-Key for a request. Mutating methods (POST/PUT/PATCH)
+   * get the caller-supplied key or a freshly minted UUID; non-mutating methods get
+   * none. requestWithRetry resolves this once and injects it so every retry reuses
+   * one key (letting the server dedup replays); a direct request() resolves per call.
+   */
+  resolveIdempotencyKey(method, requestOptions) {
+    const isMutating = ["POST", "PUT", "PATCH"].includes((method || "GET").toUpperCase());
+    if (!isMutating) {
+      return void 0;
+    }
+    return requestOptions?.idempotencyKey ?? generateUUID();
+  }
   /**
    * Make an HTTP request with timeout and error handling
    */
@@ -379,15 +455,20 @@ var BaseClient = class {
       ...this.config.headers,
       ...options.headers || {}
     };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    const credential = await this.authProvider?.getCredential({
+      tenantId: this.config.tenantId,
+      requestId
+    });
+    if (credential) {
+      headers["Authorization"] = `${credential.scheme ?? "Bearer"} ${credential.token}`;
     }
     if (this.config.environment === "sandbox") {
       headers["X-Sandbox"] = "true";
     }
     const method = (options.method || "GET").toUpperCase();
-    if (["POST", "PUT", "PATCH"].includes(method)) {
-      headers["Idempotency-Key"] = requestOptions?.idempotencyKey || generateUUID();
+    const idempotencyKey = this.resolveIdempotencyKey(method, requestOptions);
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
     }
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
@@ -408,10 +489,28 @@ var BaseClient = class {
       if (this.config.debug) {
         this.logger.debug(`${finalOptions.method || "GET"} ${endpoint}`);
       }
-      const response = await fetch(url, {
+      let response = await fetch(url, {
         ...finalOptions,
         signal: controller.signal
       });
+      if (response.status === 401 && this.authProvider?.canRefresh?.()) {
+        const refreshed = await this.authProvider.getCredential({
+          tenantId: this.config.tenantId,
+          requestId,
+          forceRefresh: true
+        });
+        if (refreshed) {
+          this.config.onCredentialRotated?.({ reason: "unauthorized" });
+          finalOptions = {
+            ...finalOptions,
+            headers: {
+              ...finalOptions.headers,
+              Authorization: `${refreshed.scheme ?? "Bearer"} ${refreshed.token}`
+            }
+          };
+          response = await fetch(url, { ...finalOptions, signal: controller.signal });
+        }
+      }
       clearTimeout(timeoutId);
       if (this.rateLimitTracker) {
         this.rateLimitTracker.updateFromHeaders(response.headers);
@@ -500,9 +599,11 @@ var BaseClient = class {
    */
   async requestWithRetry(endpoint, options = {}, serviceURL, retries = this.config.retries, requestOptions) {
     let lastError;
+    const idempotencyKey = this.resolveIdempotencyKey(options.method || "GET", requestOptions);
+    const attemptOptions = idempotencyKey ? { ...requestOptions, idempotencyKey } : requestOptions;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        return await this.request(endpoint, options, serviceURL, requestOptions);
+        return await this.request(endpoint, options, serviceURL, attemptOptions);
       } catch (error) {
         lastError = error instanceof Error ? error : new Error("Unknown error");
         if (requestOptions?.signal?.aborted) {
@@ -599,6 +700,9 @@ var BaseClient = class {
     if (config.interceptors) {
       this.interceptors = config.interceptors;
     }
+    if (config.authProvider !== void 0 || config.apiKey !== void 0) {
+      this.authProvider = this.config.authProvider ?? (this.config.apiKey ? new StaticApiKeyProvider(this.config.apiKey) : void 0);
+    }
   }
   /**
    * Get current configuration (readonly)
@@ -626,8 +730,69 @@ var BaseClient = class {
   }
 };
 
+// src/core/pagination.ts
+async function* paginate(fetchPage) {
+  let page = 1;
+  let totalPages;
+  do {
+    const response = await fetchPage(page);
+    const items = response.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    totalPages = response.total_pages ?? page;
+    if (items.length === 0) {
+      break;
+    }
+    page += 1;
+  } while (page <= totalPages);
+}
+async function collectAll(fetchPage) {
+  const items = [];
+  for await (const item of paginate(fetchPage)) {
+    items.push(item);
+  }
+  return items;
+}
+
+// src/core/dedup.ts
+var InMemoryDedupStore = class {
+  constructor(opts = {}) {
+    this.expiryById = /* @__PURE__ */ new Map();
+    this.maxEntries = opts.maxEntries ?? 1e3;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  async seen(id) {
+    return this.expiryById.has(id);
+  }
+  async mark(id, ttlMs) {
+    const now = this.now();
+    this.expiryById.set(id, now + ttlMs);
+    if (this.expiryById.size > this.maxEntries) {
+      for (const [key, expiresAt] of this.expiryById) {
+        if (now > expiresAt) {
+          this.expiryById.delete(key);
+        }
+      }
+    }
+  }
+};
+
 // src/core/webhook-utils.ts
-async function verifyWebhookSignature(payload, signature, secret) {
+async function verifyWebhookSignature(payload, signature, secret, opts = {}) {
+  const signed = parseSignedTimestamp(signature);
+  if (signed) {
+    const tolerance = opts.tolerance ?? 3e5;
+    const now = opts.now?.() ?? Date.now();
+    if (tolerance > 0 && Math.abs(now - signed.t * 1e3) > tolerance) {
+      return false;
+    }
+    const expected = await computeHmacSha256(`${signed.t}.${payload}`, secret);
+    return constantTimeEqual(signed.v1, expected);
+  }
+  if (opts.allowLegacy === false) {
+    return false;
+  }
   const hexDigest = await computeHmacSha256(payload, secret);
   const expectedPrefixed = `sha256=${hexDigest}`;
   if (signature.startsWith("sha256=")) {
@@ -635,6 +800,25 @@ async function verifyWebhookSignature(payload, signature, secret) {
   }
   return constantTimeEqual(signature, hexDigest);
 }
+function parseSignedTimestamp(signature) {
+  if (!signature.includes("t=") || !signature.includes("v1=")) {
+    return null;
+  }
+  let t;
+  let v1;
+  for (const part of signature.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") t = Number(value);
+    else if (key === "v1") v1 = value;
+  }
+  if (t === void 0 || Number.isNaN(t) || !v1) {
+    return null;
+  }
+  return { t, v1 };
+}
 async function computeHmacSha256(message, secret) {
   if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
     const encoder = new TextEncoder();
@@ -669,27 +853,63 @@ function constantTimeEqual(a, b) {
   return result === 0;
 }
 
-// src/geolocation/ciphertext.ts
-var CIPHER_TEXT_EXPIRY_MINUTES = 5;
-async function computeHMAC(key, message) {
-  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
-    const encoder = new TextEncoder();
-    const keyData = encoder.encode(key);
-    const msgData = encoder.encode(message);
-    const cryptoKey = await globalThis.crypto.subtle.importKey(
-      "raw",
-      keyData,
-      { name: "HMAC", hash: "SHA-256" },
-      false,
-      ["sign"]
-    );
-    const signature = await globalThis.crypto.subtle.sign("HMAC", cryptoKey, msgData);
-    const bytes = new Uint8Array(signature);
-    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+// src/geolocation/integrity.ts
+var isNil = (v) => v === null || v === void 0;
+function assessGpsIntegrity(input, opts = {}) {
+  const flags = [];
+  const now = opts.now ?? (() => Date.now());
+  const maxAgeMs = opts.maxAgeMs ?? 6e4;
+  const minAccuracy = opts.minAccuracyMeters ?? 1;
+  const { accuracy, altitude, altitudeAccuracy, heading, speed, timestamp } = input;
+  if (isNil(accuracy)) {
+    flags.push("accuracy_missing");
+  } else if (accuracy === 0) {
+    flags.push("accuracy_zero");
+  } else if (accuracy < minAccuracy) {
+    flags.push("accuracy_implausibly_small");
+  }
+  const hasMotion = !isNil(heading) || !isNil(speed);
+  if (hasMotion && (isNil(accuracy) || accuracy === 0)) {
+    flags.push("motion_without_accuracy");
+  }
+  if (!isNil(altitude) && isNil(altitudeAccuracy)) {
+    flags.push("altitude_without_accuracy");
+  }
+  if (timestamp !== void 0 && now() - timestamp > maxAgeMs) {
+    flags.push("stale_timestamp");
+  }
+  if (opts.permissionState === "denied" || opts.permissionState === "prompt") {
+    flags.push(`permission_${opts.permissionState}`);
+  }
+  return { suspicious: flags.length > 0, flags };
+}
+function gpsIntegrityInputFromPosition(position) {
+  const c = position.coords;
+  return {
+    latitude: c.latitude,
+    longitude: c.longitude,
+    accuracy: c.accuracy,
+    altitude: c.altitude,
+    altitudeAccuracy: c.altitudeAccuracy,
+    heading: c.heading,
+    speed: c.speed,
+    timestamp: position.timestamp
+  };
+}
+async function probeGeolocationPermission() {
+  try {
+    if (typeof navigator === "undefined" || !navigator.permissions?.query) {
+      return "unavailable";
+    }
+    const status = await navigator.permissions.query({ name: "geolocation" });
+    return status.state;
+  } catch {
+    return "unavailable";
   }
-  const { createHmac } = await import('crypto');
-  return createHmac("sha256", key).update(message).digest("hex");
 }
+
+// src/geolocation/ciphertext.ts
+var CIPHER_TEXT_EXPIRY_MINUTES = 5;
 function getWebGLInfo() {
   if (typeof document === "undefined") return null;
   try {
@@ -721,6 +941,7 @@ async function requestGPSLocation(timeout = 1e4, highAccuracy = true) {
   if (typeof navigator === "undefined" || !navigator.geolocation) {
     return null;
   }
+  const permissionState = await probeGeolocationPermission();
   return new Promise((resolve) => {
     navigator.geolocation.getCurrentPosition(
       (position) => {
@@ -737,6 +958,7 @@ async function requestGPSLocation(timeout = 1e4, highAccuracy = true) {
           resolve(null);
           return;
         }
+        const { flags } = assessGpsIntegrity(gpsIntegrityInputFromPosition(position), { permissionState });
         resolve({
           latitude,
           longitude,
@@ -745,7 +967,8 @@ async function requestGPSLocation(timeout = 1e4, highAccuracy = true) {
           altitude_accuracy: position.coords.altitudeAccuracy ?? void 0,
           heading: position.coords.heading ?? void 0,
           speed: position.coords.speed ?? void 0,
-          timestamp: position.timestamp
+          timestamp: position.timestamp,
+          integrity_flags: flags.length ? flags : void 0
         });
       },
       () => {
@@ -812,6 +1035,9 @@ async function generateCipherText(options, config) {
     );
     if (location) {
       locationData = location;
+      if (location.integrity_flags?.length) {
+        warnings.push(`GPS integrity flags (advisory): ${location.integrity_flags.join(", ")}`);
+      }
     } else if (gpsRequiredByConfig) {
       throw new VesantError(
         `GPS location is required for ${options.reason} by tenant configuration, but GPS was not available or permission was denied`,
@@ -841,15 +1067,7 @@ async function generateCipherText(options, config) {
   };
   const encoded = encodePayload(payload);
   const timestamp = now.getTime().toString(36);
-  let cipherText;
-  const hmacKey = options.signingKey || options.apiKey;
-  if (hmacKey) {
-    const message = `02.${timestamp}.${encoded}`;
-    const hmac = await computeHMAC(hmacKey, message);
-    cipherText = `${message}.${hmac}`;
-  } else {
-    cipherText = `01.${timestamp}.${encoded}`;
-  }
+  const cipherText = `01.${timestamp}.${encoded}`;
   return {
     cipherText,
     locationCaptured: !!locationData,
@@ -858,6 +1076,7 @@ async function generateCipherText(options, config) {
     expiresAt: expiry.toISOString()
   };
 }
+var collectDeviceSignals = generateCipherText;
 function decodeCipherText(cipherText) {
   try {
     const parts = cipherText.split(".");
@@ -931,8 +1150,8 @@ var GeolocationClient = class extends BaseClient {
    * ```
    */
   async verifyIP(request, requestOptions) {
-    if (!request.ip_address?.trim()) {
-      throw new ValidationError("ip_address is required and must be a non-empty string", ["ip_address"]);
+    if (request.ip_address !== void 0 && !request.ip_address.trim()) {
+      throw new ValidationError("ip_address, when provided, must be a non-empty string", ["ip_address"]);
     }
     return this.requestWithRetry("/api/v1/geo/verify", {
       method: "POST",
@@ -985,37 +1204,50 @@ var GeolocationClient = class extends BaseClient {
    * ```
    */
   async getGPSConfig(requestOptions) {
-    const config = await this.requestWithRetry("/api/v1/geo/config", void 0, void 0, void 0, requestOptions);
-    if (config.signing_key) {
-      this.cachedSigningKey = config.signing_key;
-    }
-    return config;
+    return this.requestWithRetry("/api/v1/geo/config", void 0, void 0, void 0, requestOptions);
   }
   /**
-   * Fetch the signing key from the dedicated authenticated endpoint.
+   * Mint a short-lived, single-use device-signals nonce.
    *
-   * Falls back to getGPSConfig() for backward compatibility with older servers
-   * that don't expose `/api/v1/geo/signing-key`.
+   * The nonce is bound to the tenant, user, and event type and is consumed
+   * server-side during validation, so a captured device-signals envelope cannot
+   * be replayed. `validateCipherText` mints and attaches one automatically; call
+   * this directly only if you manage the nonce yourself.
    *
-   * @returns The signing key string, or undefined if unavailable
+   * @param userId - User ID the nonce is bound to
+   * @param eventType - Event type the nonce is bound to (login, registration, ...)
+   * @returns The nonce and its expiry
+   */
+  async fetchSignalsNonce(userId, eventType, requestOptions) {
+    if (!userId?.trim()) {
+      throw new ValidationError("userId is required and must be a non-empty string", ["userId"]);
+    }
+    const request = { user_id: userId, event_type: eventType };
+    return this.request(
+      "/api/v1/geo/signals-token",
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      },
+      void 0,
+      requestOptions
+    );
+  }
+  /**
+   * Best-effort nonce mint for validation. Returns undefined if minting fails —
+   * the server is the sole authority and blocks when a nonce is required, so this
+   * never downgrades security on the client's say-so.
    */
-  async fetchSigningKey(requestOptions) {
+  async resolveSignalsNonce(userId, eventType, requestOptions) {
     try {
-      const response = await this.requestWithRetry(
-        "/api/v1/geo/signing-key",
-        void 0,
-        void 0,
-        void 0,
-        requestOptions
+      const { nonce } = await this.fetchSignalsNonce(userId, eventType, requestOptions);
+      return nonce;
+    } catch (err) {
+      this.logger.warn(
+        `Failed to mint device-signals nonce; proceeding without it: ${err instanceof Error ? err.message : String(err)}`
       );
-      if (response.signing_key) {
-        this.cachedSigningKey = response.signing_key;
-        return response.signing_key;
-      }
-    } catch {
+      return void 0;
     }
-    const config = await this.getGPSConfig(requestOptions);
-    return config.signing_key;
   }
   // ============================================================================
   // CipherText Validation
@@ -1068,12 +1300,14 @@ var GeolocationClient = class extends BaseClient {
     if (!userId?.trim()) {
       throw new ValidationError("userId is required and must be a non-empty string", ["userId"]);
     }
+    const nonce = await this.resolveSignalsNonce(userId, eventType, requestOptions);
     const request = {
       cipher_text: cipherText,
       user_id: userId,
       event_type: eventType,
       expected_ip: expectedIP,
-      customer_data: customerData
+      customer_data: customerData,
+      nonce
     };
     return this.requestWithRetry(
       "/api/v1/geo/validate-ciphertext",
@@ -1282,20 +1516,12 @@ var GeolocationClient = class extends BaseClient {
    *
    * @example
    * ```typescript
-   * // Using GPS (preferred)
+   * // GPS (the web SDK is GPS + IP only; the server handles the IP fallback)
    * const result = await client.captureLocation(token, {
    *   latitude: 37.7749,
    *   longitude: -122.4194,
    *   accuracy: 10
    * });
-   *
-   * // Using WiFi positioning (fallback)
-   * const result = await client.captureLocation(token, {
-   *   wifi_networks: [
-   *     { macAddress: "00:11:22:33:44:55", signalStrength: -50 },
-   *     { macAddress: "AA:BB:CC:DD:EE:FF", signalStrength: -70 }
-   *   ]
-   * });
    * ```
    */
   async captureLocation(token, capture, requestOptions) {
@@ -1308,34 +1534,22 @@ var GeolocationClient = class extends BaseClient {
   // CipherText Generation
   // ============================================================================
   /**
-   * Generate a signed cipherText containing device and location data.
+   * Generate a device-signals envelope containing device and location data,
+   * validated by the server.
    *
-   * Automatically passes the client's API key for HMAC signing (v02 format).
-   * If no API key is configured, falls back to unsigned v01 format.
-   *
-   * @param options - Options for cipherText generation
+   * @param options - Options for envelope generation
    * @param gpsConfig - Optional GPS config (from getGPSConfig)
-   * @returns CipherText result with the signed string
+   * @returns The device-signals envelope result
    *
    * @example
    * ```typescript
    * const result = await client.generateCipherText({ reason: 'login' });
-   * console.log(result.cipherText); // v02 signed cipherText
+   * console.log(result.cipherText); // device-signals envelope
    * ```
    */
   async generateCipherText(options, gpsConfig) {
-    let signingKey = this.cachedSigningKey;
-    let resolvedGpsConfig = gpsConfig;
-    if (!signingKey) {
-      signingKey = await this.fetchSigningKey();
-    }
-    if (!resolvedGpsConfig) {
-      resolvedGpsConfig = await this.getGPSConfig();
-    }
-    return generateCipherText(
-      { ...options, signingKey: signingKey || void 0 },
-      resolvedGpsConfig
-    );
+    const resolvedGpsConfig = gpsConfig ?? await this.getGPSConfig();
+    return generateCipherText(options, resolvedGpsConfig);
   }
   // ============================================================================
   // Utility Methods (inherited from BaseClient: healthCheck, updateConfig, getConfig, buildQueryString)
@@ -2738,12 +2952,12 @@ var KycClient = class extends BaseClient {
    * console.log(`KYC ID: ${result.kyc_id}`);
    * ```
    */
-  async requestKycSubmitLink(request) {
+  async requestKycSubmitLink(request, requestOptions) {
     return this.requestWithRetry("/api/v1/kyc/request", {
       method: "POST",
       body: JSON.stringify(request),
       headers: this.getUserHeaders()
-    });
+    }, void 0, void 0, requestOptions);
   }
   /**
    * Create a Event-Based Face Verification session.
@@ -2776,12 +2990,12 @@ var KycClient = class extends BaseClient {
    *
    * @param request - Token from `createEventBasedFaceVerificationSession`, plus the base64 selfie.
    */
-  async submitEventBasedFaceVerificationSession(request) {
+  async submitEventBasedFaceVerificationSession(request, requestOptions) {
     return this.request("/api/v1/kyc/face/submit", {
       method: "POST",
       body: JSON.stringify(request),
       headers: this.getUserHeaders()
-    });
+    }, void 0, requestOptions);
   }
   /**
    * Look up the current state of a Event-Based Face Verification session by its
@@ -2897,12 +3111,12 @@ var KycClient = class extends BaseClient {
    * console.log(`Verification submitted: ${result.reference}`);
    * ```
    */
-  async submitVerification(request) {
+  async submitVerification(request, requestOptions) {
     return this.requestWithRetry("/api/v1/kyc/submit", {
       method: "POST",
       body: JSON.stringify(request),
       headers: this.getUserHeaders()
-    });
+    }, void 0, void 0, requestOptions);
   }
   /**
    * Get a KYC request by ID
@@ -3342,10 +3556,13 @@ var TaxClient = class extends BaseClient {
       { method: "POST" }
     );
   }
-  async checkTINStatus(customerID) {
+  async checkTINStatus(customerID, requestOptions) {
     return this.requestWithRetry(
       `/api/v1/tax/customer-tax-profiles/${customerID}/check-tin`,
-      { method: "POST" }
+      { method: "POST" },
+      void 0,
+      void 0,
+      requestOptions
     );
   }
   async reRequestTaxForm(customerID, input) {
@@ -3426,14 +3643,24 @@ var TaxClient = class extends BaseClient {
 };
 
 // src/webhooks/handler.ts
+function resolveEventId(event) {
+  if (event.id) {
+    return event.id;
+  }
+  if (event.event_type === "notification.created") {
+    return event.notification?.id;
+  }
+  return void 0;
+}
 var WebhookHandler = class {
   constructor(config) {
     this.handlers = /* @__PURE__ */ new Map();
     this.anyHandlers = [];
-    this.seenEventIds = /* @__PURE__ */ new Map();
     this.secret = config.secret;
     this.tolerance = config.tolerance ?? 3e5;
     this.replayProtection = config.replayProtection ?? true;
+    this.allowLegacySignature = config.allowLegacySignature ?? true;
+    this.dedupStore = config.dedupStore ?? new InMemoryDedupStore();
   }
   /**
    * Register a handler for a specific event type.
@@ -3455,7 +3682,10 @@ var WebhookHandler = class {
    * Verify signature and parse the webhook body.
    */
   async verifyAndParse(body, signature) {
-    const isValid = await verifyWebhookSignature(body, signature, this.secret);
+    const isValid = await verifyWebhookSignature(body, signature, this.secret, {
+      tolerance: this.tolerance,
+      allowLegacy: this.allowLegacySignature
+    });
     if (!isValid) {
       throw new ValidationError("Invalid webhook signature", ["signature"]);
     }
@@ -3471,18 +3701,21 @@ var WebhookHandler = class {
   /**
    * Parse an event without signature verification (for testing).
    */
-  parseEvent(body) {
+  async parseEvent(body) {
     return this.parseAndValidate(body);
   }
-  parseAndValidate(body) {
+  async parseAndValidate(body) {
     const event = JSON.parse(body);
-    if (!event.type || !event.id || !event.timestamp) {
-      throw new ValidationError("Invalid webhook event: missing required fields (type, id, timestamp)", ["type", "id", "timestamp"]);
+    const eventId = resolveEventId(event);
+    if (!event.event_type || !eventId || !event.timestamp) {
+      throw new ValidationError(
+        "Invalid webhook event: missing required fields (event_type, id, timestamp)",
+        ["event_type", "id", "timestamp"]
+      );
     }
     if (this.tolerance > 0) {
       const eventTime = new Date(event.timestamp).getTime();
-      const now = Date.now();
-      if (Math.abs(now - eventTime) > this.tolerance) {
+      if (Math.abs(Date.now() - eventTime) > this.tolerance) {
         throw new ValidationError(
           `Webhook event timestamp is outside tolerance window (${this.tolerance}ms)`,
           ["timestamp"]
@@ -3490,26 +3723,18 @@ var WebhookHandler = class {
       }
     }
     if (this.replayProtection) {
-      if (this.seenEventIds.has(event.id)) {
+      if (await this.dedupStore.seen(eventId)) {
         throw new ValidationError(
-          `Duplicate webhook event: ${event.id} has already been processed`,
+          `Duplicate webhook event: ${eventId} has already been processed`,
           ["id"]
         );
       }
-      const now = Date.now();
-      this.seenEventIds.set(event.id, now);
-      if (this.seenEventIds.size > 1e3) {
-        for (const [id, seenAt] of this.seenEventIds) {
-          if (now - seenAt > this.tolerance) {
-            this.seenEventIds.delete(id);
-          }
-        }
-      }
+      await this.dedupStore.mark(eventId, this.tolerance);
     }
     return event;
   }
   async dispatch(event) {
-    const typeHandlers = this.handlers.get(event.type) || [];
+    const typeHandlers = this.handlers.get(event.event_type) || [];
     const allHandlers = [...typeHandlers, ...this.anyHandlers];
     for (const handler of allHandlers) {
       await handler(event);
@@ -3600,26 +3825,35 @@ exports.ComplianceClient = ComplianceClient;
 exports.ComplianceError = ComplianceError;
 exports.DEFAULT_CURRENCY_RATES = DEFAULT_CURRENCY_RATES;
 exports.GeolocationClient = GeolocationClient;
+exports.InMemoryDedupStore = InMemoryDedupStore;
 exports.KYC_DECLINED_DESCRIPTIONS = KYC_DECLINED_DESCRIPTIONS;
 exports.KycClient = KycClient;
 exports.NetworkError = NetworkError;
 exports.RateLimitError = RateLimitError;
 exports.RateLimitTracker = RateLimitTracker;
+exports.RefreshingTokenProvider = RefreshingTokenProvider;
 exports.RiskProfileClient = RiskProfileClient;
 exports.SDK_VERSION = SDK_VERSION;
 exports.ServiceUnavailableError = ServiceUnavailableError;
+exports.StaticApiKeyProvider = StaticApiKeyProvider;
 exports.TaxClient = TaxClient;
 exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
 exports.VesantError = VesantError;
 exports.WebhookHandler = WebhookHandler;
+exports.assessGpsIntegrity = assessGpsIntegrity;
+exports.collectAll = collectAll;
+exports.collectDeviceSignals = collectDeviceSignals;
 exports.createConsoleLogger = createConsoleLogger;
 exports.createNextWebhookHandler = createNextWebhookHandler;
 exports.createWebhookMiddleware = createWebhookMiddleware;
 exports.decodeCipherText = decodeCipherText;
 exports.generateCipherText = generateCipherText;
+exports.gpsIntegrityInputFromPosition = gpsIntegrityInputFromPosition;
 exports.isCipherTextExpired = isCipherTextExpired;
 exports.noopLogger = noopLogger;
+exports.paginate = paginate;
+exports.probeGeolocationPermission = probeGeolocationPermission;
 exports.sdkReasons = sdkReasons;
 exports.verifyWebhookSignature = verifyWebhookSignature;
 //# sourceMappingURL=index.js.map