@prosopo/provider 2.1.5 → 2.1.6

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

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util$1 = require("@polkadot/util");
+const utilCrypto = require("@polkadot/util-crypto");
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
+const types = require("@prosopo/types");
+const util$2 = require("@prosopo/util");
+const util = require("../../util.cjs");
+const imgCaptchaTasksUtils = require("./imgCaptchaTasksUtils.cjs");
+class ImgCaptchaManager {
+  constructor(db, pair, logger, captchaConfig) {
+    this.db = db;
+    this.pair = pair;
+    this.logger = logger;
+    this.captchaConfig = captchaConfig;
+  }
+  async getCaptchaWithProof(datasetId, solved, size) {
+    const captchaDocs = await this.db.getRandomCaptcha(solved, datasetId, size);
+    if (!captchaDocs) {
+      throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
+        context: {
+          failedFuncName: this.getCaptchaWithProof.name,
+          datasetId,
+          solved,
+          size
+        }
+      });
+    }
+    return captchaDocs;
+  }
+  async getRandomCaptchasAndRequestHash(datasetId, userAccount, ipAddress, headers) {
+    const dataset = await this.db.getDatasetDetails(datasetId);
+    if (!dataset) {
+      throw new common.ProsopoEnvError("DATABASE.DATASET_GET_FAILED", {
+        context: {
+          failedFuncName: this.getRandomCaptchasAndRequestHash.name,
+          dataset,
+          datasetId
+        }
+      });
+    }
+    const unsolvedCount = Math.abs(
+      Math.trunc(this.captchaConfig.unsolved.count)
+    );
+    const solvedCount = Math.abs(
+      Math.trunc(this.captchaConfig.solved.count)
+    );
+    if (!solvedCount) {
+      throw new common.ProsopoEnvError("CONFIG.INVALID_CAPTCHA_NUMBER");
+    }
+    const solved = await this.getCaptchaWithProof(datasetId, true, solvedCount);
+    let unsolved = [];
+    if (unsolvedCount) {
+      unsolved = await this.getCaptchaWithProof(
+        datasetId,
+        false,
+        unsolvedCount
+      );
+    }
+    const captchas = util.shuffleArray([...solved, ...unsolved]);
+    const salt = utilCrypto.randomAsHex();
+    const requestHash = datasets.computePendingRequestHash(
+      captchas.map((c) => c.captchaId),
+      userAccount,
+      salt
+    );
+    const currentTime = Date.now();
+    const signedRequestHash = util$1.u8aToHex(
+      this.pair.sign(util$1.stringToHex(requestHash))
+    );
+    const timeLimit = captchas.map((captcha) => captcha.timeLimitMs || types.DEFAULT_IMAGE_CAPTCHA_TIMEOUT).reduce((a, b) => a + b, 0);
+    const deadlineTs = timeLimit + currentTime;
+    const currentBlockNumber = 0;
+    await this.db.storeDappUserPending(
+      userAccount,
+      requestHash,
+      salt,
+      deadlineTs,
+      currentTime,
+      ipAddress,
+      headers
+    );
+    return {
+      captchas,
+      requestHash,
+      timestamp: currentTime,
+      signedRequestHash
+    };
+  }
+  /**
+   * Validate and store the text captcha solution(s) from the Dapp User in a web2 environment
+   * @param {string} userAccount
+   * @param {string} dappAccount
+   * @param {string} requestHash
+   * @param {JSON} captchas
+   * @param {string} userRequestHashSignature
+   * @param timestamp
+   * @param providerRequestHashSignature
+   * @param ipAddress
+   * @param headers
+   * @return {Promise<DappUserSolutionResult>} result containing the contract event
+   */
+  async dappUserSolution(userAccount, dappAccount, requestHash, captchas, userTimestampSignature, timestamp, providerRequestHashSignature, ipAddress, headers) {
+    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.getDappUserPending(requestHash);
+    const unverifiedCaptchaIds = captchas.map((captcha) => captcha.captchaId);
+    const pendingRequest = await this.validateDappUserSolutionRequestIsPending(
+      requestHash,
+      pendingRecord,
+      userAccount,
+      unverifiedCaptchaIds
+    );
+    if (pendingRequest) {
+      const { storedCaptchas, receivedCaptchas, captchaIds } = await this.validateReceivedCaptchasAgainstStoredCaptchas(captchas);
+      const { tree, commitmentId } = imgCaptchaTasksUtils.buildTreeAndGetCommitmentId(receivedCaptchas);
+      const datasetId = util$2.at(storedCaptchas, 0).datasetId;
+      if (!datasetId) {
+        throw new common.ProsopoEnvError("CAPTCHA.ID_MISMATCH", {
+          context: { failedFuncName: this.dappUserSolution.name }
+        });
+      }
+      await this.db.updateDappUserPendingStatus(requestHash);
+      const commit = {
+        id: commitmentId,
+        userAccount,
+        dappAccount,
+        providerAccount: this.pair.address,
+        datasetId,
+        result: { status: types.CaptchaStatus.pending },
+        userSignature: userTimestampSignature,
+        userSubmitted: true,
+        serverChecked: false,
+        requestedAtTimestamp: timestamp,
+        ipAddress,
+        headers
+      };
+      await this.db.storeDappUserSolution(receivedCaptchas, commit);
+      if (datasets.compareCaptchaSolutions(receivedCaptchas, storedCaptchas)) {
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: tree.proof(id)
+          })),
+          verified: true
+        };
+        await this.db.approveDappUserCommitment(commitmentId);
+      } else {
+        await this.db.disapproveDappUserCommitment(
+          commitmentId,
+          "CAPTCHA.INVALID_SOLUTION"
+        );
+        response = {
+          captchas: captchaIds.map((id) => ({
+            captchaId: id,
+            proof: [[]]
+          })),
+          verified: false
+        };
+      }
+    } else {
+      this.logger.info("Request hash not found");
+    }
+    return response;
+  }
+  /**
+   * Validate length of received captchas array matches length of captchas found in database
+   * Validate that the datasetId is the same for all captchas and is equal to the datasetId on the stored captchas
+   */
+  async validateReceivedCaptchasAgainstStoredCaptchas(captchas) {
+    const receivedCaptchas = datasets.parseAndSortCaptchaSolutions(captchas);
+    const captchaIds = receivedCaptchas.map((captcha) => captcha.captchaId);
+    const storedCaptchas = await this.db.getCaptchaById(captchaIds);
+    if (!storedCaptchas || receivedCaptchas.length !== storedCaptchas.length) {
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_ID", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
+        }
+      });
+    }
+    if (!storedCaptchas.every(
+      (captcha) => captcha.datasetId === util$2.at(storedCaptchas, 0).datasetId
+    )) {
+      throw new common.ProsopoEnvError("CAPTCHA.DIFFERENT_DATASET_IDS", {
+        context: {
+          failedFuncName: this.validateReceivedCaptchasAgainstStoredCaptchas.name,
+          captchas
+        }
+      });
+    }
+    return { storedCaptchas, receivedCaptchas, captchaIds };
+  }
+  /**
+   * Validate that a Dapp User is responding to their own pending captcha request
+   * @param {string} requestHash
+   * @param {PendingCaptchaRequest} pendingRecord
+   * @param {string} userAccount
+   * @param {string[]} captchaIds
+   */
+  async validateDappUserSolutionRequestIsPending(requestHash, pendingRecord, userAccount, captchaIds) {
+    const currentTime = Date.now();
+    if (!pendingRecord) {
+      this.logger.info("No pending record found");
+      return false;
+    }
+    if (pendingRecord.deadlineTimestamp < currentTime) {
+      this.logger.info("Deadline for responding to captcha has expired");
+      return false;
+    }
+    if (pendingRecord) {
+      const pendingHashComputed = datasets.computePendingRequestHash(
+        captchaIds,
+        userAccount,
+        pendingRecord.salt
+      );
+      return requestHash === pendingHashComputed;
+    }
+    return false;
+  }
+  /*
+   * Get dapp user solution from database
+   */
+  async getDappUserCommitmentById(commitmentId) {
+    const dappUserSolution = await this.db.getDappUserCommitmentById(commitmentId);
+    if (!dappUserSolution) {
+      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+        context: {
+          failedFuncName: this.getDappUserCommitmentById.name,
+          commitmentId
+        }
+      });
+    }
+    return dappUserSolution;
+  }
+  /* Check if dapp user has verified solution in cache */
+  async getDappUserCommitmentByAccount(userAccount, dappAccount) {
+    const dappUserSolutions = await this.db.getDappUserCommitmentByAccount(
+      userAccount,
+      dappAccount
+    );
+    if (dappUserSolutions.length > 0) {
+      for (const dappUserSolution of dappUserSolutions) {
+        if (dappUserSolution.result.status === types.CaptchaStatus.approved) {
+          return dappUserSolution;
+        }
+      }
+    }
+    return void 0;
+  }
+  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;
+    return {
+      status: isApproved ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED",
+      verified: isApproved,
+      commitmentId: solution.id.toString()
+    };
+  }
+}
+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,134 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("@polkadot/util");
+const common = require("@prosopo/common");
+const types = require("@prosopo/types");
+const util$1 = require("@prosopo/util");
+const powTasksUtils = require("./powTasksUtils.cjs");
+const logger = common.getLoggerDefault();
+const DEFAULT_POW_DIFFICULTY = 4;
+class PowCaptchaManager {
+  constructor(pair, db) {
+    this.pair = pair;
+    this.db = db;
+    this.POW_SEPARATOR = types.POW_SEPARATOR;
+  }
+  /**
+   * @description Generates a PoW Captcha for a given user and dapp
+   *
+   * @param {string} userAccount - user that is solving the captcha
+   * @param {string} dappAccount - dapp that is requesting the captcha
+   * @param origin - not currently used
+   */
+  async getPowCaptchaChallenge(userAccount, dappAccount, origin, powDifficulty) {
+    const difficulty = powDifficulty || DEFAULT_POW_DIFFICULTY;
+    const requestedAtTimestamp = Date.now();
+    const challenge = `${requestedAtTimestamp}___${userAccount}___${dappAccount}`;
+    const challengeSignature = util.u8aToHex(this.pair.sign(util.stringToHex(challenge)));
+    return {
+      challenge,
+      difficulty,
+      providerSignature: challengeSignature,
+      requestedAtTimestamp
+    };
+  }
+  /**
+   * @description Verifies a PoW Captcha for a given user and dapp
+   *
+   * @param {string} challenge - the starting string for the PoW challenge
+   * @param {string} difficulty - how many leading zeroes the solution must have
+   * @param {string} providerChallengeSignature - proof that the Provider provided the challenge
+   * @param {string} nonce - the string that the user has found that satisfies the PoW challenge
+   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
+   * @param {string} userTimestampSignature
+   * @param ipAddress
+   * @param headers
+   */
+  async verifyPowCaptchaSolution(challenge, difficulty, providerChallengeSignature, nonce, timeout, userTimestampSignature, ipAddress, headers) {
+    powTasksUtils.checkPowSignature(
+      challenge,
+      providerChallengeSignature,
+      this.pair.address,
+      types.ApiParams.challenge
+    );
+    const challengeSplit = challenge.split(this.POW_SEPARATOR);
+    const timestamp = Number.parseInt(util$1.at(challengeSplit, 0));
+    const userAccount = util$1.at(challengeSplit, 1);
+    powTasksUtils.checkPowSignature(
+      timestamp.toString(),
+      userTimestampSignature,
+      userAccount,
+      types.ApiParams.timestamp
+    );
+    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
+    if (!challengeRecord) {
+      logger.debug("No record of this challenge");
+      return false;
+    }
+    if (!util$1.verifyRecency(challenge, timeout)) {
+      await this.db.updatePowCaptchaRecord(
+        challenge,
+        {
+          status: types.CaptchaStatus.disapproved,
+          reason: "CAPTCHA.INVALID_TIMESTAMP"
+        },
+        false,
+        true,
+        userTimestampSignature
+      );
+      return false;
+    }
+    const correct = powTasksUtils.validateSolution(nonce, challenge, difficulty);
+    let result = { status: types.CaptchaStatus.approved };
+    if (!correct) {
+      result = {
+        status: types.CaptchaStatus.disapproved,
+        reason: "CAPTCHA.INVALID_SOLUTION"
+      };
+    }
+    await this.db.updatePowCaptchaRecord(
+      challenge,
+      result,
+      false,
+      true,
+      userTimestampSignature
+    );
+    return correct;
+  }
+  /**
+   * @description Verifies a PoW Captcha for a given user and dapp. This is called by the server to verify the user's solution
+   * and update the record in the database to show that the user has solved the captcha
+   *
+   * @param {string} dappAccount - the dapp that is requesting the captcha
+   * @param {string} challenge - the starting string for the PoW challenge
+   * @param {number} timeout - the time in milliseconds since the Provider was selected to provide the PoW captcha
+   */
+  async serverVerifyPowCaptchaSolution(dappAccount, challenge, timeout) {
+    const challengeRecord = await this.db.getPowCaptchaRecordByChallenge(challenge);
+    if (!challengeRecord) {
+      throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", {
+        context: {
+          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+          challenge
+        }
+      });
+    }
+    if (challengeRecord.serverChecked) return false;
+    const challengeDappAccount = challengeRecord.dappAccount;
+    if (dappAccount !== challengeDappAccount) {
+      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
+        context: {
+          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
+          dappAccount,
+          challengeDappAccount
+        }
+      });
+    }
+    util$1.verifyRecency(challenge, timeout);
+    await this.db.markDappUserPoWCommitmentsChecked([
+      challengeRecord.challenge
+    ]);
+    return true;
+  }
+}
+exports.PowCaptchaManager = PowCaptchaManager;

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,40 @@
+"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 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.pair, this.db);
+    this.datasetManager = new datasetTasks.DatasetManager(
+      this.config,
+      this.logger,
+      this.captchaConfig,
+      this.db
+    );
+    this.imgCaptchaManager = new imgCaptchaTasks.ImgCaptchaManager(
+      this.db,
+      this.pair,
+      this.logger,
+      this.captchaConfig
+    );
+    this.clientTaskManager = new clientTasks.ClientTaskManager(
+      this.config,
+      this.logger,
+      this.db
+    );
+  }
+}
+exports.Tasks = Tasks;

package/dist/cjs/util.cjs

@@ -0,0 +1,45 @@
+"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");
+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
+  );
+  if (runningTask) {
+    const completedTask = await db.getScheduledTaskStatus(
+      runningTask.id,
+      types.ScheduledTaskStatus.Completed
+    );
+    return !completedTask;
+  }
+  return false;
+}
+exports.checkIfTaskIsRunning = checkIfTaskIsRunning;
+exports.encodeStringAddress = encodeStringAddress;
+exports.shuffleArray = shuffleArray;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./tasks/index.js";
+export * from "./util.js";
+export * from "./api/captcha.js";
+export * from "./api/verify.js";
+export * from "./api/admin.js";
+export * from "./api/errorHandler.js";
+export * from "./api/authMiddleware.js";
+export * from "./schedulers/captchaScheduler.js";
+export * from "./schedulers/getClientList.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./tasks/index.js";
+export * from "./util.js";
+export * from "./api/captcha.js";
+export * from "./api/verify.js";
+export * from "./api/admin.js";
+export * from "./api/errorHandler.js";
+export * from "./api/authMiddleware.js";
+export * from "./schedulers/captchaScheduler.js";
+export * from "./schedulers/getClientList.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC"}

package/dist/scheduler.d.ts

@@ -0,0 +1,4 @@
+import { KeyringPair } from '@polkadot/keyring/types';
+import { ProsopoConfigOutput } from '@prosopo/types';
+export declare function batchCommitScheduler(pair: KeyringPair, config: ProsopoConfigOutput): Promise<void>;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAKpD,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,iBAgBxF"}

package/dist/scheduler.js

@@ -0,0 +1,21 @@
+import { BatchCommitmentsTask } from './batch/commitments.js';
+import { CronJob } from 'cron';
+import { ProsopoEnvError } from '@prosopo/common';
+import { ProviderEnvironment } from '@prosopo/env';
+import { at } from '@prosopo/util';
+export async function batchCommitScheduler(pair, config) {
+    const env = new ProviderEnvironment(config, pair);
+    await env.isReady();
+    if (env.db === undefined) {
+        throw new ProsopoEnvError('DATABASE.DATABASE_UNDEFINED');
+    }
+    const tasks = new BatchCommitmentsTask(config.batchCommit, env.getContractInterface(), env.db, 0n, env.logger);
+    const job = new CronJob(at(process.argv, 2), () => {
+        env.logger.debug('BatchCommitmentsTask....');
+        tasks.run().catch((err) => {
+            env.logger.error(err);
+        });
+    });
+    job.start();
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAG9B,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,EAAE,EAAE,MAAM,eAAe,CAAA;AAElC,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,IAAiB,EAAE,MAA2B;IACrF,MAAM,GAAG,GAAG,IAAI,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACjD,MAAM,GAAG,CAAC,OAAO,EAAE,CAAA;IACnB,IAAI,GAAG,CAAC,EAAE,KAAK,SAAS,EAAE;QACtB,MAAM,IAAI,eAAe,CAAC,6BAA6B,CAAC,CAAA;KAC3D;IAED,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,oBAAoB,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC9G,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE;QAC9C,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAA;QAC5C,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACtB,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACzB,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,GAAG,CAAC,KAAK,EAAE,CAAA;AACf,CAAC"}

package/dist/schedulers/captchaScheduler.d.ts

@@ -0,0 +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>;
+//# sourceMappingURL=captchaScheduler.d.ts.map

package/dist/schedulers/captchaScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captchaScheduler.d.ts","sourceRoot":"","sources":["../../src/schedulers/captchaScheduler.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAE,KAAK,mBAAmB,EAAsB,MAAM,gBAAgB,CAAC;AAK9E,wBAAsB,uBAAuB,CAC5C,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,mBAAmB,iBAkC3B"}