@reclaimprotocol/js-sdk 4.8.0 → 4.9.0

package/README.md

@@ -442,6 +442,23 @@ const proofRequest = await ReclaimProofRequest.init(APP_ID, APP_SECRET, PROVIDER
 });
 ```
 
+15. Set preferred locale for verification client:
+
+An identifier used to select a user's language and formatting preferences.
+
+This represents a Unicode Language Identifier (i.e. without Locale extensions), except variants are not supported.
+Locales are expected to be canonicalized according to the "preferred value" entries in the [IANA Language Subtag Registry](https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry). 
+For example, `he`, and `iw` are equal and both have the languageCode `he`, because `iw` is a deprecated language subtag that was replaced by the subtag `he`.
+
+Defaults to the browser's locale if available, otherwise English (en).
+
+```js
+// Initialize with options
+const proofRequest = await ReclaimProofRequest.init(APP_ID, APP_SECRET, PROVIDER_ID, {
+  preferredLocale: 'en-US',
+});
+```
+
 ## Handling Proofs on Your Backend
 
 For production applications, it's recommended to handle proofs, and errors on your backend:

package/dist/index.d.ts

@@ -81,6 +81,19 @@ type ProofRequestOptions = {
      * @default true
      */
     canAutoSubmit?: boolean;
+    /**
+     * An identifier used to select a user's language and formatting preferences.
+     *
+     * Locales are expected to be canonicalized according to the "preferred value" entries in the [IANA Language Subtag Registry](https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry).
+     * For example, `he`, and `iw` are equal and both have the languageCode `he`, because `iw` is a deprecated language subtag that was replaced by the subtag `he`.
+     *
+     * Defaults to the browser's locale if available, otherwise English (en).
+     *
+     * For more info, refer: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#description
+     *
+     * @since 4.9.0
+     */
+    preferredLocale?: string;
     /**
      * Additional metadata to pass to the verification client.
      * This can be used to customize the client experience, such as customizing themes or UI by passing context-specific information.
@@ -145,6 +158,8 @@ type ProofPropertiesJSON = {
     timeStamp?: string;
     timestamp?: string;
     appCallbackUrl?: string;
+    errorCallbackUrl?: TemplateData['errorCallbackUrl'];
+    errorRedirectUrl?: TemplateData['errorRedirectUrl'];
     claimCreationType?: ClaimCreationType;
     options?: ProofRequestOptions;
     sdkVersion: string;
@@ -152,6 +167,30 @@ type ProofPropertiesJSON = {
     resolvedProviderVersion: string;
     modalOptions?: SerializableModalOptions;
 };
+type TemplateData = {
+    sessionId: string;
+    providerId: string;
+    applicationId: string;
+    signature: string;
+    timestamp: string;
+    callbackUrl: string;
+    context: string;
+    parameters: {
+        [key: string]: string;
+    };
+    redirectUrl: string;
+    errorCallbackUrl?: string | null;
+    errorRedirectUrl?: string | null;
+    acceptAiProviders: boolean;
+    sdkVersion: string;
+    jsonProofResponse?: boolean;
+    providerVersion?: string;
+    resolvedProviderVersion: string;
+    log?: boolean;
+    canAutoSubmit?: boolean;
+    metadata?: Record<string, string>;
+    preferredLocale?: ProofRequestOptions['preferredLocale'];
+};
 
 /**
  * Verifies one or more Reclaim proofs by validating signatures and witness information
@@ -198,6 +237,8 @@ declare class ReclaimProofRequest {
     private resolvedProviderVersion?;
     private parameters;
     private redirectUrl?;
+    private errorCallbackUrl?;
+    private errorRedirectUrl?;
     private intervals;
     private timeStamp;
     private sdkVersion;
@@ -284,6 +325,41 @@ declare class ReclaimProofRequest {
      * ```
      */
     setRedirectUrl(url: string): void;
+    /**
+     * Sets a custom callback URL where errors that abort the verification process will be submitted via HTTP POST
+     *
+     * Errors will be HTTP POSTed with `header 'Content-Type': 'application/json'`.
+     * When a custom error callback URL is set, Reclaim will no longer receive errors upon submission,
+     * and listeners on the startSession method will not be triggered. Your application must
+     * coordinate with your backend to receive errors.
+     *
+     * @param url - The URL where errors should be submitted via HTTP POST
+     * @throws {InvalidParamError} When URL is invalid
+     *
+     * @example
+     * ```typescript
+     * proofRequest.setErrorCallbackUrl('https://your-backend.com/error-callback');
+     * ```
+     *
+     * @since 4.8.1
+     *
+     */
+    setErrorCallbackUrl(url: string): void;
+    /**
+     * Sets an error redirect URL where users will be redirected after an error which aborts the verification process
+     *
+     * @param url - The URL where users should be redirected after an error which aborts the verification process
+     * @throws {InvalidParamError} When URL is invalid
+     *
+     * @example
+     * ```typescript
+     * proofRequest.setErrorRedirectUrl('https://your-app.com/error');
+     * ```
+     *
+     * @since 4.8.1
+     *
+     */
+    setErrorRedirectUrl(url: string): void;
     /**
      * Sets the claim creation type for the proof request
      *
@@ -387,6 +463,22 @@ declare class ReclaimProofRequest {
      * ```
      */
     getAppCallbackUrl(): string;
+    /**
+     * Returns the currently configured error callback URL
+     *
+     * If no custom error callback URL was set via setErrorCallbackUrl(), this returns the default
+     * Reclaim service error callback URL with the current session ID.
+     *
+     * @returns The error callback URL where proofs will be submitted
+     * @throws {GetAppCallbackUrlError} When unable to retrieve the error callback URL
+     *
+     * @example
+     * ```typescript
+     * const callbackUrl = proofRequest.getErrorCallbackUrl();
+     * console.log('Errors will be sent to:', callbackUrl);
+     * ```
+     */
+    getErrorCallbackUrl(): string;
     /**
      * Returns the status URL for monitoring the current session
      *

package/dist/index.js

@@ -72,7 +72,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@reclaimprotocol/js-sdk",
-      version: "4.7.0",
+      version: "4.9.0",
       description: "Designed to request proofs from the Reclaim protocol and manage the flow of claims and witness interactions.",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -104,6 +104,7 @@ var require_package = __commonJS({
       },
       scripts: {
         build: "sh scripts/build.sh",
+        prepare: "npm run build",
         release: "release-it",
         test: "jest",
         "test:watch": "jest --watch",
@@ -322,6 +323,7 @@ var GetAppCallbackUrlError = createErrorClass("GetAppCallbackUrlError");
 var StatusUrlError = createErrorClass("StatusUrlError");
 var InavlidParametersError = createErrorClass("InavlidParametersError");
 var ProofSubmissionFailedError = createErrorClass("ProofSubmissionFailedError");
+var ErrorDuringVerificationError = createErrorClass("ErrorDuringVerificationError");
 
 // src/utils/logger.ts
 var SimpleLogger = class {
@@ -405,6 +407,10 @@ var constants = {
   get DEFAULT_RECLAIM_CALLBACK_URL() {
     return `${BACKEND_BASE_URL}/api/sdk/callback?callbackId=`;
   },
+  // Default error callback URL for Reclaim protocol
+  get DEFAULT_RECLAIM_ERROR_CALLBACK_URL() {
+    return `${BACKEND_BASE_URL}/api/sdk/error-callback?callbackId=`;
+  },
   // Default status URL for Reclaim sessions
   get DEFAULT_RECLAIM_STATUS_URL() {
     return `${BACKEND_BASE_URL}/api/sdk/session/`;
@@ -437,6 +443,12 @@ function validateFunctionParams(params, functionName) {
     }
   });
 }
+function validateFunctionParamsWithFn(param, functionName) {
+  if (!param.isValid()) {
+    logger3.info(`Validation failed: ${param.paramName} in ${functionName} is not valid`);
+    throw new InvalidParamError(`${param.paramName} passed to ${functionName} must be valid.`);
+  }
+}
 function validateParameters(parameters) {
   try {
     if (typeof parameters !== "object" || parameters === null) {
@@ -1861,6 +1873,8 @@ var emptyTemplateData = {
   context: "",
   parameters: {},
   redirectUrl: "",
+  errorCallbackUrl: "",
+  errorRedirectUrl: "",
   acceptAiProviders: false,
   sdkVersion: "",
   providerVersion: "",
@@ -1882,7 +1896,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
      * @returns 
      */
     this.getTemplateData = () => {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
       if (!this.signature) {
         throw new SignatureNotFoundError("Signature is not set.");
       }
@@ -1899,12 +1913,15 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
         resolvedProviderVersion: (_c = this.resolvedProviderVersion) != null ? _c : "",
         parameters: this.parameters,
         redirectUrl: (_d = this.redirectUrl) != null ? _d : "",
+        errorCallbackUrl: this.getErrorCallbackUrl(),
+        errorRedirectUrl: this.errorRedirectUrl,
         acceptAiProviders: (_f = (_e = this.options) == null ? void 0 : _e.acceptAiProviders) != null ? _f : false,
         sdkVersion: this.sdkVersion,
         jsonProofResponse: this.jsonProofResponse,
         log: (_h = (_g = this.options) == null ? void 0 : _g.log) != null ? _h : false,
         canAutoSubmit: (_j = (_i = this.options) == null ? void 0 : _i.canAutoSubmit) != null ? _j : true,
-        metadata: (_k = this.options) == null ? void 0 : _k.metadata
+        metadata: (_k = this.options) == null ? void 0 : _k.metadata,
+        preferredLocale: (_l = this.options) == null ? void 0 : _l.preferredLocale
       };
       return templateData;
     };
@@ -2022,6 +2039,24 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
               { paramName: "customAppClipUrl", input: options.customAppClipUrl, isString: true }
             ], "the constructor");
           }
+          if (options.preferredLocale) {
+            validateFunctionParams([
+              { paramName: "preferredLocale", input: options.preferredLocale, isString: true }
+            ], "the constructor");
+            validateFunctionParamsWithFn({
+              paramName: "preferredLocale",
+              input: options.preferredLocale,
+              isValid: () => {
+                try {
+                  Intl.getCanonicalLocales(options.preferredLocale);
+                  return true;
+                } catch (error) {
+                  logger7.info("Failed to canonicalize locale", error);
+                  return false;
+                }
+              }
+            }, "the constructor");
+          }
         }
         const proofRequestInstance = new _ReclaimProofRequest(applicationId, providerId, options);
         const signature = yield proofRequestInstance.generateSignature(appSecret);
@@ -2064,6 +2099,8 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
           parameters,
           signature,
           redirectUrl,
+          errorCallbackUrl,
+          errorRedirectUrl,
           timeStamp,
           timestamp,
           appCallbackUrl,
@@ -2092,6 +2129,12 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
         if (appCallbackUrl) {
           validateURL(appCallbackUrl, "fromJsonString");
         }
+        if (errorRedirectUrl) {
+          validateURL(errorRedirectUrl, "fromJsonString");
+        }
+        if (errorCallbackUrl) {
+          validateURL(errorCallbackUrl, "fromJsonString");
+        }
         if (context) {
           validateContext(context);
         }
@@ -2110,7 +2153,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
         }
         if (options == null ? void 0 : options.providerVersion) {
           validateFunctionParams([
-            { input: options.providerVersion, paramName: "providerVersion", isString: true }
+            { input: options.providerVersion, paramName: "options.providerVersion", isString: true }
           ], "fromJsonString");
         }
         if (resolvedProviderVersion) {
@@ -2118,6 +2161,24 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
             { input: resolvedProviderVersion, paramName: "resolvedProviderVersion", isString: true }
           ], "fromJsonString");
         }
+        if (options == null ? void 0 : options.preferredLocale) {
+          validateFunctionParams([
+            { paramName: "options.preferredLocale", input: options.preferredLocale, isString: true }
+          ], "fromJsonString");
+          validateFunctionParamsWithFn({
+            paramName: "options.preferredLocale",
+            input: options.preferredLocale,
+            isValid: () => {
+              try {
+                Intl.getCanonicalLocales(options.preferredLocale);
+                return true;
+              } catch (error) {
+                logger7.info("Failed to canonicalize locale", error);
+                return false;
+              }
+            }
+          }, "fromJsonString");
+        }
         const proofRequestInstance = new _ReclaimProofRequest(applicationId, providerId, options);
         proofRequestInstance.sessionId = sessionId;
         proofRequestInstance.context = context;
@@ -2130,6 +2191,8 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
         proofRequestInstance.resolvedProviderVersion = resolvedProviderVersion;
         proofRequestInstance.modalOptions = modalOptions;
         proofRequestInstance.jsonProofResponse = jsonProofResponse != null ? jsonProofResponse : false;
+        proofRequestInstance.errorCallbackUrl = errorCallbackUrl;
+        proofRequestInstance.errorRedirectUrl = errorRedirectUrl;
         return proofRequestInstance;
       } catch (error) {
         logger7.info("Failed to parse JSON string in fromJsonString:", error);
@@ -2178,6 +2241,47 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
     validateURL(url, "setRedirectUrl");
     this.redirectUrl = url;
   }
+  /**
+   * Sets a custom callback URL where errors that abort the verification process will be submitted via HTTP POST
+   *
+   * Errors will be HTTP POSTed with `header 'Content-Type': 'application/json'`.
+   * When a custom error callback URL is set, Reclaim will no longer receive errors upon submission,
+   * and listeners on the startSession method will not be triggered. Your application must
+   * coordinate with your backend to receive errors.
+   *
+   * @param url - The URL where errors should be submitted via HTTP POST
+   * @throws {InvalidParamError} When URL is invalid
+   *
+   * @example
+   * ```typescript
+   * proofRequest.setErrorCallbackUrl('https://your-backend.com/error-callback');
+   * ```
+   * 
+   * @since 4.8.1
+   * 
+   */
+  setErrorCallbackUrl(url) {
+    validateURL(url, "setErrorCallbackUrl");
+    this.errorCallbackUrl = url;
+  }
+  /**
+   * Sets an error redirect URL where users will be redirected after an error which aborts the verification process
+   *
+   * @param url - The URL where users should be redirected after an error which aborts the verification process
+   * @throws {InvalidParamError} When URL is invalid
+   *
+   * @example
+   * ```typescript
+   * proofRequest.setErrorRedirectUrl('https://your-app.com/error');
+   * ```
+   * 
+   * @since 4.8.1
+   * 
+   */
+  setErrorRedirectUrl(url) {
+    validateURL(url, "setErrorRedirectUrl");
+    this.errorRedirectUrl = url;
+  }
   /**
    * Sets the claim creation type for the proof request
    *
@@ -2329,6 +2433,30 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
       throw new GetAppCallbackUrlError("Error getting app callback url", error);
     }
   }
+  /**
+   * Returns the currently configured error callback URL
+   *
+   * If no custom error callback URL was set via setErrorCallbackUrl(), this returns the default
+   * Reclaim service error callback URL with the current session ID.
+   *
+   * @returns The error callback URL where proofs will be submitted
+   * @throws {GetAppCallbackUrlError} When unable to retrieve the error callback URL
+   *
+   * @example
+   * ```typescript
+   * const callbackUrl = proofRequest.getErrorCallbackUrl();
+   * console.log('Errors will be sent to:', callbackUrl);
+   * ```
+   */
+  getErrorCallbackUrl() {
+    try {
+      validateFunctionParams([{ input: this.sessionId, paramName: "sessionId", isString: true }], "getErrorCallbackUrl");
+      return this.errorCallbackUrl || `${constants.DEFAULT_RECLAIM_ERROR_CALLBACK_URL}${this.sessionId}`;
+    } catch (error) {
+      logger7.info("Error getting error callback url", error);
+      throw new GetAppCallbackUrlError("Error getting error callback url", error);
+    }
+  }
   /**
    * Returns the status URL for monitoring the current session
    *
@@ -2441,6 +2569,8 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
       parameters: this.parameters,
       signature: this.signature,
       redirectUrl: this.redirectUrl,
+      errorCallbackUrl: this.errorCallbackUrl,
+      errorRedirectUrl: this.errorRedirectUrl,
       timestamp: this.timeStamp,
       // New field with correct spelling
       timeStamp: this.timeStamp,
@@ -2768,7 +2898,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
       logger7.info("Starting session");
       const sessionUpdatePollingInterval = 3 * 1e3;
       const interval = setInterval(() => __async(this, null, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         try {
           const statusUrlResponse = yield fetchStatusUrl(this.sessionId);
           if (!statusUrlResponse.session) return;
@@ -2784,12 +2914,15 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
             }
             return;
           }
+          if (statusUrlResponse.session.statusV2 === "ERROR_SUBMISSION_FAILED" /* ERROR_SUBMISSION_FAILED */ || statusUrlResponse.session.statusV2 === "ERROR_SUBMITTED" /* ERROR_SUBMITTED */) {
+            throw new ErrorDuringVerificationError();
+          }
           const isDefaultCallbackUrl = this.getAppCallbackUrl() === `${constants.DEFAULT_RECLAIM_CALLBACK_URL}${this.sessionId}`;
           if (isDefaultCallbackUrl) {
             if (statusUrlResponse.session.proofs && statusUrlResponse.session.proofs.length > 0) {
               const proofs = statusUrlResponse.session.proofs;
               if (this.claimCreationType === "createClaim" /* STANDALONE */) {
-                const verified = yield verifyProof(proofs);
+                const verified = yield verifyProof(proofs, (_a = this.options) == null ? void 0 : _a.acceptAiProviders);
                 if (!verified) {
                   logger7.info(`Proofs not verified: ${JSON.stringify(proofs)}`);
                   throw new ProofNotVerifiedError();
@@ -2801,7 +2934,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
                 onSuccess(proofs);
               }
               this.clearInterval();
-              (_a = this.modal) == null ? void 0 : _a.close();
+              (_b = this.modal) == null ? void 0 : _b.close();
             }
           } else {
             if (statusUrlResponse.session.statusV2 === "PROOF_SUBMISSION_FAILED" /* PROOF_SUBMISSION_FAILED */) {
@@ -2812,7 +2945,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
                 onSuccess("Proof submitted successfully to the custom callback url");
               }
               this.clearInterval();
-              (_b = this.modal) == null ? void 0 : _b.close();
+              (_c = this.modal) == null ? void 0 : _c.close();
             }
           }
         } catch (e) {
@@ -2820,7 +2953,7 @@ var ReclaimProofRequest = class _ReclaimProofRequest {
             onError(e);
           }
           this.clearInterval();
-          (_c = this.modal) == null ? void 0 : _c.close();
+          (_d = this.modal) == null ? void 0 : _d.close();
         }
       }), sessionUpdatePollingInterval);
       this.intervals.set(this.sessionId, interval);