@prosopo/types 1.0.2 → 2.0.1

package/dist/cjs/dist/config/config.cjs

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const index = require("../networks/index.cjs");
+require("../provider/index.cjs");
+const network = require("./network.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"]);
+const EnvironmentTypesSchema = z.enum([
+  "development",
+  "staging",
+  "production"
+]);
+const DatabaseConfigSchema = z.record(EnvironmentTypesSchema, z.object({
+  type: z.string(),
+  endpoint: z.string(),
+  dbname: z.string(),
+  authSource: z.string()
+}));
+const BatchCommitConfigSchema = z.object({
+  interval: z.number().positive().optional().default(300),
+  maxBatchExtrinsicPercentage: z.number().positive().optional().default(59)
+});
+const ProsopoBaseConfigSchema = z.object({
+  logLevel: LogLevel.optional().default(LogLevel.enum.info),
+  defaultEnvironment: EnvironmentTypesSchema.default(EnvironmentTypesSchema.Values.production),
+  defaultNetwork: network.NetworkNamesSchema.default(network.NetworkNamesSchema.Values.astar),
+  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({
+  networks: network.ProsopoNetworkSchema.default(index),
+  database: DatabaseConfigSchema.optional(),
+  devOnlyWatchEvents: z.boolean().optional()
+}));
+const ProsopoCaptchaCountConfigSchema = z.object({
+  solved: z.object({
+    count: z.number().positive()
+  }).optional().default({ count: 1 }),
+  unsolved: z.object({
+    count: z.number().nonnegative()
+  }).optional().default({ count: 1 })
+});
+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({
+    challengeTimeout: z.number().positive().optional().default(timeouts.DEFAULT_IMAGE_CAPTCHA_TIMEOUT),
+    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")]);
+const ProcaptchaConfigSchema = ProsopoClientConfigSchema.and(z.object({
+  accountCreator: AccountCreatorConfigSchema.optional(),
+  theme: ThemeType.optional(),
+  captchas: CaptchaTimeoutSchema.optional().default(defaultCaptchaTimeouts)
+}));
+const ProsopoConfigSchema = ProsopoBasicConfigSchema.merge(z.object({
+  captchas: ProsopoCaptchaCountConfigSchema.optional().default({
+    solved: { count: 1 },
+    unsolved: { count: 0 }
+  }),
+  captchaSolutions: ProsopoCaptchaSolutionConfigSchema.optional().default({
+    requiredNumberOfSolutions: 3,
+    solutionWinningPercentage: 80,
+    captchaBlockRecency: 10
+  }),
+  batchCommit: BatchCommitConfigSchema.optional().default({
+    interval: 300,
+    maxBatchExtrinsicPercentage: 59
+  }),
+  captchaScheduler: z.object({
+    schedule: z.string().optional()
+  }).optional(),
+  server: ProsopoImageServerConfigSchema,
+  mongoEventsUri: z.string().optional(),
+  mongoCaptchaUri: z.string().optional(),
+  rateLimits: api.ApiPathRateLimits.default(api.ProviderDefaultRateLimits),
+  proxyCount: z.number().optional().default(0)
+}));
+exports.AccountCreatorConfigSchema = AccountCreatorConfigSchema;
+exports.BatchCommitConfigSchema = BatchCommitConfigSchema;
+exports.CaptchaTimeoutSchema = CaptchaTimeoutSchema;
+exports.DatabaseConfigSchema = DatabaseConfigSchema;
+exports.DatabaseTypes = DatabaseTypes;
+exports.EnvironmentTypesSchema = EnvironmentTypesSchema;
+exports.PolkadotSecretJSONSpec = PolkadotSecretJSONSpec;
+exports.ProcaptchaConfigSchema = ProcaptchaConfigSchema;
+exports.ProsopoBaseConfigSchema = ProsopoBaseConfigSchema;
+exports.ProsopoBasicConfigSchema = ProsopoBasicConfigSchema;
+exports.ProsopoCaptchaCountConfigSchema = ProsopoCaptchaCountConfigSchema;
+exports.ProsopoCaptchaSolutionConfigSchema = ProsopoCaptchaSolutionConfigSchema;
+exports.ProsopoClientConfigSchema = ProsopoClientConfigSchema;
+exports.ProsopoConfigSchema = ProsopoConfigSchema;
+exports.ProsopoImageServerConfigSchema = ProsopoImageServerConfigSchema;
+exports.ProsopoServerConfigSchema = ProsopoServerConfigSchema;

package/dist/cjs/dist/config/enumMap.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const enumMap = (enumeration, obj) => {
+  const validateKeysInEnum = (record) => Object.keys(record).every((key) => enumeration.safeParse(key).success);
+  return z.record(obj).refine(validateKeysInEnum);
+};
+exports.enumMap = enumMap;

package/dist/cjs/dist/config/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const config = require("./config.cjs");
+const network = require("./network.cjs");
+const timeouts = require("./timeouts.cjs");
+exports.AccountCreatorConfigSchema = config.AccountCreatorConfigSchema;
+exports.BatchCommitConfigSchema = config.BatchCommitConfigSchema;
+exports.CaptchaTimeoutSchema = config.CaptchaTimeoutSchema;
+exports.DatabaseConfigSchema = config.DatabaseConfigSchema;
+exports.DatabaseTypes = config.DatabaseTypes;
+exports.EnvironmentTypesSchema = config.EnvironmentTypesSchema;
+exports.PolkadotSecretJSONSpec = config.PolkadotSecretJSONSpec;
+exports.ProcaptchaConfigSchema = config.ProcaptchaConfigSchema;
+exports.ProsopoBaseConfigSchema = config.ProsopoBaseConfigSchema;
+exports.ProsopoBasicConfigSchema = config.ProsopoBasicConfigSchema;
+exports.ProsopoCaptchaCountConfigSchema = config.ProsopoCaptchaCountConfigSchema;
+exports.ProsopoCaptchaSolutionConfigSchema = config.ProsopoCaptchaSolutionConfigSchema;
+exports.ProsopoClientConfigSchema = config.ProsopoClientConfigSchema;
+exports.ProsopoConfigSchema = config.ProsopoConfigSchema;
+exports.ProsopoImageServerConfigSchema = config.ProsopoImageServerConfigSchema;
+exports.ProsopoServerConfigSchema = config.ProsopoServerConfigSchema;
+exports.NetworkConfigSchema = network.NetworkConfigSchema;
+exports.NetworkNamesSchema = network.NetworkNamesSchema;
+exports.NetworkPairTypeSchema = network.NetworkPairTypeSchema;
+exports.ProsopoNetworkSchema = network.ProsopoNetworkSchema;
+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;

package/dist/cjs/dist/config/network.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+const enumMap = require("./enumMap.cjs");
+const NetworkNamesSchema = z.enum([
+  "development",
+  "rococo",
+  "shiden",
+  "astar"
+]);
+const NetworkPairTypeSchema = z.union([
+  z.literal("sr25519"),
+  z.literal("ed25519"),
+  z.literal("ecdsa"),
+  z.literal("ethereum")
+]);
+const NetworkConfigSchema = z.object({
+  endpoint: z.array(z.string().url()),
+  contract: z.object({
+    address: z.string(),
+    name: z.string()
+  }),
+  pairType: NetworkPairTypeSchema,
+  ss58Format: z.number().positive().default(42)
+});
+const ProsopoNetworkSchema = enumMap.enumMap(NetworkNamesSchema, NetworkConfigSchema.required({
+  endpoint: true,
+  pairType: true,
+  ss58Format: true
+}));
+exports.NetworkConfigSchema = NetworkConfigSchema;
+exports.NetworkNamesSchema = NetworkNamesSchema;
+exports.NetworkPairTypeSchema = NetworkPairTypeSchema;
+exports.ProsopoNetworkSchema = ProsopoNetworkSchema;

package/dist/cjs/dist/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/dist/contract/artifacts.cjs

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const native = require("@polkadot/types-codec/native");
+const z = require("zod");
+const AbiParamSpec = z.object({
+  name: z.string(),
+  type: z.union([z.number(), z.string()])
+});
+const AbiFieldSpec = z.object({
+  name: z.string().optional(),
+  type: z.number(),
+  typeName: z.string().optional()
+});
+const AbiVariantSpec = z.object({
+  index: z.number(),
+  name: z.string()
+});
+const AbiStorageEnumFieldSpec = z.object({
+  name: z.string(),
+  fields: z.array(z.any())
+});
+const AbiStorageEnumSpec = z.record(z.number().min(0), AbiStorageEnumFieldSpec);
+const AbiTypeSpec = z.object({
+  id: z.number(),
+  type: z.object({
+    def: z.object({
+      composite: z.object({
+        fields: z.array(AbiFieldSpec).optional()
+      }).optional(),
+      variant: z.object({
+        variants: z.union([
+          z.array(AbiVariantSpec).optional(),
+          AbiStorageEnumSpec
+        ])
+      }).optional(),
+      sequence: z.object({
+        type: z.number()
+      }).optional(),
+      array: z.object({
+        len: z.number(),
+        type: z.number()
+      }).optional(),
+      primitive: z.string().optional(),
+      tuple: z.any().optional()
+    }),
+    params: z.array(AbiParamSpec).optional(),
+    path: z.array(z.string()).optional()
+  })
+});
+const AbiEnumSpec = z.object({
+  dispatchKey: z.string(),
+  variants: z.any()
+});
+const AbiText = z.union([z.instanceof(native.Text), z.string()]);
+const AbiCellSpec = z.object({
+  key: AbiText,
+  ty: z.union([z.number(), z.string()])
+});
+const AbiTypesSpec = z.array(AbiTypeSpec);
+const AbiStorageFieldSpec = z.lazy(() => z.object({
+  name: AbiText.optional(),
+  layout: z.object({
+    leaf: AbiCellSpec.optional(),
+    enum: AbiEnumSpec.optional(),
+    root: AbiStorageFieldSpec.optional(),
+    struct: AbiStorageStructSpec.optional()
+  }),
+  root_key: AbiText.optional()
+}));
+const AbiStorageStructSpec = z.object({
+  fields: z.array(AbiStorageFieldSpec),
+  name: z.string()
+});
+const AbiStorageSpec = z.object({
+  root: z.object({
+    layout: z.object({
+      struct: AbiStorageStructSpec.optional()
+    })
+  })
+});
+const AbiSpecDef = z.object({
+  constructors: z.array(z.any()),
+  docs: z.array(z.any()),
+  events: z.array(z.any()),
+  messages: z.array(z.object({
+    label: z.string(),
+    selector: z.string()
+  }))
+});
+var metadataVersion;
+(function(metadataVersion2) {
+  metadataVersion2["V1"] = "V1";
+  metadataVersion2["V2"] = "V2";
+  metadataVersion2["V3"] = "V3";
+})(metadataVersion || (metadataVersion = {}));
+const AbiDetailsSpec = z.object({
+  spec: AbiSpecDef,
+  types: AbiTypesSpec,
+  storage: AbiStorageSpec
+});
+const AbiMetaDataSpec = z.object({
+  metadataVersion: z.string().optional(),
+  source: z.object({
+    hash: z.string(),
+    language: z.string(),
+    compiler: z.string(),
+    wasm: z.string().optional()
+  }),
+  contract: z.object({
+    name: z.string(),
+    version: z.string(),
+    authors: z.array(z.string())
+  }),
+  [metadataVersion.V1]: AbiDetailsSpec.optional(),
+  [metadataVersion.V2]: AbiDetailsSpec.optional(),
+  [metadataVersion.V3]: AbiDetailsSpec.optional(),
+  spec: AbiSpecDef,
+  types: AbiTypesSpec,
+  storage: AbiStorageSpec
+});
+exports.AbiCellSpec = AbiCellSpec;
+exports.AbiDetailsSpec = AbiDetailsSpec;
+exports.AbiEnumSpec = AbiEnumSpec;
+exports.AbiFieldSpec = AbiFieldSpec;
+exports.AbiMetaDataSpec = AbiMetaDataSpec;
+exports.AbiParamSpec = AbiParamSpec;
+exports.AbiSpecDef = AbiSpecDef;
+exports.AbiStorageEnumSpec = AbiStorageEnumSpec;
+exports.AbiStorageFieldSpec = AbiStorageFieldSpec;
+exports.AbiStorageSpec = AbiStorageSpec;
+exports.AbiStorageStructSpec = AbiStorageStructSpec;
+exports.AbiText = AbiText;
+exports.AbiTypeSpec = AbiTypeSpec;
+exports.AbiTypesSpec = AbiTypesSpec;
+exports.AbiVariantSpec = AbiVariantSpec;

package/dist/cjs/dist/contract/batch.cjs

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

package/dist/cjs/dist/contract/contract.cjs

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

package/dist/cjs/dist/contract/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const artifacts = require("./artifacts.cjs");
+require("./contract.cjs");
+require("./interface.cjs");
+require("./useWeight.cjs");
+require("./batch.cjs");
+exports.AbiCellSpec = artifacts.AbiCellSpec;
+exports.AbiDetailsSpec = artifacts.AbiDetailsSpec;
+exports.AbiEnumSpec = artifacts.AbiEnumSpec;
+exports.AbiFieldSpec = artifacts.AbiFieldSpec;
+exports.AbiMetaDataSpec = artifacts.AbiMetaDataSpec;
+exports.AbiParamSpec = artifacts.AbiParamSpec;
+exports.AbiSpecDef = artifacts.AbiSpecDef;
+exports.AbiStorageEnumSpec = artifacts.AbiStorageEnumSpec;
+exports.AbiStorageFieldSpec = artifacts.AbiStorageFieldSpec;
+exports.AbiStorageSpec = artifacts.AbiStorageSpec;
+exports.AbiStorageStructSpec = artifacts.AbiStorageStructSpec;
+exports.AbiText = artifacts.AbiText;
+exports.AbiTypeSpec = artifacts.AbiTypeSpec;
+exports.AbiTypesSpec = artifacts.AbiTypesSpec;
+exports.AbiVariantSpec = artifacts.AbiVariantSpec;

package/dist/cjs/dist/contract/interface.cjs

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

package/dist/cjs/dist/contract/useWeight.cjs

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

package/dist/cjs/dist/datasets/assets.cjs

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

package/dist/cjs/dist/datasets/captcha.cjs

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const z = require("zod");
+exports.CaptchaTypes = void 0;
+(function(CaptchaTypes) {
+  CaptchaTypes["SelectAll"] = "SelectAll";
+})(exports.CaptchaTypes || (exports.CaptchaTypes = {}));
+exports.CaptchaItemTypes = void 0;
+(function(CaptchaItemTypes) {
+  CaptchaItemTypes["Text"] = "text";
+  CaptchaItemTypes["Image"] = "image";
+})(exports.CaptchaItemTypes || (exports.CaptchaItemTypes = {}));
+exports.CaptchaStates = void 0;
+(function(CaptchaStates) {
+  CaptchaStates["Solved"] = "solved";
+  CaptchaStates["Unsolved"] = "unsolved";
+})(exports.CaptchaStates || (exports.CaptchaStates = {}));
+exports.CaptchaStatus = void 0;
+(function(CaptchaStatus) {
+  CaptchaStatus["pending"] = "Pending";
+  CaptchaStatus["approved"] = "Approved";
+  CaptchaStatus["disapproved"] = "Disapproved";
+})(exports.CaptchaStatus || (exports.CaptchaStatus = {}));
+exports.GovernanceStatus = void 0;
+(function(GovernanceStatus) {
+  GovernanceStatus["active"] = "Active";
+  GovernanceStatus["inactive"] = "Inactive";
+})(exports.GovernanceStatus || (exports.GovernanceStatus = {}));
+exports.DappPayee = void 0;
+(function(DappPayee) {
+  DappPayee["provider"] = "Provider";
+  DappPayee["dapp"] = "Dapp";
+  DappPayee["any"] = "Any";
+})(exports.DappPayee || (exports.DappPayee = {}));
+const POW_SEPARATOR = "___";
+const PowChallengeIdSchema = z.custom((val) => {
+  const valSplit = val.split(POW_SEPARATOR);
+  try {
+    parseInt(valSplit[0]);
+    return valSplit.length === 3;
+  } 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(exports.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(exports.CaptchaTypes)
+});
+const LabelsContainerSchema = z.object({
+  labels: z.array(z.string())
+});
+exports.CaptchaItemSchema = CaptchaItemSchema;
+exports.CaptchaSchema = CaptchaSchema;
+exports.CaptchaSolutionArraySchema = CaptchaSolutionArraySchema;
+exports.CaptchaSolutionSchema = CaptchaSolutionSchema;
+exports.CaptchasContainerSchema = CaptchasContainerSchema;
+exports.CaptchasSchema = CaptchasSchema;
+exports.CaptchasWithNumericSolutionSchema = CaptchasWithNumericSolutionSchema;
+exports.DataSchema = DataSchema;
+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;

package/dist/cjs/dist/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/dist/datasets/index.cjs

@@ -0,0 +1,52 @@
+"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;
+Object.defineProperty(exports, "CaptchaItemTypes", {
+  enumerable: true,
+  get: () => captcha.CaptchaItemTypes
+});
+exports.CaptchaSchema = captcha.CaptchaSchema;
+exports.CaptchaSolutionArraySchema = captcha.CaptchaSolutionArraySchema;
+exports.CaptchaSolutionSchema = captcha.CaptchaSolutionSchema;
+Object.defineProperty(exports, "CaptchaStates", {
+  enumerable: true,
+  get: () => captcha.CaptchaStates
+});
+Object.defineProperty(exports, "CaptchaStatus", {
+  enumerable: true,
+  get: () => captcha.CaptchaStatus
+});
+Object.defineProperty(exports, "CaptchaTypes", {
+  enumerable: true,
+  get: () => captcha.CaptchaTypes
+});
+exports.CaptchasContainerSchema = captcha.CaptchasContainerSchema;
+exports.CaptchasSchema = captcha.CaptchasSchema;
+exports.CaptchasWithNumericSolutionSchema = captcha.CaptchasWithNumericSolutionSchema;
+Object.defineProperty(exports, "DappPayee", {
+  enumerable: true,
+  get: () => captcha.DappPayee
+});
+exports.DataSchema = captcha.DataSchema;
+Object.defineProperty(exports, "GovernanceStatus", {
+  enumerable: true,
+  get: () => 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.DatasetSchema = dataset.DatasetSchema;
+exports.DatasetWithIdsAndTreeSchema = dataset.DatasetWithIdsAndTreeSchema;
+exports.DatasetWithIdsSchema = dataset.DatasetWithIdsSchema;
+exports.DatasetWithNumericSolutionSchema = dataset.DatasetWithNumericSolutionSchema;

package/dist/cjs/dist/datasets/merkle.cjs

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

package/dist/cjs/dist/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./api/index.cjs");
+require("./config/index.cjs");
+require("./contract/index.cjs");
+require("./datasets/index.cjs");
+require("./provider/index.cjs");
+require("./procaptcha/index.cjs");
+const index$1 = require("./procaptcha-bundle/index.cjs");
+require("./procaptcha-frictionless/index.cjs");
+const index = require("./networks/index.cjs");
+Object.defineProperty(exports, "FeaturesEnum", {
+  enumerable: true,
+  get: () => index$1.FeaturesEnum
+});
+exports.networks = index;