@prosopo/procaptcha 0.1.19 → 0.2.1

package/dist/api/HttpClientBase.js

@@ -20,7 +20,7 @@ export class HttpClientBase {
         };
         this.errorHandler = (error) => Promise.reject(error.response);
         baseURL = baseURL + prefix;
-        this.axios = axios.default.create({ baseURL });
+        this.axios = axios.create({ baseURL });
         this.axios.interceptors.response.use(this.responseHandler, this.errorHandler);
     }
 }

package/dist/api/HttpClientBase.js.map

@@ -1 +1 @@
-{"version":3,"file":"HttpClientBase.js","sourceRoot":"","sources":["../../src/api/HttpClientBase.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,OAAO,KAAuC,MAAM,OAAO,CAAA;AAE3D,MAAM,OAAO,cAAc;IAGvB,YAAY,OAAe,EAAE,MAAM,GAAG,EAAE;QAM9B,oBAAe,GAAG,CAAC,QAAuB,EAAE,EAAE;YACpD,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;YAC5C,OAAO,QAAQ,CAAC,IAAI,CAAA;QACxB,CAAC,CAAA;QAES,iBAAY,GAAG,CAAC,KAAU,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QAVnE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;QAC9C,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IACjF,CAAC;CAQJ;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"HttpClientBase.js","sourceRoot":"","sources":["../../src/api/HttpClientBase.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,OAAO,KAAuC,MAAM,OAAO,CAAA;AAE3D,MAAM,OAAO,cAAc;IAGvB,YAAY,OAAe,EAAE,MAAM,GAAG,EAAE;QAM9B,oBAAe,GAAG,CAAC,QAAuB,EAAE,EAAE;YACpD,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;YAC5C,OAAO,QAAQ,CAAC,IAAI,CAAA;QACxB,CAAC,CAAA;QAES,iBAAY,GAAG,CAAC,KAAU,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QAVnE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;QACtC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IACjF,CAAC;CAQJ;AAED,eAAe,cAAc,CAAA"}

package/dist/cjs/api/Extension.cjs

@@ -0,0 +1,4 @@
+"use strict";
+class Extension {
+}
+module.exports = Extension;

package/dist/cjs/api/ExtensionWeb2.cjs

@@ -0,0 +1,88 @@
+"use strict";
+const api = require("@polkadot/api");
+const ws = require("@polkadot/rpc-provider/ws");
+const utilCrypto = require("@polkadot/util-crypto");
+const bip39 = require("@polkadot/util-crypto/mnemonic/bip39");
+const Manager = require("../modules/Manager.cjs");
+const common = require("@prosopo/common");
+const canvas = require("../modules/canvas.cjs");
+const util = require("@polkadot/util");
+const Extension = require("./Extension.cjs");
+const FingerprintJS = require("@fingerprintjs/fingerprintjs");
+const Signer = require("@polkadot/extension-base/page/Signer");
+class ExtWeb2 extends Extension {
+  async getAccount(config) {
+    const network = Manager.getNetwork(config);
+    const wsProvider = new ws.WsProvider(network.endpoint);
+    const account = await this.createAccount(wsProvider);
+    const extension = await this.createExtension(account);
+    return {
+      account,
+      extension
+    };
+  }
+  async createExtension(account) {
+    const signer = new Signer(async () => {
+      return;
+    });
+    signer.signRaw = async (payload) => {
+      const signature = account.keypair.sign(payload.data);
+      return {
+        id: 1,
+        // the id of the request to sign. This should be incremented each time and adjust the signature, but we're hacking around this. Hence the signature will always be the same given the same payload.
+        signature: util.u8aToHex(signature)
+      };
+    };
+    return {
+      accounts: {
+        get: async () => {
+          return [account];
+        },
+        subscribe: () => {
+          return () => {
+            return;
+          };
+        }
+      },
+      name: "procaptcha-web2",
+      version: "0.1.11",
+      signer
+    };
+  }
+  async createAccount(wsProvider) {
+    const params = {
+      area: { width: 300, height: 300 },
+      offsetParameter: 2001000001,
+      multiplier: 15e3,
+      fontSizeFactor: 1.5,
+      maxShadowBlur: 50,
+      numberOfRounds: 5,
+      seed: 42
+    };
+    const browserEntropy = await this.getFingerprint();
+    const canvasEntropy = canvas.picassoCanvas(params.numberOfRounds, params.seed, params);
+    const entropy = common.hexHash([canvasEntropy, browserEntropy].join(""), 128).slice(2);
+    const u8Entropy = util.stringToU8a(entropy);
+    const mnemonic = bip39.entropyToMnemonic(u8Entropy);
+    const api$1 = await api.ApiPromise.create({ provider: wsProvider });
+    const type = "sr25519";
+    const keyring = new api.Keyring({ type, ss58Format: api$1.registry.chainSS58 });
+    await utilCrypto.cryptoWaitReady();
+    const keypair = keyring.addFromMnemonic(mnemonic);
+    const address = keypair.address.length === 42 ? keypair.address : utilCrypto.encodeAddress(utilCrypto.decodeAddress(keypair.address), api$1.registry.chainSS58);
+    return {
+      address,
+      type,
+      name: address,
+      keypair
+    };
+  }
+  async getFingerprint() {
+    const fpPromise = FingerprintJS.load();
+    const fp = await fpPromise;
+    const result = await fp.get();
+    const { screenFrame, ...componentsReduced } = result.components;
+    return FingerprintJS.hashComponents(componentsReduced);
+  }
+}
+module.exports = ExtWeb2;

package/dist/cjs/api/ExtensionWeb3.cjs

@@ -0,0 +1,25 @@
+"use strict";
+const errors = require("./errors.cjs");
+const extensionDapp = require("@polkadot/extension-dapp");
+const Extension = require("./Extension.cjs");
+class ExtWeb3 extends Extension {
+  async getAccount(config) {
+    const { dappName, userAccountAddress: address } = config;
+    if (!address) {
+      throw new errors.AccountNotFoundError("No account address provided");
+    }
+    const extensions = await extensionDapp.web3Enable(dappName);
+    if (extensions.length === 0) {
+      throw new errors.ExtensionNotFoundError();
+    }
+    for (const extension of extensions) {
+      const accounts = await extension.accounts.get();
+      const account = accounts.find((account2) => account2.address === address);
+      if (account) {
+        return { account, extension };
+      }
+    }
+    throw new errors.AccountNotFoundError("No account found matching " + address);
+  }
+}
+module.exports = ExtWeb3;

package/dist/cjs/api/HttpClientBase.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const client = require("axios");
+class HttpClientBase {
+  constructor(baseURL, prefix = "") {
+    this.responseHandler = (response) => {
+      console.log("API REQUEST", response.request);
+      return response.data;
+    };
+    this.errorHandler = (error) => Promise.reject(error.response);
+    baseURL = baseURL + prefix;
+    this.axios = client.create({ baseURL });
+    this.axios.interceptors.response.use(this.responseHandler, this.errorHandler);
+  }
+}
+exports.HttpClientBase = HttpClientBase;
+exports.default = HttpClientBase;

package/dist/cjs/api/errors.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class NoExtensionsFoundError extends Error {
+  constructor(msg) {
+    super(msg || "No extensions found");
+  }
+}
+class AccountCreationUnsupportedError extends Error {
+  constructor(msg) {
+    super(msg || "Account creation is not supported");
+  }
+}
+class AccountNotFoundError extends Error {
+  constructor(msg) {
+    super(msg || "No account found");
+  }
+}
+class ExtensionNotFoundError extends Error {
+  constructor(msg) {
+    super(msg || "No extensions found");
+  }
+}
+class ExpiredError extends Error {
+  constructor(msg) {
+    super(msg || "The challenge has expired");
+  }
+}
+exports.AccountCreationUnsupportedError = AccountCreationUnsupportedError;
+exports.AccountNotFoundError = AccountNotFoundError;
+exports.ExpiredError = ExpiredError;
+exports.ExtensionNotFoundError = ExtensionNotFoundError;
+exports.NoExtensionsFoundError = NoExtensionsFoundError;

package/dist/cjs/api/handlers.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class ProsopoApiError extends Error {
+  constructor(error, context, ...params) {
+    super(error ? error.message : "Unknown API Error");
+    this.name = context && `${ProsopoApiError.name}@${context}` || ProsopoApiError.name;
+    console.error("\n********************* ERROR *********************\n");
+    console.error(this.cause, this.stack, ...params);
+  }
+}
+exports.ProsopoApiError = ProsopoApiError;

package/dist/cjs/api/index.cjs

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

package/dist/cjs/datasets/dist/captcha/captcha.cjs

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+const util$1 = require("./util.cjs");
+const util$2 = require("@polkadot/util");
+const NO_SOLUTION_VALUE = "NO_SOLUTION";
+function parseCaptchaDataset(datasetJSON) {
+  try {
+    const result = types.DatasetSchema.parse(datasetJSON);
+    const result2 = {
+      format: result.format,
+      captchas: result.captchas.map((captcha) => {
+        return {
+          ...captcha,
+          solution: captcha.solution || [],
+          unlabelled: captcha.unlabelled || []
+        };
+      })
+    };
+    if (result.datasetId !== void 0)
+      result2.datasetId = result.datasetId;
+    if (result.contentTree !== void 0)
+      result2.contentTree = result.contentTree;
+    if (result.datasetContentId !== void 0)
+      result2.datasetContentId = result.datasetContentId;
+    if (result.solutionTree !== void 0)
+      result2.solutionTree = result.solutionTree;
+    return result2;
+  } catch (err) {
+    throw new common.ProsopoEnvError(err);
+  }
+}
+function parseAndSortCaptchaSolutions(captchaJSON) {
+  try {
+    return types.CaptchaSolutionArraySchema.parse(captchaJSON).map((captcha) => ({
+      ...captcha,
+      solution: captcha.solution.sort()
+    }));
+  } catch (err) {
+    throw new common.ProsopoEnvError(err);
+  }
+}
+function captchaSort(a, b) {
+  return a.captchaId.localeCompare(b.captchaId);
+}
+function sortAndComputeHashes(received, stored) {
+  received.sort(captchaSort);
+  stored.sort(captchaSort);
+  return stored.map(({ salt, items = [], target = "", captchaId, solved }, index) => {
+    const item = util.at(received, index);
+    if (captchaId != item.captchaId) {
+      throw new common.ProsopoEnvError("CAPTCHA.ID_MISMATCH");
+    }
+    return {
+      hash: computeCaptchaHash({
+        solution: solved ? item.solution : [],
+        salt,
+        items,
+        target
+      }, true, true, false),
+      captchaId
+    };
+  });
+}
+function compareCaptchaSolutions(received, stored) {
+  if (received.length && stored.length && received.length === stored.length) {
+    const hashes = sortAndComputeHashes(received, stored);
+    return hashes.every(({ hash, captchaId }) => hash === captchaId);
+  }
+  return false;
+}
+function computeCaptchaHash(captcha, includeSolution = false, includeSalt = false, sortItemHashes) {
+  try {
+    const itemHashes = captcha.items.map((item, index) => {
+      if (item.hash) {
+        return item.hash;
+      } else {
+        throw new common.ProsopoEnvError("CAPTCHA.MISSING_ITEM_HASH", computeCaptchaHash.name, void 0, index);
+      }
+    });
+    return common.hexHashArray([
+      captcha.target,
+      // empty array hashes as empty string, undefined solution results in the array [`NO_SOLUTION`]
+      // [undefined] also hashes as empty string, which is why we don't use it
+      ...includeSolution ? getSolutionValueToHash(captcha.solution) : [],
+      includeSalt ? captcha.salt : "",
+      sortItemHashes ? itemHashes.sort() : itemHashes
+    ]);
+  } catch (err) {
+    throw new common.ProsopoEnvError(err);
+  }
+}
+function getSolutionValueToHash(solution) {
+  return solution !== void 0 ? solution.sort() : [NO_SOLUTION_VALUE];
+}
+async function computeItemHash(item) {
+  if (item.type === "text") {
+    return { ...item, hash: common.hexHash(item.data) };
+  } else if (item.type === "image") {
+    return { ...item, hash: common.hexHash(await util$1.downloadImage(item.data)) };
+  } else {
+    throw new common.ProsopoEnvError("CAPTCHA.INVALID_ITEM_FORMAT");
+  }
+}
+function matchItemsToSolutions(solutions, items) {
+  return (solutions == null ? void 0 : solutions.map((solution) => {
+    var _a;
+    const index = parseInt(solution.toString());
+    const hash = items && items[index] && (((_a = items[index]) == null ? void 0 : _a.hash) || solution);
+    if (!hash) {
+      throw new common.ProsopoEnvError("CAPTCHA.MISSING_ITEM_HASH");
+    }
+    if (!util$2.isHex(hash)) {
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_ITEM_HASH");
+    }
+    return hash;
+  })) || [];
+}
+function computeCaptchaSolutionHash(captcha) {
+  return common.hexHashArray([captcha.captchaId, captcha.captchaContentId, [...captcha.solution].sort(), captcha.salt]);
+}
+function computePendingRequestHash(captchaIds, userAccount, salt) {
+  return common.hexHashArray([...captchaIds.sort(), userAccount, salt]);
+}
+function parseCaptchaAssets(item, assetsResolver) {
+  return { ...item, path: (assetsResolver == null ? void 0 : assetsResolver.resolveAsset(item.data).getURL()) || item.data };
+}
+exports.NO_SOLUTION_VALUE = NO_SOLUTION_VALUE;
+exports.captchaSort = captchaSort;
+exports.compareCaptchaSolutions = compareCaptchaSolutions;
+exports.computeCaptchaHash = computeCaptchaHash;
+exports.computeCaptchaSolutionHash = computeCaptchaSolutionHash;
+exports.computeItemHash = computeItemHash;
+exports.computePendingRequestHash = computePendingRequestHash;
+exports.getSolutionValueToHash = getSolutionValueToHash;
+exports.matchItemsToSolutions = matchItemsToSolutions;
+exports.parseAndSortCaptchaSolutions = parseAndSortCaptchaSolutions;
+exports.parseCaptchaAssets = parseCaptchaAssets;
+exports.parseCaptchaDataset = parseCaptchaDataset;
+exports.sortAndComputeHashes = sortAndComputeHashes;

package/dist/cjs/datasets/dist/captcha/dataset.cjs

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const merkle = require("./merkle.cjs");
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+const captcha = require("./captcha.cjs");
+const logger = common.getLogger(`Info`, `dataset.ts`);
+async function hashDatasetItems(datasetRaw) {
+  return datasetRaw.captchas.map(async (captcha$1) => {
+    const items = await Promise.all(captcha$1.items.map(async (item) => captcha.computeItemHash(item)));
+    return {
+      ...captcha$1,
+      items
+    };
+  });
+}
+async function validateDatasetContent(datasetOriginal) {
+  const captchaPromises = await hashDatasetItems(datasetOriginal);
+  const captchas = await Promise.all(captchaPromises);
+  const dataset = {
+    ...datasetOriginal,
+    captchas
+  };
+  const hashes = dataset.captchas.map((captcha2) => {
+    const captchaRaw = datasetOriginal.captchas.find((captchaRaw2) => "captchaId" in captchaRaw2 ? captchaRaw2.captchaId === captcha2.captchaId : false);
+    if (captchaRaw) {
+      return captcha2.items.every((item, index) => item.hash === util.at(captchaRaw.items, index).hash);
+    } else {
+      return false;
+    }
+  });
+  return hashes.every((hash) => hash);
+}
+async function buildDataset(datasetRaw) {
+  var _a, _b;
+  logger.info(`Adding solution hashes to dataset`);
+  const dataset = await addSolutionHashesToDataset(datasetRaw);
+  logger.info(`Building dataset merkle trees`);
+  const contentTree = await buildCaptchaTree(dataset, false, false, true);
+  const solutionTree = await buildCaptchaTree(dataset, true, true, false);
+  dataset.captchas = dataset.captchas.map((captcha2, index) => {
+    var _a2, _b2;
+    return {
+      ...captcha2,
+      captchaId: util.at(solutionTree.leaves, index).hash,
+      captchaContentId: util.at(contentTree.leaves, index).hash,
+      datasetId: (_a2 = solutionTree.root) == null ? void 0 : _a2.hash,
+      datasetContentId: (_b2 = contentTree.root) == null ? void 0 : _b2.hash
+    };
+  });
+  dataset.solutionTree = solutionTree.layers;
+  dataset.contentTree = contentTree.layers;
+  dataset.datasetId = (_a = solutionTree.root) == null ? void 0 : _a.hash;
+  dataset.datasetContentId = (_b = contentTree.root) == null ? void 0 : _b.hash;
+  return dataset;
+}
+async function buildCaptchaTree(dataset, includeSolution, includeSalt, sortItemHashes) {
+  try {
+    const tree = new merkle.CaptchaMerkleTree();
+    const datasetWithItemHashes = { ...dataset };
+    const captchaHashes = datasetWithItemHashes.captchas.map((captcha$1) => captcha.computeCaptchaHash(captcha$1, includeSolution, includeSalt, sortItemHashes));
+    tree.build(captchaHashes);
+    return tree;
+  } catch (err) {
+    throw new common.ProsopoEnvError("DATASET.HASH_ERROR");
+  }
+}
+async function addSolutionHashesToDataset(datasetRaw) {
+  const captchaPromises = datasetRaw.captchas.map(async (captcha$1) => {
+    return {
+      ...captcha$1,
+      items: captcha$1.items,
+      // some captcha challenges will not have a solution
+      ...captcha$1.solution !== void 0 && { solution: captcha.matchItemsToSolutions(captcha$1.solution, captcha$1.items) }
+    };
+  });
+  const captchas = await Promise.all(captchaPromises);
+  return {
+    ...datasetRaw,
+    captchas
+  };
+}
+exports.addSolutionHashesToDataset = addSolutionHashesToDataset;
+exports.buildCaptchaTree = buildCaptchaTree;
+exports.buildDataset = buildDataset;
+exports.hashDatasetItems = hashDatasetItems;
+exports.validateDatasetContent = validateDatasetContent;

package/dist/cjs/datasets/dist/captcha/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const captcha = require("./captcha.cjs");
+const merkle = require("./merkle.cjs");
+const util = require("./util.cjs");
+const dataset = require("./dataset.cjs");
+exports.NO_SOLUTION_VALUE = captcha.NO_SOLUTION_VALUE;
+exports.captchaSort = captcha.captchaSort;
+exports.compareCaptchaSolutions = captcha.compareCaptchaSolutions;
+exports.computeCaptchaHash = captcha.computeCaptchaHash;
+exports.computeCaptchaSolutionHash = captcha.computeCaptchaSolutionHash;
+exports.computeItemHash = captcha.computeItemHash;
+exports.computePendingRequestHash = captcha.computePendingRequestHash;
+exports.getSolutionValueToHash = captcha.getSolutionValueToHash;
+exports.matchItemsToSolutions = captcha.matchItemsToSolutions;
+exports.parseAndSortCaptchaSolutions = captcha.parseAndSortCaptchaSolutions;
+exports.parseCaptchaAssets = captcha.parseCaptchaAssets;
+exports.parseCaptchaDataset = captcha.parseCaptchaDataset;
+exports.sortAndComputeHashes = captcha.sortAndComputeHashes;
+exports.CaptchaMerkleTree = merkle.CaptchaMerkleTree;
+exports.verifyProof = merkle.verifyProof;
+exports.downloadImage = util.downloadImage;
+exports.addSolutionHashesToDataset = dataset.addSolutionHashesToDataset;
+exports.buildCaptchaTree = dataset.buildCaptchaTree;
+exports.buildDataset = dataset.buildDataset;
+exports.hashDatasetItems = dataset.hashDatasetItems;
+exports.validateDatasetContent = dataset.validateDatasetContent;

package/dist/cjs/datasets/dist/captcha/merkle.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("@prosopo/util");
+const common = require("@prosopo/common");
+class MerkleNode {
+  constructor(hash) {
+    this.hash = hash;
+    this.parent = null;
+  }
+}
+class CaptchaMerkleTree {
+  constructor() {
+    this.leaves = [];
+    this.layers = [];
+  }
+  build(leaves) {
+    if (this.layers.length) {
+      this.layers = [];
+    }
+    const layerZero = [];
+    for (const leaf of leaves) {
+      const node = new MerkleNode(leaf);
+      this.leaves.push(node);
+      layerZero.push(node.hash);
+    }
+    this.layers.push(layerZero);
+    this.root = this.buildMerkleTree(this.leaves)[0];
+  }
+  buildMerkleTree(leaves) {
+    const numLeaves = leaves.length;
+    if (numLeaves === 1) {
+      return leaves;
+    }
+    const parents = [];
+    let leafIndex = 0;
+    const newLayer = [];
+    while (leafIndex < numLeaves) {
+      const leftChild = leaves[leafIndex];
+      if (leftChild === void 0) {
+        throw new Error("leftChild undefined");
+      }
+      const rightChild = leafIndex + 1 < numLeaves ? util.at(leaves, leafIndex + 1) : leftChild;
+      const parentNode = this.createParent(leftChild, rightChild);
+      newLayer.push(parentNode.hash);
+      parents.push(parentNode);
+      leafIndex += 2;
+    }
+    this.layers.push(newLayer);
+    return this.buildMerkleTree(parents);
+  }
+  createParent(leftChild, rightChild) {
+    const parent = new MerkleNode(common.hexHashArray([leftChild.hash, rightChild.hash]));
+    leftChild.parent = parent.hash;
+    rightChild.parent = parent.hash;
+    return parent;
+  }
+  proof(leafHash) {
+    const proofTree = [];
+    let layerNum = 0;
+    while (layerNum < this.layers.length - 1) {
+      const layer = this.layers[layerNum];
+      if (layer === void 0) {
+        throw new Error("layer undefined");
+      }
+      const leafIndex = layer.indexOf(leafHash);
+      let partnerIndex = leafIndex % 2 && leafIndex > 0 ? leafIndex - 1 : leafIndex + 1;
+      if (partnerIndex > layer.length - 1) {
+        partnerIndex = leafIndex;
+      }
+      const pair = [leafHash];
+      const partner = util.at(layer, partnerIndex);
+      if (partnerIndex > leafIndex) {
+        pair.push(partner);
+      } else {
+        pair.unshift(partner);
+      }
+      proofTree.push([util.at(pair, 0), util.at(pair, 1)]);
+      layerNum += 1;
+      leafHash = common.hexHashArray(pair);
+    }
+    const last = util.at(this.layers, this.layers.length - 1);
+    return [...proofTree, [util.at(last, 0)]];
+  }
+}
+function verifyProof(leaf, proof) {
+  try {
+    if (util.at(proof, 0).indexOf(leaf) === -1) {
+      return false;
+    }
+    for (const [layerIndex, layer] of proof.entries()) {
+      leaf = common.hexHashArray(layer);
+      if (util.at(proof, layerIndex + 1).indexOf(leaf) === -1) {
+        return false;
+      }
+      const last = util.at(proof, proof.length - 1);
+      if (leaf === util.at(last, 0)) {
+        return true;
+      }
+    }
+    return false;
+  } catch (err) {
+    return false;
+  }
+}
+exports.CaptchaMerkleTree = CaptchaMerkleTree;
+exports.verifyProof = verifyProof;

package/dist/cjs/datasets/dist/captcha/util.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const client = require("axios");
+async function downloadImage(url) {
+  try {
+    return new Uint8Array((await client.get(url, { url, method: "GET", responseType: "arraybuffer" })).data);
+  } catch (error) {
+    throw new common.ProsopoEnvError(error);
+  }
+}
+exports.downloadImage = downloadImage;

package/dist/cjs/datasets/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+require("./captcha/index.cjs");

package/dist/cjs/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./api/index.cjs");
+require("./modules/index.cjs");
+require("./types/index.cjs");
+require("./utils/index.cjs");
+const HttpClientBase = require("./api/HttpClientBase.cjs");
+const Manager = require("./modules/Manager.cjs");
+const ProsopoCaptchaApi = require("./modules/ProsopoCaptchaApi.cjs");
+const manager = require("./types/manager.cjs");
+const utils = require("./utils/utils.cjs");
+exports.HttpClientBase = HttpClientBase.HttpClientBase;
+exports.Manager = Manager.Manager;
+exports.defaultState = Manager.defaultState;
+exports.getNetwork = Manager.getNetwork;
+exports.ProsopoCaptchaApi = ProsopoCaptchaApi.ProsopoCaptchaApi;
+exports.ProcapchaEventNames = manager.ProcapchaEventNames;
+exports.sleep = utils.sleep;