@prosopo/provider 2.5.3 → 2.7.0

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

@@ -0,0 +1,366 @@
+"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 lang = require("../../rules/lang.cjs");
+const util = require("../../util.cjs");
+const captchaManager = require("../captchaManager.cjs");
+const frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
+const imgCaptchaTasksUtils = require("./imgCaptchaTasksUtils.cjs");
+class ImgCaptchaManager extends captchaManager.CaptchaManager {
+  constructor(db, pair, config, logger) {
+    super(db, pair, logger);
+    this.config = config;
+  }
+  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, captchaConfig, threshold, frictionlessTokenId) {
+    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(captchaConfig.unsolved.count)
+    );
+    const solvedCount = Math.abs(
+      Math.trunc(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;
+    await this.db.storePendingImageCommitment(
+      userAccount,
+      requestHash,
+      salt,
+      deadlineTs,
+      currentTime,
+      ipAddress.bigInt(),
+      threshold,
+      frictionlessTokenId
+    );
+    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 userTimestampSignature
+   * @param timestamp
+   * @param providerRequestHashSignature
+   * @param ipAddress
+   * @param headers
+   * @param threshold the percentage of captchas that must be correct to return true
+   * @return {Promise<DappUserSolutionResult>} result containing the contract event
+   */
+  async dappUserSolution(userAccount, dappAccount, requestHash, captchas, userTimestampSignature, timestamp, providerRequestHashSignature, ipAddress, headers, ja4) {
+    const verification = utilCrypto.signatureVerify(
+      util$1.stringToHex(timestamp.toString()),
+      userTimestampSignature,
+      userAccount
+    );
+    if (!verification.isValid) {
+      this.logger.info("Invalid user timestamp 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.getPendingImageCommitment(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.updatePendingImageCommitmentStatus(requestHash);
+      const commit = {
+        id: commitmentId,
+        userAccount,
+        dappAccount,
+        providerAccount: this.pair.address,
+        datasetId,
+        result: { status: types.CaptchaStatus.pending },
+        userSignature: userTimestampSignature,
+        userSubmitted: true,
+        serverChecked: false,
+        requestedAtTimestamp: timestamp,
+        ipAddress,
+        headers,
+        frictionlessTokenId: pendingRecord.frictionlessTokenId,
+        ja4
+      };
+      await this.db.storeUserImageCaptchaSolution(receivedCaptchas, commit);
+      const solutionRecords = await Promise.all(
+        storedCaptchas.map(async (captcha) => {
+          const solutionRecord = await this.db.getSolutionByCaptchaId(
+            captcha.captchaId
+          );
+          if (!solutionRecord) {
+            throw new common.ProsopoEnvError("CAPTCHA.SOLUTION_NOT_FOUND", {
+              context: { failedFuncName: this.dappUserSolution.name }
+            });
+          }
+          return solutionRecord;
+        })
+      );
+      const totalImages = storedCaptchas[0]?.items.length || 0;
+      if (datasets.compareCaptchaSolutions(
+        receivedCaptchas,
+        solutionRecords,
+        totalImages,
+        pendingRecord.threshold
+      )) {
+        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;
+  }
+  async verifyImageCaptchaSolution(user, dapp, commitmentId, maxVerifiedTime) {
+    const solution = await (commitmentId ? this.getDappUserCommitmentById(commitmentId) : this.getDappUserCommitmentByAccount(user, dapp));
+    if (!solution) {
+      this.logger.debug("Not verified - no solution found");
+      return { status: "API.USER_NOT_VERIFIED_NO_SOLUTION", verified: false };
+    }
+    if (solution.serverChecked) {
+      return { status: "API.USER_ALREADY_VERIFIED", verified: false };
+    }
+    await this.db.markDappUserCommitmentsChecked([solution.id]);
+    if (solution.result.status === types.CaptchaStatus.disapproved) {
+      return { status: "API.USER_NOT_VERIFIED", verified: false };
+    }
+    maxVerifiedTime = maxVerifiedTime || 60 * 1e3;
+    if (maxVerifiedTime) {
+      const currentTime = Date.now();
+      const timeSinceCompletion = currentTime - solution.requestedAtTimestamp;
+      if (timeSinceCompletion > maxVerifiedTime) {
+        this.logger.debug("Not verified - timed out");
+        return {
+          status: "API.USER_NOT_VERIFIED_TIME_EXPIRED",
+          verified: false
+        };
+      }
+    }
+    const isApproved = solution.result.status === types.CaptchaStatus.approved;
+    let score;
+    if (solution.frictionlessTokenId) {
+      const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(
+        solution.frictionlessTokenId
+      );
+      if (tokenRecord) {
+        score = frictionlessTasksUtils.computeFrictionlessScore(tokenRecord?.scoreComponents);
+        this.logger.info({
+          tscoreComponents: tokenRecord?.scoreComponents,
+          score
+        });
+      }
+    }
+    return {
+      status: isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED",
+      verified: isApproved,
+      commitmentId: solution.id.toString(),
+      ...score && { score }
+    };
+  }
+  checkLangRules(acceptLanguage) {
+    return lang.checkLangRules(this.config, acceptLanguage);
+  }
+  getVerificationResponse(verified, clientRecord, translateFn, score, commitmentId) {
+    return {
+      ...super.getVerificationResponse(
+        verified,
+        clientRecord,
+        translateFn,
+        score
+      ),
+      ...commitmentId && {
+        [types.ApiParams.commitmentId]: commitmentId
+      }
+    };
+  }
+}
+exports.ImgCaptchaManager = ImgCaptchaManager;

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

@@ -0,0 +1,25 @@
+"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

@@ -0,0 +1,4 @@
+"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

@@ -0,0 +1,155 @@
+"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 captchaManager = require("../captchaManager.cjs");
+const frictionlessTasksUtils = require("../frictionless/frictionlessTasksUtils.cjs");
+const powTasksUtils = require("./powTasksUtils.cjs");
+const DEFAULT_POW_DIFFICULTY = 4;
+class PowCaptchaManager extends captchaManager.CaptchaManager {
+  constructor(db, pair, logger) {
+    super(db, pair, logger);
+    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
+   * @param powDifficulty
+   */
+  async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
+    const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
+    const requestedAtTimestamp = Date.now();
+    const nonce = Math.floor(Math.random() * 1e6);
+    const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}___${nonce}`;
+    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) {
+      this.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,
+        //serverchecked
+        true,
+        // usersubmitted
+        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) {
+      this.logger.debug(`No record of this challenge: ${challenge}`);
+      return { verified: false };
+    }
+    if (challengeRecord.result.status !== types.CaptchaStatus.approved) {
+      throw new common.ProsopoApiError("CAPTCHA.INVALID_SOLUTION", {
+        context: {
+          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+          challenge
+        }
+      });
+    }
+    if (challengeRecord.serverChecked) return { verified: 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
+    ]);
+    let score;
+    if (challengeRecord.frictionlessTokenId) {
+      const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(
+        challengeRecord.frictionlessTokenId
+      );
+      if (tokenRecord) {
+        score = frictionlessTasksUtils.computeFrictionlessScore(tokenRecord?.scoreComponents);
+        this.logger.info({
+          tscoreComponents: tokenRecord?.scoreComponents,
+          score
+        });
+      }
+    }
+    return { verified: true, ...score ? { score } : {} };
+  }
+}
+exports.PowCaptchaManager = PowCaptchaManager;

package/dist/cjs/tasks/powCaptcha/powTasksUtils.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sha256 = require("@noble/hashes/sha256");
+const util = require("@polkadot/util");
+const utilCrypto = require("@polkadot/util-crypto");
+const common = require("@prosopo/common");
+const validateSolution = (nonce, challenge, difficulty) => Array.from(sha256.sha256(new TextEncoder().encode(nonce + challenge))).map((byte) => byte.toString(16).padStart(2, "0")).join("").startsWith("0".repeat(difficulty));
+const checkPowSignature = (challenge, signature, address, signatureType) => {
+  const signatureVerification = utilCrypto.signatureVerify(
+    util.stringToHex(challenge),
+    signature,
+    address
+  );
+  if (!signatureVerification.isValid) {
+    throw new common.ProsopoContractError("GENERAL.INVALID_SIGNATURE", {
+      context: {
+        ERROR: `Signature is invalid for this message: ${signatureType}`,
+        failedFuncName: checkPowSignature.name,
+        signature,
+        signatureType
+      }
+    });
+  }
+};
+exports.checkPowSignature = checkPowSignature;
+exports.validateSolution = validateSolution;

package/dist/cjs/tasks/tasks.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const clientTasks = require("./client/clientTasks.cjs");
+const datasetTasks = require("./dataset/datasetTasks.cjs");
+const frictionlessTasks = require("./frictionless/frictionlessTasks.cjs");
+const imgCaptchaTasks = require("./imgCaptcha/imgCaptchaTasks.cjs");
+const powTasks = require("./powCaptcha/powTasks.cjs");
+class Tasks {
+  constructor(env) {
+    this.config = env.config;
+    this.db = env.getDb();
+    this.captchaConfig = env.config.captchas;
+    this.logger = common.getLogger(env.config.logLevel, "Tasks");
+    if (!env.pair) {
+      throw new common.ProsopoEnvError("DEVELOPER.MISSING_PROVIDER_PAIR", {
+        context: { failedFuncName: "Tasks.constructor" }
+      });
+    }
+    this.pair = env.pair;
+    this.powCaptchaManager = new powTasks.PowCaptchaManager(
+      this.db,
+      this.pair,
+      this.logger
+    );
+    this.datasetManager = new datasetTasks.DatasetManager(
+      this.config,
+      this.logger,
+      this.captchaConfig,
+      this.db
+    );
+    this.imgCaptchaManager = new imgCaptchaTasks.ImgCaptchaManager(
+      this.db,
+      this.pair,
+      this.config,
+      this.logger
+    );
+    this.clientTaskManager = new clientTasks.ClientTaskManager(
+      this.config,
+      this.logger,
+      this.db
+    );
+    this.frictionlessManager = new frictionlessTasks.FrictionlessManager(
+      this.db,
+      this.pair,
+      this.config,
+      this.logger
+    );
+  }
+}
+exports.Tasks = Tasks;

package/dist/cjs/util.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const address = require("@polkadot/util-crypto/address");
+const hex = require("@polkadot/util/hex");
+const is = require("@polkadot/util/is");
+const common = require("@prosopo/common");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
+const ipAddress = require("ip-address");
+function encodeStringAddress(address$1) {
+  try {
+    return address.encodeAddress(
+      is.isHex(address$1) ? hex.hexToU8a(address$1) : address.decodeAddress(address$1)
+    );
+  } catch (err) {
+    throw new common.ProsopoContractError("CONTRACT.INVALID_ADDRESS", {
+      context: { address: address$1 }
+    });
+  }
+}
+function shuffleArray(array) {
+  for (let arrayIndex = array.length - 1; arrayIndex > 0; arrayIndex--) {
+    const randIndex = Math.floor(Math.random() * (arrayIndex + 1));
+    const tmp = util.at(array, randIndex);
+    array[randIndex] = util.at(array, arrayIndex);
+    array[arrayIndex] = tmp;
+  }
+  return array;
+}
+async function checkIfTaskIsRunning(taskName, db) {
+  const runningTask = await db.getLastScheduledTaskStatus(
+    taskName,
+    types.ScheduledTaskStatus.Running
+  );
+  const twoMinutesAgo = (/* @__PURE__ */ new Date()).getTime() - 1e3 * 60 * 2;
+  if (runningTask && runningTask.datetime > twoMinutesAgo) {
+    const completedTask = await db.getScheduledTaskStatus(
+      runningTask._id,
+      types.ScheduledTaskStatus.Completed
+    );
+    return !completedTask;
+  }
+  return false;
+}
+const getIPAddress = (ipAddressString) => {
+  try {
+    if (ipAddressString.match(/^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/)) {
+      return new ipAddress.Address4(ipAddressString);
+    }
+    return new ipAddress.Address6(ipAddressString);
+  } catch (e) {
+    throw new common.ProsopoEnvError("API.INVALID_IP");
+  }
+};
+exports.checkIfTaskIsRunning = checkIfTaskIsRunning;
+exports.encodeStringAddress = encodeStringAddress;
+exports.getIPAddress = getIPAddress;
+exports.shuffleArray = shuffleArray;

package/dist/schedulers/captchaScheduler.d.ts

@@ -1,4 +1,4 @@
 import type { KeyringPair } from "@polkadot/keyring/types";
 import { type ProsopoConfigOutput } from "@prosopo/types";
-export declare function storeCaptchasExternally(pair: KeyringPair, config: ProsopoConfigOutput): Promise<void>;
+export declare function storeCaptchasExternally(pair: KeyringPair, cronSchedule: string, config: ProsopoConfigOutput): Promise<void>;
 //# sourceMappingURL=captchaScheduler.d.ts.map