@prosopo/provider 0.2.0 → 0.2.1

package/dist/cjs/api/captcha.cjs

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const tasks = require("../tasks/tasks.cjs");
+const util = require("../util.cjs");
+const datasets = require("@prosopo/datasets");
+const utilCrypto = require("@polkadot/util-crypto");
+const express = require("express");
+function prosopoRouter(env) {
+  const router = express.Router();
+  const tasks$1 = new tasks.Tasks(env);
+  router.get(
+    `${types.ApiPaths.GetCaptchaChallenge}/:${types.ApiParams.datasetId}/:${types.ApiParams.user}/:${types.ApiParams.dapp}/:${types.ApiParams.blockNumber}`,
+    async (req, res, next) => {
+      try {
+        const { blockNumber, datasetId, user, dapp } = types.CaptchaRequestBody.parse(req.params);
+        const api = env.api;
+        if (api === void 0) {
+          throw new Error("api not setup");
+        }
+        utilCrypto.validateAddress(user, false, api.registry.chainSS58);
+        const blockNumberParsed = util.parseBlockNumber(blockNumber);
+        await tasks$1.validateProviderWasRandomlyChosen(user, dapp, datasetId, blockNumberParsed);
+        const taskData = await tasks$1.getRandomCaptchasAndRequestHash(datasetId, user);
+        taskData.captchas = taskData.captchas.map((cwp) => ({
+          ...cwp,
+          captcha: {
+            ...cwp.captcha,
+            items: cwp.captcha.items.map((item) => datasets.parseCaptchaAssets(item, env.assetsResolver))
+          }
+        }));
+        return res.json(taskData);
+      } catch (err) {
+        return next(new common.ProsopoApiError(err, void 0, 400));
+      }
+    }
+  );
+  router.post(types.ApiPaths.SubmitCaptchaSolution, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.CaptchaSolutionBody.parse(req.body);
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+    try {
+      const result = await tasks$1.dappUserSolution(
+        parsed[types.ApiParams.user],
+        parsed[types.ApiParams.dapp],
+        parsed[types.ApiParams.requestHash],
+        parsed[types.ApiParams.captchas],
+        parsed[types.ApiParams.signature]
+      );
+      return res.json({
+        status: req.i18n.t(result.solutionApproved ? "API.CAPTCHA_PASSED" : "API.CAPTCHA_FAILED"),
+        ...result
+      });
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+  });
+  router.post(types.ApiPaths.VerifyCaptchaSolution, async (req, res, next) => {
+    let parsed;
+    try {
+      parsed = types.VerifySolutionBody.parse(req.body);
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+    try {
+      let solution;
+      let statusMessage = "API.USER_NOT_VERIFIED";
+      if (!parsed.commitmentId) {
+        solution = await tasks$1.getDappUserCommitmentByAccount(parsed.user);
+      } else {
+        solution = await tasks$1.getDappUserCommitmentById(parsed.commitmentId);
+      }
+      if (solution) {
+        let approved = false;
+        if (solution.status === types.CaptchaStatus.approved) {
+          statusMessage = "API.USER_VERIFIED";
+          approved = true;
+        }
+        return res.json({
+          status: req.t(statusMessage),
+          solutionApproved: approved,
+          commitmentId: solution.id
+        });
+      }
+      return res.json({
+        status: req.t(statusMessage),
+        solutionApproved: false
+      });
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+  });
+  router.get(types.ApiPaths.GetProviderStatus, async (req, res, next) => {
+    try {
+      const status = await tasks$1.providerStatus();
+      return res.json({ status });
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+  });
+  router.get(types.ApiPaths.GetProviderDetails, async (req, res, next) => {
+    try {
+      const details = await tasks$1.getProviderDetails();
+      return res.json(details);
+    } catch (err) {
+      return next(new common.ProsopoApiError(err, void 0, 400));
+    }
+  });
+  return router;
+}
+exports.prosopoRouter = prosopoRouter;

package/dist/cjs/batch/commitments.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const util = require("@polkadot/util");
+const contract = require("@prosopo/contract");
+const util$1 = require("../util.cjs");
+const utilCrypto = require("@polkadot/util-crypto");
+const BN_TEN_THOUSAND = new util.BN(1e4);
+const CONTRACT_METHOD_NAME = "providerCommitMany";
+class BatchCommitmentsTask {
+  constructor(batchCommitConfig, contractApi, db, startNonce, logger) {
+    this.contract = contractApi;
+    this.db = db;
+    this.batchCommitConfig = batchCommitConfig;
+    this.logger = logger;
+    this.nonce = startNonce;
+  }
+  async run() {
+    const taskId = utilCrypto.randomAsHex(32);
+    const taskRunning = await util$1.checkIfTaskIsRunning(types.ScheduledTaskNames.BatchCommitment, this.db);
+    if (!taskRunning) {
+      const intervalExceeded = await this.batchIntervalExceeded();
+      if (intervalExceeded) {
+        try {
+          await this.db.storeScheduledTaskStatus(
+            taskId,
+            types.ScheduledTaskNames.BatchCommitment,
+            types.ScheduledTaskStatus.Running
+          );
+          const commitments = await this.getCommitments();
+          if (commitments.length > 0) {
+            this.logger.info(`Found ${commitments.length} commitments to commit`);
+            const { extrinsics, ids: commitmentIds } = await this.createExtrinsics(commitments);
+            await contract.batch(this.contract.contract, this.contract.pair, extrinsics, this.logger);
+            await this.flagBatchedCommitments(commitmentIds);
+            await this.db.storeScheduledTaskStatus(
+              taskId,
+              types.ScheduledTaskNames.BatchCommitment,
+              types.ScheduledTaskStatus.Completed,
+              {
+                data: {
+                  commitmentIds: commitments.filter((commitment) => commitmentIds.indexOf(commitment.id) > -1).map((c) => c.id)
+                }
+              }
+            );
+          }
+        } catch (e) {
+          const err = e;
+          this.logger.error(e);
+          await this.db.storeScheduledTaskStatus(
+            taskId,
+            types.ScheduledTaskNames.BatchCommitment,
+            types.ScheduledTaskStatus.Failed,
+            {
+              error: JSON.stringify(e && err.message ? err.message : e)
+            }
+          );
+        }
+      }
+    }
+  }
+  async createExtrinsics(commitments) {
+    const txs = [];
+    const fragment = this.contract.abi.findMessage(CONTRACT_METHOD_NAME);
+    const batchedCommitmentIds = [];
+    let totalRefTime = new util.BN(0);
+    let totalProofSize = new util.BN(0);
+    let totalFee = new util.BN(0);
+    const maxBlockWeight = this.contract.api.consts.system.blockWeights.maxBlock;
+    const commitmentArray = [];
+    let extrinsic;
+    for (const commitment of commitments) {
+      const commit = this.convertCommit(commitment);
+      commitmentArray.push(commit);
+      const encodedArgs = contract.encodeStringArgs(this.contract.abi, fragment, [commitmentArray]);
+      const buildExtrinsicResult = await this.contract.getExtrinsicAndGasEstimates(
+        "providerCommitMany",
+        encodedArgs
+      );
+      extrinsic = buildExtrinsicResult.extrinsic;
+      const { options, storageDeposit } = buildExtrinsicResult;
+      let paymentInfo;
+      try {
+        paymentInfo = (await extrinsic.paymentInfo(this.contract.pair)).partialFee.toBn();
+        this.logger.debug(`${CONTRACT_METHOD_NAME} paymentInfo:`, paymentInfo.toNumber());
+      } catch (e) {
+        paymentInfo = new util.BN(0);
+      }
+      totalRefTime = totalRefTime.add(
+        this.contract.api.registry.createType("WeightV2", options.gasLimit).refTime.toBn()
+      );
+      totalProofSize = totalProofSize.add(
+        this.contract.api.registry.createType("WeightV2", options.gasLimit).proofSize.toBn()
+      );
+      totalFee = totalFee.add(paymentInfo.add(storageDeposit.asCharge.toBn()));
+      const extrinsicTooHigh = this.extrinsicTooHigh(totalRefTime, totalProofSize, maxBlockWeight);
+      this.logger.debug(
+        "Free balance",
+        "`",
+        (await this.contract.api.query.system.account(this.contract.pair.address)).data.free.toBn().div(contract.oneUnit(this.contract.api)).toString(),
+        "`",
+        "UNIT"
+      );
+      this.logger.debug(
+        "Total Fee `",
+        totalFee.div(contract.oneUnit(this.contract.api)).toString(),
+        "`",
+        "UNIT"
+      );
+      const feeTooHigh = totalFee.gt(
+        (await this.contract.api.query.system.account(this.contract.pair.address)).data.free.toBn()
+      );
+      if (extrinsicTooHigh || feeTooHigh) {
+        const msg = extrinsicTooHigh ? "Max batch extrinsic percentage reached" : "Fee too high";
+        this.logger.warn(msg);
+        break;
+      } else {
+        batchedCommitmentIds.push(commitment.id);
+      }
+    }
+    if (!extrinsic) {
+      throw new contract.ProsopoContractError("No extrinsics created");
+    }
+    txs.push(extrinsic);
+    this.logger.info(`${txs.length} transactions will be batched`);
+    this.logger.debug("totalRefTime:", totalRefTime.toString());
+    this.logger.debug("totalProofSize:", totalProofSize.toString());
+    return { extrinsics: txs, ids: batchedCommitmentIds, totalFee, totalRefTime, totalProofSize };
+  }
+  extrinsicTooHigh(totalRefTime, totalProofSize, maxBlockWeight) {
+    return totalRefTime.mul(BN_TEN_THOUSAND).div(maxBlockWeight.refTime.toBn()).toNumber() / 100 > this.batchCommitConfig.maxBatchExtrinsicPercentage;
+  }
+  async batchIntervalExceeded() {
+    const lastTime = await this.db.getLastBatchCommitTime();
+    return Date.now() - lastTime.getSeconds() > this.batchCommitConfig.interval;
+  }
+  async getCommitments() {
+    return await this.db.getUnbatchedDappUserCommitments();
+  }
+  async flagBatchedCommitments(commitmentIds) {
+    await this.db.flagBatchedDappUserCommitments(commitmentIds);
+  }
+  convertCommit(commitment) {
+    const { batched, processed, userSignature, requestedAt, completedAt, ...commit } = commitment;
+    return {
+      ...commit,
+      userSignaturePart1: userSignature.slice(0, userSignature.length / 2),
+      userSignaturePart2: userSignature.slice(userSignature.length / 2),
+      // to satisfy typescript
+      requestedAt: new util.BN(requestedAt).toNumber(),
+      completedAt: new util.BN(completedAt).toNumber()
+    };
+  }
+}
+exports.BatchCommitmentsTask = BatchCommitmentsTask;

package/dist/cjs/batch/index.cjs

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

package/dist/cjs/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./tasks/index.cjs");
+const util = require("./util.cjs");
+require("./batch/index.cjs");
+const captcha = require("./api/captcha.cjs");
+const tasks = require("./tasks/tasks.cjs");
+const calculateSolutions = require("./tasks/calculateSolutions.cjs");
+const commitments = require("./batch/commitments.cjs");
+exports.calculateNewSolutions = util.calculateNewSolutions;
+exports.checkIfTaskIsRunning = util.checkIfTaskIsRunning;
+exports.encodeStringAddress = util.encodeStringAddress;
+exports.parseBlockNumber = util.parseBlockNumber;
+exports.promiseQueue = util.promiseQueue;
+exports.shuffleArray = util.shuffleArray;
+exports.updateSolutions = util.updateSolutions;
+exports.prosopoRouter = captcha.prosopoRouter;
+exports.Tasks = tasks.Tasks;
+exports.CalculateSolutionsTask = calculateSolutions.CalculateSolutionsTask;
+exports.BatchCommitmentsTask = commitments.BatchCommitmentsTask;

package/dist/cjs/tasks/calculateSolutions.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const tasks = require("./tasks.cjs");
+const util = require("../util.cjs");
+const datasets = require("@prosopo/datasets");
+class CalculateSolutionsTask extends tasks.Tasks {
+  constructor(env) {
+    super(env);
+    this.logger = common.getLogger(env.config.logLevel, "CalculateSolutionsTask");
+  }
+  /**
+   * Apply new captcha solutions to captcha dataset and recalculate merkle tree
+   */
+  async run() {
+    try {
+      const taskRunning = await util.checkIfTaskIsRunning(types.ScheduledTaskNames.CalculateSolution, this.db);
+      if (!taskRunning) {
+        const provider = (await this.contract.methods.getProvider(this.contract.pair.address, {})).value.unwrap().unwrap();
+        const unsolvedCaptchas = await this.db.getAllCaptchasByDatasetId(
+          provider.datasetId.toString(),
+          types.CaptchaStates.Unsolved
+        );
+        if (!unsolvedCaptchas) {
+          return 0;
+        }
+        const unsolvedSorted = unsolvedCaptchas.sort(datasets.captchaSort);
+        this.logger.info(`There are ${unsolvedSorted.length} unsolved CAPTCHA challenges`);
+        const requiredNumberOfSolutions = this.captchaSolutionConfig.requiredNumberOfSolutions;
+        const winningPercentage = this.captchaSolutionConfig.solutionWinningPercentage;
+        const winningNumberOfSolutions = Math.round(requiredNumberOfSolutions * (winningPercentage / 100));
+        if (unsolvedSorted && unsolvedSorted.length > 0) {
+          const captchaIds = unsolvedSorted.map((captcha) => captcha.captchaId);
+          const solutions = await this.db.getAllDappUserSolutions(captchaIds) || [];
+          const solutionsToUpdate = util.calculateNewSolutions(solutions, winningNumberOfSolutions);
+          if (solutionsToUpdate.rows().length > 0) {
+            this.logger.info(
+              `There are ${solutionsToUpdate.rows().length} CAPTCHA challenges to update with solutions`
+            );
+            try {
+              const captchaIdsToUpdate = [...solutionsToUpdate["captchaId"].values()];
+              const commitmentIds = solutions.filter((s) => captchaIdsToUpdate.indexOf(s.captchaId) > -1).map((s) => s.commitmentId);
+              const dataset = await this.db.getDataset(provider.datasetId.toString());
+              dataset.captchas = util.updateSolutions(solutionsToUpdate, dataset.captchas, this.logger);
+              await this.providerSetDataset(dataset);
+              await this.db.flagProcessedDappUserSolutions(captchaIdsToUpdate);
+              await this.db.flagProcessedDappUserCommitments(commitmentIds);
+              await this.db.removeCaptchas(captchaIdsToUpdate);
+              return solutionsToUpdate.rows().length;
+            } catch (error) {
+              this.logger.error(error);
+            }
+          }
+          return 0;
+        } else {
+          this.logger.info(`There are no CAPTCHA challenges that require their solutions to be updated`);
+          return 0;
+        }
+      }
+      return 0;
+    } catch (error) {
+      throw new common.ProsopoEnvError(error, "GENERAL.CALCULATE_CAPTCHA_SOLUTION");
+    }
+  }
+}
+exports.CalculateSolutionsTask = CalculateSolutionsTask;

package/dist/cjs/tasks/index.cjs

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

package/dist/cjs/tasks/tasks.cjs

@@ -0,0 +1,396 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const datasets = require("@prosopo/datasets");
+const common = require("@prosopo/common");
+const contract = require("@prosopo/contract");
+const util$2 = require("@prosopo/util");
+const util$1 = require("@polkadot/util");
+const utilCrypto = require("@polkadot/util-crypto");
+const util = require("../util.cjs");
+class Tasks {
+  constructor(env) {
+    if (!env.contractInterface) {
+      throw new common.ProsopoEnvError(
+        "CONTRACT.CONTRACT_UNDEFINED",
+        this.constructor.name,
+        {},
+        { contractAddress: env.contractAddress }
+      );
+    }
+    this.config = env.config;
+    this.contract = env.contractInterface;
+    this.db = env.db;
+    this.captchaConfig = env.config.captchas;
+    this.captchaSolutionConfig = env.config.captchaSolutions;
+    this.logger = common.getLogger(env.config.logLevel, "Tasks");
+  }
+  async providerSetDatasetFromFile(file) {
+    const datasetRaw = datasets.parseCaptchaDataset(file);
+    this.logger.debug("Parsed raw data set");
+    return await this.providerSetDataset(datasetRaw);
+  }
+  async providerSetDataset(datasetRaw) {
+    var _a;
+    if (datasetRaw.captchas.length < this.config.captchas.solved.count + this.config.captchas.unsolved.count) {
+      throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", this.providerSetDataset.name);
+    }
+    const solutions = datasetRaw.captchas.map((captcha) => captcha.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
+    if (solutions < this.config.captchas.solved.count) {
+      throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", this.providerSetDataset.name);
+    }
+    const dataset = await datasets.buildDataset(datasetRaw);
+    if (!dataset.datasetId || !dataset.datasetContentId) {
+      throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", this.providerSetDataset.name);
+    }
+    await ((_a = this.db) == null ? void 0 : _a.storeDataset(dataset));
+    await contract.wrapQuery(this.contract.query.providerSetDataset, this.contract.query)(
+      dataset.datasetId,
+      dataset.datasetContentId
+    );
+    const txResult = await this.contract.methods.providerSetDataset(dataset.datasetId, dataset.datasetContentId, {
+      value: 0
+    });
+    return txResult.result;
+  }
+  // Other tasks
+  /**
+   * @description Get random captchas that are solved or not solved, along with the merkle proof for each
+   * @param {string}   datasetId  the id of the data set
+   * @param {boolean}  solved    `true` when captcha is solved
+   * @param {number}   size       the number of records to be returned
+   */
+  async getCaptchaWithProof(datasetId, solved, size) {
+    const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
+    if (captchaDocs) {
+      const captchas = [];
+      for (const captcha of captchaDocs) {
+        const datasetDetails = await this.db.getDatasetDetails(datasetId);
+        const tree = new datasets.CaptchaMerkleTree();
+        if (datasetDetails.contentTree) {
+          tree.layers = datasetDetails.contentTree;
+          const proof = tree.proof(captcha.captchaContentId);
+          delete captcha.solution;
+          captcha.items = util.shuffleArray(captcha.items);
+          captchas.push({ captcha, proof });
+        }
+      }
+      return captchas;
+    }
+    throw new common.ProsopoEnvError(
+      "DATABASE.CAPTCHA_GET_FAILED",
+      this.getCaptchaWithProof.name,
+      {},
+      { datasetId, solved, size }
+    );
+  }
+  /**
+   * 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} signature
+   * @return {Promise<DappUserSolutionResult>} result containing the contract event
+   */
+  async dappUserSolution(userAccount, dappAccount, requestHash, captchas, signature) {
+    if (!await this.dappIsActive(dappAccount)) {
+      throw new common.ProsopoEnvError("CONTRACT.DAPP_NOT_ACTIVE", this.getPaymentInfo.name, {}, { dappAccount });
+    }
+    const verification = utilCrypto.signatureVerify(util$1.stringToHex(requestHash), signature, userAccount);
+    if (!verification.isValid) {
+      throw new common.ProsopoEnvError("GENERAL.INVALID_SIGNATURE", this.dappUserSolution.name, {}, { userAccount });
+    }
+    let response = {
+      captchas: [],
+      solutionApproved: false
+    };
+    const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
+    const { tree, commitmentId } = await this.buildTreeAndGetCommitmentId(receivedCaptchas);
+    const provider = (await this.contract.methods.getProvider(this.contract.pair.address, {})).value.unwrap().unwrap();
+    const pendingRecord = await this.db.getDappUserPending(requestHash);
+    const pendingRequest = await this.validateDappUserSolutionRequestIsPending(
+      requestHash,
+      pendingRecord,
+      userAccount,
+      captchaIds
+    );
+    const userSignature = util$1.hexToU8a(signature);
+    const blockNumber = (await contract.getBlockNumber(this.contract.api)).toNumber();
+    if (pendingRequest) {
+      const commit = {
+        id: commitmentId,
+        userAccount,
+        dappContract: dappAccount,
+        providerAccount: this.contract.pair.address,
+        datasetId: provider.datasetId.toString(),
+        status: types.CaptchaStatus.pending,
+        userSignature: Array.from(userSignature),
+        requestedAt: pendingRecord.requestedAtBlock,
+        // TODO is this correct or should it be block number?
+        completedAt: blockNumber,
+        processed: false,
+        batched: false
+      };
+      await this.db.storeDappUserSolution(receivedCaptchas, commit);
+      if (datasets.compareCaptchaSolutions(receivedCaptchas, storedCaptchas)) {
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: tree.proof(id)
+          })),
+          solutionApproved: true
+        };
+        await this.db.approveDappUserCommitment(commitmentId);
+      } else {
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: [[]]
+          })),
+          solutionApproved: false
+        };
+      }
+    }
+    return response;
+  }
+  /**
+   * Validate that the dapp is active in the contract
+   */
+  async dappIsActive(dappAccount) {
+    const dapp = await contract.wrapQuery(this.contract.query.getDapp, this.contract.query)(dappAccount);
+    return dapp.status.toString() === "Active";
+  }
+  /**
+   * Gets provider status in contract
+   */
+  async providerStatus() {
+    try {
+      const provider = await contract.wrapQuery(
+        this.contract.query.getProvider,
+        this.contract.query
+      )(this.contract.pair.address);
+      return { status: provider.status ? "Registered" : "Unregistered" };
+    } catch (e) {
+      return { status: "Unregistered" };
+    }
+  }
+  /**
+   * 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",
+        this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+        {},
+        captchas
+      );
+    }
+    if (!storedCaptchas.every((captcha) => captcha.datasetId === util$2.at(storedCaptchas, 0).datasetId)) {
+      throw new common.ProsopoEnvError(
+        "CAPTCHA.DIFFERENT_DATASET_IDS",
+        this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+        {},
+        captchas
+      );
+    }
+    return { storedCaptchas, receivedCaptchas, captchaIds };
+  }
+  /**
+   * Build merkle tree and get commitment from contract, returning the tree, commitment, and commitmentId
+   * @param {CaptchaSolution[]} captchaSolutions
+   * @returns {Promise<{ tree: CaptchaMerkleTree, commitment: CaptchaSolutionCommitment, commitmentId: string }>}
+   */
+  async buildTreeAndGetCommitmentId(captchaSolutions) {
+    var _a;
+    const tree = new datasets.CaptchaMerkleTree();
+    const solutionsHashed = captchaSolutions.map((captcha) => datasets.computeCaptchaSolutionHash(captcha));
+    tree.build(solutionsHashed);
+    const commitmentId = (_a = tree.root) == null ? void 0 : _a.hash;
+    if (!commitmentId) {
+      throw new common.ProsopoEnvError(
+        "CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST",
+        this.buildTreeAndGetCommitmentId.name,
+        {},
+        { commitmentId }
+      );
+    }
+    return { tree, commitmentId };
+  }
+  /**
+   * 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.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 two random captchas from specified dataset, create the response and store a hash of it, marked as pending
+   * @param {string} datasetId
+   * @param {string} userAccount
+   */
+  async getRandomCaptchasAndRequestHash(datasetId, userAccount) {
+    const dataset = await this.db.getDatasetDetails(datasetId);
+    if (!dataset) {
+      throw new common.ProsopoEnvError("DATABASE.DATASET_GET_FAILED");
+    }
+    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.captcha.captchaId),
+      userAccount,
+      salt
+    );
+    const currentTime = Date.now();
+    const timeLimit = captchas.map((captcha) => captcha.captcha.timeLimitMs || 3e4).reduce((a, b) => a + b, 0);
+    const deadlineTs = timeLimit + currentTime;
+    const currentBlockNumber = await contract.getBlockNumber(this.contract.api);
+    await this.db.storeDappUserPending(userAccount, requestHash, salt, deadlineTs, currentBlockNumber.toNumber());
+    return { captchas, requestHash };
+  }
+  /**
+   * Block by block search for blockNo
+   */
+  async isRecentBlock(contract2, header, blockNo, depth = this.captchaSolutionConfig.captchaBlockRecency) {
+    if (depth == 0) {
+      return false;
+    }
+    const headerBlockNo = header.number.toPrimitive();
+    if (headerBlockNo === blockNo) {
+      return true;
+    }
+    const parent = await contract2.api.rpc.chain.getBlock(header.parentHash);
+    return this.isRecentBlock(contract2, parent.block.header, blockNo, depth - 1);
+  }
+  /**
+   * Validate that provided `datasetId` was a result of calling `get_random_provider` method
+   * @param {string} userAccount - Same user that called `get_random_provider`
+   * @param {string} dappContractAccount - account of dapp that is requesting captcha
+   * @param {string} datasetId - `captcha_dataset_id` from the result of `get_random_provider`
+   * @param {string} blockNumber - Block on which `get_random_provider` was called
+   */
+  async validateProviderWasRandomlyChosen(userAccount, dappContractAccount, datasetId, blockNumber) {
+    const contract2 = await this.contract.contract;
+    if (!contract2) {
+      throw new common.ProsopoEnvError("CONTRACT.CONTRACT_UNDEFINED", this.validateProviderWasRandomlyChosen.name);
+    }
+    const header = await contract2.api.rpc.chain.getHeader();
+    const isBlockNoValid = await this.isRecentBlock(contract2, header, blockNumber);
+    if (!isBlockNoValid) {
+      throw new common.ProsopoEnvError(
+        "CAPTCHA.INVALID_BLOCK_NO",
+        this.validateProviderWasRandomlyChosen.name,
+        {},
+        {
+          userAccount,
+          dappContractAccount,
+          datasetId,
+          header,
+          blockNumber
+        }
+      );
+    }
+    const block = await contract2.api.rpc.chain.getBlockHash(blockNumber);
+    const randomProviderAndBlockNo = await this.contract.queryAtBlock(
+      block,
+      "getRandomActiveProvider",
+      [userAccount, dappContractAccount]
+    );
+    if (datasetId.toString().localeCompare(randomProviderAndBlockNo.provider.datasetId.toString())) {
+      throw new common.ProsopoEnvError(
+        "DATASET.INVALID_DATASET_ID",
+        this.validateProviderWasRandomlyChosen.name,
+        {},
+        randomProviderAndBlockNo
+      );
+    }
+  }
+  /**
+   * Get payment info for a transaction
+   * @param {string} userAccount
+   * @param {string} blockHash
+   * @param {string} txHash
+   * @returns {Promise<RuntimeDispatchInfo|null>}
+   */
+  async getPaymentInfo(userAccount, blockHash, txHash) {
+    const signedBlock = await this.contract.api.rpc.chain.getBlock(blockHash);
+    if (!signedBlock) {
+      return null;
+    }
+    const extrinsic = signedBlock.block.extrinsics.find((extrinsic2) => extrinsic2.hash.toString() === txHash);
+    if (!extrinsic || extrinsic.signer.toString() !== userAccount) {
+      return null;
+    }
+    const paymentInfo = await this.contract.api.rpc.payment.queryInfo(
+      extrinsic.toHex(),
+      blockHash
+    );
+    if (!paymentInfo) {
+      return null;
+    }
+    return paymentInfo;
+  }
+  /*
+   * 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",
+        this.getDappUserCommitmentById.name,
+        {},
+        { commitmentId }
+      );
+    }
+    return dappUserSolution;
+  }
+  /* Check if dapp user has verified solution in cache */
+  async getDappUserCommitmentByAccount(userAccount) {
+    const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(userAccount);
+    if (dappUserSolutions.length > 0) {
+      for (const dappUserSolution of dappUserSolutions) {
+        if (dappUserSolution.status === types.ArgumentTypes.CaptchaStatus.approved) {
+          return dappUserSolution;
+        }
+      }
+    }
+    return void 0;
+  }
+  /* Returns public details of provider */
+  async getProviderDetails() {
+    return await contract.wrapQuery(this.contract.query.getProvider, this.contract.query)(this.contract.pair.address);
+  }
+  /** Get the dataset from the databse */
+  async getProviderDataset(datasetId) {
+    return await this.db.getDataset(datasetId);
+  }
+}
+exports.Tasks = Tasks;

package/dist/cjs/util.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const util$1 = require("@prosopo/util");
+const keyring = require("@polkadot/keyring");
+const util = require("@polkadot/util");
+const pl = require("nodejs-polars");
+function encodeStringAddress(address) {
+  try {
+    return keyring.encodeAddress(util.isHex(address) ? util.hexToU8a(address) : keyring.decodeAddress(address));
+  } catch (error) {
+    throw new common.ProsopoEnvError(error, "CONTRACT.INVALID_ADDRESS", {}, address);
+  }
+}
+function shuffleArray(array) {
+  for (let arrayIndex = array.length - 1; arrayIndex > 0; arrayIndex--) {
+    const randIndex = Math.floor(Math.random() * (arrayIndex + 1));
+    const tmp = util$1.at(array, randIndex, { required: false });
+    array[randIndex] = util$1.at(array, arrayIndex, { required: false });
+    array[arrayIndex] = tmp;
+  }
+  return array;
+}
+async function promiseQueue(array) {
+  const ret = [];
+  await [...array, () => Promise.resolve(void 0)].reduce((promise, curr, i) => {
+    return promise.then((res) => {
+      if (res) {
+        ret.push({ data: res });
+      }
+      return curr();
+    }).catch((err) => {
+      ret.push({ data: err });
+      return curr();
+    });
+  }, Promise.resolve(void 0));
+  return ret;
+}
+function parseBlockNumber(blockNumberString) {
+  return parseInt(blockNumberString.replace(/,/g, ""));
+}
+function calculateNewSolutions(solutions, winningNumberOfSolutions) {
+  if (solutions.length === 0) {
+    return pl.DataFrame([]);
+  }
+  const solutionsNoEmptyArrays = solutions.map(({ solution, ...otherAttrs }) => {
+    return { solutionKey: common.arrayJoin(solution, ","), ...otherAttrs };
+  });
+  let df = pl.readRecords(solutionsNoEmptyArrays);
+  df = df.drop("salt");
+  const group = df.groupBy(["captchaId", "solutionKey"]).agg(pl.count("captchaContentId").alias("count"));
+  const filtered = group.filter(pl.col("count").gt(winningNumberOfSolutions));
+  const key = filtered["solutionKey"];
+  return filtered.withColumn(key.str.split(",").rename("solution"));
+}
+function updateSolutions(solutions, captchas, logger) {
+  return captchas.map((captcha) => {
+    if (!captcha.solution) {
+      try {
+        const captchaSolutions = [
+          // TODO is below correct? 'solution' is not in the type
+          ...solutions.filter(pl.col("captchaId").eq(pl.lit(captcha.captchaId)))["solution"].values()
+        ];
+        if (captchaSolutions.length > 0) {
+          captcha.solution = captchaSolutions[0];
+          captcha.solved = true;
+        }
+      } catch {
+        logger.debug("No solution found for captchaId", captcha.captchaId);
+      }
+    }
+    return captcha;
+  });
+}
+async function checkIfTaskIsRunning(taskName, db) {
+  const runningTask = await db.getLastScheduledTaskStatus(taskName, types.ScheduledTaskStatus.Running);
+  if (runningTask) {
+    const completedTask = await db.getScheduledTaskStatus(runningTask.taskId, types.ScheduledTaskStatus.Completed);
+    return !completedTask;
+  }
+  return false;
+}
+exports.calculateNewSolutions = calculateNewSolutions;
+exports.checkIfTaskIsRunning = checkIfTaskIsRunning;
+exports.encodeStringAddress = encodeStringAddress;
+exports.parseBlockNumber = parseBlockNumber;
+exports.promiseQueue = promiseQueue;
+exports.shuffleArray = shuffleArray;
+exports.updateSolutions = updateSolutions;

package/package.json

@@ -1,13 +1,20 @@
 {
     "name": "@prosopo/provider",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "author": "PROSOPO LIMITED <info@prosopo.io>",
     "license": "Apache-2.0",
     "main": "./dist/index.js",
     "type": "module",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/cjs/index.cjs"
+        }
+    },
     "scripts": {
         "clean": "tsc --build --clean",
-        "build": "tsc --build --verbose",
+        "build": "tsc --build --verbose tsconfig.json",
+        "build:cjs": "npx vite --config vite.cjs.config.ts build",
         "build:debug": "tsc --build --verbose",
         "build:test": "tsc --build --verbose tsconfig.test.json",
         "build:config": "tsc --project",
@@ -23,14 +30,14 @@
         "@polkadot/types": "10.9.1",
         "@polkadot/util": "12.3.2",
         "@polkadot/util-crypto": "12.3.2",
-        "@prosopo/common": "0.2.0",
-        "@prosopo/contract": "0.2.0",
-        "@prosopo/database": "0.2.0",
-        "@prosopo/datasets": "0.2.0",
-        "@prosopo/env": "0.2.0",
-        "@prosopo/types": "0.2.0",
-        "@prosopo/types-database": "0.2.0",
-        "@prosopo/types-env": "0.2.0",
+        "@prosopo/common": "0.2.1",
+        "@prosopo/contract": "0.2.1",
+        "@prosopo/database": "0.2.1",
+        "@prosopo/datasets": "0.2.1",
+        "@prosopo/env": "0.2.1",
+        "@prosopo/types": "0.2.1",
+        "@prosopo/types-database": "0.2.1",
+        "@prosopo/types-env": "0.2.1",
         "cron": "^2.1.0",
         "cron-parser": "^4.5.0",
         "express": "^4.18.1",

package/vite.cjs.config.ts

@@ -0,0 +1,6 @@
+import { ViteCommonJSConfig } from '@prosopo/config'
+import path from 'path'
+
+export default function () {
+    return ViteCommonJSConfig('provider', path.resolve('./tsconfig.cjs.json'))
+}