@prosopo/procaptcha 0.2.11 → 0.2.13

package/dist/cjs/index.cjs

@@ -4,12 +4,10 @@ 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;

package/dist/cjs/modules/Manager.cjs

@@ -1,43 +1,34 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const errors = require("../api/errors.cjs");
-const api$1 = require("@polkadot/api");
+const api = require("@polkadot/api");
 const types = require("@prosopo/types");
-const api = require("@prosopo/api");
+const rxjs = require("rxjs");
 const contract = require("@prosopo/contract");
 const common = require("@prosopo/common");
+const api$1 = require("@prosopo/api");
 require("../contracts/captcha/dist/index.cjs");
-const rpcProvider = require("@polkadot/rpc-provider");
-const util$1 = require("@prosopo/util");
+const util = require("@prosopo/util");
 const utilCrypto = require("@polkadot/util-crypto");
-const utils = require("../utils/utils.cjs");
-const util = require("@polkadot/util");
+const operators = require("rxjs/operators");
 const ExtensionWeb2 = require("../api/ExtensionWeb2.cjs");
 const ExtensionWeb3 = require("../api/ExtensionWeb3.cjs");
 const ProsopoCaptchaApi = require("./ProsopoCaptchaApi.cjs");
 const storage = require("./storage.cjs");
 const captcha = require("../contracts/captcha/dist/contract-info/captcha.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,
-    index: 0,
-    challenge: void 0,
-    solutions: void 0,
-    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 defaultState = () => ({
+  showModal: false,
+  loading: false,
+  index: 0,
+  challenge: void 0,
+  solutions: void 0,
+  isHuman: false,
+  captchaApi: void 0,
+  account: void 0
+});
+const buildUpdateState = (state, onStateUpdate) => (nextState) => {
+  Object.assign(state, nextState);
+  onStateUpdate(nextState);
 };
 const getNetwork = (config) => {
   const network = config.networks[config.defaultNetwork];
@@ -48,7 +39,7 @@ const getNetwork = (config) => {
 };
 function Manager(configOptional, state, onStateUpdate, callbacks) {
   const alertError = (error) => {
-    console.log(error);
+    console.error(error);
     alert(error.message);
   };
   const events = Object.assign(
@@ -56,7 +47,7 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
       onAccountNotFound: alertError,
       onError: alertError,
       onHuman: (output) => {
-        console.log("onHuman event triggered", output);
+        console.info("onHuman event triggered", output);
       },
       onExtensionNotFound: () => {
         alert("No extension found");
@@ -71,10 +62,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         alert("Uncompleted challenge has expired, please try again");
       },
       onOpen: () => {
-        console.log("onOpen event triggered");
+        console.info("onOpen event triggered");
       },
       onClose: () => {
-        console.log("onClose event triggered");
+        console.info("onClose event triggered");
       }
     },
     callbacks
@@ -88,16 +79,10 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const updateState = buildUpdateState(state, onStateUpdate);
-  const getConfig = () => {
-    const config = {
-      userAccountAddress: "",
-      ...configOptional
-    };
-    if (state.account) {
-      config.userAccountAddress = state.account.account.address;
-    }
-    return types.ProcaptchaConfigSchema.parse(config);
-  };
+  const getConfig = () => types.ProcaptchaConfigSchema.parse({
+    ...configOptional,
+    userAccountAddress: state.account ? state.account.account.address : configOptional.userAccountAddress || ""
+  });
   const fallable = async (fn) => {
     try {
       await fn();
@@ -108,131 +93,59 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
   };
   const start = async () => {
-    console.log("Starting procaptcha");
     events.onOpen();
     await fallable(async () => {
-      if (state.loading) {
-        console.log("Procaptcha already loading");
-        return;
-      }
-      if (state.isHuman) {
-        console.log("already human");
+      if (state.loading || state.isHuman)
         return;
-      }
       resetState();
-      updateState({ loading: true });
-      const config = getConfig();
-      updateState({ dappAccount: config.account.address });
-      await utils.sleep(100);
+      updateState({ dappAccount: getConfig().account.address, loading: true });
       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: getDappAccount()
-        });
-        setValidChallengeTimeout();
+      const contract2 = await loadContract();
+      if (await checkHumanInContract(contract2, account)) {
+        handleHumanInContract(account);
         return;
       }
       const providerUrlFromStorage = storage.getProviderUrl();
-      let providerApi;
       if (providerUrlFromStorage) {
-        providerApi = await loadProviderApi(providerUrlFromStorage);
         try {
-          const verifyDappUserResponse = await providerApi.verifyDappUser(account.account.address);
+          const verifyDappUserResponse = await getVerifyDappUserFunction(providerUrlFromStorage, account);
           if (verifyDappUserResponse.solutionApproved) {
-            updateState({ isHuman: true, loading: false });
-            events.onHuman({
-              providerUrl: providerUrlFromStorage,
-              user: account.account.address,
-              dapp: getDappAccount(),
-              commitmentId: verifyDappUserResponse.commitmentId
-            });
-            setValidChallengeTimeout();
+            handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse);
             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, getDappAccount());
-      const blockNumber = parseInt(getRandomProviderResponse.blockNumber.toString());
-      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);
+      const randomProviderResponse = await getRandomProviderResponse(contract2, account);
+      const challenge = await getChallenge(randomProviderResponse, contract2);
       if (challenge.captchas.length <= 0) {
         throw new Error("No captchas returned from provider");
       }
-      const timeMillis = challenge.captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b);
-      const timeout = setTimeout(() => {
-        console.log("challenge expired after " + timeMillis + "ms");
-        events.onChallengeExpired();
-        updateState({ isHuman: false, showModal: false, loading: false });
-      }, timeMillis);
       updateState({
+        challenge,
         index: 0,
         solutions: challenge.captchas.map(() => []),
-        challenge,
         showModal: true,
-        timeout,
-        blockNumber
+        timeout: setTimeToComplete(challenge),
+        blockNumber: getBlockNumberFromProvider(randomProviderResponse)
       });
     });
   };
   const submit = async () => {
     await fallable(async () => {
-      console.log("submitting solutions");
       clearTimeout();
+      updateState({ showModal: false });
       if (!state.challenge) {
         throw new Error("cannot submit, no challenge found");
       }
-      updateState({ showModal: false });
-      const challenge = state.challenge;
+      const datasetId = getDatasetId();
       const salt = utilCrypto.randomAsHex();
-      const captchaSolution = state.challenge.captchas.map((captcha2, index) => {
-        const solution = util$1.at(state.solutions, index);
-        return {
-          captchaId: captcha2.captcha.captchaId,
-          captchaContentId: captcha2.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,
+      const submission = await getCaptchaApi().submitCaptchaSolution(
+        getAccount().extension.signer,
+        state.challenge.requestHash,
+        datasetId,
+        getSolutionsFromState(salt),
         salt
       );
       const isHuman = submission[0].solutionApproved;
@@ -244,26 +157,20 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
         isHuman,
         loading: false
       });
-      if (state.isHuman) {
-        const trimmedUrl = common.trimProviderUrl(captchaApi.provider.provider.url.toString());
+      if (isHuman) {
+        const trimmedUrl = common.trimProviderUrl(getCaptchaApi().provider.provider.url.toString());
         storage.setProviderUrl(trimmedUrl);
         events.onHuman({
           providerUrl: trimmedUrl,
-          user: account.account.address,
+          user: getAccount().account.address,
           dapp: getDappAccount(),
           commitmentId: submission[1],
-          blockNumber
+          blockNumber: getBlockNumberFromState()
         });
         setValidChallengeTimeout();
       }
     });
   };
-  const cancel = async () => {
-    console.log("cancel");
-    clearTimeout();
-    resetState();
-    events.onClose();
-  };
   const select = (hash) => {
     if (!state.challenge) {
       throw new Error("cannot select, no challenge found");
@@ -271,17 +178,9 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     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 solution = util.at(state.solutions, state.index);
+    handleIsSelected(solution, hash);
+    updateState({ solutions: state.solutions });
   };
   const nextRound = () => {
     if (!state.challenge) {
@@ -290,44 +189,161 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     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,
-      getDappAccount()
-    );
-    updateState({ captchaApi });
+    updateState({
+      captchaApi: new ProsopoCaptchaApi.ProsopoCaptchaApi(
+        getAccount().account.address,
+        contract2,
+        provider,
+        providerApi,
+        getConfig().web2,
+        getDappAccount()
+      )
+    });
     return getCaptchaApi();
   };
+  const createBlockObservable = () => new rxjs.Observable(
+    (subscriber) => () => api.ApiPromise.create({ provider: new api.WsProvider(getNetwork(getConfig()).endpoint) }).then((api2) => {
+      api2.rpc.chain.subscribeNewHeads((header) => {
+        subscriber.next(header);
+      });
+    }).catch((error) => {
+      subscriber.error(error);
+    })
+  );
+  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);
+    updateState({ account });
+    return getAccount();
+  };
   const loadProviderApi = async (providerUrl) => {
     const config = getConfig();
-    const network = getNetwork(config);
     if (!config.account.address) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    return new api.ProviderApi(network, providerUrl, config.account.address);
+    return new api$1.ProviderApi(getNetwork(config), providerUrl, config.account.address);
+  };
+  const loadContract = async () => {
+    const network = getNetwork(getConfig());
+    const api$12 = await api.ApiPromise.create({ provider: new api.WsProvider(network.endpoint) });
+    const type = "sr25519";
+    return new contract.ProsopoCaptchaContract(
+      api$12,
+      JSON.parse(captcha.ContractAbi),
+      network.contract.address,
+      "prosopo",
+      0,
+      new api.Keyring({ type, ss58Format: api$12.registry.chainSS58 }).addFromAddress(getAccount().account.address)
+    );
+  };
+  function handleIsSelected(solution, hash) {
+    if (solution.includes(hash)) {
+      solution.splice(solution.indexOf(hash), 1);
+    } else {
+      solution.push(hash);
+    }
+  }
+  function getSolutionsFromState(salt) {
+    if (!state.challenge) {
+      throw new Error("cannot get solutions, no challenge found");
+    }
+    return state.challenge.captchas.map((captcha2, index) => ({
+      captchaId: captcha2.captcha.captchaId,
+      captchaContentId: captcha2.captcha.captchaContentId,
+      salt,
+      solution: util.at(state.solutions, index)
+    }));
+  }
+  function handleHumanInCachedProvider(providerUrlFromStorage, account, verifyDappUserResponse) {
+    updateState({ isHuman: true, loading: false });
+    events.onHuman({
+      providerUrl: providerUrlFromStorage,
+      user: account.account.address,
+      dapp: getDappAccount(),
+      commitmentId: verifyDappUserResponse.commitmentId
+    });
+    setValidChallengeTimeout();
+  }
+  function getVerifyDappUserFunction(providerUrlFromStorage, account) {
+    return loadProviderApi(providerUrlFromStorage).then(
+      (providerApi) => providerApi.verifyDappUser(account.account.address)
+    );
+  }
+  function handleHumanInContract(account) {
+    updateState({ isHuman: true, loading: false });
+    events.onHuman({
+      user: account.account.address,
+      dapp: getDappAccount()
+    });
+    setValidChallengeTimeout();
+  }
+  async function checkHumanInContract(contract2, account) {
+    try {
+      return await contract2.query.dappOperatorIsHumanUser(account.account.address, getConfig().solutionThreshold).then((res) => res.value.unwrap().unwrap());
+    } catch (err) {
+      console.error(err);
+      return false;
+    }
+  }
+  function getChallenge(getRandomProviderResponse2, contract2) {
+    return loadProviderApi(common.trimProviderUrl(getRandomProviderResponse2.provider.url.toString())).then((api2) => loadCaptchaApi(contract2, getRandomProviderResponse2, api2)).then((captchaApi) => captchaApi.getCaptchaChallenge());
+  }
+  function getRandomProviderResponse(contract$1, account) {
+    return rxjs.lastValueFrom(
+      rxjs.from(
+        contract.wrapQuery(contract$1.query.getRandomActiveProvider, contract$1.query)(
+          account.account.address,
+          getDappAccount()
+        )
+      ).pipe(
+        operators.retry({
+          count: 3,
+          delay: (error, retryCount) => {
+            console.error(`Attempt ${retryCount} failed. Retrying on next block. Error: ${error}`);
+            return createBlockObservable().pipe(operators.take(1));
+          },
+          resetOnSuccess: true
+        })
+      )
+    );
+  }
+  function setTimeToComplete(challenge) {
+    return setTimeout(
+      () => {
+        events.onChallengeExpired();
+        updateState({ isHuman: false, showModal: false, loading: false });
+      },
+      challenge.captchas.map((captcha2) => captcha2.captcha.timeLimitMs || 30 * 1e3).reduce((a, b) => a + b)
+    );
+  }
+  const setValidChallengeTimeout = () => {
+    updateState({
+      successfullChallengeTimeout: setTimeout(
+        () => {
+          updateState({ isHuman: false });
+          events.onExpired();
+        },
+        configOptional.challengeValidLength || 120 * 1e3
+      )
+    });
+  };
+  const cancel = async () => {
+    clearTimeout();
+    resetState();
+    events.onClose();
   };
   const clearTimeout = () => {
     window.clearTimeout(state.timeout);
     updateState({ timeout: void 0 });
   };
-  const setValidChallengeTimeout = () => {
-    console.log("setting valid challenge timeout");
-    const timeMillis = configOptional.challengeValidLength || 120 * 1e3;
-    const successfullChallengeTimeout = setTimeout(() => {
-      console.log("valid challenge expired after " + timeMillis + "ms");
-      updateState({ isHuman: false });
-      events.onExpired();
-    }, timeMillis);
-    updateState({ successfullChallengeTimeout });
-  };
   const resetState = () => {
     clearTimeout();
     updateState(defaultState());
@@ -338,54 +354,37 @@ function Manager(configOptional, state, onStateUpdate, callbacks) {
     }
     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;
+    return state.account;
   };
   const getDappAccount = () => {
     if (!state.dappAccount) {
       throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
     }
-    const dappAccount = state.dappAccount;
-    return dappAccount;
+    return state.dappAccount;
   };
-  const getBlockNumber = () => {
+  const getBlockNumberFromState = () => {
     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,
-      JSON.parse(captcha.ContractAbi),
-      network.contract.address,
-      "prosopo",
-      0,
-      keyring.addFromAddress(getAccount().account.address)
-    );
+    return state.blockNumber;
   };
+  function getBlockNumberFromProvider(getRandomProviderResponse2) {
+    return parseInt(getRandomProviderResponse2.blockNumber.toString());
+  }
+  function getDatasetId() {
+    if (!state.challenge) {
+      throw new Error("cannot get datasetId, no challenge found");
+    }
+    const datasetId = util.at(state.challenge.captchas, 0).captcha.datasetId;
+    if (!datasetId) {
+      throw new Error("No datasetId set for challenge");
+    }
+    return datasetId;
+  }
   return {
     start,
     cancel,

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

@@ -1,10 +1,14 @@
 "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);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Network response was not ok, status: ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
   } catch (error) {
     throw new common.ProsopoEnvError(error);
   }

package/dist/modules/Manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAGH,4BAA4B,EAE/B,MAAM,gBAAgB,CAAA;AAiBvB,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CAatD,CAAA;AAgBD,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAED;;GAEG;AACH,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAmTR,MAAM;;EA+K/B"}
+{"version":3,"file":"Manager.d.ts","sourceRoot":"","sources":["../../src/modules/Manager.ts"],"names":[],"mappings":"AAaA,OAAO,EAEH,mBAAmB,EACnB,wBAAwB,EAExB,eAAe,EACf,uBAAuB,EAC1B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAmB,4BAA4B,EAA0B,MAAM,gBAAgB,CAAA;AAetG,eAAO,MAAM,YAAY,QAAO,QAAQ,eAAe,CASrD,CAAA;AAQF,eAAO,MAAM,UAAU,WAAY,4BAA4B;;;;;;;;CAM9D,CAAA;AAED;;GAEG;AACH,wBAAgB,OAAO,CACnB,cAAc,EAAE,wBAAwB,EACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,uBAAuB,EACtC,SAAS,EAAE,mBAAmB;;;;mBAqLR,MAAM;;EA4V/B"}