@prosopo/provider 2.1.1 → 2.1.2

package/dist/cjs/schedulers/getClientList.cjs

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const env = require("@prosopo/env");
-const types = require("@prosopo/types");
-const cron = require("cron");
-const tasks = require("../tasks/tasks.cjs");
-const util = require("../util.cjs");
-async function getClientList(pair, config) {
-  const env$1 = new env.ProviderEnvironment(config, pair);
-  await env$1.isReady();
-  const tasks$1 = new tasks.Tasks(env$1);
-  const defaultSchedule = "0 * * * *";
-  const cronSchedule = config.scheduledTasks?.clientListScheduler ? config.scheduledTasks.clientListScheduler.schedule ? config.scheduledTasks.clientListScheduler.schedule : defaultSchedule : defaultSchedule;
-  const job = new cron.CronJob(cronSchedule, async () => {
-    const taskRunning = await util.checkIfTaskIsRunning(
-      types.ScheduledTaskNames.GetClientList,
-      env$1.getDb()
-    );
-    env$1.logger.info(
-      `${types.ScheduledTaskNames.GetClientList} task running: ${taskRunning}`
-    );
-    if (!taskRunning) {
-      env$1.logger.info(`${types.ScheduledTaskNames.GetClientList} task....`);
-      await tasks$1.clientTaskManager.getClientList().catch((err) => {
-        env$1.logger.error(err);
-      });
-    }
-  });
-  job.start();
-}
-exports.getClientList = getClientList;

package/dist/cjs/tasks/client/clientTasks.cjs

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const database = require("@prosopo/database");
-const types = require("@prosopo/types");
-class ClientTaskManager {
-  constructor(config, logger, db) {
-    this.config = config;
-    this.logger = logger;
-    this.providerDB = db;
-  }
-  /**
-   * @description Store commitments externally in the database
-   * @returns Promise<void>
-   */
-  async storeCommitmentsExternal() {
-    if (!this.config.mongoCaptchaUri) {
-      this.logger.info("Mongo env not set");
-      return;
-    }
-    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
-      types.ScheduledTaskNames.StoreCommitmentsExternal,
-      types.ScheduledTaskStatus.Completed
-    );
-    const taskID = await this.providerDB.createScheduledTaskStatus(
-      types.ScheduledTaskNames.StoreCommitmentsExternal,
-      types.ScheduledTaskStatus.Running
-    );
-    try {
-      let commitments = await this.providerDB.getUnstoredDappUserCommitments();
-      let powRecords = await this.providerDB.getUnstoredDappUserPoWCommitments();
-      if (lastTask) {
-        this.logger.info(
-          `Filtering records to only get updated records: ${JSON.stringify(lastTask)}`
-        );
-        this.logger.info(
-          "Last task ran at ",
-          new Date(lastTask.updated || 0),
-          "Task ID",
-          taskID
-        );
-        commitments = commitments.filter(
-          (commitment) => lastTask.updated && commitment.lastUpdatedTimestamp && (commitment.lastUpdatedTimestamp > lastTask.updated || !commitment.lastUpdatedTimestamp)
-        );
-        powRecords = powRecords.filter((commitment) => {
-          return lastTask.updated && commitment.lastUpdatedTimestamp && // either the update stamp is more recent than the last time this task ran or there is no update stamp,
-          // so it is a new record
-          (commitment.lastUpdatedTimestamp > lastTask.updated || !commitment.lastUpdatedTimestamp);
-        });
-      }
-      if (commitments.length || powRecords.length) {
-        this.logger.info(
-          `Storing ${commitments.length} commitments externally`
-        );
-        this.logger.info(
-          `Storing ${powRecords.length} pow challenges externally`
-        );
-        const captchaDB = new database.CaptchaDatabase(
-          this.config.mongoCaptchaUri,
-          void 0,
-          void 0,
-          this.logger
-        );
-        await captchaDB.saveCaptchas(commitments, powRecords);
-        await this.providerDB.markDappUserCommitmentsStored(
-          commitments.map((commitment) => commitment.id)
-        );
-        await this.providerDB.markDappUserPoWCommitmentsStored(
-          powRecords.map((powRecords2) => powRecords2.challenge)
-        );
-      }
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Completed,
-        {
-          data: {
-            commitments: commitments.map((c) => c.id),
-            powRecords: powRecords.map((pr) => pr.challenge)
-          }
-        }
-      );
-    } catch (e) {
-      this.logger.error(e);
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Failed,
-        { error: String(e) }
-      );
-    }
-  }
-  /**
-   * @description Get a list of client accounts and their settings from the client database
-   * @returns Promise<void>
-   */
-  async getClientList() {
-    if (!this.config.mongoClientUri) {
-      this.logger.info("Mongo env not set");
-      return;
-    }
-    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
-      types.ScheduledTaskNames.GetClientList,
-      types.ScheduledTaskStatus.Completed
-    );
-    const taskID = await this.providerDB.createScheduledTaskStatus(
-      types.ScheduledTaskNames.GetClientList,
-      types.ScheduledTaskStatus.Running
-    );
-    try {
-      const clientDB = new database.ClientDatabase(
-        this.config.mongoClientUri,
-        void 0,
-        // expected to come from URI
-        void 0,
-        // expected to come from URI
-        this.logger
-      );
-      const updatedAtTimestamp = lastTask ? lastTask.updated || 0 : 0;
-      console.log("updatedAtTimestamp", updatedAtTimestamp);
-      const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
-      if (newClientRecords) {
-        await this.providerDB.updateClientRecords(newClientRecords);
-      }
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Completed,
-        {
-          data: {
-            clientRecords: newClientRecords.map((c) => c.account)
-          }
-        }
-      );
-    } catch (e) {
-      this.logger.error(e);
-      await this.providerDB.updateScheduledTaskStatus(
-        taskID,
-        types.ScheduledTaskStatus.Failed,
-        { error: String(e) }
-      );
-    }
-  }
-  async registerSiteKey(siteKey) {
-    await this.providerDB.updateClientRecords([
-      {
-        account: siteKey
-      }
-    ]);
-  }
-}
-exports.ClientTaskManager = ClientTaskManager;

package/dist/cjs/tasks/dataset/datasetTasks.cjs

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const datasets = require("@prosopo/datasets");
-const datasetTasksUtils = require("./datasetTasksUtils.cjs");
-class DatasetManager {
-  constructor(config, logger, captchaConfig, db) {
-    this.config = config;
-    this.logger = logger;
-    this.captchaConfig = captchaConfig;
-    this.db = db;
-  }
-  /**
-   * @description Set the provider dataset from a file
-   *
-   * @param file JSON of the captcha dataset
-   */
-  async providerSetDatasetFromFile(file) {
-    const datasetRaw = datasets.parseCaptchaDataset(file);
-    return await this.providerSetDataset(datasetRaw);
-  }
-  async providerSetDataset(datasetRaw) {
-    const dataset = await datasetTasksUtils.providerValidateDataset(
-      datasetRaw,
-      this.captchaConfig.solved.count,
-      this.captchaConfig.unsolved.count
-    );
-    await this.db?.storeDataset(dataset);
-  }
-}
-exports.DatasetManager = DatasetManager;

package/dist/cjs/tasks/dataset/datasetTasksUtils.cjs

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const datasets = require("@prosopo/datasets");
-const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
-  if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
-    throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
-      context: { failedFuncName: providerValidateDataset.name }
-    });
-  }
-  const solutions = datasetRaw.captchas.map((captcha) => captcha.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
-  if (solutions < minSolvedCaptchas) {
-    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
-      context: { failedFuncName: providerValidateDataset.name }
-    });
-  }
-  if (solutions < minUnsolvedCaptchas) {
-    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
-      context: { failedFuncName: providerValidateDataset.name }
-    });
-  }
-  const dataset = await datasets.buildDataset(datasetRaw);
-  if (!dataset.datasetId || !dataset.datasetContentId) {
-    throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
-      context: {
-        failedFuncName: providerValidateDataset.name,
-        datasetId: dataset.datasetId,
-        datasetContentId: dataset.datasetContentId
-      }
-    });
-  }
-  return dataset;
-};
-exports.providerValidateDataset = providerValidateDataset;

package/dist/cjs/tasks/imgCaptcha/imgCaptchaTasks.cjs

@@ -1,281 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util$1 = require("@polkadot/util");
-const utilCrypto = require("@polkadot/util-crypto");
-const common = require("@prosopo/common");
-const datasets = require("@prosopo/datasets");
-const types = require("@prosopo/types");
-const util$2 = require("@prosopo/util");
-const util = require("../../util.cjs");
-const imgCaptchaTasksUtils = require("./imgCaptchaTasksUtils.cjs");
-class ImgCaptchaManager {
-  constructor(db, pair, logger, captchaConfig) {
-    this.db = db;
-    this.pair = pair;
-    this.logger = logger;
-    this.captchaConfig = captchaConfig;
-  }
-  async getCaptchaWithProof(datasetId, solved, size) {
-    const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
-    if (!captchaDocs) {
-      throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
-        context: {
-          failedFuncName: this.getCaptchaWithProof.name,
-          datasetId,
-          solved,
-          size
-        }
-      });
-    }
-    return captchaDocs;
-  }
-  async getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, headers) {
-    const dataset = await this.db.getDatasetDetails(datasetId);
-    if (!dataset) {
-      throw new common.ProsopoEnvError("DATABASE.DATASET_GET_FAILED", {
-        context: {
-          failedFuncName: this.getRandomCaptchasAndRequestHash.name,
-          dataset,
-          datasetId
-        }
-      });
-    }
-    const unsolvedCount = Math.abs(
-      Math.trunc(this.captchaConfig.unsolved.count)
-    );
-    const solvedCount = Math.abs(
-      Math.trunc(this.captchaConfig.solved.count)
-    );
-    if (!solvedCount) {
-      throw new common.ProsopoEnvError("CONFIG.INVALID_CAPTCHA_NUMBER");
-    }
-    const solved = await this.getCaptchaWithProof(datasetId, true, solvedCount);
-    let unsolved = [];
-    if (unsolvedCount) {
-      unsolved = await this.getCaptchaWithProof(
-        datasetId,
-        false,
-        unsolvedCount
-      );
-    }
-    const captchas = util.shuffleArray([...solved, ...unsolved]);
-    const salt = utilCrypto.randomAsHex();
-    const requestHash = datasets.computePendingRequestHash(
-      captchas.map((c) => c.captchaId),
-      userAccount,
-      salt
-    );
-    const currentTime = Date.now();
-    const signedRequestHash = util$1.u8aToHex(
-      this.pair.sign(util$1.stringToHex(requestHash))
-    );
-    const timeLimit = captchas.map((captcha) => captcha.timeLimitMs || types.DEFAULT_IMAGE_CAPTCHA_TIMEOUT).reduce((a, b) => a + b, 0);
-    const deadlineTs = timeLimit + currentTime;
-    const currentBlockNumber = 0;
-    await this.db.storeDappUserPending(
-      userAccount,
-      requestHash,
-      salt,
-      deadlineTs,
-      currentTime,
-      ipAddress,
-      headers
-    );
-    return {
-      captchas,
-      requestHash,
-      timestamp: currentTime,
-      signedRequestHash
-    };
-  }
-  /**
-   * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
-   * @param {string} userAccount
-   * @param {string} dappAccount
-   * @param {string} requestHash
-   * @param {JSON} captchas
-   * @param {string} userRequestHashSignature
-   * @param timestamp
-   * @param providerRequestHashSignature
-   * @param ipAddress
-   * @param headers
-   * @return {Promise<DappUserSolutionResult>} result containing the contract event
-   */
-  async dappUserSolution(userAccount, dappAccount, requestHash, captchas, userRequestHashSignature, timestamp, providerRequestHashSignature, ipAddress, headers) {
-    const verification = utilCrypto.signatureVerify(
-      util$1.stringToHex(requestHash),
-      userRequestHashSignature,
-      userAccount
-    );
-    if (!verification.isValid) {
-      this.logger.info("Invalid user requestHash signature");
-      throw new common.ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
-        context: { failedFuncName: this.dappUserSolution.name, userAccount }
-      });
-    }
-    const providerRequestHashSignatureVerify = utilCrypto.signatureVerify(
-      util$1.stringToHex(requestHash.toString()),
-      providerRequestHashSignature,
-      this.pair.address
-    );
-    if (!providerRequestHashSignatureVerify.isValid) {
-      this.logger.info("Invalid provider requestHash signature");
-      throw new common.ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
-        context: {
-          failedFuncName: this.dappUserSolution.name,
-          userAccount,
-          error: "requestHash signature is invalid"
-        }
-      });
-    }
-    let response = {
-      captchas: [],
-      verified: false
-    };
-    const pendingRecord = await this.db.getDappUserPending(requestHash);
-    const unverifiedCaptchaIds = captchas.map((captcha) => captcha.captchaId);
-    const pendingRequest = await this.validateDappUserSolutionRequestIsPending(
-      requestHash,
-      pendingRecord,
-      userAccount,
-      unverifiedCaptchaIds
-    );
-    if (pendingRequest) {
-      const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
-      const { tree, commitmentId } = imgCaptchaTasksUtils.buildTreeAndGetCommitmentId(receivedCaptchas);
-      const datasetId = util$2.at(storedCaptchas, 0).datasetId;
-      if (!datasetId) {
-        throw new common.ProsopoEnvError("CAPTCHA.ID_MISMATCH", {
-          context: { failedFuncName: this.dappUserSolution.name }
-        });
-      }
-      await this.db.updateDappUserPendingStatus(requestHash);
-      const commit = {
-        id: commitmentId,
-        userAccount,
-        dappAccount,
-        providerAccount: this.pair.address,
-        datasetId,
-        result: { status: types.CaptchaStatus.pending },
-        userSignature: userRequestHashSignature,
-        userSubmitted: true,
-        serverChecked: false,
-        requestedAtTimestamp: timestamp,
-        ipAddress,
-        headers
-      };
-      await this.db.storeDappUserSolution(receivedCaptchas, commit);
-      if (datasets.compareCaptchaSolutions(receivedCaptchas, storedCaptchas)) {
-        response = {
-          captchas: captchaIds.map((id) => ({
-            captchaId: id,
-            proof: tree.proof(id)
-          })),
-          verified: true
-        };
-        await this.db.approveDappUserCommitment(commitmentId);
-      } else {
-        await this.db.disapproveDappUserCommitment(
-          commitmentId,
-          "CAPTCHA.INVALID_SOLUTION"
-        );
-        response = {
-          captchas: captchaIds.map((id) => ({
-            captchaId: id,
-            proof: [[]]
-          })),
-          verified: false
-        };
-      }
-    } else {
-      this.logger.info("Request hash not found");
-    }
-    return response;
-  }
-  /**
-   * Validate length of received captchas array matches length of captchas found in database
-   * Validate that the datasetId is the same for all captchas and is equal to the datasetId on the stored captchas
-   */
-  async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
-    const receivedCaptchas = datasets.parseAndSortCaptchaSolutions(captchas);
-    const captchaIds = receivedCaptchas.map((captcha) => captcha.captchaId);
-    const storedCaptchas = await this.db.getCaptchaById(captchaIds);
-    if (!storedCaptchas || receivedCaptchas.length !== storedCaptchas.length) {
-      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
-        context: {
-          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
-          captchas
-        }
-      });
-    }
-    if (!storedCaptchas.every(
-      (captcha) => captcha.datasetId === util$2.at(storedCaptchas, 0).datasetId
-    )) {
-      throw new common.ProsopoEnvError("CAPTCHA.DIFFERENT_DATASET_IDS", {
-        context: {
-          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
-          captchas
-        }
-      });
-    }
-    return { storedCaptchas, receivedCaptchas, captchaIds };
-  }
-  /**
-   * Validate that a Dapp User is responding to their own pending captcha request
-   * @param {string} requestHash
-   * @param {PendingCaptchaRequest} pendingRecord
-   * @param {string} userAccount
-   * @param {string[]} captchaIds
-   */
-  async validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds) {
-    const currentTime = Date.now();
-    if (!pendingRecord) {
-      this.logger.info("No pending record found");
-      return false;
-    }
-    if (pendingRecord.deadlineTimestamp < currentTime) {
-      this.logger.info("Deadline for responding to captcha has expired");
-      return false;
-    }
-    if (pendingRecord) {
-      const pendingHashComputed = datasets.computePendingRequestHash(
-        captchaIds,
-        userAccount,
-        pendingRecord.salt
-      );
-      return requestHash === pendingHashComputed;
-    }
-    return false;
-  }
-  /*
-   * Get dapp user solution from database
-   */
-  async getDappUserCommitmentById(commitmentId) {
-    const dappUserSolution = await this.db.getDappUserCommitmentById(commitmentId);
-    if (!dappUserSolution) {
-      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-        context: {
-          failedFuncName: this.getDappUserCommitmentById.name,
-          commitmentId
-        }
-      });
-    }
-    return dappUserSolution;
-  }
-  /* Check if dapp user has verified solution in cache */
-  async getDappUserCommitmentByAccount(userAccount, dappAccount) {
-    const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(
-      userAccount,
-      dappAccount
-    );
-    if (dappUserSolutions.length > 0) {
-      for (const dappUserSolution of dappUserSolutions) {
-        if (dappUserSolution.result.status === types.CaptchaStatus.approved) {
-          return dappUserSolution;
-        }
-      }
-    }
-    return void 0;
-  }
-}
-exports.ImgCaptchaManager = ImgCaptchaManager;

package/dist/cjs/tasks/imgCaptcha/imgCaptchaTasksUtils.cjs

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const datasets = require("@prosopo/datasets");
-const buildTreeAndGetCommitmentId = (captchaSolutions) => {
-  const tree = new datasets.CaptchaMerkleTree();
-  const solutionsHashed = captchaSolutions.map(
-    (captcha) => datasets.computeCaptchaSolutionHash(captcha)
-  );
-  tree.build(solutionsHashed);
-  const commitmentId = tree.root?.hash;
-  if (!commitmentId) {
-    throw new common.ProsopoEnvError(
-      "CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST",
-      {
-        context: {
-          failedFuncName: buildTreeAndGetCommitmentId.name,
-          commitmentId
-        }
-      }
-    );
-  }
-  return { tree, commitmentId };
-};
-exports.buildTreeAndGetCommitmentId = buildTreeAndGetCommitmentId;

package/dist/cjs/tasks/index.cjs

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const tasks = require("./tasks.cjs");
-exports.Tasks = tasks.Tasks;

package/dist/cjs/tasks/powCaptcha/powTasks.cjs

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const util$1 = require("@prosopo/util");
-const powTasksUtils = require("./powTasksUtils.cjs");
-const logger = common.getLoggerDefault();
-class PowCaptchaManager {
-  constructor(pair, db) {
-    this.pair = pair;
-    this.db = db;
-    this.POW_SEPARATOR = types.POW_SEPARATOR;
-  }
-  /**
-   * @description Generates a PoW Captcha for a given user and dapp
-   *
-   * @param {string} userAccount - user that is solving the captcha
-   * @param {string} dappAccount - dapp that is requesting the captcha
-   * @param origin - not currently used
-   */
-  async getPowCaptchaChallenge(userAccount, dappAccount, origin) {
-    const difficulty = 4;
-    const requestedAtTimestamp = Date.now();
-    const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}`;
-    const challengeSignature = util.u8aToHex(this.pair.sign(util.stringToHex(challenge)));
-    return {
-      challenge,
-      difficulty,
-      providerSignature: challengeSignature,
-      requestedAtTimestamp
-    };
-  }
-  /**
-   * @description Verifies a PoW Captcha for a given user and dapp
-   *
-   * @param {string} challenge - the starting string for the PoW challenge
-   * @param {string} difficulty - how many leading zeroes the solution must have
-   * @param {string} providerChallengeSignature - proof that the Provider provided the challenge
-   * @param {string} nonce - the string that the user has found that satisfies the PoW challenge
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
-   * @param {string} userTimestampSignature
-   * @param ipAddress
-   * @param headers
-   */
-  async verifyPowCaptchaSolution(challenge, difficulty, providerChallengeSignature, nonce, timeout, userTimestampSignature, ipAddress, headers) {
-    powTasksUtils.checkPowSignature(
-      challenge,
-      providerChallengeSignature,
-      this.pair.address,
-      types.ApiParams.challenge
-    );
-    const challengeSplit = challenge.split(this.POW_SEPARATOR);
-    const timestamp = Number.parseInt(util$1.at(challengeSplit, 0));
-    const userAccount = util$1.at(challengeSplit, 1);
-    powTasksUtils.checkPowSignature(
-      timestamp.toString(),
-      userTimestampSignature,
-      userAccount,
-      types.ApiParams.timestamp
-    );
-    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      logger.debug("No record of this challenge");
-      return false;
-    }
-    if (!util$1.verifyRecency(challenge, timeout)) {
-      await this.db.updatePowCaptchaRecord(
-        challenge,
-        {
-          status: types.CaptchaStatus.disapproved,
-          reason: "CAPTCHA.INVALID_TIMESTAMP"
-        },
-        false,
-        true,
-        userTimestampSignature
-      );
-      return false;
-    }
-    const correct = powTasksUtils.validateSolution(nonce, challenge, difficulty);
-    let result = { status: types.CaptchaStatus.approved };
-    if (!correct) {
-      result = {
-        status: types.CaptchaStatus.disapproved,
-        reason: "CAPTCHA.INVALID_SOLUTION"
-      };
-    }
-    await this.db.updatePowCaptchaRecord(
-      challenge,
-      result,
-      false,
-      true,
-      userTimestampSignature
-    );
-    return correct;
-  }
-  /**
-   * @description Verifies a PoW Captcha for a given user and dapp. This is called by the server to verify the user's solution
-   * and update the record in the database to show that the user has solved the captcha
-   *
-   * @param {string} dappAccount - the dapp that is requesting the captcha
-   * @param {string} challenge - the starting string for the PoW challenge
-   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
-   */
-  async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout) {
-    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
-    if (!challengeRecord) {
-      throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
-        context: {
-          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-          challenge
-        }
-      });
-    }
-    if (challengeRecord.serverChecked) return false;
-    const challengeDappAccount = challengeRecord.dappAccount;
-    if (dappAccount !== challengeDappAccount) {
-      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-        context: {
-          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-          dappAccount,
-          challengeDappAccount
-        }
-      });
-    }
-    util$1.verifyRecency(challenge, timeout);
-    await this.db.markDappUserPoWCommitmentsChecked([
-      challengeRecord.challenge
-    ]);
-    return true;
-  }
-}
-exports.PowCaptchaManager = PowCaptchaManager;