@prosopo/types 0.2.13 → 0.2.14

package/dist/cjs/config/config.cjs

@@ -4,90 +4,94 @@ const common = require("@prosopo/common");
 const network = require("./network.cjs");
 const z = require("zod");
 const index = require("../networks/index.cjs");
-const DatabaseTypes = z.z.enum(["mongo", "mongoMemory"]);
-const EnvironmentTypesSchema = z.z.enum(["development", "staging", "production"]);
-const DatabaseConfigSchema = z.z.record(
+const DatabaseTypes = z.enum(["mongo", "mongoMemory"]);
+const EnvironmentTypesSchema = z.enum(["development", "staging", "production"]);
+const DatabaseConfigSchema = z.record(
   EnvironmentTypesSchema,
-  z.z.object({
-    type: z.z.string(),
-    endpoint: z.z.string(),
-    dbname: z.z.string(),
-    authSource: z.z.string()
+  z.object({
+    type: z.string(),
+    endpoint: z.string(),
+    dbname: z.string(),
+    authSource: z.string()
   })
 );
-const BatchCommitConfigSchema = z.z.object({
-  interval: z.z.number().positive().optional().default(300),
-  maxBatchExtrinsicPercentage: z.z.number().positive().optional().default(59)
+const BatchCommitConfigSchema = z.object({
+  interval: z.number().positive().optional().default(300),
+  maxBatchExtrinsicPercentage: z.number().positive().optional().default(59)
 });
-const ProsopoBaseConfigSchema = z.z.object({
+const ProsopoBaseConfigSchema = z.object({
   logLevel: common.LogLevel.optional().default(common.LogLevel.enum.info),
   defaultEnvironment: EnvironmentTypesSchema.default(EnvironmentTypesSchema.Values.production),
   defaultNetwork: network.NetworkNamesSchema.default(network.NetworkNamesSchema.Values.rococo),
   // The account with which to query the contract.merge sign transactions
-  account: z.z.object({
-    address: z.z.string().optional(),
-    secret: z.z.string().optional(),
-    password: z.z.string().optional()
+  account: z.object({
+    address: z.string().optional(),
+    secret: z.string().optional(),
+    password: z.string().optional()
   })
 });
 const ProsopoBasicConfigSchema = ProsopoBaseConfigSchema.merge(
-  z.z.object({
+  z.object({
     networks: network.ProsopoNetworksSchema.default(index),
     database: DatabaseConfigSchema.optional()
   })
 );
-const ProsopoCaptchaCountConfigSchema = z.z.object({
-  solved: z.z.object({
-    count: z.z.number().positive()
+const ProsopoCaptchaCountConfigSchema = z.object({
+  solved: z.object({
+    count: z.number().positive()
   }).optional().default({ count: 1 }),
-  unsolved: z.z.object({
-    count: z.z.number().nonnegative()
+  unsolved: z.object({
+    count: z.number().nonnegative()
   }).optional().default({ count: 1 })
 });
-const ProsopoImageServerConfigSchema = z.z.object({
-  baseURL: z.z.string().url(),
-  port: z.z.number().optional().default(9229)
+const ProsopoImageServerConfigSchema = z.object({
+  baseURL: z.string().url(),
+  port: z.number().optional().default(9229)
 });
-const ProsopoCaptchaSolutionConfigSchema = z.z.object({
-  requiredNumberOfSolutions: z.z.number().positive().min(2),
-  solutionWinningPercentage: z.z.number().positive().max(100),
-  captchaBlockRecency: z.z.number().positive().min(2)
+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.z.object({
-    userAccountAddress: z.z.string().optional(),
-    web2: z.z.boolean().optional().default(true),
-    solutionThreshold: z.z.number().positive().max(100).optional().default(80),
-    dappName: z.z.string().optional().default("ProsopoClientDapp"),
-    serverUrl: z.z.string().url()
+  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()
   })
-).refine((schema) => schema.defaultNetwork in schema.networks, "defaultNetwork must be in networks");
-const ProsopoServerConfigSchema = ProsopoClientConfigSchema;
-const AccountCreatorConfigSchema = z.z.object({
-  area: z.z.object({
-    width: z.z.number().positive(),
-    height: z.z.number().positive()
+);
+const ProsopoServerConfigSchema = ProsopoClientConfigSchema.merge(
+  z.object({
+    serverUrl: z.string().url()
+  })
+);
+const AccountCreatorConfigSchema = z.object({
+  area: z.object({
+    width: z.number().positive(),
+    height: z.number().positive()
   }),
-  offsetParameter: z.z.number().positive(),
-  multiplier: z.z.number().positive(),
-  fontSizeFactor: z.z.number().positive(),
-  maxShadowBlur: z.z.number().positive(),
-  numberOfRounds: z.z.number().positive(),
-  seed: z.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.z.union([z.z.literal("light"), z.z.literal("dark")]);
+const ThemeType = z.union([z.literal("light"), z.literal("dark")]);
 const ProcaptchaConfigSchema = ProsopoClientConfigSchema.and(
-  z.z.object({
+  z.object({
     accountCreator: AccountCreatorConfigSchema.optional(),
     theme: ThemeType.optional(),
-    challengeValidLength: z.z.number().positive().optional()
+    challengeValidLength: z.number().positive().optional()
   })
 );
 const ProsopoConfigSchema = ProsopoBasicConfigSchema.merge(
-  z.z.object({
+  z.object({
     captchas: ProsopoCaptchaCountConfigSchema.optional().default({
       solved: { count: 1 },
-      unsolved: { count: 1 }
+      unsolved: { count: 0 }
     }),
     captchaSolutions: ProsopoCaptchaSolutionConfigSchema.optional().default({
       requiredNumberOfSolutions: 3,

package/dist/cjs/config/enumMap.cjs

@@ -2,7 +2,7 @@
 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.z.record(obj).refine(validateKeysInEnum);
+  const validateKeysInEnum = (record2) => Object.keys(record2).every((key) => enumeration.safeParse(key).success);
+  return z.record(obj).refine(validateKeysInEnum);
 };
 exports.enumMap = enumMap;

package/dist/cjs/config/network.cjs

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

package/dist/cjs/contract/artifacts.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@polkadot/types");
+const native = require("@polkadot/types-codec/native");
 const z = require("zod");
 const AbiParamSpec = z.object({
   name: z.string(),
@@ -48,7 +48,7 @@ const AbiEnumSpec = z.object({
   dispatchKey: z.string(),
   variants: z.any()
 });
-const AbiText = z.union([z.instanceof(types.Text), z.string()]);
+const AbiText = z.union([z.instanceof(native.Text), z.string()]);
 const AbiCellSpec = z.object({
   key: AbiText,
   ty: z.union([z.number(), z.string()])

package/dist/cjs/datasets/captcha.cjs

@@ -15,61 +15,61 @@ var CaptchaStates = /* @__PURE__ */ ((CaptchaStates2) => {
   CaptchaStates2["Unsolved"] = "unsolved";
   return CaptchaStates2;
 })(CaptchaStates || {});
-const CaptchaSchema = z.z.object({
-  captchaId: z.z.union([z.z.string(), z.z.undefined()]),
-  captchaContentId: z.z.union([z.z.string(), z.z.undefined()]),
-  salt: z.z.string().min(34),
-  solution: z.z.number().array().optional(),
-  unlabelled: z.z.number().array().optional(),
-  timeLimit: z.z.number().optional()
+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.z.object({
-  hash: z.z.string(),
-  data: z.z.string(),
-  type: z.z.nativeEnum(CaptchaItemTypes)
+const CaptchaItemSchema = z.object({
+  hash: z.string(),
+  data: z.string(),
+  type: z.nativeEnum(CaptchaItemTypes)
 });
 const HashedCaptchaItemSchema = CaptchaItemSchema.extend({
-  hash: z.z.string()
+  hash: z.string()
 });
 const LabelledItemSchema = HashedCaptchaItemSchema.extend({
-  label: z.z.string()
+  label: z.string()
 });
 const MaybeLabelledHashedItemSchema = HashedCaptchaItemSchema.extend({
-  label: z.z.string().optional()
+  label: z.string().optional()
 });
 const SelectAllCaptchaSchemaRaw = CaptchaSchema.extend({
-  items: z.z.array(CaptchaItemSchema),
-  target: z.z.string()
+  items: z.array(CaptchaItemSchema),
+  target: z.string()
 });
 const SelectAllCaptchaSchema = SelectAllCaptchaSchemaRaw.extend({
-  solution: z.z.string().array().optional(),
-  unlabelled: z.z.string().array().optional()
+  solution: z.string().array().optional(),
+  unlabelled: z.string().array().optional()
 });
 const SelectAllCaptchaSchemaWithNumericSolution = SelectAllCaptchaSchema.extend({
-  solution: z.z.number().array().optional(),
-  unlabelled: z.z.number().array().optional()
+  solution: z.number().array().optional(),
+  unlabelled: z.number().array().optional()
 });
-const CaptchasSchema = z.z.array(SelectAllCaptchaSchemaRaw);
-const CaptchasWithNumericSolutionSchema = z.z.array(SelectAllCaptchaSchemaWithNumericSolution);
-const CaptchaSolutionSchema = z.z.object({
-  captchaId: z.z.string(),
-  captchaContentId: z.z.string(),
-  solution: z.z.string().array(),
-  salt: z.z.string().min(34)
+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.z.array(CaptchaSolutionSchema);
-const DataSchema = z.z.object({
-  items: z.z.array(MaybeLabelledHashedItemSchema)
+const CaptchaSolutionArraySchema = z.array(CaptchaSolutionSchema);
+const DataSchema = z.object({
+  items: z.array(MaybeLabelledHashedItemSchema)
 });
-const LabelledDataSchema = z.z.object({
-  items: z.z.array(LabelledItemSchema)
+const LabelledDataSchema = z.object({
+  items: z.array(LabelledItemSchema)
 });
-const CaptchasContainerSchema = z.z.object({
+const CaptchasContainerSchema = z.object({
   captchas: CaptchasSchema,
-  format: z.z.nativeEnum(CaptchaTypes)
+  format: z.nativeEnum(CaptchaTypes)
 });
-const LabelsContainerSchema = z.z.object({
-  labels: z.z.array(z.z.string())
+const LabelsContainerSchema = z.object({
+  labels: z.array(z.string())
 });
 exports.CaptchaItemSchema = CaptchaItemSchema;
 exports.CaptchaItemTypes = CaptchaItemTypes;

package/dist/cjs/datasets/dataset.cjs

@@ -2,29 +2,29 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const captcha = require("./captcha.cjs");
 const z = require("zod");
-const DatasetSchema = z.z.object({
-  datasetId: z.z.string().optional(),
-  datasetContentId: z.z.string().optional(),
+const DatasetSchema = z.object({
+  datasetId: z.string().optional(),
+  datasetContentId: z.string().optional(),
   captchas: captcha.CaptchasSchema,
-  format: z.z.nativeEnum(captcha.CaptchaTypes),
-  solutionTree: z.z.array(z.z.array(z.z.string())).optional(),
-  contentTree: z.z.array(z.z.array(z.z.string())).optional(),
-  timeLimit: z.z.number().optional()
+  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.z.object({
-  datasetId: z.z.string(),
-  datasetContentId: z.z.string().optional(),
-  captchas: z.z.array(captcha.SelectAllCaptchaSchema),
-  format: z.z.nativeEnum(captcha.CaptchaTypes),
-  solutionTree: z.z.array(z.z.array(z.z.string())).optional(),
-  contentTree: z.z.array(z.z.array(z.z.string())).optional()
+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.z.array(z.z.array(z.z.string())),
-  contentTree: z.z.array(z.z.array(z.z.string()))
+  solutionTree: z.array(z.array(z.string())),
+  contentTree: z.array(z.array(z.string()))
 });
 exports.DatasetSchema = DatasetSchema;
 exports.DatasetWithIdsAndTreeSchema = DatasetWithIdsAndTreeSchema;

package/dist/cjs/procaptcha/manager.cjs

@@ -3,14 +3,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../provider/index.cjs");
 const z = require("zod");
 const api = require("../provider/api.cjs");
-const ProcaptchaOutputSchema = z.z.object({
-  [api.ApiParams.commitmentId]: z.z.string().optional(),
-  [api.ApiParams.providerUrl]: z.z.string().optional(),
-  [api.ApiParams.dapp]: z.z.string(),
-  [api.ApiParams.user]: z.z.string(),
-  [api.ApiParams.blockNumber]: z.z.number().optional()
+const ProcaptchaOutputSchema = z.object({
+  [api.ApiParams.commitmentId]: z.string().optional(),
+  [api.ApiParams.providerUrl]: z.string().optional(),
+  [api.ApiParams.dapp]: z.string(),
+  [api.ApiParams.user]: z.string(),
+  [api.ApiParams.blockNumber]: z.number().optional()
 });
-const ProcaptchaResponse = z.z.object({
+const ProcaptchaResponse = z.object({
   [api.ApiParams.procaptchaResponse]: ProcaptchaOutputSchema
 });
 exports.ProcaptchaOutputSchema = ProcaptchaOutputSchema;

package/dist/cjs/provider/api.cjs

@@ -20,60 +20,61 @@ var ApiParams = /* @__PURE__ */ ((ApiParams2) => {
   ApiParams2["requestHash"] = "requestHash";
   ApiParams2["captchas"] = "captchas";
   ApiParams2["commitmentId"] = "commitmentId";
+  ApiParams2["proof"] = "proof";
   ApiParams2["providerUrl"] = "providerUrl";
   ApiParams2["procaptchaResponse"] = "procaptcha-response";
   return ApiParams2;
 })(ApiParams || {});
-const CaptchaRequestBody = z.z.object({
+const CaptchaRequestBody = z.object({
   [
     "user"
     /* user */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "dapp"
     /* dapp */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "datasetId"
     /* datasetId */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "blockNumber"
     /* blockNumber */
-  ]: z.z.string()
+  ]: z.string()
 });
-const CaptchaSolutionBody = z.z.object({
+const CaptchaSolutionBody = z.object({
   [
     "user"
     /* user */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "dapp"
     /* dapp */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "captchas"
     /* captchas */
-  ]: z.z.array(captcha.CaptchaSolutionSchema),
+  ]: z.array(captcha.CaptchaSolutionSchema),
   [
     "requestHash"
     /* requestHash */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "signature"
     /* signature */
-  ]: z.z.string()
+  ]: z.string()
   // the signature to prove account ownership
 });
-const VerifySolutionBody = z.z.object({
+const VerifySolutionBody = z.object({
   [
     "user"
     /* user */
-  ]: z.z.string(),
+  ]: z.string(),
   [
     "commitmentId"
     /* commitmentId */
-  ]: z.z.string().optional()
+  ]: z.string().optional()
 });
 exports.ApiParams = ApiParams;
 exports.ApiPaths = ApiPaths;

package/dist/cjs/provider/argv.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../contracts/captcha/dist/index.cjs");
+const typesArguments = require("@prosopo/captcha-contract/types-arguments");
 const z = require("zod");
-const captcha = require("../contracts/captcha/dist/types-arguments/captcha.cjs");
-const PayeeSchema = z.z.nativeEnum(captcha.Payee);
+const PayeeSchema = z.nativeEnum(typesArguments.Payee);
 exports.PayeeSchema = PayeeSchema;