@prosopo/procaptcha-pow 2.5.5 → 2.6.2

package/CHANGELOG.md

@@ -0,0 +1,43 @@
+# @prosopo/procaptcha-pow
+
+## 2.6.2
+
+### Patch Changes
+
+- 6ff193a: Change settings type
+- Updated dependencies [6ff193a]
+  - @prosopo/procaptcha-common@2.6.2
+  - @prosopo/types@2.6.2
+  - @prosopo/procaptcha@2.6.2
+  - @prosopo/account@2.6.2
+  - @prosopo/api@2.6.2
+
+## 2.6.1
+
+### Patch Changes
+
+- Updated dependencies [52feffc]
+  - @prosopo/types@2.6.1
+  - @prosopo/procaptcha@2.6.1
+  - @prosopo/account@2.6.1
+  - @prosopo/api@2.6.1
+  - @prosopo/procaptcha-common@2.6.1
+
+## 2.6.0
+
+### Minor Changes
+
+- a0bfc8a: bump all pkg versions since independent versioning applied
+
+### Patch Changes
+
+- Updated dependencies [a0bfc8a]
+  - @prosopo/account@2.6.0
+  - @prosopo/api@2.6.0
+  - @prosopo/common@2.6.0
+  - @prosopo/locale@2.6.0
+  - @prosopo/procaptcha@2.6.0
+  - @prosopo/procaptcha-common@2.6.0
+  - @prosopo/types@2.6.0
+  - @prosopo/util@2.6.0
+  - @prosopo/widget-skeleton@2.6.0

package/dist/cjs/components/ProcaptchaPoW.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const react = require("react");
+const _interopNamespaceDefaultOnly = (e) => Object.freeze(Object.defineProperty({ __proto__: null, default: e }, Symbol.toStringTag, { value: "Module" }));
+const ProcaptchaWidget = react.lazy(
+  async () => Promise.resolve().then(() => /* @__PURE__ */ _interopNamespaceDefaultOnly(require("./ProcaptchaWidget.cjs")))
+);
+const ProcaptchaPow = (props) => /* @__PURE__ */ jsxRuntime.jsx(react.Suspense, { children: /* @__PURE__ */ jsxRuntime.jsx(
+  ProcaptchaWidget,
+  {
+    config: props.config,
+    callbacks: props.callbacks,
+    frictionlessState: props.frictionlessState,
+    i18n: props.i18n
+  }
+) });
+exports.ProcaptchaPow = ProcaptchaPow;

package/dist/cjs/components/ProcaptchaWidget.cjs

@@ -0,0 +1,90 @@
+"use strict";
+const jsxRuntime = require("@emotion/react/jsx-runtime");
+const locale = require("@prosopo/locale");
+const procaptchaCommon = require("@prosopo/procaptcha-common");
+const types = require("@prosopo/types");
+const widgetSkeleton = require("@prosopo/widget-skeleton");
+const react = require("react");
+const Manager = require("../services/Manager.cjs");
+const PROCAPTCHA_EXECUTE_EVENT = "procaptcha:execute";
+const Procaptcha = (props) => {
+  const { t } = locale.useTranslation();
+  const config = props.config;
+  const i18n = props.i18n;
+  const theme = "light" === config.theme ? widgetSkeleton.lightTheme : widgetSkeleton.darkTheme;
+  const frictionlessState = props.frictionlessState;
+  const callbacks = props.callbacks || {};
+  const [state, _updateState] = procaptchaCommon.useProcaptcha(react.useState, react.useRef);
+  const [loading, setLoading] = react.useState(false);
+  const updateState = procaptchaCommon.buildUpdateState(state, _updateState);
+  const manager = react.useRef(
+    Manager.Manager(config, state, updateState, callbacks, frictionlessState)
+  );
+  react.useEffect(() => {
+    if (config.language) {
+      if (i18n) {
+        if (i18n.language !== config.language) {
+          i18n.changeLanguage(config.language).then((r) => r);
+        }
+      } else {
+        locale.loadI18next(false).then((i18n2) => {
+          if (i18n2.language !== config.language)
+            i18n2.changeLanguage(config.language).then((r) => r);
+        });
+      }
+    }
+  }, [i18n, config.language]);
+  react.useEffect(() => {
+    if (state.error) {
+      setLoading(false);
+      if (state.error.key === "CAPTCHA.NO_SESSION_FOUND" && frictionlessState) {
+        setTimeout(() => {
+          frictionlessState.restart();
+        }, 3e3);
+      }
+    }
+  }, [state.error, frictionlessState]);
+  react.useEffect(() => {
+    if (config.mode === types.ModeEnum.invisible) {
+      const handleExecuteEvent = (event) => {
+        try {
+          manager.current.start();
+        } catch (error) {
+          console.error("Error starting PoW verification:", error);
+        }
+      };
+      document.addEventListener(PROCAPTCHA_EXECUTE_EVENT, handleExecuteEvent);
+      return () => {
+        document.removeEventListener(
+          PROCAPTCHA_EXECUTE_EVENT,
+          handleExecuteEvent
+        );
+      };
+    }
+    return () => {
+    };
+  }, [config.mode]);
+  if (config.mode === types.ModeEnum.invisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    procaptchaCommon.Checkbox,
+    {
+      checked: state.isHuman,
+      onChange: async () => {
+        if (loading) {
+          return;
+        }
+        setLoading(true);
+        await manager.current.start();
+        setLoading(false);
+      },
+      theme,
+      labelText: t("WIDGET.I_AM_HUMAN"),
+      error: state.error?.message,
+      "aria-label": "human checkbox",
+      loading
+    }
+  );
+};
+module.exports = Procaptcha;

package/dist/cjs/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./components/ProcaptchaWidget.cjs");
+const ProcaptchaPoW = require("./components/ProcaptchaPoW.cjs");
+exports.ProcaptchaPow = ProcaptchaPoW.ProcaptchaPow;

package/dist/cjs/services/Manager.cjs

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string = require("@polkadot/util/string");
+const api = require("@prosopo/api");
+const common = require("@prosopo/common");
+const procaptchaCommon = require("@prosopo/procaptcha-common");
+const types = require("@prosopo/types");
+const util = require("@prosopo/util");
+const Manager = (configInput, state, onStateUpdate, callbacks, frictionlessState) => {
+  const events = procaptchaCommon.getDefaultEvents(callbacks);
+  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 clearTimeout = () => {
+    window.clearTimeout(Number(state.timeout));
+    updateState({ timeout: void 0 });
+  };
+  const onFailed = () => {
+    updateState({
+      isHuman: false,
+      loading: false
+    });
+    events.onFailed();
+    resetState(frictionlessState?.restart);
+  };
+  const clearSuccessfulChallengeTimeout = () => {
+    window.clearTimeout(Number(state.successfullChallengeTimeout));
+    updateState({ successfullChallengeTimeout: void 0 });
+  };
+  const getConfig = () => {
+    const config = {
+      userAccountAddress: "",
+      ...configInput
+    };
+    if (state.account) {
+      config.userAccountAddress = state.account.account.address;
+    }
+    return types.ProcaptchaConfigSchema.parse(config);
+  };
+  const getAccount = () => {
+    if (!state.account) {
+      throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
+        context: { error: "Account not loaded" }
+      });
+    }
+    const account = state.account;
+    return { account };
+  };
+  const getDappAccount = () => {
+    if (!state.dappAccount) {
+      throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
+    }
+    const dappAccount = state.dappAccount;
+    return dappAccount;
+  };
+  const updateState = procaptchaCommon.buildUpdateState(state, onStateUpdate);
+  const resetState = (frictionlessRestart) => {
+    clearTimeout();
+    clearSuccessfulChallengeTimeout();
+    updateState(defaultState());
+    events.onReset();
+    if (frictionlessRestart) {
+      frictionlessRestart();
+    }
+  };
+  const setValidChallengeTimeout = () => {
+    const timeMillis = getConfig().captchas.pow.solutionTimeout;
+    const successfullChallengeTimeout = setTimeout(() => {
+      updateState({ isHuman: false });
+      events.onExpired();
+      resetState(frictionlessState?.restart);
+    }, timeMillis);
+    updateState({ successfullChallengeTimeout });
+  };
+  const start = async () => {
+    await procaptchaCommon.providerRetry(
+      async () => {
+        if (state.loading) {
+          return;
+        }
+        if (state.isHuman) {
+          return;
+        }
+        resetState();
+        updateState({
+          loading: true
+        });
+        updateState({ attemptCount: state.attemptCount + 1 });
+        const config = getConfig();
+        const selectAccount = async () => {
+          if (frictionlessState) {
+            return frictionlessState.userAccount;
+          }
+          const ext = new (await procaptchaCommon.ExtensionLoader(config.web2))();
+          return ext.getAccount(config);
+        };
+        const user = await selectAccount();
+        const userAccount = user.account.address;
+        updateState({
+          account: { account: { address: userAccount } }
+        });
+        updateState({ dappAccount: config.account.address });
+        await util.sleep(100);
+        if (!config.web2 && !config.userAccountAddress) {
+          throw new common.ProsopoEnvError("GENERAL.ACCOUNT_NOT_FOUND", {
+            context: {
+              error: "Account address has not been set for web3 mode"
+            }
+          });
+        }
+        let getRandomProviderResponse = void 0;
+        if (frictionlessState?.provider) {
+          getRandomProviderResponse = frictionlessState.provider;
+        } else {
+          getRandomProviderResponse = await procaptchaCommon.getRandomActiveProvider(
+            getConfig()
+          );
+        }
+        const providerUrl = getRandomProviderResponse.provider.url;
+        const providerApi = new api.ProviderApi(providerUrl, getDappAccount());
+        const challenge = await providerApi.getPowCaptchaChallenge(
+          userAccount,
+          getDappAccount(),
+          frictionlessState?.sessionId
+        );
+        if (challenge.error) {
+          updateState({
+            loading: false,
+            error: {
+              message: challenge.error.message,
+              key: challenge.error.key || "API.UNKNOWN_ERROR"
+            }
+          });
+        } else {
+          const solution = util.solvePoW(challenge.challenge, challenge.difficulty);
+          const signer = user.extension?.signer;
+          if (!signer || !signer.signRaw) {
+            throw new common.ProsopoEnvError("GENERAL.CANT_FIND_KEYRINGPAIR", {
+              context: {
+                error: "Signer is not defined, cannot sign message to prove account ownership"
+              }
+            });
+          }
+          const userTimestampSignature = await signer.signRaw({
+            address: userAccount,
+            data: string.stringToHex(challenge[types.ApiParams.timestamp].toString()),
+            type: "bytes"
+          });
+          const verifiedSolution = await providerApi.submitPowCaptchaSolution(
+            challenge,
+            getAccount().account.account.address,
+            getDappAccount(),
+            solution,
+            userTimestampSignature.signature.toString(),
+            config.captchas.pow.verifiedTimeout
+          );
+          if (verifiedSolution[types.ApiParams.verified]) {
+            updateState({
+              isHuman: true,
+              loading: false
+            });
+            events.onHuman(
+              types.encodeProcaptchaOutput({
+                [types.ApiParams.providerUrl]: providerUrl,
+                [types.ApiParams.user]: getAccount().account.account.address,
+                [types.ApiParams.dapp]: getDappAccount(),
+                [types.ApiParams.challenge]: challenge.challenge,
+                [types.ApiParams.nonce]: solution,
+                [types.ApiParams.timestamp]: challenge.timestamp,
+                [types.ApiParams.signature]: {
+                  [types.ApiParams.provider]: challenge.signature.provider,
+                  [types.ApiParams.user]: {
+                    [types.ApiParams.timestamp]: userTimestampSignature.signature.toString()
+                  }
+                }
+              })
+            );
+            setValidChallengeTimeout();
+          } else {
+            onFailed();
+          }
+        }
+      },
+      start,
+      () => {
+        resetState();
+      },
+      state.attemptCount,
+      3
+    );
+  };
+  return {
+    start,
+    resetState
+  };
+};
+exports.Manager = Manager;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/procaptcha-pow",
-	"version": "2.5.5",
+	"version": "2.6.2",
 	"author": "PROSOPO LIMITED <info@prosopo.io>",
 	"license": "Apache-2.0",
 	"main": "./dist/index.js",
@@ -24,18 +24,20 @@
 		"build": "tsc --build --verbose",
 		"build:cjs": "npx vite --config vite.cjs.config.ts build"
 	},
-	"browserslist": ["> 0.5%, last 2 versions, not dead"],
+	"browserslist": [
+		"> 0.5%, last 2 versions, not dead"
+	],
 	"dependencies": {
 		"@polkadot/util": "12.6.2",
-		"@prosopo/account": "2.5.5",
-		"@prosopo/api": "2.5.5",
-		"@prosopo/common": "2.5.5",
-		"@prosopo/locale": "2.5.5",
-		"@prosopo/procaptcha": "2.5.5",
-		"@prosopo/procaptcha-common": "2.5.5",
-		"@prosopo/types": "2.5.5",
-		"@prosopo/util": "2.5.5",
-		"@prosopo/widget-skeleton": "2.5.5",
+		"@prosopo/account": "2.6.2",
+		"@prosopo/api": "2.6.2",
+		"@prosopo/common": "2.6.0",
+		"@prosopo/locale": "2.6.0",
+		"@prosopo/procaptcha": "2.6.2",
+		"@prosopo/procaptcha-common": "2.6.2",
+		"@prosopo/types": "2.6.2",
+		"@prosopo/util": "2.6.0",
+		"@prosopo/widget-skeleton": "2.6.0",
 		"express": "4.21.2",
 		"react": "18.3.1"
 	},
@@ -47,7 +49,7 @@
 		}
 	},
 	"devDependencies": {
-		"@prosopo/config": "2.5.5",
+		"@prosopo/config": "2.6.0",
 		"@vitest/coverage-v8": "3.0.9",
 		"concurrently": "9.0.1",
 		"del-cli": "6.0.0",
@@ -60,7 +62,8 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/prosopo/captcha.git"
+		"url": "git+https://github.com/prosopo/captcha.git",
+		"directory": "packages/procaptcha-pow"
 	},
 	"bugs": {
 		"url": "https://github.com/prosopo/captcha/issues"