@prosopo/procaptcha 0.2.0 → 0.2.2

package/dist/cjs/modules/Manager.cjs

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../api/errors.cjs");
+const api$1 = require("@polkadot/api");
+const api = require("@prosopo/api");
+const contract = require("@prosopo/contract");
+const rpcProvider = require("@polkadot/rpc-provider");
+const util$1 = require("@prosopo/util");
+const utilCrypto = require("@polkadot/util-crypto");
+const utils = require("../utils/utils.cjs");
+const util = require("@polkadot/util");
+const common = require("@prosopo/common");
+const ExtensionWeb2 = require("../api/ExtensionWeb2.cjs");
+const ExtensionWeb3 = require("../api/ExtensionWeb3.cjs");
+const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
+const storage = require("./storage.cjs");
+const defaultState = () => {
+  return {
+    // note order matters! see buildUpdateState. These fields are set in order, so disable modal first, then set loading to false, etc.
+    showModal: false,
+    loading: false,
+    challenge: void 0,
+    solutions: [],
+    index: -1,
+    isHuman: false,
+    captchaApi: void 0,
+    account: void 0
+    // don't handle timeout here, this should be handled by the state management
+  };
+};
+const buildUpdateState = (state, onStateUpdate) => {
+  const updateCurrentState = (nextState) => {
+    Object.assign(state, nextState);
+    onStateUpdate(nextState);
+    console.log("Procaptcha state update:", nextState, "\nResult:", state);
+  };
+  return updateCurrentState;
+};
+const getNetwork = (config) => {
+  const network = config.networks[config.defaultEnvironment];
+  if (!network) {
+    throw new Error(`No network found for environment ${config.defaultEnvironment}`);
+  }
+  return network;
+};
+function Manager(configOptional, state, onStateUpdate, callbacks) {
+  const alertError = (error) => {
+    console.log(error);
+    alert(error.message);
+  };
+  const events = Object.assign(
+    {
+      onAccountNotFound: alertError,
+      onError: alertError,
+      onHuman: (output) => {
+        console.log("onHuman event triggered", output);
+      },
+      onExtensionNotFound: () => {
+        alert("No extension found");
+      },
+      onExpired: () => {
+        alert("Challenge has expired, please try again");
+      },
+      onFailed: () => {
+        alert("Captcha challenge failed. Please try again");
+      }
+    },
+    callbacks
+  );
+  const dispatchErrorEvent = (err) => {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (error instanceof errors.AccountNotFoundError) {
+      events.onAccountNotFound(error.message);
+    } else {
+      events.onError(error);
+    }
+  };
+  const updateState = buildUpdateState(state, onStateUpdate);
+  const getConfig = () => {
+    const config = {
+      userAccountAddress: "",
+      ...configOptional
+    };
+    if (state.account) {
+      config.userAccountAddress = state.account.account.address;
+    }
+    return config;
+  };
+  const fallable = async (fn) => {
+    try {
+      await fn();
+    } catch (err) {
+      console.error(err);
+      dispatchErrorEvent(err);
+      updateState({ isHuman: false, showModal: false, loading: false });
+    }
+  };
+  const start = async () => {
+    console.log("Starting procaptcha");
+    await fallable(async () => {
+      if (state.loading) {
+        console.log("Procaptcha already loading");
+        return;
+      }
+      if (state.isHuman) {
+        console.log("already human");
+        return;
+      }
+      resetState();
+      updateState({ loading: true });
+      const config = getConfig();
+      updateState({ dappAccount: config.account.address });
+      await utils.sleep(100);
+      const account = await loadAccount();
+      const contract$1 = await loadContract();
+      let contractIsHuman = false;
+      try {
+        contractIsHuman = (await contract$1.query.dappOperatorIsHumanUser(account.account.address, config.solutionThreshold)).value.unwrap().unwrap();
+      } catch (error) {
+        console.warn(error);
+      }
+      if (contractIsHuman) {
+        updateState({ isHuman: true, loading: false });
+        events.onHuman({
+          user: account.account.address,
+          dapp: config.account.address
+        });
+        return;
+      }
+      const providerUrlFromStorage = storage.getProviderUrl();
+      let providerApi;
+      if (providerUrlFromStorage) {
+        providerApi = await loadProviderApi(providerUrlFromStorage);
+        try {
+          const verifyDappUserResponse = await providerApi.verifyDappUser(account.account.address);
+          if (verifyDappUserResponse.solutionApproved) {
+            updateState({ isHuman: true, loading: false });
+            events.onHuman({
+              providerUrl: providerUrlFromStorage,
+              user: account.account.address,
+              dapp: config.account.address,
+              commitmentId: verifyDappUserResponse.commitmentId
+            });
+            return;
+          }
+        } catch (err) {
+          console.error("Error contacting provider from storage", providerUrlFromStorage);
+        }
+      }
+      const payload = {
+        address: account.account.address,
+        data: util.stringToU8a("message"),
+        type: "bytes"
+      };
+      const signed = await account.extension.signer.signRaw(payload);
+      console.log("Signature:", signed);
+      const getRandomProviderResponse = await contract.wrapQuery(
+        contract$1.query.getRandomActiveProvider,
+        contract$1.query
+      )(account.account.address, config.account.address);
+      const blockNumber = getRandomProviderResponse.blockNumber;
+      console.log("provider", getRandomProviderResponse);
+      const providerUrl = common.trimProviderUrl(getRandomProviderResponse.provider.url.toString());
+      providerApi = await loadProviderApi(providerUrl);
+      console.log("providerApi", providerApi);
+      const captchaApi = await loadCaptchaApi(contract$1, getRandomProviderResponse, providerApi);
+      console.log("captchaApi", captchaApi);
+      const challenge = await captchaApi.getCaptchaChallenge();
+      console.log("challenge", challenge);
+      if (challenge.captchas.length <= 0) {
+        throw new Error("No captchas returned from provider");
+      }
+      const timeMillis = challenge.captchas.map((captcha) => captcha.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b);
+      const timeout = setTimeout(() => {
+        console.log("challenge expired after " + timeMillis + "ms");
+        events.onExpired();
+        updateState({ isHuman: false, showModal: false, loading: false });
+      }, timeMillis);
+      updateState({
+        index: 0,
+        solutions: challenge.captchas.map(() => []),
+        challenge,
+        showModal: true,
+        timeout,
+        blockNumber
+      });
+    });
+  };
+  const submit = async () => {
+    await fallable(async () => {
+      console.log("submitting solutions");
+      clearTimeout();
+      if (!state.challenge) {
+        throw new Error("cannot submit, no challenge found");
+      }
+      updateState({ showModal: false });
+      const challenge = state.challenge;
+      const salt = utilCrypto.randomAsHex();
+      const captchaSolution = state.challenge.captchas.map((captcha, index) => {
+        const solution = util$1.at(state.solutions, index);
+        return {
+          captchaId: captcha.captcha.captchaId,
+          captchaContentId: captcha.captcha.captchaContentId,
+          salt,
+          solution
+        };
+      });
+      const account = getAccount();
+      const blockNumber = getBlockNumber();
+      const signer = account.extension.signer;
+      const first = util$1.at(challenge.captchas, 0);
+      if (!first.captcha.datasetId) {
+        throw new Error("No datasetId set for challenge");
+      }
+      const captchaApi = getCaptchaApi();
+      const submission = await captchaApi.submitCaptchaSolution(
+        signer,
+        challenge.requestHash,
+        first.captcha.datasetId,
+        captchaSolution,
+        salt
+      );
+      const isHuman = submission[0].solutionApproved;
+      if (!isHuman) {
+        events.onFailed();
+      }
+      updateState({
+        submission,
+        isHuman,
+        loading: false
+      });
+      if (state.isHuman) {
+        const trimmedUrl = common.trimProviderUrl(captchaApi.provider.provider.url.toString());
+        storage.setProviderUrl(trimmedUrl);
+        events.onHuman({
+          providerUrl: trimmedUrl,
+          user: account.account.address,
+          dapp: getDappAccount(),
+          commitmentId: submission[1],
+          blockNumber
+        });
+      }
+    });
+  };
+  const cancel = async () => {
+    console.log("cancel");
+    clearTimeout();
+    resetState();
+  };
+  const select = (hash) => {
+    if (!state.challenge) {
+      throw new Error("cannot select, no challenge found");
+    }
+    if (state.index >= state.challenge.captchas.length || state.index < 0) {
+      throw new Error("cannot select, round index out of range");
+    }
+    const index = state.index;
+    const solutions = state.solutions;
+    const solution = util$1.at(solutions, index);
+    if (solution.includes(hash)) {
+      console.log("deselecting", hash);
+      solution.splice(solution.indexOf(hash), 1);
+    } else {
+      console.log("selecting", hash);
+      solution.push(hash);
+    }
+    updateState({ solutions });
+  };
+  const nextRound = () => {
+    if (!state.challenge) {
+      throw new Error("cannot proceed to next round, no challenge found");
+    }
+    if (state.index + 1 >= state.challenge.captchas.length) {
+      throw new Error("cannot proceed to next round, already at last round");
+    }
+    console.log("proceeding to next round");
+    updateState({ index: state.index + 1 });
+  };
+  const loadCaptchaApi = async (contract2, provider, providerApi) => {
+    const config = getConfig();
+    const captchaApi = new ProsopoCaptchaApi.ProsopoCaptchaApi(
+      getAccount().account.address,
+      contract2,
+      provider,
+      providerApi,
+      config.web2,
+      config.account.address
+    );
+    updateState({ captchaApi });
+    return getCaptchaApi();
+  };
+  const loadProviderApi = async (providerUrl) => {
+    const config = getConfig();
+    const network = getNetwork(config);
+    return new api.ProviderApi(network, providerUrl, config.account.address);
+  };
+  const clearTimeout = () => {
+    window.clearTimeout(state.timeout);
+    updateState({ timeout: void 0 });
+  };
+  const resetState = () => {
+    clearTimeout();
+    updateState(defaultState());
+  };
+  const getCaptchaApi = () => {
+    if (!state.captchaApi) {
+      throw new Error("Captcha api not set");
+    }
+    return state.captchaApi;
+  };
+  const loadAccount = async () => {
+    const config = getConfig();
+    if (!config.web2 && !config.userAccountAddress) {
+      throw new Error("Account address has not been set for web3 mode");
+    }
+    const ext = config.web2 ? new ExtensionWeb2() : new ExtensionWeb3();
+    const account = await ext.getAccount(config);
+    storage.setAccount(account.account.address);
+    console.log("Using account:", account);
+    updateState({ account });
+    return getAccount();
+  };
+  const getAccount = () => {
+    if (!state.account) {
+      throw new Error("Account not loaded");
+    }
+    const account = state.account;
+    return account;
+  };
+  const getDappAccount = () => {
+    if (!state.dappAccount) {
+      throw new Error("Dapp account not loaded");
+    }
+    const dappAccount = state.dappAccount;
+    return dappAccount;
+  };
+  const getBlockNumber = () => {
+    if (!state.blockNumber) {
+      throw new Error("Account not loaded");
+    }
+    const blockNumber = state.blockNumber;
+    return blockNumber;
+  };
+  const loadContract = async () => {
+    const config = getConfig();
+    const network = getNetwork(config);
+    const api2 = await api$1.ApiPromise.create({ provider: new rpcProvider.WsProvider(network.endpoint) });
+    const type = "sr25519";
+    const keyring = new api$1.Keyring({ type, ss58Format: api2.registry.chainSS58 });
+    return new contract.ProsopoCaptchaContract(
+      api2,
+      contract.abiJson,
+      network.contract.address,
+      keyring.addFromAddress(getAccount().account.address),
+      "prosopo",
+      0
+    );
+  };
+  return {
+    start,
+    cancel,
+    submit,
+    select,
+    nextRound
+  };
+}
+exports.Manager = Manager;
+exports.defaultState = defaultState;
+exports.getNetwork = getNetwork;

package/dist/cjs/modules/ProsopoCaptchaApi.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("../datasets/dist/index.cjs");
+const handlers = require("../api/handlers.cjs");
+const common = require("@prosopo/common");
+const util = require("@prosopo/util");
+const util$1 = require("@polkadot/util");
+const merkle = require("../datasets/dist/captcha/merkle.cjs");
+const captcha = require("../datasets/dist/captcha/captcha.cjs");
+class ProsopoCaptchaApi {
+  constructor(userAccount, contract, provider, providerApi, web2, dappAccount) {
+    this.userAccount = userAccount;
+    this.contract = contract;
+    this.provider = provider;
+    this.providerApi = providerApi;
+    this.web2 = web2;
+    this.dappAccount = dappAccount;
+  }
+  async getCaptchaChallenge() {
+    try {
+      const captchaChallenge = await this.providerApi.getCaptchaChallenge(this.userAccount, this.provider);
+      this.verifyCaptchaChallengeContent(this.provider, captchaChallenge);
+      return captchaChallenge;
+    } catch (e) {
+      throw new common.ProsopoEnvError(e);
+    }
+  }
+  verifyCaptchaChallengeContent(provider, captchaChallenge) {
+    const first = util.at(captchaChallenge.captchas, 0);
+    const proofLength = first.proof.length;
+    console.log(provider.provider);
+    const last = util.at(first.proof, proofLength - 1);
+    if (provider.provider.datasetIdContent.toString() !== util.at(last, 0)) {
+      throw new common.ProsopoEnvError("CAPTCHA.INVALID_DATASET_CONTENT_ID");
+    }
+    for (const captchaWithProof of captchaChallenge.captchas) {
+      if (!verifyCaptchaData(captchaWithProof)) {
+        throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
+      }
+      if (!merkle.verifyProof(captchaWithProof.captcha.captchaContentId, captchaWithProof.proof)) {
+        throw new common.ProsopoEnvError("CAPTCHA.INVALID_CAPTCHA_CHALLENGE");
+      }
+    }
+    console.log("CAPTCHA.CHALLENGE_VERIFIED");
+    return;
+  }
+  async submitCaptchaSolution(signer, requestHash, datasetId, solutions, salt) {
+    const tree = new merkle.CaptchaMerkleTree();
+    const captchasHashed = solutions.map((captcha$1) => captcha.computeCaptchaSolutionHash(captcha$1));
+    tree.build(captchasHashed);
+    const commitmentId = tree.root.hash;
+    console.log("solveCaptchaChallenge commitmentId", commitmentId);
+    const tx = void 0;
+    let signature = void 0;
+    if (this.web2) {
+      if (!signer || !signer.signRaw) {
+        throw new Error("Signer is not defined, cannot sign message to prove account ownership");
+      }
+      const signed = await signer.signRaw({
+        address: this.userAccount,
+        data: util$1.stringToHex(requestHash),
+        type: "bytes"
+      });
+      signature = signed.signature;
+    }
+    let result;
+    try {
+      result = await this.providerApi.submitCaptchaSolution(
+        solutions,
+        requestHash,
+        this.contract.pair.address,
+        salt,
+        signature
+      );
+    } catch (err) {
+      throw new handlers.ProsopoApiError(err);
+    }
+    return [result, commitmentId, tx];
+  }
+}
+async function verifyCaptchaData(captchaWithProof) {
+  const captcha$1 = captchaWithProof.captcha;
+  const proof = captchaWithProof.proof;
+  if (!(await Promise.all(captcha$1.items.map(async (item) => (await captcha.computeItemHash(item)).hash === item.hash))).every(
+    (hash) => hash === true
+  )) {
+    return false;
+  }
+  const captchaHash = captcha.computeCaptchaHash(captcha$1, false, false, false);
+  if (captchaHash !== captcha$1.captchaContentId) {
+    return false;
+  }
+  return util.at(proof, 0).indexOf(captchaHash) !== -1;
+}
+exports.ProsopoCaptchaApi = ProsopoCaptchaApi;
+exports.default = ProsopoCaptchaApi;