@prosopo/scripts 3.0.11 → 3.0.13

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @prosopo/scripts
 
+## 3.0.13
+### Patch Changes
+
+- Updated dependencies [9e4e7ca]
+  - @prosopo/provider@3.2.2
+  - @prosopo/cli@3.1.2
+
+## 3.0.12
+### Patch Changes
+
+- 3573f0b: fix npm scripts bundle command
+- 3573f0b: build using vite, typecheck using tsc
+- efd8102: Add tests for unwrap error helper
+- f29fc7e: Refining API error handling. Adding more language strings
+- 3573f0b: standardise all vite based npm scripts for bundling
+- Updated dependencies [2f0c830]
+- Updated dependencies [52dbf21]
+- Updated dependencies [93d5e50]
+- Updated dependencies [3573f0b]
+- Updated dependencies [3573f0b]
+- Updated dependencies [efd8102]
+- Updated dependencies [93d5e50]
+- Updated dependencies [63519d7]
+- Updated dependencies [f29fc7e]
+- Updated dependencies [3573f0b]
+- Updated dependencies [2d0dd8a]
+  - @prosopo/provider@3.2.1
+  - @prosopo/util@3.0.3
+  - @prosopo/types-env@2.7.14
+  - @prosopo/keyring@2.8.7
+  - @prosopo/types@3.0.4
+  - @prosopo/types-database@3.0.10
+  - @prosopo/datasets@3.0.10
+  - @prosopo/account@2.7.10
+  - @prosopo/common@3.1.0
+  - @prosopo/dotenv@3.0.5
+  - @prosopo/cli@3.1.1
+  - @prosopo/env@3.1.1
+  - @prosopo/config@3.1.1
+
 ## 3.0.11
 ### Patch Changes
 

package/dist/cjs/cli/index.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const util = require("@polkadot/util");
+const common = require("@prosopo/common");
+const dotenv = require("@prosopo/dotenv");
+const types = require("@prosopo/types");
+const workspace = require("@prosopo/workspace");
+const yargs = require("yargs");
+const helpers = require("yargs/helpers");
+require("../contract/index.cjs");
+const setVersion = require("../scripts/setVersion.cjs");
+require("../setup/index.cjs");
+require("../util/index.cjs");
+const exec = require("../util/exec.cjs");
+const setup = require("../setup/setup.cjs");
+const _import = require("../contract/import.cjs");
+const rootDir = path.resolve(".");
+dotenv.loadEnv(rootDir);
+async function processArgs(args) {
+  const parsed = await yargs(helpers.hideBin(args)).option("logLevel", {
+    describe: "set log level",
+    choices: Object.keys(common.LogLevel.enum)
+  }).argv;
+  const log = common.getLogger(common.parseLogLevel(parsed.logLevel), "CLI");
+  await yargs(helpers.hideBin(args)).usage("Usage: $0 [global options] <command> [options]").command(
+    "create_env_files",
+    "Copies the env.xyz files to .env.xyz",
+    (yargs2) => yargs2,
+    async () => {
+      const env = dotenv.getEnv();
+      const scripts = workspace.getScriptsPkgDir();
+      await exec.exec(`cp -v ${scripts}/env.${env} ${scripts}/.env.${env}`);
+    },
+    []
+  ).command({
+    command: "setup",
+    describe: "Setup the development environment by registering a provider, staking, loading a data set and then registering a dapp and staking.",
+    builder: (yargs2) => yargs2.option("sites", {
+      type: "boolean",
+      demandOption: false,
+      default: true,
+      desc: "Set up sites"
+    }).option("provider", {
+      type: "boolean",
+      demandOption: false,
+      default: true,
+      desc: "Set up the provider"
+    }),
+    handler: async (argv) => {
+      log.info(() => ({ msg: "Running setup scripts" }));
+      await setup.setup(argv.provider, argv.sites);
+    }
+  }).command({
+    command: "import_contract",
+    describe: "Import a contract into the contract package.",
+    builder: (yargs2) => yargs2.option("in", {
+      type: "string",
+      demandOption: true,
+      desc: "The path to the contract's abi"
+    }).option("out", {
+      type: "string",
+      demandOption: true,
+      desc: "The path to the output directory"
+    }),
+    handler: async (argv) => {
+      await _import(argv.in, argv.out);
+    }
+  }).command({
+    command: "version",
+    describe: "Set the version of packages",
+    builder: (yargs2) => yargs2.option("v", { type: "string", demandOption: true }),
+    handler: async (argv) => {
+      await setVersion(String(argv.v));
+    }
+  }).command({
+    command: "token <token>",
+    describe: "Encode or Decode a Procaptcha token to the JSON output format",
+    builder: (yargs2) => yargs2.positional("token", {
+      describe: "a Procaptcha token to decode",
+      type: "string",
+      demandOption: true
+    }),
+    handler: async (argv) => {
+      if (!util.isHex(argv.token)) {
+        log.debug(() => ({ msg: "Encoding token to hex" }));
+        log.info(() => ({
+          data: { result: types.encodeProcaptchaOutput(JSON.parse(argv.token)) }
+        }));
+      } else {
+        log.debug(() => ({ msg: "Decoding token from hex" }));
+        log.info(() => ({
+          data: { result: types.decodeProcaptchaOutput(argv.token) }
+        }));
+      }
+    }
+  }).argv;
+}
+processArgs(process.argv).then(() => {
+  process.exit(0);
+}).catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+exports.processArgs = processArgs;

package/dist/cjs/contract/import.cjs

@@ -0,0 +1,183 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const common = require("@prosopo/common");
+const lodash = require("@prosopo/util/lodash");
+require("../util/index.cjs");
+const exec = require("../util/exec.cjs");
+const replaceExtension = (file, ext) => {
+  const parts = file.split(".");
+  parts.pop();
+  parts.push(ext);
+  return parts.join(".");
+};
+async function importContract(pathToAbis, pathToOutput) {
+  const verbose = false;
+  pathToAbis = path.relative(process.cwd(), pathToAbis);
+  pathToOutput = path.relative(process.cwd(), pathToOutput);
+  if (!fs.existsSync(pathToAbis))
+    throw new common.ProsopoEnvError("FS.FILE_NOT_FOUND", {
+      context: { error: `Path to ABIs does not exist: ${pathToAbis}` }
+    });
+  await exec.exec(`mkdir -p ${pathToOutput}`);
+  const cmd = `npx @prosopo/typechain-polkadot --in ${pathToAbis} --out ${pathToOutput}`;
+  await exec.exec(cmd);
+  const name = path.basename(pathToAbis);
+  await exec.exec(`cp ${pathToAbis}/${name}.json ${pathToOutput}/${name}.json`);
+  const _ = lodash.lodash();
+  const writeIndexJsFiles = (src) => {
+    const typeChainDirs = fs.readdirSync(src).filter((file2) => {
+      return fs.lstatSync(`${src}/${file2}`).isDirectory();
+    });
+    const rootExports = [];
+    const typeChainExports = [
+      {
+        dir: "build-extrinsic",
+        defaultExportName: "extrinsics"
+      },
+      {
+        dir: "constructors"
+      },
+      {
+        dir: "contract-info",
+        exports: [
+          {
+            name: "ContractAbi"
+          },
+          {
+            name: "ContractFile"
+          }
+        ]
+      },
+      {
+        dir: "contracts",
+        defaultExportName: "contract"
+      },
+      {
+        dir: "data"
+      },
+      {
+        dir: "event-data"
+      },
+      // { // no events used so this is empty - not sure about structure so left out
+      //     dir: 'event-types'
+      // },
+      {
+        dir: "events"
+      },
+      {
+        dir: "mixed-methods",
+        defaultExportName: "methods"
+      },
+      {
+        dir: "query",
+        defaultExportName: "query"
+      },
+      {
+        dir: "tx-sign-and-send",
+        defaultExportName: "tx"
+      }
+    ];
+    let file = "";
+    for (const typeChainExport of typeChainExports) {
+      const dirPath = `${src}/${typeChainExport.dir}`;
+      const files = fs.readdirSync(dirPath);
+      if (files.length !== 1) {
+        throw new common.ProsopoEnvError("FS.INVALID_DIR_FORMAT", {
+          context: {
+            error: `Expected 1 file in ${dirPath}, found ${files.length}`
+          }
+        });
+      }
+      file = files[0] || "";
+      if (file === "") {
+        throw new common.ProsopoEnvError("FS.FILE_NOT_FOUND", {
+          context: { error: `No file found in ${dirPath}` }
+        });
+      }
+      if (file.endsWith(".ts")) {
+        file = replaceExtension(file, "js");
+      }
+      if (typeChainExport.defaultExportName !== void 0) {
+        const name2 = _.upperFirst(
+          _.camelCase(typeChainExport.defaultExportName || typeChainExport.dir)
+        );
+        rootExports.push(
+          `export { default as ${name2} } from './${typeChainExport.dir}/${file}'`
+        );
+      }
+      if (typeChainExport.exports !== void 0) {
+        for (const namedExport of typeChainExport.exports) {
+          const alias = namedExport.alias ? ` as ${namedExport.alias}` : "";
+          rootExports.push(
+            `export { ${namedExport.name}${alias} } from './${typeChainExport.dir}/${file}'`
+          );
+        }
+      }
+    }
+    rootExports.push(`export * from './shared/utils.js'`);
+    const regex = /export\s+([a-z]+)\s+(\w+)/g;
+    const fileTs = replaceExtension(file, "ts");
+    const typesArgumentsFileContent = fs.readFileSync(
+      `${src}/types-arguments/${fileTs}`,
+      "utf8"
+    );
+    const typesReturnsFileContent = fs.readFileSync(
+      `${src}/types-returns/${fileTs}`,
+      "utf8"
+    );
+    const argumentTypes = Array.from(
+      typesArgumentsFileContent.matchAll(regex)
+    ).map((match) => {
+      return {
+        name: match[2] || "",
+        category: match[1] || ""
+      };
+    });
+    const returnTypes = Array.from(
+      typesReturnsFileContent.matchAll(regex)
+    ).map((match) => {
+      return {
+        name: match[2] || "",
+        category: match[1] || ""
+      };
+    });
+    const argumentTypeNames = argumentTypes.map((entry) => entry.name);
+    const uniqueTypes = [...argumentTypes];
+    const locations = [...argumentTypes.map(() => "types-arguments")];
+    for (const entry of returnTypes) {
+      if (!argumentTypeNames.includes(entry.name)) {
+        uniqueTypes.push(entry);
+        locations.push("types-arguments");
+      } else {
+        locations.push("types-returns");
+      }
+    }
+    uniqueTypes.forEach((entry, i) => {
+      const location = locations[i];
+      const prefix = entry.category === "type" || entry.category === "interface" ? " type" : "";
+      rootExports.push(
+        `export${prefix} { ${entry.name} } from './${location}/${file}'`
+      );
+    });
+    fs.writeFileSync(`${src}/index.ts`, rootExports.join("\n"));
+  };
+  writeIndexJsFiles(pathToOutput);
+}
+const getExtension = (str) => {
+  const i = str.indexOf("assert");
+  if (i >= 0) {
+    str = str.slice(0, i);
+  }
+  const arr = str.split(".");
+  if (arr.length <= 1) {
+    return "";
+  }
+  return arr.pop();
+};
+const getPath = (str) => {
+  const j = Math.max(str.lastIndexOf('"'), str.lastIndexOf("'"));
+  const i = Math.max(str.indexOf('"'), str.indexOf("'"));
+  return str.slice(i + 1, j);
+};
+module.exports = importContract;

package/dist/cjs/contract/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _import = require("./import.cjs");
+exports.importContract = _import;

package/dist/cjs/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./setup/index.cjs");
+require("./util/index.cjs");
+const index = require("./cli/index.cjs");
+require("./contract/index.cjs");
+const setup = require("./setup/setup.cjs");
+const provider = require("./setup/provider.cjs");
+const loadContractFiles = require("./util/loadContractFiles.cjs");
+const updateEnv = require("./util/updateEnv.cjs");
+const exec = require("./util/exec.cjs");
+const fluxLogDappDetails = require("./util/fluxLogDappDetails.cjs");
+const _import = require("./contract/import.cjs");
+exports.processArgs = index.processArgs;
+exports.setup = setup.setup;
+exports.updateEnvFile = setup.updateEnvFile;
+exports.setupProvider = provider.setupProvider;
+exports.AbiJSON = loadContractFiles.AbiJSON;
+exports.Wasm = loadContractFiles.Wasm;
+exports.findEnvFiles = updateEnv.findEnvFiles;
+exports.updateDemoHTMLFiles = updateEnv.updateDemoHTMLFiles;
+exports.updateEnvFiles = updateEnv.updateEnvFiles;
+exports.exec = exec.exec;
+exports.extractReferrersFromLogs = fluxLogDappDetails.extractReferrersFromLogs;
+exports.importContract = _import;

package/dist/cjs/scripts/setVersion.cjs

@@ -0,0 +1,132 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const toml = require("@iarna/toml");
+const common = require("@prosopo/common");
+const dotenv = require("@prosopo/dotenv");
+const workspace = require("@prosopo/workspace");
+dotenv.loadEnv();
+const logLevel = common.parseLogLevel(process.env.PROSOPO_LOG_LEVEL);
+const log = common.getLogger(logLevel, "setVersion");
+log.info(() => ({ data: { logLevel } }));
+const parseVersion = (version) => {
+  try {
+    const parts = version.split(".");
+    if (parts.length !== 3) {
+      throw new Error();
+    }
+    let [major, minor, patch] = parts;
+    major = Number.parseInt(major ?? "").toString();
+    minor = Number.parseInt(minor ?? "").toString();
+    patch = Number.parseInt(patch ?? "").toString();
+    if (major === "NaN" || minor === "NaN" || patch === "NaN") {
+      throw new Error();
+    }
+    return `${major}.${minor}.${patch}`;
+  } catch (e) {
+    throw new Error("Version must be in the format of x.y.z");
+  }
+};
+const find = (pth, filter) => {
+  const files = fs.readdirSync(pth);
+  const results = [];
+  for (const file of files) {
+    const fullPath = path.join(pth, file);
+    if (filter(fullPath)) {
+      results.push(fullPath);
+    }
+    try {
+      if (fs.statSync(fullPath).isDirectory()) {
+        results.push(...find(fullPath, filter));
+      }
+    } catch (e) {
+      log.debug(() => ({ data: { fullPath }, msg: "Not a directory" }));
+    }
+  }
+  return results;
+};
+async function setVersion(versionIn, ignore) {
+  log.info(() => ({ data: { versionIn }, msg: "Setting version to" }));
+  const version = parseVersion(versionIn);
+  const root = workspace.getRootDir();
+  const ignorePaths = ["node_modules", "cargo-cache", ...ignore ?? []];
+  log.debug(() => ({ data: { ignorePaths }, msg: "Ignoring paths" }));
+  const files = find(root, (pth) => {
+    if (ignorePaths.some((ignorePath) => pth.includes(ignorePath))) {
+      return false;
+    }
+    const basename = path.basename(pth);
+    return basename === "package.json" || basename === "Cargo.toml";
+  });
+  files.filter((pth) => path.extname(pth) === ".json").forEach((pth) => {
+    log.debug(() => ({ data: { pth }, msg: "setting version in" }));
+    const content = fs.readFileSync(pth, "utf8");
+    const jsonContent = JSON.parse(content);
+    if (jsonContent.version) {
+      jsonContent.version = version;
+    }
+    for (const obj of [
+      jsonContent.dependencies ?? {},
+      jsonContent.devDependencies ?? {},
+      jsonContent.peerDependencies ?? {}
+    ]) {
+      for (const key of Object.keys(obj)) {
+        if (key.startsWith("@prosopo") && !key.includes("typechain")) {
+          log.debug(() => ({
+            data: { key, version, pth },
+            msg: "setting dependency version"
+          }));
+          obj[key] = version;
+        }
+      }
+    }
+    fs.writeFileSync(pth, `${JSON.stringify(jsonContent, null, 4)}
+`);
+  });
+  files.filter((pth) => path.extname(pth) === ".toml").filter((pth) => {
+    return !ignorePaths.some((ignorePath) => pth.includes(ignorePath));
+  }).forEach((pth) => {
+    log.debug(() => ({ data: { pth }, msg: "setting version in" }));
+    const content = fs.readFileSync(pth, "utf8");
+    const tomlContent = toml.parse(content);
+    if (tomlContent.workspace) {
+      if (tomlContent.workspace.version) {
+        tomlContent.workspace.version = version;
+      }
+    } else {
+      tomlContent.package.version = version;
+    }
+    fs.writeFileSync(pth, `${toml.stringify(tomlContent)}
+`);
+  });
+  files.filter((pth) => path.extname(pth) === ".toml").forEach((pth) => {
+    log.debug(() => ({
+      data: { pth },
+      msg: "setting dependency versions in"
+    }));
+    const content = fs.readFileSync(pth, "utf8");
+    const tomlContent = toml.parse(content);
+    if (tomlContent.workspace) {
+      if (tomlContent.workspace.version) {
+        tomlContent.workspace.version = version;
+      }
+    } else {
+      for (const obj of [
+        tomlContent.dependencies ?? {},
+        tomlContent["dev-dependencies"] ?? {}
+      ]) {
+        for (const [key, value] of Object.entries(obj)) {
+          if (value.path) {
+            path.join(value.path, "Cargo.toml");
+            const depContent = fs.readFileSync(pth, "utf8");
+            const depTomlContent = toml.parse(depContent);
+            value.version = depTomlContent.version;
+          }
+        }
+      }
+    }
+    fs.writeFileSync(pth, `${toml.stringify(tomlContent)}
+`);
+  });
+}
+module.exports = setVersion;

package/dist/cjs/setup/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const setup = require("./setup.cjs");
+const provider = require("./provider.cjs");
+exports.setup = setup.setup;
+exports.updateEnvFile = setup.updateEnvFile;
+exports.setupProvider = provider.setupProvider;

package/dist/cjs/setup/provider.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const datasets = require("@prosopo/datasets");
+const provider = require("@prosopo/provider");
+async function setupProvider(env) {
+  const logger = env.logger;
+  const tasks = new provider.Tasks(env);
+  logger.info(() => ({ msg: "   - providerSetDataset" }));
+  await tasks.datasetManager.providerSetDataset(datasets.datasetWithSolutionHashes);
+}
+exports.setupProvider = setupProvider;

package/dist/cjs/setup/setup.cjs

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const cli = require("@prosopo/cli");
+const common = require("@prosopo/common");
+const dotenv = require("@prosopo/dotenv");
+const env = require("@prosopo/env");
+const keyring = require("@prosopo/keyring");
+const util = require("@prosopo/util");
+const fse = require("fs-extra");
+require("../util/index.cjs");
+const provider = require("./provider.cjs");
+const site = require("./site.cjs");
+const updateEnv = require("../util/updateEnv.cjs");
+const logger = common.getLogger(common.LogLevel.enum.info, "setup");
+const __dirname$1 = path.resolve();
+function getRootDir() {
+  const rootDir = process.env.PROSOPO_ROOT_DIR || path.resolve(__dirname$1, "../..");
+  logger.info(() => ({ msg: "Root dir:", data: { rootDir } }));
+  return rootDir;
+}
+function getDatasetFilePath() {
+  const datasetFile = process.env.PROSOPO_PROVIDER_DATASET_FILE || path.resolve("../data/captchas.json");
+  logger.info(() => ({ msg: "Dataset file:", data: { datasetFile } }));
+  return datasetFile;
+}
+function getDefaultProvider() {
+  const host = process.env.PROSOPO_PROVIDER_HOST || "localhost";
+  return {
+    url: process.env.PROSOPO_API_PORT ? `http://${host}:${process.env.PROSOPO_API_PORT}` : `http://${host}:9229`,
+    datasetFile: getDatasetFilePath(),
+    address: process.env.PROSOPO_PROVIDER_ADDRESS || "",
+    secret: cli.getSecret(),
+    captchaDatasetId: "",
+    pair: keyring.getPair(cli.getSecret())
+  };
+}
+async function copyEnvFile() {
+  try {
+    const rootDir = getRootDir();
+    const tplLocation = path.resolve(rootDir, "./dev/scripts");
+    const tplEnvFile = dotenv.getEnvFile(tplLocation, "env");
+    const envFile = dotenv.getEnvFile(tplLocation, ".env");
+    await fse.copy(tplEnvFile, envFile, { overwrite: false });
+  } catch (err) {
+    logger.debug(() => ({ msg: "Error copying env file", err }));
+  }
+}
+function updateEnvFileVar(source, name, value) {
+  const envVar = new RegExp(`.*(${name}=)(.*)`, "g");
+  if (envVar.test(source)) {
+    return source.replace(envVar, `$1${value}`);
+  }
+  return `${source}
+${name}=${value}`;
+}
+async function updateEnvFile(vars) {
+  const rootDir = getRootDir();
+  const envFile = dotenv.getEnvFile(rootDir, ".env");
+  let readEnvFile = await fse.readFile(envFile, "utf8");
+  for (const key in vars) {
+    readEnvFile = updateEnvFileVar(readEnvFile, key, util.get(vars, key));
+  }
+  logger.info(() => ({ msg: `Updating ${envFile}` }));
+  await fse.writeFile(envFile, readEnvFile);
+}
+async function setup(provider$1, sites) {
+  if (!provider$1 && !sites) {
+    logger.info(() => ({ msg: "No setup required, exiting." }));
+    process.exit(0);
+  }
+  const defaultProvider = getDefaultProvider();
+  if (defaultProvider.secret) {
+    const hasProviderAccount = defaultProvider.address && defaultProvider.secret;
+    logger.debug(() => ({
+      msg: "ENVIRONMENT",
+      data: { nodeEnv: process.env.NODE_ENV }
+    }));
+    const [mnemonic, address] = !hasProviderAccount ? await keyring.generateMnemonic() : [defaultProvider.secret, defaultProvider.address];
+    logger.debug(() => ({ msg: `Address: ${address}` }));
+    logger.debug(() => ({ msg: `Mnemonic: ${mnemonic}` }));
+    logger.debug(() => ({ msg: "Writing .env file..." }));
+    await copyEnvFile();
+    if (!process.env.PROSOPO_SITE_KEY) {
+      throw new common.ProsopoEnvError("DEVELOPER.PROSOPO_SITE_KEY_MISSING");
+    }
+    const config = cli.defaultConfig();
+    const providerSecret = config.account.secret;
+    const pair = keyring.getPair(providerSecret);
+    const authAccount = keyring.getPair(config.authAccount.secret);
+    const env$1 = new env.ProviderEnvironment(config, pair, authAccount);
+    await env$1.isReady();
+    defaultProvider.secret = mnemonic;
+    env$1.logger.info(() => ({
+      msg: `Registering provider... ${defaultProvider.address}`
+    }));
+    defaultProvider.pair = keyring.getPair(providerSecret);
+    if (provider$1) {
+      await provider.setupProvider(env$1);
+      if (!hasProviderAccount) {
+        await updateEnvFile({
+          PROVIDER_MNEMONIC: `"${mnemonic}"`,
+          PROVIDER_ADDRESS: address
+        });
+      }
+    }
+    if (sites) {
+      for (const siteKey of keyring.getDefaultSiteKeys()) {
+        siteKey.pair = keyring.getPair(siteKey.secret);
+        env$1.logger.info(() => ({
+          msg: `Registering ${siteKey.secret} siteKey ... ${siteKey.pair?.address}`
+        }));
+        await site.registerSiteKey(env$1, siteKey.pair.address, siteKey.settings);
+        env$1.logger.debug(() => ({
+          msg: "Updating env files with PROSOPO_SITE_KEY"
+        }));
+        await updateEnv.updateDemoHTMLFiles(
+          [/data-sitekey="(\w{48})"/, /siteKey:\s*'(\w{48})'/],
+          siteKey.pair.address,
+          env$1.logger
+        );
+        const envVarNames = siteKey.settings.captchaType === "image" ? [
+          "PROSOPO_SITE_KEY",
+          `PROSOPO_SITE_KEY_${siteKey.settings.captchaType.toUpperCase()}`
+        ] : [
+          `PROSOPO_SITE_KEY_${siteKey.settings.captchaType.toUpperCase()}`
+        ];
+        await updateEnv.updateEnvFiles(envVarNames, siteKey.pair.address, env$1.logger);
+      }
+    }
+    process.exit();
+  } else {
+    console.error("no secret found in .env file");
+    throw new common.ProsopoEnvError("GENERAL.NO_MNEMONIC_OR_SEED");
+  }
+}
+exports.setup = setup;
+exports.updateEnvFile = updateEnvFile;

package/dist/cjs/setup/site.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const provider = require("@prosopo/provider");
+const types = require("@prosopo/types");
+async function registerSiteKey(env, siteKey, settings = {}) {
+  const logger = env.logger;
+  const tasks = new provider.Tasks(env);
+  logger.info(() => ({
+    msg: "registerSiteKey",
+    data: { siteKey, captchaType: settings.captchaType }
+  }));
+  await tasks.clientTaskManager.registerSiteKey(
+    siteKey,
+    types.Tier.Professional,
+    types.ClientSettingsSchema.parse({
+      captchaType: types.CaptchaType.frictionless,
+      frictionlessThreshold: 0.8,
+      powDifficulty: 4,
+      imageThreshold: 0.8,
+      ...settings,
+      domains: settings.domains && settings.domains.length > 0 ? settings.domains : ["localhost", "0.0.0.0"]
+    })
+  );
+}
+exports.registerSiteKey = registerSiteKey;