@reclaimprotocol/js-sdk 5.4.1 → 5.4.2-dev.0

package/dist/index.js

@@ -84,10 +84,20 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@reclaimprotocol/js-sdk",
-      version: "5.4.1",
+      version: "5.4.2-dev.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",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        "./internal": {
+          types: "./dist/internal.d.ts",
+          default: "./dist/internal.js"
+        }
+      },
       keywords: [
         "reclaim",
         "protocol",
@@ -108,7 +118,8 @@ var require_package = __commonJS({
       ],
       tsup: {
         entry: [
-          "src/index.ts"
+          "src/index.ts",
+          "src/internal.ts"
         ],
         splitting: false,
         sourcemap: true,
@@ -192,8 +203,40 @@ var require_package = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ApplicationError: () => ApplicationError,
+  AttestorTeeVerificationError: () => AttestorTeeVerificationError,
+  BackendServerError: () => BackendServerError,
+  CallbackUrlRequiredError: () => CallbackUrlRequiredError,
+  ErrorDuringVerificationError: () => ErrorDuringVerificationError,
+  GetAppCallbackUrlError: () => GetAppCallbackUrlError,
+  GetStatusUrlError: () => GetStatusUrlError,
+  HASH_MATCH_MULTIPLE_DEFAULT: () => HASH_MATCH_MULTIPLE_DEFAULT,
+  HASH_REQUIRED_DEFAULT: () => HASH_REQUIRED_DEFAULT,
+  InavlidParametersError: () => InavlidParametersError,
+  InitError: () => InitError,
+  InitSessionError: () => InitSessionError,
+  InvalidParamError: () => InvalidParamError,
+  InvalidRequestSpecError: () => InvalidRequestSpecError,
+  InvalidSignatureError: () => InvalidSignatureError,
+  NoProviderParamsError: () => NoProviderParamsError,
+  ProofNotValidatedError: () => ProofNotValidatedError,
+  ProofNotVerifiedError: () => ProofNotVerifiedError,
+  ProofSubmissionFailedError: () => ProofSubmissionFailedError,
+  ProviderConfigFetchError: () => ProviderConfigFetchError,
+  ProviderFailedError: () => ProviderFailedError,
+  ProviderNotFoundError: () => ProviderNotFoundError,
   ReclaimProofRequest: () => ReclaimProofRequest,
+  SessionNotStartedError: () => SessionNotStartedError,
+  SetContextError: () => SetContextError,
+  SetParamsError: () => SetParamsError,
+  SetSignatureError: () => SetSignatureError,
+  SignatureGeneratingError: () => SignatureGeneratingError,
+  SignatureNotFoundError: () => SignatureNotFoundError,
+  StatusUrlError: () => StatusUrlError,
   TeeVerificationError: () => TeeVerificationError,
+  TimeoutError: () => TimeoutError,
+  UnknownProofsNotValidatedError: () => UnknownProofsNotValidatedError,
+  UpdateSessionError: () => UpdateSessionError,
   assertValidProofsByHash: () => assertValidProofsByHash,
   assertValidateProof: () => assertValidateProof,
   assertVerifiedProof: () => assertVerifiedProof,
@@ -208,6 +251,7 @@ __export(index_exports, {
   generateSpecsFromRequestSpecTemplate: () => generateSpecsFromRequestSpecTemplate,
   getAttestors: () => getAttestors,
   getDeviceType: () => getDeviceType,
+  getHashFromProof: () => getHashFromProof,
   getHttpProviderClaimParamsFromProof: () => getHttpProviderClaimParamsFromProof,
   getIdentifierFromClaimInfo: () => getIdentifierFromClaimInfo,
   getMobileDeviceType: () => getMobileDeviceType,
@@ -1504,6 +1548,9 @@ function generateAttestationNonce(appSecret, applicationId, sessionId, timestamp
   return import_ethers4.ethers.keccak256(import_ethers4.ethers.toUtf8Bytes(noncePayload)).replace(/^0x/i, "");
 }
 
+// src/utils/proofValidationUtils.ts
+var import_assert = __toESM(require("assert"));
+
 // src/utils/providerUtils.ts
 var logger7 = logger_default.logger;
 function fetchProviderHashRequirementsBy(providerId, exactProviderVersionString, allowedTags, proofs) {
@@ -1625,7 +1672,20 @@ function hashRequestSpec(request) {
 var logger8 = logger_default.logger;
 var HASH_REQUIRED_DEFAULT = true;
 var HASH_MATCH_MULTIPLE_DEFAULT = true;
-function assertValidProofsByHash(proofs, config) {
+function getHashFromProof(proof, piiConfig) {
+  if ((piiConfig == null ? void 0 : piiConfig.hasNoPii) === true) {
+    const contextObject = JSON.parse(proof.claimData.context);
+    (0, import_assert.default)(contextObject, "Context must be present in proof's claimData");
+    const providerHash = contextObject.providerHash;
+    (0, import_assert.default)(providerHash, "Provider hash must be present in proof's claimData.context");
+    return [providerHash];
+  }
+  const claimParams = getHttpProviderClaimParamsFromProof(proof);
+  const computedHashesOfProof = hashProofClaimParams(claimParams);
+  const proofHashes = Array.isArray(computedHashesOfProof) ? computedHashesOfProof.map((h) => h.toLowerCase().trim()) : [computedHashesOfProof.toLowerCase().trim()];
+  return proofHashes;
+}
+function assertValidProofsByHash(proofs, config, piiConfig) {
   var _a, _b;
   if (!config.hashes) {
     throw new ProofNotValidatedError("No proof hash was provided for validation");
@@ -1633,9 +1693,7 @@ function assertValidProofsByHash(proofs, config) {
   const unvalidatedProofHashByIndex = /* @__PURE__ */ new Map();
   for (let i = 0; i < proofs.length; i++) {
     const proof = proofs[i];
-    const claimParams = getHttpProviderClaimParamsFromProof(proof);
-    const computedHashesOfProof = hashProofClaimParams(claimParams);
-    const proofHashes = Array.isArray(computedHashesOfProof) ? computedHashesOfProof.map((h) => h.toLowerCase().trim()) : [computedHashesOfProof.toLowerCase().trim()];
+    const proofHashes = getHashFromProof(proof, piiConfig);
     unvalidatedProofHashByIndex.set(i, proofHashes);
   }
   for (const hashRequirement of config.hashes) {
@@ -1643,7 +1701,9 @@ function assertValidProofsByHash(proofs, config) {
     const expectedHashes = Array.isArray(hashRequirement.value) ? hashRequirement.value.map((h) => h.toLowerCase().trim()) : [hashRequirement.value.toLowerCase().trim()];
     const isRequired = (_a = hashRequirement.required) != null ? _a : HASH_REQUIRED_DEFAULT;
     const canMatchMultiple = (_b = hashRequirement.multiple) != null ? _b : HASH_MATCH_MULTIPLE_DEFAULT;
-    for (const [i, proofHashes] of unvalidatedProofHashByIndex.entries()) {
+    for (let i = 0; i < proofs.length; i++) {
+      if (!unvalidatedProofHashByIndex.has(i)) continue;
+      const proofHashes = unvalidatedProofHashByIndex.get(i);
       const intersection = expectedHashes.filter((eh) => proofHashes.includes(eh));
       if (intersection.length > 0) {
         unvalidatedProofHashByIndex.delete(i);
@@ -1684,7 +1744,7 @@ function getHttpProviderClaimParamsFromProof(proof) {
   }
   throw new ProofNotValidatedError("Proof has no HTTP provider params to hash");
 }
-function assertValidateProof(proofs, config) {
+function assertValidateProof(proofs, config, piiConfig) {
   return __async(this, null, function* () {
     if ("dangerouslyDisableContentValidation" in config && config.dangerouslyDisableContentValidation) {
       logger8.warn("Validation skipped because it was disabled during proof verification");
@@ -1705,14 +1765,14 @@ function assertValidateProof(proofs, config) {
         let lastError = null;
         for (const hashRequirement of hashRequirementsFromProvider) {
           try {
-            return yield assertValidateProof(proofs, hashRequirement);
+            return yield assertValidateProof(proofs, hashRequirement, piiConfig);
           } catch (e) {
             lastError = e;
           }
         }
         throw new ProofNotValidatedError("Could not validate proof", lastError);
       } else {
-        return assertValidateProof(proofs, hashRequirementsFromProvider[0]);
+        return assertValidateProof(proofs, hashRequirementsFromProvider[0], piiConfig);
       }
     }
     const effectiveHashRequirement = ("hashes" in config && Array.isArray(config == null ? void 0 : config.hashes) ? config.hashes : []).map((it) => {
@@ -1724,9 +1784,13 @@ function assertValidateProof(proofs, config) {
         return it;
       }
     });
-    return assertValidProofsByHash(proofs, {
-      hashes: effectiveHashRequirement
-    });
+    return assertValidProofsByHash(
+      proofs,
+      {
+        hashes: effectiveHashRequirement
+      },
+      piiConfig
+    );
   });
 }
 
@@ -1740,7 +1804,7 @@ var SUPPORTED_PROOF_VERSIONS = ["v2", "v3"];
 var TOKEN_CLOCK_SKEW_S = 60;
 var NONCE_TIMESTAMP_MAX_SKEW_MS = 10 * 60 * 1e3;
 var BROWSER_ENVIRONMENT_ERROR = "TEE attestation verification is only supported in non-browser environments. Run verifyTeeAttestation on your server or API route.";
-function assert(condition, message) {
+function assert2(condition, message) {
   if (!condition) {
     throw new Error(message);
   }
@@ -1790,7 +1854,7 @@ function decodeUtf8(bytes) {
 }
 function decodeJwt(token) {
   const parts = token.split(".");
-  assert(parts.length === 3, "attestation token is not a JWT");
+  assert2(parts.length === 3, "attestation token is not a JWT");
   return {
     header: JSON.parse(decodeUtf8(decodeBase64Url(parts[0]))),
     payload: JSON.parse(decodeUtf8(decodeBase64Url(parts[1]))),
@@ -1800,7 +1864,7 @@ function decodeJwt(token) {
 }
 function getFetch() {
   const fetchFn = globalThis.fetch;
-  assert(fetchFn, "fetch is not available in this environment");
+  assert2(fetchFn, "fetch is not available in this environment");
   return fetchFn.bind(globalThis);
 }
 function getSubtleCrypto() {
@@ -1836,19 +1900,19 @@ var cachedJwksAt = 0;
 function verifyJwtSignature(token, issuer) {
   return __async(this, null, function* () {
     const { header, payload, signingInput, signature } = decodeJwt(token);
-    assert(header.alg === "RS256", `unexpected attestation signing algorithm: ${header.alg}`);
-    assert(typeof header.kid === "string" && header.kid.length > 0, "attestation token kid is missing");
+    assert2(header.alg === "RS256", `unexpected attestation signing algorithm: ${header.alg}`);
+    assert2(typeof header.kid === "string" && header.kid.length > 0, "attestation token kid is missing");
     const isCacheFresh = cachedJwksKeys && Date.now() - cachedJwksAt < JWKS_CACHE_TTL_MS;
     if (!isCacheFresh) {
       const oidc = yield fetchJson(`${issuer}/.well-known/openid-configuration`);
-      assert(typeof (oidc == null ? void 0 : oidc.jwks_uri) === "string" && oidc.jwks_uri.length > 0, "issuer JWKS URI is missing");
+      assert2(typeof (oidc == null ? void 0 : oidc.jwks_uri) === "string" && oidc.jwks_uri.length > 0, "issuer JWKS URI is missing");
       cachedJwksUri = oidc.jwks_uri;
       const jwks = yield fetchJson(cachedJwksUri);
       cachedJwksKeys = (jwks == null ? void 0 : jwks.keys) || [];
       cachedJwksAt = Date.now();
     }
     const jwk = cachedJwksKeys.find((key) => key.kid === header.kid);
-    assert(jwk, `no JWKS key found for kid ${header.kid}`);
+    assert2(jwk, `no JWKS key found for kid ${header.kid}`);
     const cryptoKey = yield getSubtleCrypto().importKey(
       "jwk",
       jwk,
@@ -1862,7 +1926,7 @@ function verifyJwtSignature(token, issuer) {
       signature,
       new TextEncoder().encode(signingInput)
     );
-    assert(isValid, "JWT signature verification failed");
+    assert2(isValid, "JWT signature verification failed");
     return payload;
   });
 }
@@ -1883,16 +1947,16 @@ function parseProofContext(proof) {
   }
   const ctx = parsedContext;
   const expectedNonce = ctx.attestationNonce;
-  assert(typeof expectedNonce === "string" && expectedNonce.length > 0, "Proof context is missing attestationNonce");
+  assert2(typeof expectedNonce === "string" && expectedNonce.length > 0, "Proof context is missing attestationNonce");
   const nonceDataObj = ctx.attestationNonceData;
-  assert(isNonceContextData(nonceDataObj), "Proof context is missing or has invalid attestationNonceData (requires applicationId, sessionId, timestamp)");
+  assert2(isNonceContextData(nonceDataObj), "Proof context is missing or has invalid attestationNonceData (requires applicationId, sessionId, timestamp)");
   return { parsedContext: ctx, nonceDataObj, expectedNonce };
 }
 function verifyApplicationAndSessionBinding(proof, parsedContext, nonceDataObj, expectedApplicationId) {
   var _a;
   const { applicationId, sessionId, timestamp } = nonceDataObj;
   if (expectedApplicationId) {
-    assert(
+    assert2(
       applicationId.toLowerCase() === expectedApplicationId.toLowerCase(),
       `Application ID Mismatch! Expected ${expectedApplicationId}, but proof context contains ${applicationId}`
     );
@@ -1927,11 +1991,11 @@ function verifyApplicationAndSessionBinding(proof, parsedContext, nonceDataObj,
 function verifyNonceMaterial(expectedNonce, nonceDataObj, expectedAppSecret) {
   const cleanExpectedNonce = normalizeHex(expectedNonce);
   const { applicationId, sessionId, timestamp } = nonceDataObj;
-  assert(cleanExpectedNonce.length > 0, "Proof context attestationNonce is empty");
-  assert(isHex(cleanExpectedNonce), "Proof context attestationNonce is not valid hex");
+  assert2(cleanExpectedNonce.length > 0, "Proof context attestationNonce is empty");
+  assert2(isHex(cleanExpectedNonce), "Proof context attestationNonce is not valid hex");
   if (expectedAppSecret) {
     const recomputedNonce = generateAttestationNonce(expectedAppSecret, applicationId, sessionId, timestamp);
-    assert(
+    assert2(
       recomputedNonce === cleanExpectedNonce,
       "Attestation nonce verification failed: app secret, application ID, session ID, or timestamp do not match"
     );
@@ -1944,7 +2008,7 @@ function verifyNonceMaterial(expectedNonce, nonceDataObj, expectedAppSecret) {
       nonceMsg,
       expectedNonce.startsWith("0x") ? expectedNonce : `0x${expectedNonce}`
     );
-    assert(
+    assert2(
       recoveredAddress.toLowerCase() === applicationId.toLowerCase(),
       `Nonce signature verification failed: recovered ${recoveredAddress}, expected ${applicationId}`
     );
@@ -1966,12 +2030,12 @@ function assertTokenFresh(claims) {
 }
 function assertAudienceClaim(aud) {
   if (typeof aud === "string") {
-    assert(aud.length > 0, "attestation token audience is empty");
+    assert2(aud.length > 0, "attestation token audience is empty");
     return;
   }
   if (Array.isArray(aud)) {
-    assert(aud.length > 0, "attestation token audience is empty");
-    assert(aud.every((entry) => typeof entry === "string" && entry.length > 0), "attestation token audience contains invalid entries");
+    assert2(aud.length > 0, "attestation token audience is empty");
+    assert2(aud.every((entry) => typeof entry === "string" && entry.length > 0), "attestation token audience contains invalid entries");
     return;
   }
   throw new Error("attestation token audience is missing");
@@ -1986,22 +2050,22 @@ function assertProofShape(teeAttestation) {
     throw new Error(`${teeAttestation.error.code}: ${teeAttestation.error.message}`);
   }
   const proofVersion = getProofVersion(teeAttestation);
-  assert(typeof proofVersion === "string" && SUPPORTED_PROOF_VERSIONS.includes(proofVersion), `unexpected proof version: ${proofVersion}`);
-  assert(teeAttestation.tee_provider === EXPECTED_TEE_PROVIDER, `unexpected tee provider: ${teeAttestation.tee_provider}`);
-  assert(teeAttestation.tee_technology === EXPECTED_TEE_TECHNOLOGY, `unexpected tee technology: ${teeAttestation.tee_technology}`);
-  assert(typeof teeAttestation.nonce === "string" && teeAttestation.nonce.length > 0, "tee attestation nonce missing");
-  assert(typeof teeAttestation.timestamp === "string" && teeAttestation.timestamp.length > 0, "tee attestation timestamp missing");
-  assert(!Number.isNaN(Date.parse(teeAttestation.timestamp)), "tee attestation timestamp is invalid");
-  assert(typeof ((_a = teeAttestation.workload) == null ? void 0 : _a.image_digest) === "string" && teeAttestation.workload.image_digest.length > 0, "workload image digest missing");
-  assert(typeof ((_b = teeAttestation.verifier) == null ? void 0 : _b.image_digest) === "string" && teeAttestation.verifier.image_digest.length > 0, "verifier image digest missing");
-  assert(typeof ((_c = teeAttestation.attestation) == null ? void 0 : _c.token) === "string" && teeAttestation.attestation.token.length > 0, "attestation token missing");
+  assert2(typeof proofVersion === "string" && SUPPORTED_PROOF_VERSIONS.includes(proofVersion), `unexpected proof version: ${proofVersion}`);
+  assert2(teeAttestation.tee_provider === EXPECTED_TEE_PROVIDER, `unexpected tee provider: ${teeAttestation.tee_provider}`);
+  assert2(teeAttestation.tee_technology === EXPECTED_TEE_TECHNOLOGY, `unexpected tee technology: ${teeAttestation.tee_technology}`);
+  assert2(typeof teeAttestation.nonce === "string" && teeAttestation.nonce.length > 0, "tee attestation nonce missing");
+  assert2(typeof teeAttestation.timestamp === "string" && teeAttestation.timestamp.length > 0, "tee attestation timestamp missing");
+  assert2(!Number.isNaN(Date.parse(teeAttestation.timestamp)), "tee attestation timestamp is invalid");
+  assert2(typeof ((_a = teeAttestation.workload) == null ? void 0 : _a.image_digest) === "string" && teeAttestation.workload.image_digest.length > 0, "workload image digest missing");
+  assert2(typeof ((_b = teeAttestation.verifier) == null ? void 0 : _b.image_digest) === "string" && teeAttestation.verifier.image_digest.length > 0, "verifier image digest missing");
+  assert2(typeof ((_c = teeAttestation.attestation) == null ? void 0 : _c.token) === "string" && teeAttestation.attestation.token.length > 0, "attestation token missing");
 }
 function computeDigestBinding(teeAttestation) {
   return __async(this, null, function* () {
     const proofVersion = getProofVersion(teeAttestation);
     if (proofVersion === "v3") {
-      assert(typeof teeAttestation.workload.container_name === "string" && teeAttestation.workload.container_name.length > 0, "workload container name missing");
-      assert(typeof teeAttestation.verifier.container_name === "string" && teeAttestation.verifier.container_name.length > 0, "verifier container name missing");
+      assert2(typeof teeAttestation.workload.container_name === "string" && teeAttestation.workload.container_name.length > 0, "workload container name missing");
+      assert2(typeof teeAttestation.verifier.container_name === "string" && teeAttestation.verifier.container_name.length > 0, "verifier container name missing");
       return sha256Hex([
         "v3",
         `workload.container_name=${teeAttestation.workload.container_name}`,
@@ -2020,15 +2084,15 @@ function verifyGcpClaims(teeAttestation, expectedNonce) {
   return __async(this, null, function* () {
     var _a;
     const claims = yield verifyJwtSignature(teeAttestation.attestation.token, GCP_CONFIDENTIAL_SPACE_ISSUER);
-    assert(claims.iss === GCP_CONFIDENTIAL_SPACE_ISSUER, `unexpected issuer: ${claims.iss}`);
+    assert2(claims.iss === GCP_CONFIDENTIAL_SPACE_ISSUER, `unexpected issuer: ${claims.iss}`);
     assertAudienceClaim(claims.aud);
-    assert(Array.isArray(claims.eat_nonce), "eat_nonce claim missing");
+    assert2(Array.isArray(claims.eat_nonce), "eat_nonce claim missing");
     const digestBinding = yield computeDigestBinding(teeAttestation);
-    assert(claims.eat_nonce.includes(expectedNonce), "request nonce is not present in attestation token");
-    assert(claims.eat_nonce.includes(digestBinding), "digest-binding nonce is not present in attestation token");
-    assert(claims.hwmodel === EXPECTED_HW_MODEL, `unexpected hwmodel: ${claims.hwmodel}`);
-    assert(claims.secboot === true, "secure boot claim is not true");
-    assert((_a = claims.submods) == null ? void 0 : _a.gce, "gce submod claim missing");
+    assert2(claims.eat_nonce.includes(expectedNonce), "request nonce is not present in attestation token");
+    assert2(claims.eat_nonce.includes(digestBinding), "digest-binding nonce is not present in attestation token");
+    assert2(claims.hwmodel === EXPECTED_HW_MODEL, `unexpected hwmodel: ${claims.hwmodel}`);
+    assert2(claims.secboot === true, "secure boot claim is not true");
+    assert2((_a = claims.submods) == null ? void 0 : _a.gce, "gce submod claim missing");
     assertTokenFresh(claims);
   });
 }
@@ -2050,9 +2114,9 @@ function verifyTeeAttestation(proof, appSecret) {
       verifyNonceMaterial(expectedNonce, nonceDataObj, appSecret);
       const cleanExpectedNonce = normalizeHex(expectedNonce);
       const cleanTeeNonce = normalizeHex(teeAttestation.nonce);
-      assert(cleanTeeNonce.length > 0, "TEE attestation nonce is empty");
-      assert(isHex(cleanTeeNonce), "TEE attestation nonce is not valid hex");
-      assert(cleanTeeNonce === cleanExpectedNonce, `Nonce Mismatch! Expected ${cleanExpectedNonce}, got ${cleanTeeNonce}`);
+      assert2(cleanTeeNonce.length > 0, "TEE attestation nonce is empty");
+      assert2(isHex(cleanTeeNonce), "TEE attestation nonce is not valid hex");
+      assert2(cleanTeeNonce === cleanExpectedNonce, `Nonce Mismatch! Expected ${cleanExpectedNonce}, got ${cleanTeeNonce}`);
       yield verifyGcpClaims(teeAttestation, cleanExpectedNonce);
       return { isVerified: true };
     } catch (error) {
@@ -2318,11 +2382,14 @@ function verifyProof(proofOrProofs, config) {
       if (!config) {
         throw new ProofNotValidatedError("Verification configuration is required for `verifyProof(proof, config)`");
       }
-      const attestors = yield getAttestors();
-      for (const proof of proofs) {
-        yield assertVerifiedProof(proof, attestors);
+      if (config.hasNoPii !== true) {
+        console.info({ pii: config.hasNoPii });
+        const attestors = yield getAttestors();
+        for (const proof of proofs) {
+          yield assertVerifiedProof(proof, attestors);
+        }
       }
-      yield assertValidateProof(proofs, config);
+      yield assertValidateProof(proofs, config, { hasNoPii: config.hasNoPii });
       let isTeeAttestationVerified;
       let isAttestorTeeAttestationVerified;
       if (config.teeAttestation && "dangerouslyDisableContentValidation" in config && config.dangerouslyDisableContentValidation) {
@@ -3899,8 +3966,40 @@ function generateInitSignature(appSecret, providerId, timestamp) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ApplicationError,
+  AttestorTeeVerificationError,
+  BackendServerError,
+  CallbackUrlRequiredError,
+  ErrorDuringVerificationError,
+  GetAppCallbackUrlError,
+  GetStatusUrlError,
+  HASH_MATCH_MULTIPLE_DEFAULT,
+  HASH_REQUIRED_DEFAULT,
+  InavlidParametersError,
+  InitError,
+  InitSessionError,
+  InvalidParamError,
+  InvalidRequestSpecError,
+  InvalidSignatureError,
+  NoProviderParamsError,
+  ProofNotValidatedError,
+  ProofNotVerifiedError,
+  ProofSubmissionFailedError,
+  ProviderConfigFetchError,
+  ProviderFailedError,
+  ProviderNotFoundError,
   ReclaimProofRequest,
+  SessionNotStartedError,
+  SetContextError,
+  SetParamsError,
+  SetSignatureError,
+  SignatureGeneratingError,
+  SignatureNotFoundError,
+  StatusUrlError,
   TeeVerificationError,
+  TimeoutError,
+  UnknownProofsNotValidatedError,
+  UpdateSessionError,
   assertValidProofsByHash,
   assertValidateProof,
   assertVerifiedProof,
@@ -3915,6 +4014,7 @@ function generateInitSignature(appSecret, providerId, timestamp) {
   generateSpecsFromRequestSpecTemplate,
   getAttestors,
   getDeviceType,
+  getHashFromProof,
   getHttpProviderClaimParamsFromProof,
   getIdentifierFromClaimInfo,
   getMobileDeviceType,