@prosopo/provider 0.2.32 → 0.2.36

package/dist/cjs/api/admin.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const types = require("@prosopo/types");
+require("../index.cjs");
+const typesReturns = require("@prosopo/captcha-contract/types-returns");
+const common = require("@prosopo/common");
+const express = require("express");
+const authMiddleware = require("./authMiddleware.cjs");
+const contract = require("@prosopo/contract");
+const tasks = require("../tasks/tasks.cjs");
+const commitments = require("../batch/commitments.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const z__namespace = /* @__PURE__ */ _interopNamespaceDefault(z);
+const apiBatchCommitConfig = {
+  interval: 0,
+  maxBatchExtrinsicPercentage: 59
+};
+function prosopoAdminRouter(env) {
+  const router = express.Router();
+  const tasks$1 = new tasks.Tasks(env);
+  router.use(authMiddleware.authMiddleware(tasks$1, env));
+  router.post(types.AdminApiPaths.BatchCommit, async (req, res, next) => {
+    if (env.db) {
+      try {
+        const batchCommitter = new commitments.BatchCommitmentsTask(
+          apiBatchCommitConfig,
+          env.getContractInterface(),
+          env.db,
+          0n,
+          env.logger
+        );
+        const result = await batchCommitter.run();
+        console.info(`Batch commit complete: ${result}`);
+        res.status(200).send(result);
+      } catch (err) {
+        console.error(err);
+        res.status(500).send(err);
+      }
+    } else {
+      console.error("No database configured");
+      res.status(500).send("No database configured");
+    }
+  });
+  router.post(types.AdminApiPaths.UpdateDataset, async (req, res, next) => {
+    try {
+      const result = await tasks$1.providerSetDataset(req.body);
+      console.info(`Dataset update complete: ${result}`);
+      res.status(200).send(result);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send(err);
+    }
+  });
+  router.post(types.AdminApiPaths.ProviderDeregister, async (req, res, next) => {
+    var _a;
+    try {
+      const address = (_a = env.pair) == null ? void 0 : _a.address;
+      if (!address) {
+        throw new common.ProsopoEnvError("DEVELOPER.MISSING_ENV_VARIABLE", { context: { error: "No address" } });
+      }
+      await tasks$1.contract.tx.providerDeregister();
+    } catch (err) {
+      console.error(err);
+      res.status(500).send(err);
+    }
+  });
+  router.post(types.AdminApiPaths.ProviderUpdate, async (req, res, next) => {
+    try {
+      const { url, fee, payee, value, address } = z__namespace.object({
+        url: z__namespace.string(),
+        fee: z__namespace.number().optional(),
+        payee: z__namespace.nativeEnum(typesReturns.Payee).optional(),
+        value: z__namespace.number().optional(),
+        address: z__namespace.string()
+      }).parse(req.body);
+      const provider = (await tasks$1.contract.query.getProvider(address, {})).value.unwrap().unwrap();
+      if (provider && (url || fee || payee || value)) {
+        const urlConverted = url ? Array.from(new common.UrlConverter().encode(url.toString())) : provider.url;
+        await contract.wrapQuery(tasks$1.contract.query.providerUpdate, tasks$1.contract.query)(
+          urlConverted,
+          fee || provider.fee,
+          payee || provider.payee,
+          { value: value || 0 }
+        );
+        const result = await tasks$1.contract.tx.providerUpdate(
+          urlConverted,
+          fee || provider.fee,
+          payee || provider.payee,
+          { value: value || 0 }
+        );
+        console.info(JSON.stringify(result, null, 2));
+      }
+    } catch (err) {
+      console.error(err);
+      res.status(500).send(err);
+    }
+  });
+  return router;
+}
+exports.prosopoAdminRouter = prosopoAdminRouter;

package/dist/cjs/api/authMiddleware.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const util = require("@polkadot/util");
+const authMiddleware = (tasks, env) => {
+  return async (req, res, next) => {
+    try {
+      const { signature, blocknumber } = extractHeaders(req);
+      if (!env.pair) {
+        throw new common.ProsopoEnvError("CONTRACT.CANNOT_FIND_KEYPAIR");
+      }
+      verifyEnvironmentKeyPair(env);
+      await verifyBlockNumber(blocknumber, tasks);
+      verifySignature(signature, blocknumber, env.pair);
+      next();
+    } catch (err) {
+      console.error("Auth Middleware Error:", err);
+      res.status(401).json({ error: "Unauthorized", message: err });
+    }
+  };
+};
+const extractHeaders = (req) => {
+  const signature = req.headers.signature;
+  const blocknumber = req.headers.blocknumber;
+  if (!signature || !blocknumber) {
+    throw new common.ProsopoApiError("CONTRACT.INVALID_DATA_FORMAT", {
+      context: { error: "Missing signature or block number" }
+    });
+  }
+  if (Array.isArray(signature) || Array.isArray(blocknumber) || !util.isHex(signature)) {
+    throw new common.ProsopoApiError("CONTRACT.INVALID_DATA_FORMAT", { context: { error: "Invalid header format" } });
+  }
+  return { signature, blocknumber };
+};
+const verifyEnvironmentKeyPair = (env) => {
+  if (!env.pair) {
+    throw new common.ProsopoEnvError("CONTRACT.CANNOT_FIND_KEYPAIR");
+  }
+};
+const verifyBlockNumber = async (blockNumber, tasks) => {
+  const parsedBlockNumber = parseInt(blockNumber);
+  const currentBlockNumber = await tasks.getCurrentBlockNumber();
+  if (isNaN(parsedBlockNumber) || parsedBlockNumber < currentBlockNumber - 500 || parsedBlockNumber > currentBlockNumber) {
+    throw new common.ProsopoApiError("API.BAD_REQUEST", {
+      context: {
+        error: `Invalid block number ${parsedBlockNumber}, current block number is ${currentBlockNumber}`
+      }
+    });
+  }
+};
+const verifySignature = (signature, blockNumber, pair) => {
+  const u8Sig = util.hexToU8a(signature);
+  if (!pair.verify(blockNumber, u8Sig, pair.publicKey)) {
+    throw new common.ProsopoApiError("GENERAL.INVALID_SIGNATURE", { context: { error: "Signature verification failed" } });
+  }
+};
+exports.authMiddleware = authMiddleware;

package/dist/cjs/api/captcha.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("@prosopo/types");
-const captcha = require("../contracts/captcha/dist/types-returns/captcha.cjs");
+const typesReturns = require("@prosopo/captcha-contract/types-returns");
 const common = require("@prosopo/common");
 const tasks = require("../tasks/tasks.cjs");
 const util = require("../util.cjs");
@@ -18,7 +18,9 @@ function prosopoRouter(env) {
         const { blockNumber, datasetId, user, dapp } = types.CaptchaRequestBody.parse(req.params);
         const api = env.api;
         if (api === void 0) {
-          throw new Error("api not setup");
+          throw new common.ProsopoApiError("DEVELOPER.METHOD_NOT_IMPLEMENTED", {
+            context: { error: "api not setup", env }
+          });
         }
         address.validateAddress(user, false, api.registry.chainSS58);
         const blockNumberParsed = util.parseBlockNumber(blockNumber);
@@ -36,7 +38,7 @@ function prosopoRouter(env) {
         };
         return res.json(captchaResponse);
       } catch (err) {
-        return next(new common.ProsopoApiError(err, void 0, 400));
+        return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { error: err, errorCode: 400 } }));
       }
     }
   );
@@ -45,7 +47,7 @@ function prosopoRouter(env) {
     try {
       parsed = types.CaptchaSolutionBody.parse(req.body);
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", { context: { errorCode: 400, error: err } }));
     }
     try {
       const result = await tasks$1.dappUserSolution(
@@ -60,7 +62,7 @@ function prosopoRouter(env) {
         ...result
       });
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("API.UNKNOWN", { context: { errorCode: 400, error: err } }));
     }
   });
   router.post(types.ApiPaths.VerifyCaptchaSolution, async (req, res, next) => {
@@ -68,34 +70,38 @@ function prosopoRouter(env) {
     try {
       parsed = types.VerifySolutionBody.parse(req.body);
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("CAPTCHA.PARSE_ERROR", { context: { errorCode: 400, error: err } }));
     }
     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);
+      const solution = await (parsed.commitmentId ? tasks$1.getDappUserCommitmentById(parsed.commitmentId) : tasks$1.getDappUserCommitmentByAccount(parsed.user));
+      if (!solution) {
+        return res.json({ status: req.t("API.USER_NOT_VERIFIED"), solutionApproved: false });
       }
-      if (solution) {
-        let approved = false;
-        if (solution.status === captcha.CaptchaStatus.approved) {
-          statusMessage = "API.USER_VERIFIED";
-          approved = true;
+      if (parsed.maxVerifiedTime) {
+        const currentBlockNumber = await tasks$1.getCurrentBlockNumber();
+        const blockTimeMs = await tasks$1.getBlockTimeMs();
+        const timeSinceCompletion = (currentBlockNumber - solution.completedAt) * blockTimeMs;
+        if (timeSinceCompletion > parsed.maxVerifiedTime) {
+          return res.json({ status: req.t("API.USER_NOT_VERIFIED"), solutionApproved: false });
         }
-        return res.json({
-          status: req.t(statusMessage),
-          solutionApproved: approved,
-          commitmentId: solution.id
-        });
       }
+      const isApproved = solution.status === typesReturns.CaptchaStatus.approved;
       return res.json({
-        status: req.t(statusMessage),
-        solutionApproved: false
+        status: req.t(isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"),
+        solutionApproved: isApproved,
+        commitmentId: solution.id
       });
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { errorCode: 400, error: err } }));
+    }
+  });
+  router.post(types.ApiPaths.SubmitUserEvents, async (req, res, next) => {
+    try {
+      const { events, accountId } = req.body;
+      await tasks$1.saveCaptchaEvent(events, accountId);
+      return res.json({ status: "success" });
+    } catch (err) {
+      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { errorCode: 400, error: err } }));
     }
   });
   router.get(types.ApiPaths.GetProviderStatus, async (req, res, next) => {
@@ -103,7 +109,7 @@ function prosopoRouter(env) {
       const status = await tasks$1.providerStatus();
       return res.json({ status });
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { errorCode: 400, error: err } }));
     }
   });
   router.get(types.ApiPaths.GetProviderDetails, async (req, res, next) => {
@@ -111,7 +117,7 @@ function prosopoRouter(env) {
       const details = await tasks$1.getProviderDetails();
       return res.json(details);
     } catch (err) {
-      return next(new common.ProsopoApiError(err, void 0, 400));
+      return next(new common.ProsopoApiError("API.BAD_REQUEST", { context: { errorCode: 400, error: err } }));
     }
   });
   return router;

package/dist/cjs/batch/commitments.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const bn = require("@polkadot/util/bn");
 const types = require("@prosopo/types");
+const common = require("@prosopo/common");
 const contract = require("@prosopo/contract");
 const util = require("../util.cjs");
 const random = require("@polkadot/util-crypto/random");
@@ -44,6 +45,7 @@ class BatchCommitmentsTask {
               }
             );
           }
+          return commitments;
         } catch (e) {
           const err = e;
           this.logger.error(e);
@@ -55,6 +57,7 @@ class BatchCommitmentsTask {
               error: JSON.stringify(e && err.message ? err.message : e)
             }
           );
+          return err.message;
         }
       }
     }
@@ -119,7 +122,7 @@ class BatchCommitmentsTask {
       }
     }
     if (!extrinsic) {
-      throw new contract.ProsopoContractError("No extrinsics created");
+      throw new common.ProsopoContractError("CONTRACT.TX_ERROR", { context: { error: "No extrinsics created" } });
     }
     txs.push(extrinsic);
     this.logger.info(`${txs.length} transactions will be batched`);

package/dist/cjs/index.cjs

@@ -4,6 +4,7 @@ require("./tasks/index.cjs");
 const util = require("./util.cjs");
 require("./batch/index.cjs");
 const captcha = require("./api/captcha.cjs");
+const admin = require("./api/admin.cjs");
 const tasks = require("./tasks/tasks.cjs");
 const calculateSolutions = require("./tasks/calculateSolutions.cjs");
 const commitments = require("./batch/commitments.cjs");
@@ -15,6 +16,7 @@ exports.promiseQueue = util.promiseQueue;
 exports.shuffleArray = util.shuffleArray;
 exports.updateSolutions = util.updateSolutions;
 exports.prosopoRouter = captcha.prosopoRouter;
+exports.prosopoAdminRouter = admin.prosopoAdminRouter;
 exports.Tasks = tasks.Tasks;
 exports.CalculateSolutionsTask = calculateSolutions.CalculateSolutionsTask;
 exports.BatchCommitmentsTask = commitments.BatchCommitmentsTask;

package/dist/cjs/tasks/calculateSolutions.cjs

@@ -60,7 +60,7 @@ class CalculateSolutionsTask extends tasks.Tasks {
       }
       return 0;
     } catch (error) {
-      throw new common.ProsopoEnvError(error, "GENERAL.CALCULATE_CAPTCHA_SOLUTION");
+      throw new common.ProsopoEnvError("GENERAL.CALCULATE_CAPTCHA_SOLUTION", { context: { error } });
     }
   }
 }

package/dist/cjs/tasks/tasks.cjs

@@ -1,24 +1,22 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const datasets = require("@prosopo/datasets");
-const captcha = require("../contracts/captcha/dist/types-returns/captcha.cjs");
+const typesReturns = require("@prosopo/captcha-contract/types-returns");
 const common = require("@prosopo/common");
 const contract = require("@prosopo/contract");
 const util$1 = require("@prosopo/util");
 const hex = require("@polkadot/util/hex");
 const random = require("@polkadot/util-crypto/random");
+const database = require("@prosopo/database");
 const util = require("../util.cjs");
 const signature = require("@polkadot/util-crypto/signature");
 const string = require("@polkadot/util/string");
 class Tasks {
   constructor(env) {
     if (!env.contractInterface) {
-      throw new common.ProsopoEnvError(
-        "CONTRACT.CONTRACT_UNDEFINED",
-        this.constructor.name,
-        {},
-        { contractAddress: env.contractAddress }
-      );
+      throw new common.ProsopoEnvError("CONTRACT.CONTRACT_UNDEFINED", {
+        context: { failedFuncName: this.constructor.name, contractAddress: env.contractAddress }
+      });
     }
     this.config = env.config;
     this.contract = env.contractInterface;
@@ -35,18 +33,26 @@ class Tasks {
   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);
+      throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
+        context: { failedFuncName: this.providerSetDataset.name }
+      });
     }
-    const solutions = datasetRaw.captchas.map((captcha2) => captcha2.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
+    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);
+      throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+        context: { failedFuncName: this.providerSetDataset.name }
+      });
     }
     if (solutions < this.config.captchas.unsolved.count) {
-      throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", this.providerSetDataset.name);
+      throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+        context: { failedFuncName: 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);
+      throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
+        context: { failedFuncName: this.providerSetDataset.name }
+      });
     }
     await ((_a = this.db) == null ? void 0 : _a.storeDataset(dataset));
     await contract.wrapQuery(this.contract.query.providerSetDataset, this.contract.query)(
@@ -69,25 +75,22 @@ class Tasks {
     const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
     if (captchaDocs) {
       const captchas = [];
-      for (const captcha2 of captchaDocs) {
+      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(captcha2.captchaContentId);
-          delete captcha2.solution;
-          captcha2.items = util.shuffleArray(captcha2.items);
-          captchas.push({ captcha: captcha2, proof });
+          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 }
-    );
+    throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
+      context: { failedFuncName: this.getCaptchaWithProof.name, datasetId, solved, size }
+    });
   }
   /**
    * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
@@ -100,11 +103,15 @@ class Tasks {
    */
   async dappUserSolution(userAccount, dappAccount, requestHash, captchas, signature$1) {
     if (!await this.dappIsActive(dappAccount)) {
-      throw new common.ProsopoEnvError("CONTRACT.DAPP_NOT_ACTIVE", this.getPaymentInfo.name, {}, { dappAccount });
+      throw new common.ProsopoEnvError("CONTRACT.DAPP_NOT_ACTIVE", {
+        context: { failedFuncName: this.getPaymentInfo.name, dappAccount }
+      });
     }
     const verification = signature.signatureVerify(string.stringToHex(requestHash), signature$1, userAccount);
     if (!verification.isValid) {
-      throw new common.ProsopoEnvError("GENERAL.INVALID_SIGNATURE", this.dappUserSolution.name, {}, { userAccount });
+      throw new common.ProsopoEnvError("GENERAL.INVALID_SIGNATURE", {
+        context: { failedFuncName: this.dappUserSolution.name, userAccount }
+      });
     }
     let response = {
       captchas: [],
@@ -129,7 +136,7 @@ class Tasks {
         dappContract: dappAccount,
         providerAccount: this.contract.pair.address,
         datasetId: provider.datasetId.toString(),
-        status: captcha.CaptchaStatus.pending,
+        status: typesReturns.CaptchaStatus.pending,
         userSignature: Array.from(userSignature),
         requestedAt: pendingRecord.requestedAtBlock,
         // TODO is this correct or should it be block number?
@@ -186,23 +193,23 @@ class Tasks {
    */
   async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
     const receivedCaptchas = datasets.parseAndSortCaptchaSolutions(captchas);
-    const captchaIds = receivedCaptchas.map((captcha2) => captcha2.captchaId);
+    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
-      );
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
+        }
+      });
     }
-    if (!storedCaptchas.every((captcha2) => captcha2.datasetId === util$1.at(storedCaptchas, 0).datasetId)) {
-      throw new common.ProsopoEnvError(
-        "CAPTCHA.DIFFERENT_DATASET_IDS",
-        this.validateReceivedCaptchasAgainstStoredCaptchas.name,
-        {},
-        captchas
-      );
+    if (!storedCaptchas.every((captcha) => captcha.datasetId === util$1.at(storedCaptchas, 0).datasetId)) {
+      throw new common.ProsopoEnvError("CAPTCHA.DIFFERENT_DATASET_IDS", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
+        }
+      });
     }
     return { storedCaptchas, receivedCaptchas, captchaIds };
   }
@@ -214,16 +221,16 @@ class Tasks {
   async buildTreeAndGetCommitmentId(captchaSolutions) {
     var _a;
     const tree = new datasets.CaptchaMerkleTree();
-    const solutionsHashed = captchaSolutions.map((captcha2) => datasets.computeCaptchaSolutionHash(captcha2));
+    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 }
-      );
+      throw new common.ProsopoEnvError("CONTRACT.CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST", {
+        context: {
+          failedFuncName: this.buildTreeAndGetCommitmentId.name,
+          commitmentId
+        }
+      });
     }
     return { tree, commitmentId };
   }
@@ -274,7 +281,7 @@ class Tasks {
       salt
     );
     const currentTime = Date.now();
-    const timeLimit = captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 3e4).reduce((a, b) => a + b, 0);
+    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());
@@ -304,23 +311,23 @@ class Tasks {
   async validateProviderWasRandomlyChosen(userAccount, dappContractAccount, datasetId, blockNumber) {
     const contract2 = await this.contract.contract;
     if (!contract2) {
-      throw new common.ProsopoEnvError("CONTRACT.CONTRACT_UNDEFINED", this.validateProviderWasRandomlyChosen.name);
+      throw new common.ProsopoEnvError("CONTRACT.CONTRACT_UNDEFINED", {
+        context: { failedFuncName: 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,
-        {},
-        {
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_BLOCK_NO", {
+        context: {
+          failedFuncName: this.validateProviderWasRandomlyChosen.name,
           userAccount,
           dappContractAccount,
           datasetId,
           header,
           blockNumber
         }
-      );
+      });
     }
     const block = await contract2.api.rpc.chain.getBlockHash(blockNumber);
     const randomProviderAndBlockNo = await this.contract.queryAtBlock(
@@ -329,12 +336,12 @@ class Tasks {
       [userAccount, dappContractAccount]
     );
     if (datasetId.toString().localeCompare(randomProviderAndBlockNo.provider.datasetId.toString())) {
-      throw new common.ProsopoEnvError(
-        "DATASET.INVALID_DATASET_ID",
-        this.validateProviderWasRandomlyChosen.name,
-        {},
-        randomProviderAndBlockNo
-      );
+      throw new common.ProsopoEnvError("DATASET.INVALID_DATASET_ID", {
+        context: {
+          failedFuncName: this.validateProviderWasRandomlyChosen.name,
+          randomProviderAndBlockNo
+        }
+      });
     }
   }
   /**
@@ -368,12 +375,12 @@ class Tasks {
   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 }
-      );
+      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+        context: {
+          failedFuncName: this.getDappUserCommitmentById.name,
+          commitmentId
+        }
+      });
     }
     return dappUserSolution;
   }
@@ -382,7 +389,7 @@ class Tasks {
     const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(userAccount);
     if (dappUserSolutions.length > 0) {
       for (const dappUserSolution of dappUserSolutions) {
-        if (dappUserSolution.status === captcha.CaptchaStatus.approved) {
+        if (dappUserSolution.status === typesReturns.CaptchaStatus.approved) {
           return dappUserSolution;
         }
       }
@@ -391,11 +398,35 @@ class Tasks {
   }
   /* Returns public details of provider */
   async getProviderDetails() {
-    return await contract.wrapQuery(this.contract.query.getProvider, this.contract.query)(this.contract.pair.address);
+    const provider = await contract.wrapQuery(
+      this.contract.query.getProvider,
+      this.contract.query
+    )(this.contract.pair.address);
+    const dbConnectionOk = await this.getCaptchaWithProof(provider.datasetId, true, 1).then(() => true).catch(() => false);
+    return { provider, dbConnectionOk };
   }
-  /** Get the dataset from the databse */
+  /** Get the dataset from the database */
   async getProviderDataset(datasetId) {
     return await this.db.getDataset(datasetId);
   }
+  /**
+   * Get the current block number
+   */
+  async getCurrentBlockNumber() {
+    return (await contract.getBlockNumber(this.contract.api)).toNumber();
+  }
+  /**
+   * Get the current block time in milliseconds
+   */
+  async getBlockTimeMs() {
+    const blockTime = this.contract.api.consts.babe.expectedBlockTime;
+    return blockTime.toNumber();
+  }
+  async saveCaptchaEvent(events, accountId) {
+    if (!this.config.mongoAtlasUri) {
+      return;
+    }
+    await database.saveCaptchaEvent(events, accountId, this.config.mongoAtlasUri);
+  }
 }
 exports.Tasks = Tasks;