@prosopo/provider 1.0.2 → 2.0.0

package/dist/cjs/tasks/tasks.cjs

@@ -1,537 +1,34 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const datasets = require("@prosopo/datasets");
-const typesReturns = require("@prosopo/captcha-contract/types-returns");
 const common = require("@prosopo/common");
-const contract = require("@prosopo/contract");
-const util$2 = require("@prosopo/util");
-const hex = require("@polkadot/util/hex");
-const random = require("@polkadot/util-crypto/random");
-const database = require("@prosopo/database");
-const sha256 = require("@noble/hashes/sha256");
-const util = require("../util.cjs");
-const signature = require("@polkadot/util-crypto/signature");
-const string = require("@polkadot/util/string");
-const util$1 = require("@polkadot/util");
-const POW_SEPARATOR = "___";
+const datasetTasks = require("./dataset/datasetTasks.cjs");
+const imgCaptchaTasks = require("./imgCaptcha/imgCaptchaTasks.cjs");
+const powTasks = require("./powCaptcha/powTasks.cjs");
 class Tasks {
   constructor(env) {
-    if (!env.contractInterface) {
-      throw new common.ProsopoEnvError("CONTRACT.CONTRACT_UNDEFINED", {
-        context: { failedFuncName: this.constructor.name, contractAddress: env.contractAddress }
-      });
-    }
     this.config = env.config;
-    this.contract = env.contractInterface;
-    this.db = env.db;
+    this.db = env.getDb();
     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) {
-    if (datasetRaw.captchas.length < this.config.captchas.solved.count + this.config.captchas.unsolved.count) {
-      throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
-        context: { failedFuncName: 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", {
-        context: { failedFuncName: this.providerSetDataset.name }
-      });
-    }
-    if (solutions < this.config.captchas.unsolved.count) {
-      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", {
-        context: { failedFuncName: this.providerSetDataset.name }
-      });
-    }
-    await this.db?.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", {
-      context: { failedFuncName: this.getCaptchaWithProof.name, datasetId, solved, size }
-    });
-  }
-  /**
-   * @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
-   */
-  async getPowCaptchaChallenge(userAccount, dappAccount, origin) {
-    const difficulty = 4;
-    const latestHeader = await this.contract.api.rpc.chain.getHeader();
-    const latestBlockNumber = latestHeader.number.toNumber();
-    const challenge = `${latestBlockNumber}___${userAccount}___${dappAccount}`;
-    const signature2 = util$1.u8aToHex(this.contract.pair.sign(string.stringToHex(challenge)));
-    return { challenge, difficulty, signature: signature2 };
-  }
-  /**
-   * @description Verifies a PoW Captcha for a given user and dapp
-   *
-   * @param {string} blockNumber - the block at which the Provider was selected
-   * @param {string} challenge - the starting string for the PoW challenge
-   * @param {string} difficulty - how many leading zeroes the solution must have
-   * @param {string} signature - 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
-   */
-  async verifyPowCaptchaSolution(blockNumber, challenge, difficulty, signature$1, nonce, timeout) {
-    const recent = contract.verifyRecency(this.contract.api, blockNumber, timeout);
-    if (!recent) {
-      throw new common.ProsopoContractError("CONTRACT.INVALID_BLOCKHASH", {
-        context: {
-          ERROR: `Block in which the Provider was selected must be within the last ${timeout / 1e3} seconds`,
-          failedFuncName: this.verifyPowCaptchaSolution.name,
-          blockNumber
-        }
-      });
-    }
-    const signatureVerification = signature.signatureVerify(string.stringToHex(challenge), signature$1, this.contract.pair.address);
-    if (!signatureVerification.isValid) {
-      throw new common.ProsopoContractError("GENERAL.INVALID_SIGNATURE", {
-        context: {
-          ERROR: "Provider signature is invalid for this message",
-          failedFuncName: this.verifyPowCaptchaSolution.name,
-          signature: signature$1
-        }
-      });
-    }
-    const solutionValid = Array.from(sha256.sha256(new TextEncoder().encode(nonce + challenge))).map((byte) => byte.toString(16).padStart(2, "0")).join("").startsWith("0".repeat(difficulty));
-    if (!solutionValid) {
-      throw new common.ProsopoContractError("API.CAPTCHA_FAILED", {
-        context: {
-          ERROR: "Captcha solution is invalid",
-          failedFuncName: this.verifyPowCaptchaSolution.name,
-          nonce,
-          challenge,
-          difficulty
-        }
-      });
-    }
-    await this.db.storePowCaptchaRecord(challenge, false);
-    return true;
-  }
-  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.checked) {
-      return false;
-    }
-    const [blocknumber, userAccount, challengeDappAccount] = challengeRecord.challenge.split(POW_SEPARATOR);
-    if (dappAccount !== challengeDappAccount) {
-      throw new common.ProsopoEnvError("CAPTCHA.DAPP_USER_SOLUTION_NOT_FOUND", {
-        context: {
-          failedFuncName: this.serverVerifyPowCaptchaSolution.name,
-          dappAccount,
-          challengeDappAccount
-        }
-      });
-    }
-    if (!blocknumber) {
-      throw new common.ProsopoContractError("CONTRACT.INVALID_BLOCKHASH", {
-        context: {
-          ERROR: "Block number not provided",
-          failedFuncName: this.verifyPowCaptchaSolution.name,
-          blocknumber
-        }
-      });
-    }
-    const recent = contract.verifyRecency(this.contract.api, parseInt(blocknumber), timeout);
-    if (!recent) {
-      throw new common.ProsopoContractError("CONTRACT.INVALID_BLOCKHASH", {
-        context: {
-          ERROR: `Block in which the Provider was selected must be within the last ${timeout / 1e3} seconds`,
-          failedFuncName: this.verifyPowCaptchaSolution.name,
-          blocknumber
-        }
-      });
-    }
-    await this.db.updatePowCaptchaRecord(challengeRecord.challenge, true);
-    return true;
-  }
-  /**
-   * 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$1) {
-    if (!await this.dappIsActive(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", {
-        context: { failedFuncName: this.dappUserSolution.name, userAccount }
-      });
-    }
-    let response = {
-      captchas: [],
-      verified: 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 = hex.hexToU8a(signature$1);
-    const blockNumber = await contract.getCurrentBlockNumber(this.contract.api);
-    if (pendingRequest) {
-      await this.db.updateDappUserPendingStatus(requestHash);
-      const commit = {
-        id: commitmentId,
-        userAccount,
-        dappContract: dappAccount,
-        providerAccount: this.contract.pair.address,
-        datasetId: provider.datasetId.toString(),
-        status: typesReturns.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,
-        stored: false
-      };
-      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 {
-        response = {
-          captchas: captchaIds.map((id) => ({
-            captchaId: id,
-            proof: [[]]
-          })),
-          verified: 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", {
-        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 };
-  }
-  /**
-   * 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) {
-    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: 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 = random.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 || types.DEFAULT_IMAGE_CAPTCHA_TIMEOUT).reduce((a, b) => a + b, 0);
-    const deadlineTs = timeLimit + currentTime;
-    const currentBlockNumber = await contract.getCurrentBlockNumber(this.contract.api);
-    await this.db.storeDappUserPending(userAccount, requestHash, salt, deadlineTs, currentBlockNumber);
-    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", {
-        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", {
-        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(
-      block,
-      "getRandomActiveProvider",
-      [userAccount, dappContractAccount]
+    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
     );
-    if (datasetId.toString().localeCompare(randomProviderAndBlockNo.provider.datasetId.toString())) {
-      throw new common.ProsopoEnvError("DATASET.INVALID_DATASET_ID", {
-        context: {
-          failedFuncName: 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
+    this.imgCaptchaManager = new imgCaptchaTasks.ImgCaptchaManager(
+      this.db,
+      this.pair,
+      this.logger,
+      this.captchaConfig
     );
-    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", {
-        context: {
-          failedFuncName: 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 === typesReturns.CaptchaStatus.approved) {
-          return dappUserSolution;
-        }
-      }
-    }
-    return void 0;
-  }
-  /* Returns public details of provider */
-  async getProviderDetails() {
-    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 database */
-  async getProviderDataset(datasetId) {
-    return await this.db.getDataset(datasetId);
-  }
-  async saveCaptchaEvent(events, accountId) {
-    if (!this.config.devOnlyWatchEvents || !this.config.mongoEventsUri) {
-      this.logger.info("Dev watch events not set to true, not saving events");
-      return;
-    }
-    await database.saveCaptchaEvent(events, accountId, this.config.mongoEventsUri);
-  }
-  async storeCommitmentsExternal() {
-    if (!this.config.mongoCaptchaUri) {
-      this.logger.info("Mongo env not set");
-      return;
-    }
-    const commitments = await this.db.getUnstoredDappUserCommitments();
-    this.logger.info(`Storing ${commitments.length} commitments externally`);
-    await database.saveCaptchas(commitments, this.config.mongoCaptchaUri);
-    const commitIds = commitments.map((commitment) => commitment.id);
-    await this.db.markDappUserCommitmentsStored(commitIds);
   }
 }
 exports.Tasks = Tasks;

package/dist/cjs/util.cjs

@@ -1,16 +1,20 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const util = require("@prosopo/util");
 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));
+    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 } });
+    throw new common.ProsopoContractError("CONTRACT.INVALID_ADDRESS", {
+      context: { address: address$1 }
+    });
   }
 }
 function shuffleArray(array) {
@@ -24,26 +28,35 @@ function shuffleArray(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));
+  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, ""));
+  return Number.parseInt(blockNumberString.replace(/,/g, ""));
 }
 async function checkIfTaskIsRunning(taskName, db) {
-  const runningTask = await db.getLastScheduledTaskStatus(taskName, types.ScheduledTaskStatus.Running);
+  const runningTask = await db.getLastScheduledTaskStatus(
+    taskName,
+    types.ScheduledTaskStatus.Running
+  );
   if (runningTask) {
-    const completedTask = await db.getScheduledTaskStatus(runningTask.taskId, types.ScheduledTaskStatus.Completed);
+    const completedTask = await db.getScheduledTaskStatus(
+      runningTask.taskId,
+      types.ScheduledTaskStatus.Completed
+    );
     return !completedTask;
   }
   return false;

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-export * from './tasks/index.js';
-export * from './util.js';
-export * from './batch/index.js';
-export * from './api/captcha.js';
-export * from './api/verify.js';
-export * from './api/admin.js';
-export * from './api/errorHandler.js';
-export * from './api/captchaScheduler.js';
+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/captchaScheduler.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,uBAAuB,CAAA;AACrC,cAAc,2BAA2B,CAAA"}
+{"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,2BAA2B,CAAC"}

package/dist/index.js

@@ -1,9 +1,8 @@
-export * from './tasks/index.js';
-export * from './util.js';
-export * from './batch/index.js';
-export * from './api/captcha.js';
-export * from './api/verify.js';
-export * from './api/admin.js';
-export * from './api/errorHandler.js';
-export * from './api/captchaScheduler.js';
+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/captchaScheduler.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,uBAAuB,CAAA;AACrC,cAAc,2BAA2B,CAAA"}
+{"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,2BAA2B,CAAC"}