@prosopo/types 0.1.14

package/dist/datasets/dataset.d.ts

@@ -0,0 +1,301 @@
+import { ArgumentTypes } from '../contract/typechain/captcha/types-arguments';
+import { Captcha, CaptchaTypes, CaptchaWithoutId } from './captcha';
+import { z } from 'zod';
+export type DatasetBase = {
+    datasetId?: ArgumentTypes.Hash;
+    datasetContentId?: ArgumentTypes.Hash;
+    format: CaptchaTypes;
+    contentTree?: string[][];
+    solutionTree?: string[][];
+};
+export interface Dataset extends DatasetBase {
+    captchas: CaptchaWithoutId[] | Captcha[];
+}
+export interface DatasetRaw extends DatasetBase {
+    captchas: CaptchaWithoutId[];
+}
+export type DatasetWithIds = {
+    datasetId: ArgumentTypes.Hash;
+    datasetContentId: ArgumentTypes.Hash;
+    captchas: Captcha[];
+    format: CaptchaTypes;
+    contentTree?: string[][];
+    solutionTree?: string[][];
+};
+export interface DatasetWithIdsAndTree extends DatasetWithIds {
+    contentTree: string[][];
+}
+export declare const DatasetSchema: z.ZodObject<{
+    datasetId: z.ZodOptional<z.ZodString>;
+    datasetContentId: z.ZodOptional<z.ZodString>;
+    captchas: z.ZodArray<z.ZodObject<{
+        captchaId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        captchaContentId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        salt: z.ZodString;
+        solution: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        timeLimit: z.ZodOptional<z.ZodNumber>;
+        items: z.ZodArray<z.ZodObject<{
+            hash: z.ZodOptional<z.ZodString>;
+            data: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("./captcha").CaptchaItemTypes>;
+        }, "strip", z.ZodTypeAny, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }>, "many">;
+        target: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+    format: z.ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+    contentTree: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+    timeLimit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+    timeLimit?: number | undefined;
+}, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+    timeLimit?: number | undefined;
+}>;
+export declare const DatasetWithIdsSchema: z.ZodObject<{
+    datasetId: z.ZodString;
+    datasetContentId: z.ZodOptional<z.ZodString>;
+    captchas: z.ZodArray<z.ZodObject<{
+        captchaId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        captchaContentId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        salt: z.ZodString;
+        timeLimit: z.ZodOptional<z.ZodNumber>;
+        items: z.ZodArray<z.ZodObject<{
+            hash: z.ZodOptional<z.ZodString>;
+            data: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("./captcha").CaptchaItemTypes>;
+        }, "strip", z.ZodTypeAny, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }>, "many">;
+        target: z.ZodString;
+        solution: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }>, "many">;
+    format: z.ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+    contentTree: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+}, "strip", z.ZodTypeAny, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }[];
+    datasetId: string;
+    format: CaptchaTypes;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }[];
+    datasetId: string;
+    format: CaptchaTypes;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}>;
+export declare const DatasetWithIdsAndTreeSchema: z.ZodObject<{
+    captchas: z.ZodArray<z.ZodObject<{
+        captchaId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        captchaContentId: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+        salt: z.ZodString;
+        timeLimit: z.ZodOptional<z.ZodNumber>;
+        items: z.ZodArray<z.ZodObject<{
+            hash: z.ZodOptional<z.ZodString>;
+            data: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("./captcha").CaptchaItemTypes>;
+        }, "strip", z.ZodTypeAny, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }, {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }>, "many">;
+        target: z.ZodString;
+        solution: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }, {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }>, "many">;
+    datasetId: z.ZodString;
+    datasetContentId: z.ZodOptional<z.ZodString>;
+    format: z.ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
+    contentTree: z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">;
+}, "strip", z.ZodTypeAny, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }[];
+    datasetId: string;
+    format: CaptchaTypes;
+    solutionTree: string[][];
+    contentTree: string[][];
+    datasetContentId?: string | undefined;
+}, {
+    captchas: {
+        salt: string;
+        items: {
+            type: import("./captcha").CaptchaItemTypes;
+            data: string;
+            hash?: string | undefined;
+        }[];
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        timeLimit?: number | undefined;
+        solution?: string[] | undefined;
+    }[];
+    datasetId: string;
+    format: CaptchaTypes;
+    solutionTree: string[][];
+    contentTree: string[][];
+    datasetContentId?: string | undefined;
+}>;
+//# sourceMappingURL=dataset.d.ts.map

package/dist/datasets/dataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.d.ts","sourceRoot":"","sources":["../../src/datasets/dataset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAC7E,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAA0C,MAAM,WAAW,CAAA;AAC3G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,MAAM,WAAW,GAAG;IACtB,SAAS,CAAC,EAAE,aAAa,CAAC,IAAI,CAAA;IAC9B,gBAAgB,CAAC,EAAE,aAAa,CAAC,IAAI,CAAA;IACrC,MAAM,EAAE,YAAY,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,WAAW,OAAQ,SAAQ,WAAW;IACxC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,OAAO,EAAE,CAAA;CAC3C;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC3C,QAAQ,EAAE,gBAAgB,EAAE,CAAA;CAC/B;AAED,MAAM,MAAM,cAAc,GAAG;IACzB,SAAS,EAAE,aAAa,CAAC,IAAI,CAAA;IAC7B,gBAAgB,EAAE,aAAa,CAAC,IAAI,CAAA;IACpC,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,YAAY,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IACzD,WAAW,EAAE,MAAM,EAAE,EAAE,CAAA;CAC1B;AAID,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}

package/dist/datasets/dataset.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetWithIdsAndTreeSchema = exports.DatasetWithIdsSchema = exports.DatasetSchema = void 0;
+const captcha_1 = require("./captcha");
+const zod_1 = require("zod");
+// Zod schemas
+exports.DatasetSchema = zod_1.z.object({
+    datasetId: zod_1.z.string().optional(),
+    datasetContentId: zod_1.z.string().optional(),
+    captchas: captcha_1.CaptchasSchema,
+    format: zod_1.z.nativeEnum(captcha_1.CaptchaTypes),
+    solutionTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())).optional(),
+    contentTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())).optional(),
+    timeLimit: zod_1.z.number().optional(),
+});
+exports.DatasetWithIdsSchema = zod_1.z.object({
+    datasetId: zod_1.z.string(),
+    datasetContentId: zod_1.z.string().optional(),
+    captchas: zod_1.z.array(captcha_1.SelectAllCaptchaSchema),
+    format: zod_1.z.nativeEnum(captcha_1.CaptchaTypes),
+    solutionTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())).optional(),
+    contentTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())).optional(),
+});
+exports.DatasetWithIdsAndTreeSchema = exports.DatasetWithIdsSchema.extend({
+    solutionTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())),
+    contentTree: zod_1.z.array(zod_1.z.array(zod_1.z.string())),
+});
+//# sourceMappingURL=dataset.js.map

package/dist/datasets/dataset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.js","sourceRoot":"","sources":["../../src/datasets/dataset.ts"],"names":[],"mappings":";;;AACA,uCAA2G;AAC3G,6BAAuB;AA+BvB,cAAc;AAED,QAAA,aAAa,GAAG,OAAC,CAAC,MAAM,CAAC;IAClC,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACvC,QAAQ,EAAE,wBAAc;IACxB,MAAM,EAAE,OAAC,CAAC,UAAU,CAAC,sBAAY,CAAC;IAClC,YAAY,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IACrD,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpD,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACnC,CAAC,CAAA;AAEW,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IACzC,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACvC,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,gCAAsB,CAAC;IACzC,MAAM,EAAE,OAAC,CAAC,UAAU,CAAC,sBAAY,CAAC;IAClC,YAAY,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IACrD,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;CACvD,CAAC,CAAA;AAEW,QAAA,2BAA2B,GAAG,4BAAoB,CAAC,MAAM,CAAC;IACnE,YAAY,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1C,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC;CAC5C,CAAC,CAAA"}

package/dist/datasets/index.d.ts

@@ -0,0 +1,5 @@
+export * from './captcha';
+export * from './dataset';
+export * from './merkle';
+export * from './assets';
+//# sourceMappingURL=index.d.ts.map

package/dist/datasets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datasets/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA"}

package/dist/datasets/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./captcha"), exports);
+tslib_1.__exportStar(require("./dataset"), exports);
+tslib_1.__exportStar(require("./merkle"), exports);
+tslib_1.__exportStar(require("./assets"), exports);
+//# sourceMappingURL=index.js.map

package/dist/datasets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/datasets/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,oDAAyB;AACzB,mDAAwB;AACxB,mDAAwB"}

package/dist/datasets/merkle.d.ts

@@ -0,0 +1,10 @@
+export interface MerkleNodeInterface {
+    hash: string;
+    parent: string | null;
+}
+export type MerkleLeaf = string;
+export type MerkleLayer = MerkleLeaf[];
+export type MerkleProofLayer = [MerkleLeaf, MerkleLeaf];
+export type MerkleRootLayer = [MerkleLeaf];
+export type MerkleProof = [...MerkleProofLayer[], MerkleRootLayer];
+//# sourceMappingURL=merkle.d.ts.map

package/dist/datasets/merkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../../src/datasets/merkle.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAE/B,MAAM,MAAM,WAAW,GAAG,UAAU,EAAE,CAAA;AAEtC,MAAM,MAAM,gBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AAEvD,MAAM,MAAM,eAAe,GAAG,CAAC,UAAU,CAAC,CAAA;AAE1C,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,gBAAgB,EAAE,EAAE,eAAe,CAAC,CAAA"}

package/dist/datasets/merkle.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copyright (C) 2021-2023 Prosopo (UK) Ltd.
+// This file is part of provider <https://github.com/prosopo/provider>.
+//
+// provider is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// provider is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with provider.  If not, see <http://www.gnu.org/licenses/>.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=merkle.js.map

package/dist/datasets/merkle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.js","sourceRoot":"","sources":["../../src/datasets/merkle.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,uEAAuE;AACvE,EAAE;AACF,mEAAmE;AACnE,uEAAuE;AACvE,oEAAoE;AACpE,sCAAsC;AACtC,EAAE;AACF,8DAA8D;AAC9D,iEAAiE;AACjE,gEAAgE;AAChE,+CAA+C;AAC/C,EAAE;AACF,oEAAoE;AACpE,oEAAoE"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config';
+export * from './contract';
+export * from './datasets';
+export * from './provider';
+export * from './procaptcha';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./contract"), exports);
+tslib_1.__exportStar(require("./datasets"), exports);
+tslib_1.__exportStar(require("./provider"), exports);
+tslib_1.__exportStar(require("./procaptcha"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,mDAAwB;AACxB,qDAA0B;AAC1B,qDAA0B;AAC1B,qDAA0B;AAC1B,uDAA4B"}

package/dist/procaptcha/index.d.ts

@@ -0,0 +1,2 @@
+export * from './manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/procaptcha/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procaptcha/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/dist/procaptcha/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./manager"), exports);
+//# sourceMappingURL=index.js.map

package/dist/procaptcha/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/procaptcha/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB"}

package/dist/procaptcha/manager.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+export declare const ProcaptchaOutputSchema: z.ZodObject<{
+    commitmentId: z.ZodOptional<z.ZodString>;
+    providerUrl: z.ZodOptional<z.ZodString>;
+    dapp: z.ZodString;
+    user: z.ZodString;
+    blockNumber: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    user: string;
+    dapp: string;
+    commitmentId?: string | undefined;
+    providerUrl?: string | undefined;
+    blockNumber?: number | undefined;
+}, {
+    user: string;
+    dapp: string;
+    commitmentId?: string | undefined;
+    providerUrl?: string | undefined;
+    blockNumber?: number | undefined;
+}>;
+/**
+ * The information produced by procaptcha on completion of the captcha process,
+ * whether verified by smart contract, a pending commitment in the cache of a
+ * provider or a captcha challenge.
+ */
+export type ProcaptchaOutput = z.infer<typeof ProcaptchaOutputSchema>;
+export declare const ProcaptchaResponse: z.ZodObject<{
+    "procaptcha-response": z.ZodObject<{
+        commitmentId: z.ZodOptional<z.ZodString>;
+        providerUrl: z.ZodOptional<z.ZodString>;
+        dapp: z.ZodString;
+        user: z.ZodString;
+        blockNumber: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        user: string;
+        dapp: string;
+        commitmentId?: string | undefined;
+        providerUrl?: string | undefined;
+        blockNumber?: number | undefined;
+    }, {
+        user: string;
+        dapp: string;
+        commitmentId?: string | undefined;
+        providerUrl?: string | undefined;
+        blockNumber?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    "procaptcha-response": {
+        user: string;
+        dapp: string;
+        commitmentId?: string | undefined;
+        providerUrl?: string | undefined;
+        blockNumber?: number | undefined;
+    };
+}, {
+    "procaptcha-response": {
+        user: string;
+        dapp: string;
+        commitmentId?: string | undefined;
+        providerUrl?: string | undefined;
+        blockNumber?: number | undefined;
+    };
+}>;
+//# sourceMappingURL=manager.d.ts.map

package/dist/procaptcha/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/procaptcha/manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAMjC,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B,CAAA"}

package/dist/procaptcha/manager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcaptchaResponse = exports.ProcaptchaOutputSchema = void 0;
+const provider_1 = require("../provider");
+const zod_1 = require("zod");
+exports.ProcaptchaOutputSchema = zod_1.z.object({
+    [provider_1.ApiParams.commitmentId]: zod_1.z.string().optional(),
+    [provider_1.ApiParams.providerUrl]: zod_1.z.string().optional(),
+    [provider_1.ApiParams.dapp]: zod_1.z.string(),
+    [provider_1.ApiParams.user]: zod_1.z.string(),
+    [provider_1.ApiParams.blockNumber]: zod_1.z.number().optional(),
+});
+exports.ProcaptchaResponse = zod_1.z.object({
+    [provider_1.ApiParams.procaptchaResponse]: exports.ProcaptchaOutputSchema,
+});
+//# sourceMappingURL=manager.js.map

package/dist/procaptcha/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../src/procaptcha/manager.ts"],"names":[],"mappings":";;;AAAA,0CAAuC;AACvC,6BAAuB;AAEV,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,CAAC,oBAAS,CAAC,YAAY,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/C,CAAC,oBAAS,CAAC,WAAW,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9C,CAAC,oBAAS,CAAC,IAAI,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE;IAC5B,CAAC,oBAAS,CAAC,IAAI,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE;IAC5B,CAAC,oBAAS,CAAC,WAAW,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjD,CAAC,CAAA;AASW,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,CAAC,oBAAS,CAAC,kBAAkB,CAAC,EAAE,8BAAsB;CACzD,CAAC,CAAA"}

package/dist/provider/accounts.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="bn.js" />
+import { BN } from '@polkadot/util';
+import { KeyringPair } from '@polkadot/keyring/types';
+import { Payee } from '../contract/typechain/captcha/types-arguments/captcha';
+export interface IUserAccount {
+    secret?: string;
+    address: string;
+}
+export interface IProviderAccount extends IUserAccount {
+    url: string;
+    fee: number;
+    datasetFile: string;
+    stake: number | BN;
+    payee: Payee.dapp;
+    captchaDatasetId: string;
+    pair?: KeyringPair;
+}
+export interface IDappAccount {
+    secret: string;
+    contractAccount: string;
+    fundAmount: number | BN;
+    pair?: KeyringPair;
+}
+//# sourceMappingURL=accounts.d.ts.map

package/dist/provider/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/provider/accounts.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,uDAAuD,CAAA;AAE7E,MAAM,WAAW,YAAY;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IAClD,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,GAAG,EAAE,CAAA;IAClB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAA;IACjB,gBAAgB,EAAE,MAAM,CAAA;IACxB,IAAI,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,GAAG,EAAE,CAAA;IACvB,IAAI,CAAC,EAAE,WAAW,CAAA;CACrB"}

package/dist/provider/accounts.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=accounts.js.map

package/dist/provider/accounts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.js","sourceRoot":"","sources":["../../src/provider/accounts.ts"],"names":[],"mappings":""}