@prosopo/account 0.3.1

package/dist/cjs/common/dist/array.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ARRAY_JOINER = "";
+function arrayJoin(arr, joiner) {
+  return arr.join(joiner ? joiner : ARRAY_JOINER);
+}
+exports.ARRAY_JOINER = ARRAY_JOINER;
+exports.arrayJoin = arrayJoin;

package/dist/cjs/common/dist/asyncFactory.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const error = require("./error.cjs");
+class AsyncFactory {
+  constructor() {
+    throw new error.ProsopoEnvError("GENERAL.ASYNC_FACTORY_CREATE");
+  }
+  static async create(...args) {
+    return await Object.create(this.prototype).init(...args);
+  }
+}
+exports.AsyncFactory = AsyncFactory;
+exports.default = AsyncFactory;

package/dist/cjs/common/dist/custom.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/common/dist/error.cjs

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./index.cjs");
+const logger = require("./logger.cjs");
+const i18n = require("i18next");
+class ProsopoBaseError extends Error {
+  constructor(error, options) {
+    const logger$1 = options?.logger || logger.getLoggerDefault();
+    const logLevel = options?.logLevel || "error";
+    if (error instanceof Error) {
+      super(error.message);
+      this.translationKey = options?.translationKey;
+      this.context = {
+        ...options?.context,
+        ...options?.translationKey ? { translationMessage: i18n.t(options.translationKey) } : {}
+      };
+    } else {
+      super(i18n.t(error));
+      this.translationKey = error;
+      this.context = options?.context;
+    }
+    if (options?.silent)
+      this.logError(logger$1, logLevel);
+  }
+  logError(logger2, logLevel) {
+    const errorFormatter = "\n*************** ERROR ***************\n";
+    const errorName = `Error Type: ${this.name}
+`;
+    const errorParams = JSON.stringify({ error: this.message, context: this.context });
+    const errorMessage = `${errorFormatter}${errorName}${errorParams}`;
+    logger2[logLevel](errorMessage);
+  }
+}
+class ProsopoError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoEnvError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoEnvError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoContractError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoContractError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoDBError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoDBError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoCliError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoCliError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoDatasetError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoDatasetError";
+    options = { ...options, name: errorName };
+    super(error, options);
+  }
+}
+class ProsopoApiError extends ProsopoBaseError {
+  constructor(error, options) {
+    const errorName = options?.name || "ProsopoApiError";
+    const errorCode = options?.context?.code || 500;
+    options = { ...options, name: errorName, context: { ...options?.context, errorCode } };
+    super(error, options);
+    this.code = errorCode;
+  }
+}
+exports.ProsopoApiError = ProsopoApiError;
+exports.ProsopoBaseError = ProsopoBaseError;
+exports.ProsopoCliError = ProsopoCliError;
+exports.ProsopoContractError = ProsopoContractError;
+exports.ProsopoDBError = ProsopoDBError;
+exports.ProsopoDatasetError = ProsopoDatasetError;
+exports.ProsopoEnvError = ProsopoEnvError;
+exports.ProsopoError = ProsopoError;

package/dist/cjs/common/dist/hash.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array = require("./array.cjs");
+const blake2 = require("@polkadot/util-crypto/blake2");
+const HEX_HASH_BIT_LENGTH = 256;
+function hexHash(data, bitLength) {
+  return blake2.blake2AsHex(data, bitLength);
+}
+function hexHashArray(arr) {
+  return hexHash(array.arrayJoin(arr));
+}
+exports.HEX_HASH_BIT_LENGTH = HEX_HASH_BIT_LENGTH;
+exports.hexHash = hexHash;
+exports.hexHashArray = hexHashArray;

package/dist/cjs/common/dist/i18n.cjs

@@ -0,0 +1,29 @@
+"use strict";
+const i18nextHttpMiddleware = require("i18next-http-middleware");
+const reactI18next = require("react-i18next");
+const utils = require("./utils.cjs");
+const Backend = require("i18next-http-backend");
+const LanguageDetector = require("i18next-browser-languagedetector");
+const i18n = require("i18next");
+const en = require("./locales/en.json.cjs");
+const commonOptions = {
+  debug: false,
+  fallbackLng: "en",
+  resources: {
+    en: {
+      translation: en.default
+    }
+  }
+};
+const reactOptions = {
+  react: {
+    useSuspense: false
+  }
+};
+const nodeOptions = {};
+if (utils.isClientSide()) {
+  i18n.use(LanguageDetector).use(reactI18next.initReactI18next).init({ ...commonOptions, ...reactOptions });
+} else {
+  i18n.use(new Backend(void 0, { reloadInterval: false })).use(i18nextHttpMiddleware.LanguageDetector).init({ ...commonOptions, ...nodeOptions });
+}
+module.exports = i18n;

package/dist/cjs/common/dist/index.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./i18n.cjs");
+require("./react/index.cjs");
+require("./node/index.cjs");
+const utils = require("./utils.cjs");
+require("./custom.cjs");
+const error = require("./error.cjs");
+const logger = require("./logger.cjs");
+const array = require("./array.cjs");
+const hash = require("./hash.cjs");
+const asyncFactory = require("./asyncFactory.cjs");
+const string = require("./string.cjs");
+const UrlConverter = require("./node/UrlConverter.cjs");
+exports.isClientSide = utils.isClientSide;
+exports.reverseHexString = utils.reverseHexString;
+exports.snakeToCamelCase = utils.snakeToCamelCase;
+exports.translationKeys = utils.translationKeys;
+exports.trimProviderUrl = utils.trimProviderUrl;
+exports.ProsopoApiError = error.ProsopoApiError;
+exports.ProsopoBaseError = error.ProsopoBaseError;
+exports.ProsopoCliError = error.ProsopoCliError;
+exports.ProsopoContractError = error.ProsopoContractError;
+exports.ProsopoDBError = error.ProsopoDBError;
+exports.ProsopoDatasetError = error.ProsopoDatasetError;
+exports.ProsopoEnvError = error.ProsopoEnvError;
+exports.ProsopoError = error.ProsopoError;
+exports.LogLevel = logger.LogLevel;
+exports.Loggable = logger.Loggable;
+exports.getLogLevel = logger.getLogLevel;
+exports.getLogger = logger.getLogger;
+exports.getLoggerDefault = logger.getLoggerDefault;
+exports.ARRAY_JOINER = array.ARRAY_JOINER;
+exports.arrayJoin = array.arrayJoin;
+exports.HEX_HASH_BIT_LENGTH = hash.HEX_HASH_BIT_LENGTH;
+exports.hexHash = hash.hexHash;
+exports.hexHashArray = hash.hexHashArray;
+exports.AsyncFactory = asyncFactory.AsyncFactory;
+exports.capitaliseFirstLetter = string.capitaliseFirstLetter;
+exports.UrlConverter = UrlConverter.UrlConverter;

package/dist/cjs/common/dist/locales/en.json.cjs

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const WIDGET = {
+  SELECT_ALL: "Select all images containing a",
+  NEXT: "Next",
+  SUBMIT: "Submit",
+  CANCEL: "Cancel",
+  SELECT_ACCOUNT: "Select account",
+  NO_ACCOUNTS_FOUND: "No accounts found",
+  ACCOUNT_NOT_FOUND: "Account not found",
+  NO_EXTENSION_FOUND: "No extension found",
+  EXTENSION_NOT_FOUND: "Extension not found",
+  CANVAS: "Error with Captcha canvas"
+};
+const GENERAL = {
+  BAD_SURI: "Bad SURI",
+  CANNOT_FIND_CONFIG_FILE: "prosopo.config.js / prosopo.config.ts cannot be found.",
+  JSON_LOAD_FAILED: "Failed to load JSON file",
+  CREATE_JSON_FILE_FAILED: "Failed to create JSON file",
+  ASSERT_ERROR: "AssertionError",
+  GENERATE_CAPTCHAS_JSON_FAILED: "Something went wrong while creating captchas json file",
+  CALCULATE_CAPTCHA_SOLUTION: "Something went wrong while calculating captcha solutions",
+  MNEMONIC_UNDEFINED: "Mnemonic Undefined. Please set the mnemonic in environment variables",
+  NO_MNEMONIC_OR_SEED: "No mnemonic or seed provided",
+  ASYNC_FACTORY_CREATE: "Use `create` factory method",
+  CANT_FIND_KEYRINGPAIR: "Can't find the keyringpair for {{address}}",
+  ENVIRONMENT_NOT_READY: "Environment not ready",
+  INVALID_SIGNATURE: "Invalid signature",
+  PAIR_TYPE_UNDEFINED: "Pair type undefined",
+  NOT_IMPLEMENTED: "Not implemented",
+  NO_PAIR_TYPE_OR_SS58_FORMAT: "No pair type or ss58 format provided",
+  SITE_KEY_MISSING: "SITE KEY missing",
+  ACCOUNT_NOT_FOUND: "Account not found"
+};
+const CONTRACT = {
+  INVALID_METHOD: "Invalid contract method",
+  TX_ERROR: "Error making tx",
+  QUERY_ERROR: "Error making query",
+  INVALID_ADDRESS: "Failed to encode invalid address",
+  INVALID_STORAGE_NAME: "Failed to find given storage name",
+  CAPTCHA_SOLUTION_COMMITMENT_DOES_NOT_EXIST: "Captcha solution commitment does not exist",
+  DAPP_NOT_ACTIVE: "Dapp is not active",
+  CONTRACT_UNDEFINED: "Contract undefined",
+  SIGNER_UNDEFINED: "Signer undefined",
+  SIGNER_NOT_SUPPORTED: "Signer is not supported. Use connect instead, e.g. contract.connect(signer)",
+  CANNOT_FIND_KEYPAIR: "Cannot find keypair",
+  INVALID_TYPE: "Invalid type",
+  INVALID_ABI: "Invalid ABI",
+  NOT_HANDLED: "Not handled",
+  INVALID_STORAGE_TYPE: "Invalid storage type",
+  INTERRUPTED_EVENT: "Event interrupted",
+  TOO_MANY_CALLS: "Too many calls",
+  UNKNOWN_ERROR: "Unknown error",
+  CHAIN_DECIMALS_UNDEFINED: "Chain decimals are not defined",
+  INVALID_DATA_FORMAT: "Invalid data format",
+  INVALID_BLOCKHASH: "Invalid blockhash"
+};
+const CONFIG = {
+  UNKNOWN_ENVIRONMENT: "Unknown environment requested",
+  INVALID_CAPTCHA_NUMBER: "Please configure captchas configurations correctly",
+  CONFIGURATIONS_LOAD_FAILED: "Prosopo configurations load failed",
+  INVALID_LOG_LEVEL: "Invalid log level",
+  INVALID_PACKAGE_DIR: "Invalid package directory"
+};
+const DATASET = {
+  DATASET_PARSE_ERROR: "Error parsing dataset",
+  SOLUTION_PARSE_ERROR: "Error parsing dataset",
+  HASH_ERROR: "Error hashing dataset",
+  INVALID_DATASET_ID: "Invalid dataset id",
+  DATASET_ID_UNDEFINED: "Dataset id undefined",
+  NOT_ENOUGH_LABELS: "Not enough labels",
+  NOT_ENOUGH_IMAGES: "Not enough images",
+  CAPTCHAS_COUNT_LESS_THAN_CONFIGURED: "Number of captchas in dataset is less than configured number of captchas",
+  SOLUTIONS_COUNT_LESS_THAN_CONFIGURED: "Number of solutions in dataset is less than configured number of solutions",
+  DUPLICATE_IMAGE: "duplicate image detected",
+  MERKLE_ERROR: "Error creating merkle tree"
+};
+const DATABASE = {
+  CONNECT_ERROR: "Failed to connect",
+  DATABASE_IMPORT_FAILED: "Failed to import database engine",
+  DATABASE_UNDEFINED: "Database client is not connected",
+  DATABASE_HOST_UNDEFINED: "Database host address is not defined",
+  COLLECTION_UNDEFINED: "Database collection is not available",
+  DATASET_LOAD_FAILED: "Data set load failed",
+  DATASET_GET_FAILED: "Failed to get dataset",
+  CAPTCHA_GET_FAILED: "Failed to get captcha",
+  CAPTCHA_UPDATE_FAILED: "Failed to update captcha",
+  IMAGE_GET_FAILED: "Failed to get image",
+  NO_CAPTCHAS_FOUND: "No captcha matching datasetId",
+  PENDING_RECORD_NOT_FOUND: "No pending record found",
+  INVALID_HASH: "Invalid hash",
+  SOLUTION_GET_FAILED: "Failed to get solution",
+  DATASET_WITH_SOLUTIONS_GET_FAILED: "No datasets found with required number of solutions",
+  SOLUTION_APPROVE_FAILED: "Failed to approve solution",
+  SOLUTION_FLAG_FAILED: "Failed to flag solution as processed",
+  TABLES_UNDEFINED: "Tables undefined",
+  CONNECTION_UNDEFINED: "Connection undefined",
+  COMMITMENT_FLAG_FAILED: "Failed to flag commitment as processed"
+};
+const CAPTCHA = {
+  PARSE_ERROR: "Error parsing captcha",
+  INVALID_CAPTCHA_ID: "Invalid captcha id",
+  SOLUTION_HASH_ERROR: "Error hashing solution",
+  INVALID_ITEM_FORMAT: "Only image and text item types allowed",
+  INVALID_SOLUTION_TYPE: "Invalid solution type",
+  INVALID_ITEM_HASH: "Invalid item hash",
+  DIFFERENT_DATASET_IDS: "Dataset ids do not match",
+  INVALID_BLOCK_NO: "Invalid block number",
+  ID_MISMATCH: "captcha id mismatch",
+  MISSING_ITEM_HASH: "missing item hash",
+  INVALID_LEAF_HASH: "Invalid leaf hash",
+  INVALID_CAPTCHA_CHALLENGE: "Invalid captcha challenge",
+  INVALID_DATASET_CONTENT_ID: "Invalid dataset content id",
+  DAPP_USER_SOLUTION_NOT_FOUND: "Dapp user solution not found",
+  INVALID_PROVIDER_URL: "Invalid provider url",
+  NO_CAPTCHA: "No captcha found"
+};
+const API = {
+  BODY_UNDEFINED: "Body must be defined in API POST call",
+  PARAMETER_UNDEFINED: "Parameters must be defined in API POST call",
+  CAPTCHA_FAILED: "You answered one or more captchas incorrectly. Please try again",
+  CAPTCHA_PENDING: "Captcha solutions submitted and awaiting approval",
+  CAPTCHA_PASSED: "You correctly answered the captchas",
+  BAD_REQUEST: "BadRequest",
+  PAYMENT_INFO_NOT_FOUND: "Payment info not found for given block and transaction hashes",
+  USER_VERIFIED: "User verified",
+  USER_NOT_VERIFIED: "User not verified",
+  UNKNOWN: "Unknown API error"
+};
+const CLI = {
+  PARAMETER_ERROR: "Invalid parameter"
+};
+const DEVELOPER = {
+  PROSOPO_SITE_KEY_MISSING: "PROSOPO_SITE_KEY is not set in .env file.",
+  BALANCE_TOO_LOW: "{{mnemonic}} balance too low: {{balance}}",
+  CAPTCHA_ID_MISSING: "Cannot find captcha data id",
+  COMMITMENT_ID_MISSING: "Commitment id missing",
+  PROVIDER_NOT_FOUND: "Provider not found",
+  PROVIDER_NO_CAPTCHA: "No captchas returned from provider",
+  CREATE_ACCOUNT_FAILED: "Could not create an account!",
+  CREATE_ACCOUNT_FAILED_OUT_OF_FUNDS: "Could not create an account as there are no funds. Restart the substrate node.",
+  NO_MOCK_ENV: "MockEnvironment not set up",
+  ACCOUNT_TYPE_MISSING: "{{accountType}} not created by databasePopulator",
+  FUNDING_FAILED: "Funding failed",
+  MISSING_PROVIDER_PAIR: "Missing provider pair",
+  NETWORK_NOT_FOUND: "Network not found",
+  MISSING_ENV_VARIABLE: "Missing environment variable",
+  GENERAL: "General Dev Error, see context",
+  MISSING_SECRET_KEY: "Missing secret key",
+  KEY_ERROR: "Key error",
+  METHOD_NOT_IMPLEMENTED: "Method not implemented"
+};
+const FS = {
+  DIRECTORY_NOT_FOUND: "Directory not found",
+  FILE_NOT_FOUND: "File not found",
+  FILE_ALREADY_EXISTS: "File already exists",
+  DIRECTORY_ALREADY_EXISTS: "Directory already exists",
+  SAME_FILE: "Same file",
+  INVALID_DIR_FORMAT: "Invalid directory format"
+};
+const PROGUI = {
+  NO_STATE_PROVIDER: "useGlobalState must be used within a GlobalStateProvider",
+  NO_POLKADOT_EXTENSION: "Polkadot extension not found"
+};
+const translationEn = {
+  WIDGET,
+  GENERAL,
+  CONTRACT,
+  CONFIG,
+  DATASET,
+  DATABASE,
+  CAPTCHA,
+  API,
+  CLI,
+  DEVELOPER,
+  FS,
+  PROGUI
+};
+exports.API = API;
+exports.CAPTCHA = CAPTCHA;
+exports.CLI = CLI;
+exports.CONFIG = CONFIG;
+exports.CONTRACT = CONTRACT;
+exports.DATABASE = DATABASE;
+exports.DATASET = DATASET;
+exports.DEVELOPER = DEVELOPER;
+exports.FS = FS;
+exports.GENERAL = GENERAL;
+exports.PROGUI = PROGUI;
+exports.WIDGET = WIDGET;
+exports.default = translationEn;

package/dist/cjs/common/dist/logger.cjs

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tslib = require("tslib");
+const consola = require("consola");
+const error = require("./error.cjs");
+const zod = require("zod");
+var _Loggable_logger;
+const LogLevel = zod.enum(["trace", "debug", "info", "warn", "error", "fatal", "log"]);
+function getLogger(logLevel, scope) {
+  return getLoggerAdapterConsola(getLogLevel(logLevel), scope);
+}
+function getLoggerDefault() {
+  return defaultLogger;
+}
+const getLoggerAdapterConsola = (logLevel, scope) => {
+  const logger = consola.createConsola({ formatOptions: { colors: true, date: true } }).withTag(scope);
+  let currentLevel = logLevel;
+  const result = {
+    log: logger.log,
+    info: logger.info,
+    debug: logger.debug,
+    trace: logger.trace,
+    warn: logger.warn,
+    error: logger.error,
+    fatal: logger.fatal,
+    setLogLevel: (level) => {
+      let logLevel2 = NaN;
+      level = getLogLevel(level);
+      switch (level) {
+        case LogLevel.enum.trace:
+          logLevel2 = consola.LogLevels.trace;
+          break;
+        case LogLevel.enum.debug:
+          logLevel2 = consola.LogLevels.debug;
+          break;
+        case LogLevel.enum.info:
+          logLevel2 = consola.LogLevels.info;
+          break;
+        case LogLevel.enum.warn:
+          logLevel2 = consola.LogLevels.warn;
+          break;
+        case LogLevel.enum.error:
+          logLevel2 = consola.LogLevels.error;
+          break;
+        case LogLevel.enum.fatal:
+          logLevel2 = consola.LogLevels.fatal;
+          break;
+        case LogLevel.enum.log:
+          logLevel2 = consola.LogLevels.log;
+          break;
+        default:
+          throw new Error(`Invalid log level translation to consola's log level: ${level}`);
+      }
+      logger.level = logLevel2;
+      currentLevel = level;
+    },
+    getLogLevel: () => {
+      return currentLevel;
+    }
+  };
+  result.setLogLevel(logLevel);
+  return result;
+};
+function getLogLevel(logLevel) {
+  logLevel = logLevel || process.env.PROSOPO_LOG_LEVEL || "Info";
+  logLevel = logLevel.toString().toLowerCase();
+  try {
+    return LogLevel.parse(logLevel);
+  } catch (e) {
+    throw new error.ProsopoEnvError("CONFIG.INVALID_LOG_LEVEL", { context: { logLevel } });
+  }
+}
+const defaultLogger = getLoggerAdapterConsola(LogLevel.enum.info, "global");
+class Loggable {
+  constructor() {
+    _Loggable_logger.set(this, void 0);
+    tslib.__classPrivateFieldSet(this, _Loggable_logger, getLoggerDefault(), "f");
+  }
+  get logger() {
+    return tslib.__classPrivateFieldGet(this, _Loggable_logger, "f");
+  }
+  set logger(logger) {
+    tslib.__classPrivateFieldSet(this, _Loggable_logger, logger, "f");
+  }
+}
+_Loggable_logger = /* @__PURE__ */ new WeakMap();
+exports.LogLevel = LogLevel;
+exports.Loggable = Loggable;
+exports.getLogLevel = getLogLevel;
+exports.getLogger = getLogger;
+exports.getLoggerDefault = getLoggerDefault;