@prosopo/types 2.5.3 → 2.6.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# @prosopo/types
+
+## 2.6.1
+
+### Patch Changes
+
+- 52feffc: Adjustable difficulty img captcha
+
+## 2.6.0
+
+### Minor Changes
+
+- a0bfc8a: bump all pkg versions since independent versioning applied
+
+### Patch Changes
+
+- Updated dependencies [a0bfc8a]
+  - @prosopo/common@2.6.0
+  - @prosopo/locale@2.6.0

package/dist/cjs/api/api.cjs

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

package/dist/cjs/api/index.cjs

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

package/dist/cjs/api/params.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var ApiParams = /* @__PURE__ */ ((ApiParams2) => {
+  ApiParams2["datasetId"] = "datasetId";
+  ApiParams2["user"] = "user";
+  ApiParams2["dapp"] = "dapp";
+  ApiParams2["provider"] = "provider";
+  ApiParams2["blockNumber"] = "blockNumber";
+  ApiParams2["requestHash"] = "requestHash";
+  ApiParams2["captchas"] = "captchas";
+  ApiParams2["commitmentId"] = "commitmentId";
+  ApiParams2["proof"] = "proof";
+  ApiParams2["dappSignature"] = "dappSignature";
+  ApiParams2["dappUserSignature"] = "dappUserSignature";
+  ApiParams2["providerUrl"] = "providerUrl";
+  ApiParams2["procaptchaResponse"] = "procaptcha-response";
+  ApiParams2["verifiedTimeout"] = "verifiedTimeout";
+  ApiParams2["maxVerifiedTime"] = "maxVerifiedTime";
+  ApiParams2["verified"] = "verified";
+  ApiParams2["status"] = "status";
+  ApiParams2["challenge"] = "challenge";
+  ApiParams2["difficulty"] = "difficulty";
+  ApiParams2["nonce"] = "nonce";
+  ApiParams2["timeouts"] = "timeouts";
+  ApiParams2["token"] = "token";
+  ApiParams2["secret"] = "secret";
+  ApiParams2["timestamp"] = "timestamp";
+  ApiParams2["signature"] = "signature";
+  ApiParams2["error"] = "error";
+  ApiParams2["siteKey"] = "siteKey";
+  ApiParams2["captchaType"] = "captchaType";
+  ApiParams2["sessionId"] = "sessionId";
+  ApiParams2["settings"] = "settings";
+  ApiParams2["domains"] = "domains";
+  ApiParams2["frictionlessThreshold"] = "frictionlessThreshold";
+  ApiParams2["powDifficulty"] = "powDifficulty";
+  ApiParams2["score"] = "score";
+  ApiParams2["tier"] = "tier";
+  ApiParams2["detectorKey"] = "detectorKey";
+  return ApiParams2;
+})(ApiParams || {});
+exports.ApiParams = ApiParams;

package/dist/cjs/client/captchaType/captchaType.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var CaptchaType = /* @__PURE__ */ ((CaptchaType2) => {
+  CaptchaType2["image"] = "image";
+  CaptchaType2["pow"] = "pow";
+  CaptchaType2["frictionless"] = "frictionless";
+  return CaptchaType2;
+})(CaptchaType || {});
+exports.CaptchaType = CaptchaType;

package/dist/cjs/client/captchaType/captchaTypeSpec.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const captchaType = require("./captchaType.cjs");
+const CaptchaTypeSpec = z.nativeEnum(captchaType.CaptchaType);
+exports.CaptchaTypeSpec = CaptchaTypeSpec;

package/dist/cjs/client/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const user = require("./user.cjs");
+const settings = require("./settings.cjs");
+const captchaType = require("./captchaType/captchaType.cjs");
+const captchaTypeSpec = require("./captchaType/captchaTypeSpec.cjs");
+exports.Tier = user.Tier;
+exports.TierMonthlyLimits = user.TierMonthlyLimits;
+exports.TierSchema = user.TierSchema;
+exports.ClientSettingsSchema = settings.ClientSettingsSchema;
+exports.captchaTypeDefault = settings.captchaTypeDefault;
+exports.domainsDefault = settings.domainsDefault;
+exports.frictionlessThresholdDefault = settings.frictionlessThresholdDefault;
+exports.imageThresholdDefault = settings.imageThresholdDefault;
+exports.powDifficultyDefault = settings.powDifficultyDefault;
+exports.CaptchaType = captchaType.CaptchaType;
+exports.CaptchaTypeSpec = captchaTypeSpec.CaptchaTypeSpec;

package/dist/cjs/client/settings.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const captchaType = require("./captchaType/captchaType.cjs");
+const captchaTypeSpec = require("./captchaType/captchaTypeSpec.cjs");
+const captchaTypeDefault = captchaType.CaptchaType.frictionless;
+const domainsDefault = [];
+const frictionlessThresholdDefault = 0.5;
+const powDifficultyDefault = 4;
+const imageThresholdDefault = 0.8;
+const ClientSettingsSchema = z.object({
+  captchaType: captchaTypeSpec.CaptchaTypeSpec.default(captchaTypeDefault),
+  domains: z.array(z.string()).default([...domainsDefault]),
+  frictionlessThreshold: z.number().default(frictionlessThresholdDefault),
+  powDifficulty: z.number().default(powDifficultyDefault),
+  imageThreshold: z.number().default(imageThresholdDefault)
+});
+exports.ClientSettingsSchema = ClientSettingsSchema;
+exports.captchaTypeDefault = captchaTypeDefault;
+exports.domainsDefault = domainsDefault;
+exports.frictionlessThresholdDefault = frictionlessThresholdDefault;
+exports.imageThresholdDefault = imageThresholdDefault;
+exports.powDifficultyDefault = powDifficultyDefault;

package/dist/cjs/client/user.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+var Tier = /* @__PURE__ */ ((Tier2) => {
+  Tier2["Free"] = "free";
+  Tier2["Professional"] = "professional";
+  Tier2["Enterprise"] = "enterprise";
+  return Tier2;
+})(Tier || {});
+const TierSchema = z.z.nativeEnum(Tier);
+const TierMonthlyLimits = {
+  [
+    "free"
+    /* Free */
+  ]: {
+    verificationRequests: 1e5
+  },
+  [
+    "professional"
+    /* Professional */
+  ]: {
+    verificationRequests: 1e6
+  },
+  [
+    "enterprise"
+    /* Enterprise */
+  ]: {
+    verificationRequests: "Unlimited"
+  }
+};
+exports.Tier = Tier;
+exports.TierMonthlyLimits = TierMonthlyLimits;
+exports.TierSchema = TierSchema;

package/dist/cjs/config/config.cjs

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const locale = require("@prosopo/locale");
+const z = require("zod");
+require("../provider/index.cjs");
+const frictionless = require("./frictionless.cjs");
+const timeouts = require("./timeouts.cjs");
+const api = require("../provider/api.cjs");
+const LogLevel = z.enum([
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+  "log"
+]);
+const DatabaseTypes = z.enum([
+  "mongo",
+  "mongoMemory",
+  "provider",
+  "client",
+  "captcha"
+]);
+const EnvironmentTypesSchema = z.enum([
+  "development",
+  "staging",
+  "production"
+]);
+const DatabaseConfigSchema = z.record(
+  EnvironmentTypesSchema,
+  z.object({
+    type: z.string(),
+    endpoint: z.string(),
+    dbname: z.string().default("prosopo"),
+    authSource: z.string().default("admin")
+  })
+);
+const ProsopoBaseConfigSchema = z.object({
+  logLevel: LogLevel.optional().default(LogLevel.enum.info),
+  defaultEnvironment: EnvironmentTypesSchema.default(
+    EnvironmentTypesSchema.Values.production
+  ),
+  // The account with which to query the contract.merge sign transactions
+  account: z.object({
+    address: z.string().optional(),
+    secret: z.string().optional(),
+    password: z.string().optional()
+  })
+});
+const PolkadotSecretJSONSpec = z.object({
+  encoded: z.string(),
+  encoding: z.object({
+    content: z.array(z.string()),
+    type: z.array(z.string()),
+    version: z.string()
+  }),
+  address: z.string(),
+  meta: z.object({
+    genesisHash: z.string(),
+    name: z.string(),
+    whenCreated: z.number()
+  })
+});
+const ProsopoBasicConfigSchema = ProsopoBaseConfigSchema.merge(
+  z.object({
+    database: DatabaseConfigSchema.optional(),
+    devOnlyWatchEvents: z.boolean().optional()
+  })
+);
+const ProsopoImageServerConfigSchema = z.object({
+  baseURL: z.string().url(),
+  port: z.number().optional().default(9229)
+});
+const ProsopoCaptchaSolutionConfigSchema = z.object({
+  requiredNumberOfSolutions: z.number().positive().min(2),
+  solutionWinningPercentage: z.number().positive().max(100),
+  captchaBlockRecency: z.number().positive().min(2)
+});
+const ProsopoClientConfigSchema = ProsopoBasicConfigSchema.merge(
+  z.object({
+    userAccountAddress: z.string().optional(),
+    web2: z.boolean().optional().default(true),
+    solutionThreshold: z.number().positive().max(100).optional().default(80),
+    dappName: z.string().optional().default("ProsopoClientDapp"),
+    serverUrl: z.string().optional()
+  })
+);
+const defaultImageCaptchaTimeouts = {
+  challengeTimeout: timeouts.DEFAULT_IMAGE_CAPTCHA_TIMEOUT,
+  solutionTimeout: timeouts.DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT,
+  verifiedTimeout: timeouts.DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT,
+  cachedTimeout: timeouts.DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED
+};
+const defaultPoWCaptchaTimeouts = {
+  challengeTimeout: timeouts.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT,
+  solutionTimeout: timeouts.DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT,
+  cachedTimeout: timeouts.DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT
+};
+const defaultContractCaptchaTimeouts = {
+  maxVerifiedTime: timeouts.DEFAULT_MAX_VERIFIED_TIME_CONTRACT
+};
+const defaultCaptchaTimeouts = {
+  image: defaultImageCaptchaTimeouts,
+  pow: defaultPoWCaptchaTimeouts,
+  contract: defaultContractCaptchaTimeouts
+};
+const CaptchaTimeoutSchema = z.object({
+  image: z.object({
+    // Set this to a default value for the frontend
+    challengeTimeout: z.number().positive().optional().default(timeouts.DEFAULT_IMAGE_CAPTCHA_TIMEOUT),
+    // Set this to a default value for the frontend
+    solutionTimeout: z.number().positive().optional().default(timeouts.DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT),
+    verifiedTimeout: z.number().positive().optional().default(timeouts.DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT),
+    cachedTimeout: z.number().positive().optional().default(timeouts.DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED)
+  }).default(defaultImageCaptchaTimeouts),
+  pow: z.object({
+    verifiedTimeout: z.number().positive().optional().default(timeouts.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT),
+    solutionTimeout: z.number().positive().optional().default(timeouts.DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT),
+    cachedTimeout: z.number().positive().optional().default(timeouts.DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT)
+  }).default(defaultPoWCaptchaTimeouts),
+  contract: z.object({
+    maxVerifiedTime: z.number().positive().optional().default(timeouts.DEFAULT_MAX_VERIFIED_TIME_CONTRACT)
+  }).default(defaultContractCaptchaTimeouts)
+}).default(defaultCaptchaTimeouts);
+const ProsopoServerConfigSchema = ProsopoClientConfigSchema.merge(
+  z.object({
+    serverUrl: z.string().url().optional(),
+    timeouts: CaptchaTimeoutSchema.optional().default(defaultCaptchaTimeouts)
+  })
+);
+const AccountCreatorConfigSchema = z.object({
+  area: z.object({
+    width: z.number().positive(),
+    height: z.number().positive()
+  }),
+  offsetParameter: z.number().positive(),
+  multiplier: z.number().positive(),
+  fontSizeFactor: z.number().positive(),
+  maxShadowBlur: z.number().positive(),
+  numberOfRounds: z.number().positive(),
+  seed: z.number().positive()
+});
+const ThemeType = z.union([z.literal("light"), z.literal("dark")]);
+var ModeEnum = /* @__PURE__ */ ((ModeEnum2) => {
+  ModeEnum2["visible"] = "visible";
+  ModeEnum2["invisible"] = "invisible";
+  return ModeEnum2;
+})(ModeEnum || {});
+const Mode = z.enum([
+  "visible",
+  "invisible"
+  /* invisible */
+]).optional();
+const ProcaptchaConfigSchema = ProsopoClientConfigSchema.and(
+  z.object({
+    theme: ThemeType.optional().default("light"),
+    captchas: CaptchaTimeoutSchema.optional().default(defaultCaptchaTimeouts),
+    language: locale.LanguageSchema.optional(),
+    mode: Mode.optional().default(
+      "visible"
+      /* visible */
+    )
+  })
+);
+const ProsopoConfigSchema = ProsopoBasicConfigSchema.merge(
+  z.object({
+    captchas: api.ProsopoCaptchaCountConfigSchema.optional().default({
+      solved: { count: 1 },
+      unsolved: { count: 0 }
+    }),
+    penalties: frictionless.FrictionlessPenalties,
+    scheduledTasks: z.object({
+      captchaScheduler: z.object({
+        schedule: z.string().optional()
+      }).optional(),
+      clientListScheduler: z.object({
+        schedule: z.string().optional()
+      }).optional()
+    }).optional(),
+    server: ProsopoImageServerConfigSchema,
+    mongoEventsUri: z.string().optional(),
+    mongoCaptchaUri: z.string().optional(),
+    mongoClientUri: z.string().optional(),
+    rateLimits: api.ApiPathRateLimits.default(api.ProviderDefaultRateLimits),
+    proxyCount: z.number().optional().default(0),
+    lRules: z.record(z.string(), z.number()).optional(),
+    authAccount: z.object({
+      address: z.string().optional(),
+      secret: z.string().optional(),
+      password: z.string().optional()
+    })
+  })
+);
+exports.AccountCreatorConfigSchema = AccountCreatorConfigSchema;
+exports.CaptchaTimeoutSchema = CaptchaTimeoutSchema;
+exports.DatabaseConfigSchema = DatabaseConfigSchema;
+exports.DatabaseTypes = DatabaseTypes;
+exports.EnvironmentTypesSchema = EnvironmentTypesSchema;
+exports.Mode = Mode;
+exports.ModeEnum = ModeEnum;
+exports.PolkadotSecretJSONSpec = PolkadotSecretJSONSpec;
+exports.ProcaptchaConfigSchema = ProcaptchaConfigSchema;
+exports.ProsopoBaseConfigSchema = ProsopoBaseConfigSchema;
+exports.ProsopoBasicConfigSchema = ProsopoBasicConfigSchema;
+exports.ProsopoCaptchaSolutionConfigSchema = ProsopoCaptchaSolutionConfigSchema;
+exports.ProsopoClientConfigSchema = ProsopoClientConfigSchema;
+exports.ProsopoConfigSchema = ProsopoConfigSchema;
+exports.ProsopoImageServerConfigSchema = ProsopoImageServerConfigSchema;
+exports.ProsopoServerConfigSchema = ProsopoServerConfigSchema;

package/dist/cjs/config/frictionless.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const FrictionlessPenalties = z.object({
+  PENALTY_OLD_TIMESTAMP: z.number().positive().optional().default(0.2),
+  PENALTY_ACCESS_RULE: z.number().positive().optional().default(0.5)
+});
+exports.FrictionlessPenalties = FrictionlessPenalties;

package/dist/cjs/config/index.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const config = require("./config.cjs");
+const network = require("./network.cjs");
+const timeouts = require("./timeouts.cjs");
+const frictionless = require("./frictionless.cjs");
+exports.AccountCreatorConfigSchema = config.AccountCreatorConfigSchema;
+exports.CaptchaTimeoutSchema = config.CaptchaTimeoutSchema;
+exports.DatabaseConfigSchema = config.DatabaseConfigSchema;
+exports.DatabaseTypes = config.DatabaseTypes;
+exports.EnvironmentTypesSchema = config.EnvironmentTypesSchema;
+exports.Mode = config.Mode;
+exports.ModeEnum = config.ModeEnum;
+exports.PolkadotSecretJSONSpec = config.PolkadotSecretJSONSpec;
+exports.ProcaptchaConfigSchema = config.ProcaptchaConfigSchema;
+exports.ProsopoBaseConfigSchema = config.ProsopoBaseConfigSchema;
+exports.ProsopoBasicConfigSchema = config.ProsopoBasicConfigSchema;
+exports.ProsopoCaptchaSolutionConfigSchema = config.ProsopoCaptchaSolutionConfigSchema;
+exports.ProsopoClientConfigSchema = config.ProsopoClientConfigSchema;
+exports.ProsopoConfigSchema = config.ProsopoConfigSchema;
+exports.ProsopoImageServerConfigSchema = config.ProsopoImageServerConfigSchema;
+exports.ProsopoServerConfigSchema = config.ProsopoServerConfigSchema;
+exports.NetworkPairTypeSchema = network.NetworkPairTypeSchema;
+exports.DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT = timeouts.DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT;
+exports.DEFAULT_IMAGE_CAPTCHA_TIMEOUT = timeouts.DEFAULT_IMAGE_CAPTCHA_TIMEOUT;
+exports.DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT = timeouts.DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT;
+exports.DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED = timeouts.DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED;
+exports.DEFAULT_MAX_VERIFIED_TIME_CONTRACT = timeouts.DEFAULT_MAX_VERIFIED_TIME_CONTRACT;
+exports.DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT = timeouts.DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT;
+exports.DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT = timeouts.DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT;
+exports.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT = timeouts.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT;
+exports.FrictionlessPenalties = frictionless.FrictionlessPenalties;

package/dist/cjs/config/network.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const NetworkPairTypeSchema = z.union([
+  z.literal("sr25519"),
+  z.literal("ed25519"),
+  z.literal("ecdsa"),
+  z.literal("ethereum")
+]);
+exports.NetworkPairTypeSchema = NetworkPairTypeSchema;

package/dist/cjs/config/timeouts.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ONE_MINUTE = 60 * 1e3;
+const DEFAULT_IMAGE_CAPTCHA_TIMEOUT = ONE_MINUTE;
+const DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT = DEFAULT_IMAGE_CAPTCHA_TIMEOUT * 2;
+const DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT = DEFAULT_IMAGE_CAPTCHA_TIMEOUT * 3;
+const DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED = DEFAULT_IMAGE_CAPTCHA_TIMEOUT * 15;
+const DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT = ONE_MINUTE;
+const DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT = DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT * 2;
+const DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT = DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT * 3;
+const DEFAULT_MAX_VERIFIED_TIME_CONTRACT = ONE_MINUTE * 15;
+exports.DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT = DEFAULT_IMAGE_CAPTCHA_SOLUTION_TIMEOUT;
+exports.DEFAULT_IMAGE_CAPTCHA_TIMEOUT = DEFAULT_IMAGE_CAPTCHA_TIMEOUT;
+exports.DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT = DEFAULT_IMAGE_CAPTCHA_VERIFIED_TIMEOUT;
+exports.DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED = DEFAULT_IMAGE_MAX_VERIFIED_TIME_CACHED;
+exports.DEFAULT_MAX_VERIFIED_TIME_CONTRACT = DEFAULT_MAX_VERIFIED_TIME_CONTRACT;
+exports.DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT = DEFAULT_POW_CAPTCHA_CACHED_TIMEOUT;
+exports.DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT = DEFAULT_POW_CAPTCHA_SOLUTION_TIMEOUT;
+exports.DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT = DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT;

package/dist/cjs/datasets/assets.cjs

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

package/dist/cjs/datasets/captcha.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+var CaptchaTypes = /* @__PURE__ */ ((CaptchaTypes2) => {
+  CaptchaTypes2["SelectAll"] = "SelectAll";
+  return CaptchaTypes2;
+})(CaptchaTypes || {});
+var CaptchaItemTypes = /* @__PURE__ */ ((CaptchaItemTypes2) => {
+  CaptchaItemTypes2["Text"] = "text";
+  CaptchaItemTypes2["Image"] = "image";
+  return CaptchaItemTypes2;
+})(CaptchaItemTypes || {});
+var CaptchaStates = /* @__PURE__ */ ((CaptchaStates2) => {
+  CaptchaStates2["Solved"] = "solved";
+  CaptchaStates2["Unsolved"] = "unsolved";
+  return CaptchaStates2;
+})(CaptchaStates || {});
+var CaptchaStatus = /* @__PURE__ */ ((CaptchaStatus2) => {
+  CaptchaStatus2["pending"] = "Pending";
+  CaptchaStatus2["approved"] = "Approved";
+  CaptchaStatus2["disapproved"] = "Disapproved";
+  return CaptchaStatus2;
+})(CaptchaStatus || {});
+var GovernanceStatus = /* @__PURE__ */ ((GovernanceStatus2) => {
+  GovernanceStatus2["active"] = "Active";
+  GovernanceStatus2["inactive"] = "Inactive";
+  return GovernanceStatus2;
+})(GovernanceStatus || {});
+var DappPayee = /* @__PURE__ */ ((DappPayee2) => {
+  DappPayee2["provider"] = "Provider";
+  DappPayee2["dapp"] = "Dapp";
+  DappPayee2["any"] = "Any";
+  return DappPayee2;
+})(DappPayee || {});
+const TimestampSchema = z.number();
+const POW_SEPARATOR = "___";
+const PowChallengeIdSchema = z.custom((val) => {
+  const valSplit = val.split(POW_SEPARATOR);
+  try {
+    Number.parseInt(valSplit[0]);
+    return valSplit.length === 4;
+  } catch (e) {
+    return false;
+  }
+});
+const CaptchaSchema = z.object({
+  captchaId: z.union([z.string(), z.undefined()]),
+  captchaContentId: z.union([z.string(), z.undefined()]),
+  salt: z.string().min(34),
+  solution: z.number().array().optional(),
+  unlabelled: z.number().array().optional(),
+  timeLimit: z.number().optional()
+});
+const CaptchaItemSchema = z.object({
+  hash: z.string(),
+  data: z.string(),
+  type: z.nativeEnum(CaptchaItemTypes)
+});
+const HashedCaptchaItemSchema = CaptchaItemSchema.extend({
+  hash: z.string()
+});
+const LabelledItemSchema = HashedCaptchaItemSchema.extend({
+  label: z.string()
+});
+const MaybeLabelledHashedItemSchema = HashedCaptchaItemSchema.extend({
+  label: z.string().optional()
+});
+const SelectAllCaptchaSchemaRaw = CaptchaSchema.extend({
+  items: z.array(CaptchaItemSchema),
+  target: z.string()
+});
+const SelectAllCaptchaSchema = SelectAllCaptchaSchemaRaw.extend({
+  solution: z.string().array().optional(),
+  unlabelled: z.string().array().optional()
+});
+const SelectAllCaptchaSchemaWithNumericSolution = SelectAllCaptchaSchema.extend({
+  solution: z.number().array().optional(),
+  unlabelled: z.number().array().optional()
+});
+const CaptchasSchema = z.array(SelectAllCaptchaSchemaRaw);
+const CaptchasWithNumericSolutionSchema = z.array(
+  SelectAllCaptchaSchemaWithNumericSolution
+);
+const CaptchaSolutionSchema = z.object({
+  captchaId: z.string(),
+  captchaContentId: z.string(),
+  solution: z.string().array(),
+  salt: z.string().min(34)
+});
+const CaptchaSolutionArraySchema = z.array(CaptchaSolutionSchema);
+const DataSchema = z.object({
+  items: z.array(MaybeLabelledHashedItemSchema)
+});
+const LabelledDataSchema = z.object({
+  items: z.array(LabelledItemSchema)
+});
+const CaptchasContainerSchema = z.object({
+  captchas: CaptchasSchema,
+  format: z.nativeEnum(CaptchaTypes)
+});
+const LabelsContainerSchema = z.object({
+  labels: z.array(z.string())
+});
+exports.CaptchaItemSchema = CaptchaItemSchema;
+exports.CaptchaItemTypes = CaptchaItemTypes;
+exports.CaptchaSchema = CaptchaSchema;
+exports.CaptchaSolutionArraySchema = CaptchaSolutionArraySchema;
+exports.CaptchaSolutionSchema = CaptchaSolutionSchema;
+exports.CaptchaStates = CaptchaStates;
+exports.CaptchaStatus = CaptchaStatus;
+exports.CaptchaTypes = CaptchaTypes;
+exports.CaptchasContainerSchema = CaptchasContainerSchema;
+exports.CaptchasSchema = CaptchasSchema;
+exports.CaptchasWithNumericSolutionSchema = CaptchasWithNumericSolutionSchema;
+exports.DappPayee = DappPayee;
+exports.DataSchema = DataSchema;
+exports.GovernanceStatus = GovernanceStatus;
+exports.HashedCaptchaItemSchema = HashedCaptchaItemSchema;
+exports.LabelledDataSchema = LabelledDataSchema;
+exports.LabelledItemSchema = LabelledItemSchema;
+exports.LabelsContainerSchema = LabelsContainerSchema;
+exports.MaybeLabelledHashedItemSchema = MaybeLabelledHashedItemSchema;
+exports.POW_SEPARATOR = POW_SEPARATOR;
+exports.PowChallengeIdSchema = PowChallengeIdSchema;
+exports.SelectAllCaptchaSchema = SelectAllCaptchaSchema;
+exports.SelectAllCaptchaSchemaRaw = SelectAllCaptchaSchemaRaw;
+exports.SelectAllCaptchaSchemaWithNumericSolution = SelectAllCaptchaSchemaWithNumericSolution;
+exports.TimestampSchema = TimestampSchema;

package/dist/cjs/datasets/dataset.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const captcha = require("./captcha.cjs");
+const DatasetSchema = z.object({
+  datasetId: z.string().optional(),
+  datasetContentId: z.string().optional(),
+  captchas: captcha.CaptchasSchema,
+  format: z.nativeEnum(captcha.CaptchaTypes),
+  solutionTree: z.array(z.array(z.string())).optional(),
+  contentTree: z.array(z.array(z.string())).optional(),
+  timeLimit: z.number().optional()
+});
+const DatasetWithNumericSolutionSchema = DatasetSchema.extend({
+  captchas: captcha.CaptchasWithNumericSolutionSchema
+});
+const DatasetWithIdsSchema = z.object({
+  datasetId: z.string(),
+  datasetContentId: z.string().optional(),
+  captchas: z.array(captcha.SelectAllCaptchaSchema),
+  format: z.nativeEnum(captcha.CaptchaTypes),
+  solutionTree: z.array(z.array(z.string())).optional(),
+  contentTree: z.array(z.array(z.string())).optional()
+});
+const DatasetWithIdsAndTreeSchema = DatasetWithIdsSchema.extend({
+  solutionTree: z.array(z.array(z.string())),
+  contentTree: z.array(z.array(z.string()))
+});
+exports.DatasetSchema = DatasetSchema;
+exports.DatasetWithIdsAndTreeSchema = DatasetWithIdsAndTreeSchema;
+exports.DatasetWithIdsSchema = DatasetWithIdsSchema;
+exports.DatasetWithNumericSolutionSchema = DatasetWithNumericSolutionSchema;

package/dist/cjs/datasets/index.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const captcha = require("./captcha.cjs");
+const dataset = require("./dataset.cjs");
+require("./merkle.cjs");
+require("./assets.cjs");
+exports.CaptchaItemSchema = captcha.CaptchaItemSchema;
+exports.CaptchaItemTypes = captcha.CaptchaItemTypes;
+exports.CaptchaSchema = captcha.CaptchaSchema;
+exports.CaptchaSolutionArraySchema = captcha.CaptchaSolutionArraySchema;
+exports.CaptchaSolutionSchema = captcha.CaptchaSolutionSchema;
+exports.CaptchaStates = captcha.CaptchaStates;
+exports.CaptchaStatus = captcha.CaptchaStatus;
+exports.CaptchaTypes = captcha.CaptchaTypes;
+exports.CaptchasContainerSchema = captcha.CaptchasContainerSchema;
+exports.CaptchasSchema = captcha.CaptchasSchema;
+exports.CaptchasWithNumericSolutionSchema = captcha.CaptchasWithNumericSolutionSchema;
+exports.DappPayee = captcha.DappPayee;
+exports.DataSchema = captcha.DataSchema;
+exports.GovernanceStatus = captcha.GovernanceStatus;
+exports.HashedCaptchaItemSchema = captcha.HashedCaptchaItemSchema;
+exports.LabelledDataSchema = captcha.LabelledDataSchema;
+exports.LabelledItemSchema = captcha.LabelledItemSchema;
+exports.LabelsContainerSchema = captcha.LabelsContainerSchema;
+exports.MaybeLabelledHashedItemSchema = captcha.MaybeLabelledHashedItemSchema;
+exports.POW_SEPARATOR = captcha.POW_SEPARATOR;
+exports.PowChallengeIdSchema = captcha.PowChallengeIdSchema;
+exports.SelectAllCaptchaSchema = captcha.SelectAllCaptchaSchema;
+exports.SelectAllCaptchaSchemaRaw = captcha.SelectAllCaptchaSchemaRaw;
+exports.SelectAllCaptchaSchemaWithNumericSolution = captcha.SelectAllCaptchaSchemaWithNumericSolution;
+exports.TimestampSchema = captcha.TimestampSchema;
+exports.DatasetSchema = dataset.DatasetSchema;
+exports.DatasetWithIdsAndTreeSchema = dataset.DatasetWithIdsAndTreeSchema;
+exports.DatasetWithIdsSchema = dataset.DatasetWithIdsSchema;
+exports.DatasetWithNumericSolutionSchema = dataset.DatasetWithNumericSolutionSchema;

package/dist/cjs/datasets/merkle.cjs

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