@reclaimprotocol/js-sdk 1.3.10 → 2.0.0

package/dist/index.js

@@ -67,7 +67,9 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Reclaim: () => Reclaim
+  ReclaimProofRequest: () => ReclaimProofRequest,
+  transformForOnchain: () => transformForOnchain,
+  verifyProof: () => verifyProof
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -122,16 +124,241 @@ function createSignDataForClaim(data) {
 }
 
 // src/Reclaim.ts
-var import_uuid = require("uuid");
-var import_ethers5 = require("ethers");
+var import_ethers6 = require("ethers");
 var import_canonicalize2 = __toESM(require("canonicalize"));
 
-// src/utils.ts
-var import_url_parse = __toESM(require("url-parse"));
-var import_ethers4 = require("ethers");
+// src/utils/errors.ts
+function createErrorClass(name) {
+  return class extends Error {
+    constructor(message, innerError) {
+      super(message);
+      this.innerError = innerError;
+      this.name = name;
+      if (innerError) {
+        this.stack += `
+Caused by: ${innerError.stack}`;
+      }
+    }
+  };
+}
+var TimeoutError = createErrorClass("TimeoutError");
+var ProofNotVerifiedError = createErrorClass("ProofNotVerifiedError");
+var SessionNotStartedError = createErrorClass("SessionNotStartedError");
+var ProviderNotFoundError = createErrorClass("ProviderNotFoundError");
+var BuildProofRequestError = createErrorClass("BuildProofRequestError");
+var SignatureGeneratingError = createErrorClass("SignatureGeneratingError");
+var SignatureNotFoundError = createErrorClass("SignatureNotFoundError");
+var InvalidSignatureError = createErrorClass("InvalidSignatureError");
+var UpdateSessionError = createErrorClass("UpdateSessionError");
+var InitSessionError = createErrorClass("InitSessionError");
+var ProviderFailedError = createErrorClass("ProviderFailedError");
+var InvalidParamError = createErrorClass("InvalidParamError");
+var ApplicationError = createErrorClass("ApplicationError");
+var InitError = createErrorClass("InitError");
+var AvailableParamsError = createErrorClass("AvailableParamsError");
+var BackendServerError = createErrorClass("BackendServerError");
+var GetStatusUrlError = createErrorClass("GetStatusUrlError");
+var NoProviderParamsError = createErrorClass("NoProviderParamsError");
+var SetParamsError = createErrorClass("SetParamsError");
+var AddContextError = createErrorClass("AddContextError");
+var SetSignatureError = createErrorClass("SetSignatureError");
+var GetAppCallbackUrlError = createErrorClass("GetAppCallbackUrlError");
+var GetRequestUrlError = createErrorClass("GetRequestUrlError");
 
-// src/contract-types/contracts/factories/Reclaim__factory.ts
+// src/utils/logger.ts
+var import_pino = __toESM(require("pino"));
+var logger = (0, import_pino.default)({
+  level: "info",
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true
+    }
+  }
+});
+function setLogLevel(level) {
+  logger.level = level;
+}
+var logger_default = {
+  logger,
+  setLogLevel
+};
+
+// src/utils/helper.ts
+var logger2 = logger_default.logger;
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceAll(str, find, replace) {
+  if (find === "")
+    return str;
+  return str.replace(new RegExp(escapeRegExp(find), "g"), replace);
+}
+function scheduleIntervalEndingTask(sessionId, intervals, onFailureCallback, timeout = 1e3 * 60 * 10) {
+  setTimeout(() => {
+    if (intervals.has(sessionId)) {
+      const message = "Interval ended without receiving proofs";
+      onFailureCallback(new TimeoutError(message));
+      logger2.info(message);
+      clearInterval(intervals.get(sessionId));
+      intervals.delete(sessionId);
+    }
+  }, timeout);
+}
+
+// src/utils/constants.ts
+var BACKEND_BASE_URL = "https://api.reclaimprotocol.org";
+var constants = {
+  // Default callback URL for Reclaim protocol
+  DEFAULT_RECLAIM_CALLBACK_URL: `${BACKEND_BASE_URL}/api/sdk/callback?callbackId=`,
+  // Default status URL for Reclaim sessions
+  DEFAULT_RECLAIM_STATUS_URL: `${BACKEND_BASE_URL}/api/sdk/session/`,
+  // URL for sharing Reclaim templates
+  RECLAIM_SHARE_URL: "https://share.reclaimprotocol.org/verifier/?template="
+};
+
+// src/utils/validationUtils.ts
 var import_ethers2 = require("ethers");
+var import_canonicalize = __toESM(require("canonicalize"));
+var logger3 = logger_default.logger;
+function validateFunctionParams(params, functionName) {
+  params.forEach(({ input, paramName, isString }) => {
+    if (input == null) {
+      logger3.info(`Validation failed: ${paramName} in ${functionName} is null or undefined`);
+      throw new InvalidParamError(`${paramName} passed to ${functionName} must not be null or undefined.`);
+    }
+    if (isString && typeof input !== "string") {
+      logger3.info(`Validation failed: ${paramName} in ${functionName} is not a string`);
+      throw new InvalidParamError(`${paramName} passed to ${functionName} must be a string.`);
+    }
+    if (isString && input.trim() === "") {
+      logger3.info(`Validation failed: ${paramName} in ${functionName} is an empty string`);
+      throw new InvalidParamError(`${paramName} passed to ${functionName} must not be an empty string.`);
+    }
+  });
+}
+function validateURL(url, functionName) {
+  try {
+    new URL(url);
+  } catch (e) {
+    logger3.info(`URL validation failed for ${url} in ${functionName}: ${e.message}`);
+    throw new InvalidParamError(`Invalid URL format ${url} passed to ${functionName}.`, e);
+  }
+}
+function validateSignature(providerId, signature, applicationId, timestamp) {
+  try {
+    logger3.info(`Starting signature validation for providerId: ${providerId}, applicationId: ${applicationId}, timestamp: ${timestamp}`);
+    const message = (0, import_canonicalize.default)({ providerId, timestamp });
+    if (!message) {
+      logger3.info("Failed to canonicalize message for signature validation");
+      throw new Error("Failed to canonicalize message");
+    }
+    const messageHash = import_ethers2.ethers.keccak256(new TextEncoder().encode(message));
+    let appId = import_ethers2.ethers.verifyMessage(
+      import_ethers2.ethers.getBytes(messageHash),
+      import_ethers2.ethers.hexlify(signature)
+    ).toLowerCase();
+    if (import_ethers2.ethers.getAddress(appId) !== import_ethers2.ethers.getAddress(applicationId)) {
+      logger3.info(`Signature validation failed: Mismatch between derived appId (${appId}) and provided applicationId (${applicationId})`);
+      throw new InvalidSignatureError(`Signature does not match the application id: ${appId}`);
+    }
+    logger3.info(`Signature validated successfully for applicationId: ${applicationId}`);
+  } catch (err) {
+    logger3.info(`Signature validation failed: ${err.message}`);
+    if (err instanceof InvalidSignatureError) {
+      throw err;
+    }
+    throw new InvalidSignatureError(`Failed to validate signature: ${err.message}`);
+  }
+}
+function validateRequestedProof(requestedProof) {
+  if (!requestedProof.url) {
+    logger3.info(`Requested proof validation failed: Provided url in requested proof is not valid`);
+    throw new InvalidParamError(`The provided url in requested proof is not valid`);
+  }
+  if (requestedProof.parameters && typeof requestedProof.parameters !== "object") {
+    logger3.info(`Requested proof validation failed: Provided parameters in requested proof is not valid`);
+    throw new InvalidParamError(`The provided parameters in requested proof is not valid`);
+  }
+}
+function validateContext(context) {
+  if (!context.contextAddress) {
+    logger3.info(`Context validation failed: Provided context address in context is not valid`);
+    throw new InvalidParamError(`The provided context address in context is not valid`);
+  }
+  if (!context.contextMessage) {
+    logger3.info(`Context validation failed: Provided context message in context is not valid`);
+    throw new InvalidParamError(`The provided context message in context is not valid`);
+  }
+  validateFunctionParams([
+    { input: context.contextAddress, paramName: "contextAddress", isString: true },
+    { input: context.contextMessage, paramName: "contextMessage", isString: true }
+  ], "validateContext");
+}
+
+// src/utils/sessionUtils.ts
+var logger4 = logger_default.logger;
+function initSession(providerId, appId, timestamp, signature) {
+  return __async(this, null, function* () {
+    logger4.info(`Initializing session for providerId: ${providerId}, appId: ${appId}`);
+    try {
+      const response = yield fetch(`${BACKEND_BASE_URL}/api/sdk/init-session/`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ providerId, appId, timestamp, signature })
+      });
+      const res = yield response.json();
+      if (!response.ok) {
+        logger4.info(`Session initialization failed: ${res.message || "Unknown error"}`);
+        throw new InitSessionError(res.message || `Error initializing session with providerId: ${providerId}`);
+      }
+      return res;
+    } catch (err) {
+      logger4.info({
+        message: "Failed to initialize session",
+        providerId,
+        appId,
+        timestamp,
+        error: err
+      });
+      throw err;
+    }
+  });
+}
+function updateSession(sessionId, status) {
+  return __async(this, null, function* () {
+    logger4.info(`Updating session status for sessionId: ${sessionId}, new status: ${status}`);
+    validateFunctionParams(
+      [{ input: sessionId, paramName: "sessionId", isString: true }],
+      "updateSession"
+    );
+    try {
+      const response = yield fetch(`${BACKEND_BASE_URL}/api/sdk/update/session/`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId, status })
+      });
+      const res = yield response.json();
+      if (!response.ok) {
+        const errorMessage = `Error updating session with sessionId: ${sessionId}. Status Code: ${response.status}`;
+        logger4.info(errorMessage, res);
+        throw new UpdateSessionError(errorMessage);
+      }
+      logger4.info(`Session status updated successfully for sessionId: ${sessionId}`);
+      return res;
+    } catch (err) {
+      const errorMessage = `Failed to update session with sessionId: ${sessionId}`;
+      logger4.info(errorMessage, err);
+      throw new UpdateSessionError(`Error updating session with sessionId: ${sessionId}`);
+    }
+  });
+}
+
+// src/utils/proofUtils.ts
+var import_ethers5 = require("ethers");
+
+// src/contract-types/contracts/factories/Reclaim__factory.ts
+var import_ethers3 = require("ethers");
 var _abi = [
   {
     anonymous: false,
@@ -668,7 +895,7 @@ var _abi = [
 ];
 var Reclaim__factory = class {
   static connect(address, signerOrProvider) {
-    return new import_ethers2.Contract(address, _abi, signerOrProvider);
+    return new import_ethers3.Contract(address, _abi, signerOrProvider);
   }
 };
 Reclaim__factory.abi = _abi;
@@ -688,7 +915,7 @@ var config_default = {
 };
 
 // src/smart-contract.ts
-var import_ethers3 = require("ethers");
+var import_ethers4 = require("ethers");
 var DEFAULT_CHAIN_ID = 11155420;
 function makeBeacon(chainId) {
   chainId = chainId || DEFAULT_CHAIN_ID;
@@ -744,7 +971,7 @@ function getContract(chainId) {
     if (!contractData) {
       throw new Error(`Unsupported chain: "${chainKey}"`);
     }
-    const rpcProvider = new import_ethers3.ethers.JsonRpcProvider(contractData.rpcUrl);
+    const rpcProvider = new import_ethers4.ethers.JsonRpcProvider(contractData.rpcUrl);
     existingContractsMap[chainKey] = Reclaim__factory.connect(
       contractData.address,
       rpcProvider
@@ -753,372 +980,114 @@ function getContract(chainId) {
   return existingContractsMap[chainKey];
 }
 
-// src/utils.ts
-var import_canonicalize = __toESM(require("canonicalize"));
-
-// src/constants.ts
-var BACKEND_BASE_URL = "https://api.reclaimprotocol.org";
-var constants = {
-  GET_PROVIDERS_BY_ID_API: BACKEND_BASE_URL + "/api/applications",
-  DEFAULT_RECLAIM_CALLBACK_URL: BACKEND_BASE_URL + "/api/sdk/callback?callbackId=",
-  DEFAULT_RECLAIM_STATUS_URL: BACKEND_BASE_URL + "/api/sdk/session/",
-  RECLAIM_SHARE_URL: "https://share.reclaimprotocol.org/instant/?template=",
-  RECLAIM_GET_BRANCH_URL: BACKEND_BASE_URL + "/api/sdk/get-branch-url"
-};
-
-// src/errors.ts
-var TimeoutError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-};
-var ProofNotVerifiedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProofNotVerifiedError";
-  }
-};
-var SessionNotStartedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SessionNotStartedError";
-  }
-};
-var ProviderAPIError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProviderAPIError";
-  }
-};
-var BuildProofRequestError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BuildProofRequest";
-  }
-};
-var SignatureNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SignatureNotFound";
-  }
-};
-var InvalidSignatureError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidSignatureError";
-  }
-};
-var UpdateSessionError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UpdateSessionError";
-  }
-};
-var CreateSessionError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CreateSessionError";
-  }
-};
-var ProviderFailedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProviderFailedError";
-  }
-};
-var InvalidParamError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidParamError";
-  }
-};
-var ApplicationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ApplicationError";
-  }
-};
-
-// src/utils.ts
-function validateNotNullOrUndefined(input, paramName, functionName) {
-  if (input == null) {
-    throw new InvalidParamError(`${paramName} passed to ${functionName} must not be null or undefined.`);
-  }
-}
-function validateNonEmptyString(input, paramName, functionName) {
-  if (typeof input !== "string") {
-    throw new InvalidParamError(`${paramName} passed to ${functionName} must be a string.`);
-  }
-  if (input.trim() === "") {
-    throw new InvalidParamError(`${paramName} passed to ${functionName} must be a non-empty string.`);
-  }
-}
-function validateURL(url, functionName) {
-  validateNotNullOrUndefined(url, "url", functionName);
-  validateNonEmptyString(url, "url", functionName);
-  try {
-    new import_url_parse.default(url);
-  } catch (e) {
-    throw new InvalidParamError(`Invalid URL format passed to ${functionName}.`);
-  }
-}
-function getWitnessesForClaim(epoch, identifier, timestampS) {
-  return __async(this, null, function* () {
-    const beacon = makeBeacon();
-    if (!beacon)
-      throw new Error("No beacon");
-    const state = yield beacon.getState(epoch);
-    const witnessList = fetchWitnessListForClaim(state, identifier, timestampS);
-    return witnessList.map((w) => w.id.toLowerCase());
-  });
-}
-function recoverSignersOfSignedClaim({
-  claim,
-  signatures
-}) {
-  const dataStr = createSignDataForClaim(__spreadValues({}, claim));
-  return signatures.map(
-    (signature) => import_ethers4.ethers.verifyMessage(dataStr, import_ethers4.ethers.hexlify(signature)).toLowerCase()
+// src/utils/proofUtils.ts
+var logger5 = logger_default.logger;
+function generateRequestedProof(provider) {
+  const providerParams = {};
+  provider.responseSelections.forEach(
+    (rs) => rs.responseMatch.split(/{{(.*?)}}/).filter((_, i) => i % 2).forEach((param) => providerParams[param] = "")
   );
+  const proof = {
+    url: provider.url,
+    parameters: providerParams
+  };
+  return proof;
 }
-function assertValidSignedClaim(claim, expectedWitnessAddresses) {
-  const witnessAddresses = recoverSignersOfSignedClaim(claim);
-  const witnessesNotSeen = new Set(expectedWitnessAddresses);
-  for (const witness of witnessAddresses) {
-    if (witnessesNotSeen.has(witness)) {
-      witnessesNotSeen.delete(witness);
+function getFilledParameters(requestedProof) {
+  return Object.keys(requestedProof.parameters).reduce((acc, param) => {
+    if (requestedProof.parameters[param]) {
+      acc[param] = requestedProof.parameters[param];
     }
-  }
-  if (witnessesNotSeen.size > 0) {
-    throw new ProofNotVerifiedError(
-      `Missing signatures from ${expectedWitnessAddresses.join(", ")}`
-    );
-  }
+    return acc;
+  }, {});
 }
 function getShortenedUrl(url) {
   return __async(this, null, function* () {
+    logger5.info(`Attempting to shorten URL: ${url}`);
     try {
       validateURL(url, "getShortenedUrl");
-      const response = yield fetch(BACKEND_BASE_URL + "/api/sdk/shortener", {
+      const response = yield fetch(`${BACKEND_BASE_URL}/api/sdk/shortener`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          fullUrl: url
-        })
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ fullUrl: url })
       });
       const res = yield response.json();
+      if (!response.ok) {
+        logger5.info(`Failed to shorten URL: ${url}, Response: ${JSON.stringify(res)}`);
+        return url;
+      }
       const shortenedVerificationUrl = res.result.shortUrl;
       return shortenedVerificationUrl;
     } catch (err) {
+      logger5.info(`Error shortening URL: ${url}, Error: ${err}`);
       return url;
     }
   });
 }
-function createSession(sessionId, appId, providerId) {
+function createLinkWithTemplateData(templateData) {
   return __async(this, null, function* () {
-    validateNotNullOrUndefined(sessionId, "sessionId", "createSession");
-    validateNotNullOrUndefined(appId, "appId", "createSession");
-    validateNotNullOrUndefined(providerId, "providerId", "createSession");
-    validateNonEmptyString(sessionId, "sessionId", "createSession");
-    validateNonEmptyString(appId, "appId", "createSession");
-    validateNonEmptyString(providerId, "providerId", "createSession");
+    let template = encodeURIComponent(JSON.stringify(templateData));
+    template = replaceAll(template, "(", "%28");
+    template = replaceAll(template, ")", "%29");
+    const fullLink = `${constants.RECLAIM_SHARE_URL}${template}`;
     try {
-      const response = yield fetch(BACKEND_BASE_URL + "/api/sdk/create-session/", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          sessionId,
-          appId,
-          providerId
-        })
-      });
-      if (!response.ok) {
-        throw new CreateSessionError("Error creating session with sessionId: " + sessionId);
-      }
-      const res = yield response.json();
-      return res;
+      const shortenedLink = yield getShortenedUrl(fullLink);
+      return shortenedLink;
     } catch (err) {
-      throw new CreateSessionError("Error creating session with sessionId: " + sessionId);
+      logger5.info(`Error creating link for sessionId: ${templateData.sessionId}, Error: ${err}`);
+      return fullLink;
     }
   });
 }
-function updateSession(sessionId, status) {
-  return __async(this, null, function* () {
-    validateNotNullOrUndefined(sessionId, "sessionId", "updateSession");
-    validateNonEmptyString(sessionId, "sessionId", "updateSession");
-    try {
-      const response = yield fetch(BACKEND_BASE_URL + "/api/sdk/update-session/", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          sessionId,
-          status
-        })
-      });
-      if (!response.ok) {
-        throw new UpdateSessionError("Error updating session with sessionId: " + sessionId);
-      }
-      const res = yield response.json();
-      return res;
-    } catch (err) {
-      throw new UpdateSessionError("Error updating session with sessionId: " + sessionId);
-    }
-  });
-}
-function fetchProvidersByAppId(appId, providerId) {
+function getWitnessesForClaim(epoch, identifier, timestampS) {
   return __async(this, null, function* () {
-    try {
-      const response = yield fetch(`${constants.GET_PROVIDERS_BY_ID_API}/${appId}/provider/${providerId}`);
-      if (response.status === 404) {
-        throw new ApplicationError("Application not found with AppId: " + appId);
-      }
-      if (response.status !== 200) {
-        throw new Error();
-      }
-      const res = yield response.json();
-      return res.providers.httpProvider;
-    } catch (err) {
-      if (err instanceof ApplicationError) {
-        throw err;
-      }
-      throw new ProviderAPIError("Error fetching provider with AppId: " + appId);
+    const beacon = makeBeacon();
+    if (!beacon) {
+      logger5.info("No beacon available for getting witnesses");
+      throw new Error("No beacon available");
     }
+    const state = yield beacon.getState(epoch);
+    const witnessList = fetchWitnessListForClaim(state, identifier, timestampS);
+    const witnesses = witnessList.map((w) => w.id.toLowerCase());
+    return witnesses;
   });
 }
-function validateProviderIdsAndReturnProviders(providerId, providers) {
-  let providerExists = providers.some((provider) => providerId == provider.httpProviderId);
-  if (!providerExists) {
-    throw new ProviderAPIError(`The following provider Id is not included in your application => ${providerId}`);
-  }
-  return providers.find((provider) => providerId == provider.httpProviderId);
-}
-function generateRequestedProofs(provider, context, callbackUrl, statusUrl, sessionId, redirectUser) {
-  const providerParams = {};
-  provider.responseSelections.forEach((rs) => rs.responseMatch.split(/{{(.*?)}}/).filter((e, i) => i % 2).forEach((param) => providerParams[param] = void 0));
-  const claims = [{
-    provider: encodeURIComponent(provider.name),
-    context: JSON.stringify(context),
-    httpProviderId: provider.httpProviderId,
-    payload: {
-      metadata: {
-        name: encodeURIComponent(provider.name),
-        logoUrl: provider.logoUrl,
-        proofCardText: provider.proofCardText,
-        proofCardTitle: provider.proofCardTitle
-      },
-      url: provider.url,
-      urlType: provider.urlType,
-      method: provider.method,
-      login: {
-        url: provider.loginUrl
-      },
-      responseSelections: provider.responseSelections,
-      customInjection: provider.customInjection,
-      bodySniff: provider.bodySniff,
-      userAgent: provider.userAgent,
-      geoLocation: provider.geoLocation,
-      matchType: provider.matchType,
-      injectionType: provider.injectionType,
-      disableRequestReplay: provider.disableRequestReplay,
-      verificationType: provider.verificationType,
-      parameters: providerParams
-    }
-  }];
-  return {
-    id: sessionId,
-    sessionId,
-    name: redirectUser ? "web-r-SDK" : "web-SDK",
-    callbackUrl,
-    statusUrl,
-    claims
-  };
+function recoverSignersOfSignedClaim({
+  claim,
+  signatures
+}) {
+  const dataStr = createSignDataForClaim(__spreadValues({}, claim));
+  const signers = signatures.map(
+    (signature) => import_ethers5.ethers.verifyMessage(dataStr, import_ethers5.ethers.hexlify(signature)).toLowerCase()
+  );
+  return signers;
 }
-function validateSignature(requestedProofs, signature, applicationId, linkingVersion, timeStamp) {
-  var _a, _b;
-  try {
-    let appId = "";
-    if (requestedProofs.claims.length && (linkingVersion === "V2Linking" || ((_b = (_a = requestedProofs.claims[0]) == null ? void 0 : _a.payload) == null ? void 0 : _b.verificationType) === "MANUAL")) {
-      appId = import_ethers4.ethers.verifyMessage(
-        import_ethers4.ethers.getBytes(
-          import_ethers4.ethers.keccak256(
-            new TextEncoder().encode((0, import_canonicalize.default)({
-              providerId: requestedProofs.claims[0].httpProviderId,
-              timestamp: timeStamp
-            }))
-          )
-        ),
-        import_ethers4.ethers.hexlify(signature)
-      ).toLowerCase();
-    } else {
-      appId = import_ethers4.ethers.verifyMessage(
-        import_ethers4.ethers.getBytes(
-          import_ethers4.ethers.keccak256(
-            new TextEncoder().encode((0, import_canonicalize.default)(requestedProofs))
-          )
-        ),
-        import_ethers4.ethers.hexlify(signature)
-      ).toLowerCase();
-    }
-    if (import_ethers4.ethers.getAddress(appId) !== import_ethers4.ethers.getAddress(applicationId)) {
-      throw new InvalidSignatureError(`Signature does not match the application id: ${appId}`);
+function assertValidSignedClaim(claim, expectedWitnessAddresses) {
+  const witnessAddresses = recoverSignersOfSignedClaim(claim);
+  const witnessesNotSeen = new Set(expectedWitnessAddresses);
+  for (const witness of witnessAddresses) {
+    if (witnessesNotSeen.has(witness)) {
+      witnessesNotSeen.delete(witness);
     }
-  } catch (err) {
-    throw err;
   }
-}
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function replaceAll(str, find, replace) {
-  return str.replace(new RegExp(escapeRegExp(find), "g"), replace);
-}
-function getBranchLink(template) {
-  return __async(this, null, function* () {
-    try {
-      const options = {
-        method: "POST",
-        headers: { accept: "application/json", "content-type": "application/json" },
-        body: JSON.stringify({
-          template
-        })
-      };
-      const response = yield fetch(constants.RECLAIM_GET_BRANCH_URL, options);
-      if (response.status !== 200) {
-        throw new Error(
-          "Error creating verification request - Branch Link not created"
-        );
-      }
-      const data = yield response.json();
-      const link = data == null ? void 0 : data.branchUrl;
-      if (!link) {
-        throw new Error(
-          "Error creating verification request - Branch Link not created"
-        );
-      }
-      return link;
-    } catch (err) {
-      throw err;
-    }
-  });
+  if (witnessesNotSeen.size > 0) {
+    const missingWitnesses = Array.from(witnessesNotSeen).join(", ");
+    logger5.info(`Claim validation failed. Missing signatures from: ${missingWitnesses}`);
+    throw new ProofNotVerifiedError(
+      `Missing signatures from ${missingWitnesses}`
+    );
+  }
 }
 
 // src/Reclaim.ts
-var import_pino = __toESM(require("pino"));
-var logger = (0, import_pino.default)();
-var _Reclaim = class _Reclaim {
-  static verifySignedProof(proof) {
-    return __async(this, null, function* () {
-      var _a;
-      if (!proof.signatures.length) {
-        throw new Error("No signatures");
-      }
+var logger6 = logger_default.logger;
+function verifyProof(proof) {
+  return __async(this, null, function* () {
+    var _a;
+    if (!proof.signatures.length) {
+      throw new SignatureNotFoundError("No signatures");
+    }
+    try {
       let witnesses = [];
       if (proof.witnesses.length && ((_a = proof.witnesses[0]) == null ? void 0 : _a.url) === "manual-verify") {
         witnesses.push(proof.witnesses[0].id);
@@ -1129,375 +1098,365 @@ var _Reclaim = class _Reclaim {
           proof.claimData.timestampS
         );
       }
-      try {
-        const calculatedIdentifier = getIdentifierFromClaimInfo({
-          parameters: JSON.parse(
-            (0, import_canonicalize2.default)(proof.claimData.parameters)
-          ),
-          provider: proof.claimData.provider,
-          context: proof.claimData.context
-        });
-        proof.identifier = replaceAll(proof.identifier, '"', "");
-        if (calculatedIdentifier !== proof.identifier) {
-          throw new ProofNotVerifiedError("Identifier Mismatch");
-        }
-        const signedClaim = {
-          claim: __spreadValues({}, proof.claimData),
-          signatures: proof.signatures.map((signature) => {
-            return import_ethers5.ethers.getBytes(signature);
-          })
-        };
-        assertValidSignedClaim(signedClaim, witnesses);
-      } catch (e) {
-        logger.error(e);
-        return false;
-      }
-      return true;
-    });
-  }
-  static transformForOnchain(proof) {
-    const claimInfoBuilder = /* @__PURE__ */ new Map([
-      ["context", proof.claimData.context],
-      ["parameters", proof.claimData.parameters],
-      ["provider", proof.claimData.provider]
-    ]);
-    const claimInfo = Object.fromEntries(claimInfoBuilder);
-    const claimBuilder = /* @__PURE__ */ new Map([
-      ["epoch", proof.claimData.epoch],
-      ["identifier", proof.claimData.identifier],
-      ["owner", proof.claimData.owner],
-      ["timestampS", proof.claimData.timestampS]
-    ]);
-    const signedClaim = {
-      claim: Object.fromEntries(claimBuilder),
-      signatures: proof.signatures
-    };
-    return { claimInfo, signedClaim };
-  }
-  static verifyProvider(proof, providerHash) {
-    try {
-      validateNotNullOrUndefined(providerHash, "applicationId", "verifyProvider function");
-      validateNotNullOrUndefined(proof, "proof", "verifyProvider function");
-      validateNonEmptyString(providerHash, "applicationId", "verifyProvider function");
-      validateNonEmptyString(proof.claimData.context, "context", "verifyProvider function");
-      const jsonContext = JSON.parse(proof.claimData.context);
-      if (!jsonContext.providerHash) {
-        logger.info(`ProviderHash is not included in proof's context`);
-        return false;
-      }
-      if (providerHash !== jsonContext.providerHash) {
-        logger.info(`ProviderHash in context: ${jsonContext.providerHash} does not match the stored providerHash: ${providerHash}`);
-        return false;
+      const calculatedIdentifier = getIdentifierFromClaimInfo({
+        parameters: JSON.parse(
+          (0, import_canonicalize2.default)(proof.claimData.parameters)
+        ),
+        provider: proof.claimData.provider,
+        context: proof.claimData.context
+      });
+      proof.identifier = replaceAll(proof.identifier, '"', "");
+      if (calculatedIdentifier !== proof.identifier) {
+        throw new ProofNotVerifiedError("Identifier Mismatch");
       }
-      return true;
+      const signedClaim = {
+        claim: __spreadValues({}, proof.claimData),
+        signatures: proof.signatures.map((signature) => {
+          return import_ethers6.ethers.getBytes(signature);
+        })
+      };
+      assertValidSignedClaim(signedClaim, witnesses);
     } catch (e) {
-      logger.error(e);
+      logger6.info(`Error verifying proof: ${e instanceof Error ? e.message : String(e)}`);
       return false;
     }
-  }
-};
-_Reclaim.ProofRequest = class {
-  constructor(applicationId, options) {
+    return true;
+  });
+}
+function transformForOnchain(proof) {
+  const claimInfoBuilder = /* @__PURE__ */ new Map([
+    ["context", proof.claimData.context],
+    ["parameters", proof.claimData.parameters],
+    ["provider", proof.claimData.provider]
+  ]);
+  const claimInfo = Object.fromEntries(claimInfoBuilder);
+  const claimBuilder = /* @__PURE__ */ new Map([
+    ["epoch", proof.claimData.epoch],
+    ["identifier", proof.claimData.identifier],
+    ["owner", proof.claimData.owner],
+    ["timestampS", proof.claimData.timestampS]
+  ]);
+  const signedClaim = {
+    claim: Object.fromEntries(claimBuilder),
+    signatures: proof.signatures
+  };
+  return { claimInfo, signedClaim };
+}
+var ReclaimProofRequest = class _ReclaimProofRequest {
+  // Private constructor
+  constructor(applicationId, providerId, options) {
     this.context = { contextAddress: "0x0", contextMessage: "" };
     this.intervals = /* @__PURE__ */ new Map();
-    validateNotNullOrUndefined(applicationId, "applicationId", "the constructor");
-    validateNonEmptyString(applicationId, "applicationId", "the constructor");
-    if (options == null ? void 0 : options.sessionId) {
-      validateNonEmptyString(options == null ? void 0 : options.sessionId, "sessionId", "the constructor");
-    }
-    this.linkingVersion = "V1";
-    this.applicationId = applicationId;
-    this.sessionId = (options == null ? void 0 : options.sessionId) || (0, import_uuid.v4)().toString();
-    logger.level = (options == null ? void 0 : options.log) ? "info" : "silent";
-    logger.info(
-      `Initializing client with applicationId: ${this.applicationId} and sessionId: ${this.sessionId}`
-    );
+    this.providerId = providerId;
     this.timeStamp = Date.now().toString();
+    this.applicationId = applicationId;
+    this.sessionId = "";
+    if (options == null ? void 0 : options.log) {
+      logger_default.setLogLevel("info");
+    } else {
+      logger_default.setLogLevel("silent");
+    }
+    this.options = options;
+    logger6.info(`Initializing client with applicationId: ${this.applicationId}`);
   }
-  addContext(address, message) {
-    validateNotNullOrUndefined(address, "address", "addContext");
-    validateNotNullOrUndefined(message, "message", "addContext");
-    this.context = { contextAddress: address, contextMessage: message };
+  // Static initialization methods
+  static init(applicationId, appSecret, providerId, options) {
+    return __async(this, null, function* () {
+      try {
+        validateFunctionParams([
+          { paramName: "applicationId", input: applicationId, isString: true },
+          { paramName: "providerId", input: providerId, isString: true },
+          { paramName: "appSecret", input: appSecret, isString: true }
+        ], "the constructor");
+        if (options) {
+          if (options.acceptAiProviders) {
+            validateFunctionParams([
+              { paramName: "acceptAiProviders", input: options.acceptAiProviders }
+            ], "the constructor");
+          }
+          if (options.log) {
+            validateFunctionParams([
+              { paramName: "log", input: options.log }
+            ], "the constructor");
+          }
+        }
+        const proofRequestInstance = new _ReclaimProofRequest(applicationId, providerId, options);
+        const signature = yield proofRequestInstance.generateSignature(appSecret);
+        proofRequestInstance.setSignature(signature);
+        const data = yield initSession(providerId, applicationId, proofRequestInstance.timeStamp, signature);
+        proofRequestInstance.sessionId = data.sessionId;
+        yield proofRequestInstance.buildProofRequest(data.provider);
+        return proofRequestInstance;
+      } catch (error) {
+        logger6.info(error);
+        throw new InitError("Failed to initialize ReclaimProofRequest", error);
+      }
+    });
   }
+  static fromJsonString(jsonString) {
+    return __async(this, null, function* () {
+      try {
+        const {
+          applicationId,
+          providerId,
+          sessionId,
+          context,
+          requestedProof,
+          signature,
+          redirectUrl,
+          timeStamp,
+          appCallbackUrl,
+          options
+        } = JSON.parse(jsonString);
+        validateFunctionParams([
+          { input: applicationId, paramName: "applicationId", isString: true },
+          { input: providerId, paramName: "providerId", isString: true },
+          { input: signature, paramName: "signature", isString: true },
+          { input: sessionId, paramName: "sessionId", isString: true },
+          { input: timeStamp, paramName: "timeStamp", isString: true }
+        ], "fromJsonString");
+        validateRequestedProof(requestedProof);
+        if (redirectUrl) {
+          validateURL(redirectUrl, "fromJsonString");
+        }
+        if (appCallbackUrl) {
+          validateURL(appCallbackUrl, "fromJsonString");
+        }
+        if (context) {
+          validateContext(context);
+        }
+        const proofRequestInstance = new _ReclaimProofRequest(applicationId, providerId, options);
+        proofRequestInstance.sessionId = sessionId;
+        proofRequestInstance.context = context;
+        proofRequestInstance.requestedProof = requestedProof;
+        proofRequestInstance.appCallbackUrl = appCallbackUrl;
+        proofRequestInstance.redirectUrl = redirectUrl;
+        proofRequestInstance.timeStamp = timeStamp;
+        proofRequestInstance.signature = signature;
+        return proofRequestInstance;
+      } catch (error) {
+        logger6.info("Failed to parse JSON string in fromJsonString:", error);
+        throw new InvalidParamError("Invalid JSON string provided to fromJsonString");
+      }
+    });
+  }
+  // Setter methods
   setAppCallbackUrl(url) {
     validateURL(url, "setAppCallbackUrl");
-    const urlObj = new URL(url);
-    urlObj.searchParams.append("callbackId", this.sessionId);
-    this.appCallbackUrl = urlObj.toString();
+    this.appCallbackUrl = url;
   }
   setRedirectUrl(url) {
     validateURL(url, "setRedirectUrl");
-    const urlObj = new URL(url);
-    this.redirectUrl = urlObj.toString();
+    this.redirectUrl = url;
   }
-  setStatusUrl(url) {
-    validateURL(url, "setStatusUrl");
-    this.statusUrl = url;
+  addContext(address, message) {
+    try {
+      validateFunctionParams([
+        { input: address, paramName: "address", isString: true },
+        { input: message, paramName: "message", isString: true }
+      ], "addContext");
+      this.context = { contextAddress: address, contextMessage: message };
+    } catch (error) {
+      logger6.info("Error adding context", error);
+      throw new AddContextError("Error adding context", error);
+    }
   }
-  setSignature(signature) {
-    validateNotNullOrUndefined(signature, "signature", "setSignature");
-    validateNonEmptyString(signature, "signature", "setSignature");
-    this.signature = signature;
+  setParams(params) {
+    try {
+      const requestedProof = this.getRequestedProof();
+      if (!requestedProof || !this.requestedProof) {
+        throw new BuildProofRequestError("Requested proof is not present.");
+      }
+      const currentParams = this.availableParams();
+      if (!currentParams) {
+        throw new NoProviderParamsError("No params present in the provider config.");
+      }
+      const paramsToSet = Object.keys(params);
+      for (const param of paramsToSet) {
+        if (!currentParams.includes(param)) {
+          throw new InvalidParamError(
+            `Cannot set parameter ${param} for provider ${this.providerId}. Available parameters: ${currentParams}`
+          );
+        }
+      }
+      this.requestedProof.parameters = __spreadValues(__spreadValues({}, requestedProof.parameters), params);
+    } catch (error) {
+      logger6.info("Error Setting Params:", error);
+      throw new SetParamsError("Error setting params", error);
+    }
   }
+  // Getter methods
   getAppCallbackUrl() {
-    return this.appCallbackUrl || `${constants.DEFAULT_RECLAIM_CALLBACK_URL}${this.sessionId}`;
+    try {
+      validateFunctionParams([{ input: this.sessionId, paramName: "sessionId", isString: true }], "getAppCallbackUrl");
+      return this.appCallbackUrl || `${constants.DEFAULT_RECLAIM_CALLBACK_URL}${this.sessionId}`;
+    } catch (error) {
+      logger6.info("Error getting app callback url", error);
+      throw new GetAppCallbackUrlError("Error getting app callback url", error);
+    }
   }
   getStatusUrl() {
-    return this.statusUrl || `${constants.DEFAULT_RECLAIM_STATUS_URL}${this.sessionId}`;
+    try {
+      validateFunctionParams([{ input: this.sessionId, paramName: "sessionId", isString: true }], "getStatusUrl");
+      return `${constants.DEFAULT_RECLAIM_STATUS_URL}${this.sessionId}`;
+    } catch (error) {
+      logger6.info("Error fetching Status Url", error);
+      throw new GetStatusUrlError("Error fetching status url", error);
+    }
   }
-  getRequestedProofs() {
+  // Private helper methods
+  setSignature(signature) {
     try {
-      if (!this.requestedProofs) {
-        throw new BuildProofRequestError(
-          "Call buildProofRequest(providerId: string) first!"
-        );
-      }
-      return this.requestedProofs;
-    } catch (err) {
-      throw err;
+      validateFunctionParams([{ input: signature, paramName: "signature", isString: true }], "setSignature");
+      this.signature = signature;
+      logger6.info(`Signature set successfully for session ID: ${this.sessionId}`);
+    } catch (error) {
+      logger6.info("Error setting signature", error);
+      throw new SetSignatureError("Error setting signature", error);
     }
   }
   generateSignature(applicationSecret) {
     return __async(this, null, function* () {
-      var _a, _b;
       try {
-        const wallet = new import_ethers5.ethers.Wallet(applicationSecret);
-        const requestedProofs = this.getRequestedProofs();
-        if (requestedProofs.claims.length && (this.linkingVersion === "V2Linking" || ((_b = (_a = requestedProofs.claims[0]) == null ? void 0 : _a.payload) == null ? void 0 : _b.verificationType) === "MANUAL")) {
-          const signature2 = yield wallet.signMessage(
-            import_ethers5.ethers.getBytes(
-              import_ethers5.ethers.keccak256(
-                new TextEncoder().encode(
-                  (0, import_canonicalize2.default)({
-                    providerId: requestedProofs.claims[0].httpProviderId,
-                    timestamp: this.timeStamp
-                  })
-                )
-              )
-            )
-          );
-          return signature2;
+        const wallet = new import_ethers6.ethers.Wallet(applicationSecret);
+        const canonicalData = (0, import_canonicalize2.default)({ providerId: this.providerId, timestamp: this.timeStamp });
+        if (!canonicalData) {
+          throw new SignatureGeneratingError("Failed to canonicalize data for signing.");
         }
-        const signature = yield wallet.signMessage(
-          import_ethers5.ethers.getBytes(
-            import_ethers5.ethers.keccak256(
-              new TextEncoder().encode(
-                (0, import_canonicalize2.default)(requestedProofs)
-              )
-            )
-          )
-        );
-        return signature;
+        const messageHash = import_ethers6.ethers.keccak256(new TextEncoder().encode(canonicalData));
+        return yield wallet.signMessage(import_ethers6.ethers.getBytes(messageHash));
       } catch (err) {
-        logger.error(err);
-        throw new BuildProofRequestError(
-          "Error generating signature for applicationSecret: " + applicationSecret
-        );
+        logger6.info(`Error generating proof request for applicationId: ${this.applicationId}, providerId: ${this.providerId}, signature: ${this.signature}, timeStamp: ${this.timeStamp}`, err);
+        throw new SignatureGeneratingError(`Error generating signature for applicationSecret: ${applicationSecret}`);
       }
     });
   }
-  buildProofRequest(providerId, redirectUser = false, linkingVersion) {
+  buildProofRequest(provider) {
     return __async(this, null, function* () {
-      let providers = yield fetchProvidersByAppId(this.applicationId, providerId);
-      const provider = validateProviderIdsAndReturnProviders(
-        providerId,
-        providers
-      );
       try {
-        this.providerId = providerId;
-        this.requestedProofs = generateRequestedProofs(
-          provider,
-          this.context,
-          this.getAppCallbackUrl(),
-          this.getStatusUrl(),
-          this.sessionId,
-          redirectUser
-        );
-        if (linkingVersion) {
-          if (linkingVersion === "V2Linking") {
-            this.linkingVersion = linkingVersion;
-          } else {
-            throw new BuildProofRequestError(
-              "Invalid linking version. Supported linking versions are V2Linking"
-            );
-          }
-        }
-        return this.requestedProofs;
+        this.requestedProof = generateRequestedProof(provider);
+        return this.requestedProof;
       } catch (err) {
-        logger.error(err);
-        throw new BuildProofRequestError(
-          "Something went wrong while generating proof request"
-        );
+        logger6.info(err instanceof Error ? err.message : String(err));
+        throw new BuildProofRequestError("Something went wrong while generating proof request", err);
       }
     });
   }
-  createVerificationRequest() {
+  getRequestedProof() {
+    if (!this.requestedProof) {
+      throw new BuildProofRequestError("RequestedProof is not present in the instance.");
+    }
+    return this.requestedProof;
+  }
+  availableParams() {
+    try {
+      const requestedProofs = this.getRequestedProof();
+      let availableParamsStore = Object.keys(requestedProofs.parameters);
+      availableParamsStore = availableParamsStore.concat(requestedProofs.url.split(/{{(.*?)}}/).filter((_, i) => i % 2));
+      return [...new Set(availableParamsStore)];
+    } catch (error) {
+      logger6.info("Error fetching available params", error);
+      throw new AvailableParamsError("Error fetching available params", error);
+    }
+  }
+  clearInterval() {
+    if (this.sessionId && this.intervals.has(this.sessionId)) {
+      clearInterval(this.intervals.get(this.sessionId));
+      this.intervals.delete(this.sessionId);
+    }
+  }
+  // Public methods
+  toJsonString(options) {
+    return JSON.stringify({
+      applicationId: this.applicationId,
+      providerId: this.providerId,
+      sessionId: this.sessionId,
+      context: this.context,
+      requestedProof: this.requestedProof,
+      appCallbackUrl: this.appCallbackUrl,
+      signature: this.signature,
+      redirectUrl: this.redirectUrl,
+      timeStamp: this.timeStamp,
+      options: this.options
+    });
+  }
+  getRequestUrl() {
     return __async(this, null, function* () {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c;
+      logger6.info("Creating Request Url");
+      if (!this.signature) {
+        throw new SignatureNotFoundError("Signature is not set.");
+      }
       try {
-        const requestedProofs = yield this.getRequestedProofs();
-        if (!requestedProofs) {
-          throw new BuildProofRequestError(
-            "Requested proofs are not built yet. Call buildProofRequest(providerId: string) first!"
-          );
-        }
-        if (!this.signature) {
-          throw new SignatureNotFoundError(
-            "Signature is not set. Use reclaim.setSignature(signature) to set the signature"
-          );
-        }
-        validateSignature(requestedProofs, this.signature, this.applicationId, this.linkingVersion, this.timeStamp);
-        let templateData = {};
-        if (requestedProofs.claims.length && (this.linkingVersion === "V2Linking" || ((_b = (_a = requestedProofs.claims[0]) == null ? void 0 : _a.payload) == null ? void 0 : _b.verificationType) === "MANUAL")) {
-          templateData = {
-            sessionId: this.sessionId,
-            providerId: this.providerId,
-            applicationId: this.applicationId,
-            signature: this.signature,
-            timestamp: this.timeStamp,
-            callbackUrl: this.getAppCallbackUrl(),
-            context: JSON.stringify(this.context),
-            verificationType: requestedProofs.claims[0].payload.verificationType,
-            parameters: requestedProofs.claims[0].payload.parameters,
-            redirectUrl: (_c = this.redirectUrl) != null ? _c : ""
-          };
-        } else {
-          templateData = __spreadProps(__spreadValues({}, requestedProofs), {
-            signature: this.signature
-          });
-        }
-        let template = encodeURIComponent(
-          JSON.stringify(templateData)
-        );
-        template = replaceAll(template, "(", "%28");
-        template = replaceAll(template, ")", "%29");
-        let link = "";
-        if (requestedProofs.claims.length && (this.linkingVersion === "V2Linking" || ((_e = (_d = requestedProofs.claims[0]) == null ? void 0 : _d.payload) == null ? void 0 : _e.verificationType) === "MANUAL")) {
-          link = `https://share.reclaimprotocol.org/verifier?template=` + template;
-          link = yield getShortenedUrl(link);
-        } else {
-          link = yield getBranchLink(template);
-        }
-        yield createSession(this.sessionId, this.applicationId, this.providerId);
-        return { requestUrl: link, statusUrl: this.getStatusUrl() };
+        const requestedProof = this.getRequestedProof();
+        validateSignature(this.providerId, this.signature, this.applicationId, this.timeStamp);
+        const templateData = {
+          sessionId: this.sessionId,
+          providerId: this.providerId,
+          applicationId: this.applicationId,
+          signature: this.signature,
+          timestamp: this.timeStamp,
+          callbackUrl: this.getAppCallbackUrl(),
+          context: JSON.stringify(this.context),
+          parameters: getFilledParameters(requestedProof),
+          redirectUrl: (_a = this.redirectUrl) != null ? _a : "",
+          acceptAiProviders: (_c = (_b = this.options) == null ? void 0 : _b.acceptAiProviders) != null ? _c : false
+        };
+        const link = yield createLinkWithTemplateData(templateData);
+        logger6.info("Request Url created successfully: " + link);
+        yield updateSession(this.sessionId, "SESSION_STARTED" /* SESSION_STARTED */);
+        return link;
       } catch (error) {
-        logger.error("Error creating verification request:", error);
+        logger6.info("Error creating Request Url:", error);
         throw error;
       }
     });
   }
   startSession(_0) {
-    return __async(this, arguments, function* ({
-      onSuccessCallback,
-      onFailureCallback
-    }) {
+    return __async(this, arguments, function* ({ onSuccess, onError }) {
       const statusUrl = this.getStatusUrl();
-      if (statusUrl && this.sessionId) {
-        logger.info("Starting session");
-        try {
-          yield updateSession(this.sessionId, "SDK_STARTED" /* SDK_STARTED */);
-        } catch (e) {
-          logger.error(e);
-        }
-        const interval = setInterval(() => __async(this, null, function* () {
-          try {
-            const res = yield fetch(statusUrl);
-            const data = yield res.json();
-            if (!data.session)
-              return;
-            if (data.session.status === "FAILED" /* FAILED */)
-              throw new ProviderFailedError();
-            if (data.session.proofs.length === 0)
-              return;
-            const proof = data.session.proofs[0];
-            const verified = yield _Reclaim.verifySignedProof(proof);
-            if (!verified) {
-              throw new ProofNotVerifiedError();
-            }
-            if (onSuccessCallback) {
-              try {
-                yield updateSession(this.sessionId, "SDK_RECEIVED" /* SDK_RECEIVED */);
-              } catch (e) {
-                logger.error(e);
-              }
-              onSuccessCallback(data.session.proofs);
-            }
-            clearInterval(this.intervals.get(this.sessionId));
-            this.intervals.delete(this.sessionId);
-          } catch (e) {
-            if (!(e instanceof ProviderFailedError)) {
-              try {
-                yield updateSession(this.sessionId, "FAILED" /* FAILED */);
-              } catch (e2) {
-                logger.error(e2);
-              }
-            }
-            if (onFailureCallback) {
-              onFailureCallback(e);
-            }
-            clearInterval(this.intervals.get(this.sessionId));
-            this.intervals.delete(this.sessionId);
-          }
-        }), 3e3);
-        this.intervals.set(this.sessionId, interval);
-        this.scheduleIntervalEndingTask(onFailureCallback);
-      } else {
+      if (!statusUrl || !this.sessionId) {
         const message = "Session can't be started due to undefined value of statusUrl and sessionId";
-        logger.error(message);
+        logger6.info(message);
         throw new SessionNotStartedError(message);
       }
-    });
-  }
-  scheduleIntervalEndingTask(onFailureCallback) {
-    setTimeout(() => __async(this, null, function* () {
-      if (this.intervals.has(this.sessionId)) {
-        const message = "Interval ended without receiveing proofs";
-        yield updateSession(this.sessionId, "FAILED" /* FAILED */);
-        onFailureCallback(new TimeoutError(message));
-        logger.warn(message);
-        clearInterval(this.intervals.get(this.sessionId));
-      }
-    }), 1e3 * 60 * 10);
-  }
-  availableParams() {
-    const requestedProofs = this.getRequestedProofs();
-    if (!requestedProofs || !this.requestedProofs) {
-      throw new BuildProofRequestError(
-        "Requested proofs are not built yet. Call buildProofRequest(providerId: string) first!"
-      );
-    }
-    let availableParamsStore = Object.keys(requestedProofs.claims[0].payload.parameters);
-    availableParamsStore = availableParamsStore.concat(requestedProofs.claims[0].payload.url.split(/{{(.*?)}}/).filter((_, i) => i % 2));
-    availableParamsStore = availableParamsStore.concat(requestedProofs.claims[0].payload.login.url.split(/{{(.*?)}}/).filter((_, i) => i % 2));
-    return [...new Set(availableParamsStore)];
-  }
-  setParams(params) {
-    try {
-      const requestedProofs = this.getRequestedProofs();
-      if (!requestedProofs || !this.requestedProofs) {
-        throw new BuildProofRequestError(
-          "Requested proofs are not built yet. Call buildProofRequest(providerId: string) first!"
-        );
-      }
-      const availableParams = this.availableParams();
-      const paramsToSet = Object.keys(params);
-      for (let i = 0; i < paramsToSet.length; i++) {
-        if (requestedProofs.claims[0].payload.verificationType === "WITNESS" && !availableParams.includes(paramsToSet[i])) {
-          throw new InvalidParamError(
-            `Cannot Set parameter ${paramsToSet[i]} for provider ${this.providerId} available Prameters inculde : ${availableParams}`
-          );
+      logger6.info("Starting session");
+      const interval = setInterval(() => __async(this, null, function* () {
+        try {
+          const res = yield fetch(statusUrl);
+          const data = yield res.json();
+          if (!data.session)
+            return;
+          if (data.session.status === "PROOF_GENERATION_FAILED" /* PROOF_GENERATION_FAILED */)
+            throw new ProviderFailedError();
+          if (data.session.proofs.length === 0)
+            return;
+          const proof = data.session.proofs[0];
+          const verified = yield verifyProof(proof);
+          if (!verified) {
+            logger6.info(`Proof not verified: ${proof}`);
+            throw new ProofNotVerifiedError();
+          }
+          if (onSuccess) {
+            onSuccess(proof);
+          }
+          this.clearInterval();
+        } catch (e) {
+          if (onError) {
+            onError(e);
+          }
+          this.clearInterval();
         }
-      }
-      this.requestedProofs.claims[0].payload.parameters = __spreadValues(__spreadValues({}, requestedProofs.claims[0].payload.parameters), params);
-    } catch (error) {
-      logger.error("Error Setting Params:", error);
-      throw error;
-    }
+      }), 3e3);
+      this.intervals.set(this.sessionId, interval);
+      scheduleIntervalEndingTask(this.sessionId, this.intervals, onError);
+    });
   }
 };
-var Reclaim = _Reclaim;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Reclaim
+  ReclaimProofRequest,
+  transformForOnchain,
+  verifyProof
 });
 //# sourceMappingURL=index.js.map