@nucypher/taco 0.5.0 → 0.6.0-alpha.1

package/dist/cjs/conditions/multi-condition.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxNestedDepth = void 0;
+const compound_condition_1 = require("./compound-condition");
+const if_then_else_condition_1 = require("./if-then-else-condition");
+const sequential_1 = require("./sequential");
+const maxNestedDepth = (maxDepth) => (condition, currentDepth = 1) => {
+    if (condition.conditionType === compound_condition_1.CompoundConditionType ||
+        condition.conditionType === sequential_1.SequentialConditionType ||
+        condition.conditionType === if_then_else_condition_1.IfThenElseConditionType) {
+        if (currentDepth > maxDepth) {
+            // no more multi-condition types allowed at this level
+            return false;
+        }
+        if (condition.conditionType === compound_condition_1.CompoundConditionType) {
+            return condition.operands.every((child) => (0, exports.maxNestedDepth)(maxDepth)(child, currentDepth + 1));
+        }
+        else if (condition.conditionType === sequential_1.SequentialConditionType) {
+            return condition.conditionVariables.every((child) => (0, exports.maxNestedDepth)(maxDepth)(child.condition, currentDepth + 1));
+        }
+        else {
+            // if-then-else condition
+            const ifThenElseConditions = [];
+            ifThenElseConditions.push(condition.ifCondition);
+            ifThenElseConditions.push(condition.thenCondition);
+            if (typeof condition.elseCondition !== 'boolean') {
+                ifThenElseConditions.push(condition.elseCondition);
+            }
+            return ifThenElseConditions.every((child) => (0, exports.maxNestedDepth)(maxDepth)(child, currentDepth + 1));
+        }
+    }
+    return true;
+};
+exports.maxNestedDepth = maxNestedDepth;
+//# sourceMappingURL=multi-condition.js.map

package/dist/cjs/conditions/multi-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-condition.js","sourceRoot":"","sources":["../../../src/conditions/multi-condition.ts"],"names":[],"mappings":";;;AAAA,6DAA6D;AAE7D,qEAAmE;AACnE,6CAA+E;AAExE,MAAM,cAAc,GACzB,CAAC,QAAgB,EAAE,EAAE,CACrB,CAAC,SAAyB,EAAE,YAAY,GAAG,CAAC,EAAW,EAAE;IACvD,IACE,SAAS,CAAC,aAAa,KAAK,0CAAqB;QACjD,SAAS,CAAC,aAAa,KAAK,oCAAuB;QACnD,SAAS,CAAC,aAAa,KAAK,gDAAuB,EACnD,CAAC;QACD,IAAI,YAAY,GAAG,QAAQ,EAAE,CAAC;YAC5B,sDAAsD;YACtD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,SAAS,CAAC,aAAa,KAAK,0CAAqB,EAAE,CAAC;YACtD,OAAO,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAqB,EAAE,EAAE,CACxD,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,YAAY,GAAG,CAAC,CAAC,CAClD,CAAC;QACJ,CAAC;aAAM,IAAI,SAAS,CAAC,aAAa,KAAK,oCAAuB,EAAE,CAAC;YAC/D,OAAO,SAAS,CAAC,kBAAkB,CAAC,KAAK,CACvC,CAAC,KAA6B,EAAE,EAAE,CAChC,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,YAAY,GAAG,CAAC,CAAC,CAC9D,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,yBAAyB;YACzB,MAAM,oBAAoB,GAAG,EAAE,CAAC;YAChC,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YACjD,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACnD,IAAI,OAAO,SAAS,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;gBACjD,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACrD,CAAC;YACD,OAAO,oBAAoB,CAAC,KAAK,CAAC,CAAC,KAAqB,EAAE,EAAE,CAC1D,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,YAAY,GAAG,CAAC,CAAC,CAClD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AArCS,QAAA,cAAc,kBAqCvB"}

package/dist/cjs/conditions/schemas/common.d.ts

@@ -0,0 +1,12 @@
+import { Primitive, z } from 'zod';
+export declare const plainStringSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const UserAddressSchema: z.ZodEnum<[":userAddress", ":userAddressExternalEIP4361"]>;
+export declare const baseConditionSchema: z.ZodObject<{
+    conditionType: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    conditionType: string;
+}, {
+    conditionType: string;
+}>;
+declare function createUnionSchema<T extends readonly Primitive[]>(values: T): z.ZodNever | z.ZodLiteral<Primitive> | z.ZodUnion<[z.ZodLiteral<Primitive>, z.ZodLiteral<Primitive>, ...z.ZodLiteral<Primitive>[]]>;
+export default createUnionSchema;

package/dist/cjs/conditions/schemas/common.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseConditionSchema = exports.UserAddressSchema = exports.plainStringSchema = void 0;
+const taco_auth_1 = require("@nucypher/taco-auth");
+const zod_1 = require("zod");
+const const_1 = require("../const");
+// We want to discriminate between ContextParams and plain strings
+// If a string starts with `:`, it's a ContextParam
+exports.plainStringSchema = zod_1.z.string().refine((str) => {
+    return !str.startsWith(const_1.CONTEXT_PARAM_PREFIX);
+}, {
+    message: `String must not be a context parameter i.e. not start with "${const_1.CONTEXT_PARAM_PREFIX}"`,
+});
+exports.UserAddressSchema = zod_1.z.enum([
+    taco_auth_1.USER_ADDRESS_PARAM_DEFAULT,
+    taco_auth_1.USER_ADDRESS_PARAM_EXTERNAL_EIP4361,
+]);
+exports.baseConditionSchema = zod_1.z.object({
+    conditionType: zod_1.z.string(),
+});
+// Source: https://github.com/colinhacks/zod/issues/831#issuecomment-1063481764
+const createUnion = (values) => {
+    const zodLiterals = values.map((value) => zod_1.z.literal(value));
+    return zod_1.z.union(zodLiterals);
+};
+function createUnionSchema(values) {
+    if (values.length === 0) {
+        return zod_1.z.never();
+    }
+    if (values.length === 1) {
+        return zod_1.z.literal(values[0]);
+    }
+    return createUnion(values);
+}
+exports.default = createUnionSchema;
+//# sourceMappingURL=common.js.map

package/dist/cjs/conditions/schemas/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/conditions/schemas/common.ts"],"names":[],"mappings":";;;AAAA,mDAG6B;AAC7B,6BAA+C;AAE/C,oCAAgD;AAEhD,kEAAkE;AAClE,mDAAmD;AACtC,QAAA,iBAAiB,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAChD,CAAC,GAAG,EAAE,EAAE;IACN,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,4BAAoB,CAAC,CAAC;AAC/C,CAAC,EACD;IACE,OAAO,EAAE,+DAA+D,4BAAoB,GAAG;CAChG,CACF,CAAC;AAEW,QAAA,iBAAiB,GAAG,OAAC,CAAC,IAAI,CAAC;IACtC,sCAA0B;IAC1B,+CAAmC;CACpC,CAAC,CAAC;AAEU,QAAA,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE;CAC1B,CAAC,CAAC;AAEH,+EAA+E;AAC/E,MAAM,WAAW,GAAG,CAGlB,MAAS,EACT,EAAE;IACF,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAIzD,CAAC;IACF,OAAO,OAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,SAAS,iBAAiB,CAAiC,MAAS;IAClE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,OAAC,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,OAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,WAAW,CAChB,MAAqE,CACtE,CAAC;AACJ,CAAC;AAED,kBAAe,iBAAiB,CAAC"}

package/dist/cjs/conditions/schemas/compound.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const CompoundConditionType = "compound";
+export declare const compoundConditionSchema: z.ZodSchema;
+export type CompoundConditionProps = z.infer<typeof compoundConditionSchema>;

package/dist/cjs/conditions/schemas/compound.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compoundConditionSchema = exports.CompoundConditionType = void 0;
+const zod_1 = require("zod");
+const multi_condition_1 = require("../multi-condition");
+const common_1 = require("./common");
+const utils_1 = require("./utils");
+exports.CompoundConditionType = 'compound';
+exports.compoundConditionSchema = zod_1.z.lazy(() => common_1.baseConditionSchema
+    .extend({
+    conditionType: zod_1.z
+        .literal(exports.CompoundConditionType)
+        .default(exports.CompoundConditionType),
+    operator: zod_1.z.enum(['and', 'or', 'not']),
+    operands: zod_1.z.array(utils_1.anyConditionSchema).min(1).max(5),
+})
+    .refine((condition) => {
+    // 'and' and 'or' operators must have at least 2 operands
+    if (['and', 'or'].includes(condition.operator)) {
+        return condition.operands.length >= 2;
+    }
+    // 'not' operator must have exactly 1 operand
+    if (condition.operator === 'not') {
+        return condition.operands.length === 1;
+    }
+    // We test positive cases exhaustively, so we return false here:
+    return false;
+}, ({ operands, operator }) => ({
+    message: `Invalid number of operands ${operands.length} for operator "${operator}"`,
+    path: ['operands'],
+}))
+    .refine((condition) => (0, multi_condition_1.maxNestedDepth)(2)(condition), {
+    message: 'Exceeded max nested depth of 2 for multi-condition type',
+    path: ['operands'],
+}));
+//# sourceMappingURL=compound.js.map

package/dist/cjs/conditions/schemas/compound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compound.js","sourceRoot":"","sources":["../../../../src/conditions/schemas/compound.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,wDAAoD;AAEpD,qCAA+C;AAC/C,mCAA6C;AAEhC,QAAA,qBAAqB,GAAG,UAAU,CAAC;AAEnC,QAAA,uBAAuB,GAAgB,OAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAC9D,4BAAmB;KAChB,MAAM,CAAC;IACN,aAAa,EAAE,OAAC;SACb,OAAO,CAAC,6BAAqB,CAAC;SAC9B,OAAO,CAAC,6BAAqB,CAAC;IACjC,QAAQ,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACtC,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,0BAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACpD,CAAC;KACD,MAAM,CACL,CAAC,SAAS,EAAE,EAAE;IACZ,yDAAyD;IACzD,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/C,OAAO,SAAS,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,6CAA6C;IAC7C,IAAI,SAAS,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;QACjC,OAAO,SAAS,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,gEAAgE;IAChE,OAAO,KAAK,CAAC;AACf,CAAC,EACD,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3B,OAAO,EAAE,8BAA8B,QAAQ,CAAC,MAAM,kBAAkB,QAAQ,GAAG;IACnF,IAAI,EAAE,CAAC,UAAU,CAAC;CACnB,CAAC,CACH;KACA,MAAM,CACL,CAAC,SAAS,EAAE,EAAE,CAAC,IAAA,gCAAc,EAAC,CAAC,CAAC,CAAC,SAAS,CAAC,EAC3C;IACE,OAAO,EAAE,yDAAyD;IAClE,IAAI,EAAE,CAAC,UAAU,CAAC;CACnB,CACF,CACJ,CAAC"}

package/dist/cjs/conditions/schemas/context.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const contextParamSchema: z.ZodString;
+export declare const paramOrContextParamSchema: z.ZodSchema;

package/dist/cjs/conditions/schemas/context.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramOrContextParamSchema = exports.contextParamSchema = void 0;
+const zod_1 = require("zod");
+const const_1 = require("../const");
+const common_1 = require("./common");
+exports.contextParamSchema = zod_1.z
+    .string()
+    .regex(const_1.CONTEXT_PARAM_FULL_MATCH_REGEXP);
+const paramSchema = zod_1.z.union([common_1.plainStringSchema, zod_1.z.boolean(), zod_1.z.number()]);
+exports.paramOrContextParamSchema = zod_1.z.union([
+    paramSchema,
+    exports.contextParamSchema,
+    zod_1.z.lazy(() => zod_1.z.array(exports.paramOrContextParamSchema)),
+]);
+//# sourceMappingURL=context.js.map

package/dist/cjs/conditions/schemas/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../../src/conditions/schemas/context.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,oCAA2D;AAE3D,qCAA6C;AAEhC,QAAA,kBAAkB,GAAG,OAAC;KAChC,MAAM,EAAE;KACR,KAAK,CAAC,uCAA+B,CAAC,CAAC;AAE1C,MAAM,WAAW,GAAG,OAAC,CAAC,KAAK,CAAC,CAAC,0BAAiB,EAAE,OAAC,CAAC,OAAO,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAE7D,QAAA,yBAAyB,GAAgB,OAAC,CAAC,KAAK,CAAC;IAC5D,WAAW;IACX,0BAAkB;IAClB,OAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAC,CAAC,KAAK,CAAC,iCAAyB,CAAC,CAAC;CACjD,CAAC,CAAC"}

package/dist/cjs/conditions/schemas/contract.d.ts

@@ -0,0 +1,428 @@
+import { z } from 'zod';
+declare const functionAbiSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"function">;
+    inputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<[string, ...string[]]>;
+        internalType: z.ZodEnum<[string, ...string[]]>;
+    }, "strict", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        internalType: string;
+    }, {
+        type: string;
+        name: string;
+        internalType: string;
+    }>, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<[string, ...string[]]>;
+        internalType: z.ZodEnum<[string, ...string[]]>;
+    }, "strict", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        internalType: string;
+    }, {
+        type: string;
+        name: string;
+        internalType: string;
+    }>, "atleastone">;
+    stateMutability: z.ZodUnion<[z.ZodLiteral<"view">, z.ZodLiteral<"pure">]>;
+}, "strict", z.ZodTypeAny, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}>, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}>, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}, {
+    type: "function";
+    name: string;
+    inputs: {
+        type: string;
+        name: string;
+        internalType: string;
+    }[];
+    outputs: [{
+        type: string;
+        name: string;
+        internalType: string;
+    }, ...{
+        type: string;
+        name: string;
+        internalType: string;
+    }[]];
+    stateMutability: "view" | "pure";
+}>;
+export type FunctionAbiProps = z.infer<typeof functionAbiSchema>;
+export declare const ContractConditionType = "contract";
+export declare const contractConditionSchema: z.ZodEffects<z.ZodObject<{
+    returnValueTest: z.ZodObject<{
+        index: z.ZodOptional<z.ZodNumber>;
+        comparator: z.ZodEnum<["==", ">", "<", ">=", "<=", "!="]>;
+        value: z.ZodType<any, z.ZodTypeDef, any>;
+    }, "strip", z.ZodTypeAny, {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    }, {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    }>;
+    chain: z.ZodNever | z.ZodLiteral<z.Primitive> | z.ZodUnion<[z.ZodLiteral<z.Primitive>, z.ZodLiteral<z.Primitive>, ...z.ZodLiteral<z.Primitive>[]]>;
+    conditionType: z.ZodDefault<z.ZodLiteral<"contract">>;
+    contractAddress: z.ZodEffects<z.ZodString, string, string>;
+    standardContractType: z.ZodOptional<z.ZodEnum<["ERC20", "ERC721"]>>;
+    method: z.ZodString;
+    functionAbi: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"function">;
+        inputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<[string, ...string[]]>;
+            internalType: z.ZodEnum<[string, ...string[]]>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            internalType: string;
+        }, {
+            type: string;
+            name: string;
+            internalType: string;
+        }>, "many">;
+        outputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<[string, ...string[]]>;
+            internalType: z.ZodEnum<[string, ...string[]]>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            internalType: string;
+        }, {
+            type: string;
+            name: string;
+            internalType: string;
+        }>, "atleastone">;
+        stateMutability: z.ZodUnion<[z.ZodLiteral<"view">, z.ZodLiteral<"pure">]>;
+    }, "strict", z.ZodTypeAny, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }>, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }>, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }, {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    }>>;
+    parameters: z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">;
+}, "strip", z.ZodTypeAny, {
+    conditionType: "contract";
+    parameters: any[];
+    returnValueTest: {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    };
+    method: string;
+    contractAddress: string;
+    chain?: z.Primitive;
+    standardContractType?: "ERC20" | "ERC721" | undefined;
+    functionAbi?: {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    } | undefined;
+}, {
+    parameters: any[];
+    returnValueTest: {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    };
+    method: string;
+    contractAddress: string;
+    chain?: z.Primitive;
+    conditionType?: "contract" | undefined;
+    standardContractType?: "ERC20" | "ERC721" | undefined;
+    functionAbi?: {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    } | undefined;
+}>, {
+    conditionType: "contract";
+    parameters: any[];
+    returnValueTest: {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    };
+    method: string;
+    contractAddress: string;
+    chain?: z.Primitive;
+    standardContractType?: "ERC20" | "ERC721" | undefined;
+    functionAbi?: {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    } | undefined;
+}, {
+    parameters: any[];
+    returnValueTest: {
+        comparator: "==" | ">" | "<" | ">=" | "<=" | "!=";
+        index?: number | undefined;
+        value?: any;
+    };
+    method: string;
+    contractAddress: string;
+    chain?: z.Primitive;
+    conditionType?: "contract" | undefined;
+    standardContractType?: "ERC20" | "ERC721" | undefined;
+    functionAbi?: {
+        type: "function";
+        name: string;
+        inputs: {
+            type: string;
+            name: string;
+            internalType: string;
+        }[];
+        outputs: [{
+            type: string;
+            name: string;
+            internalType: string;
+        }, ...{
+            type: string;
+            name: string;
+            internalType: string;
+        }[]];
+        stateMutability: "view" | "pure";
+    } | undefined;
+}>;
+export type ContractConditionProps = z.infer<typeof contractConditionSchema>;
+export {};

package/dist/cjs/conditions/schemas/contract.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractConditionSchema = exports.ContractConditionType = void 0;
+const shared_1 = require("@nucypher/shared");
+const ethers_1 = require("ethers");
+const zod_1 = require("zod");
+const context_1 = require("./context");
+const rpc_1 = require("./rpc");
+// TODO: Consider replacing with `z.unknown`:
+//    Since Solidity types are tied to Solidity version, we may not be able to accurately represent them in Zod.
+//    Alternatively, find a TS Solidity type lib.
+const EthBaseTypes = [
+    'bool',
+    'string',
+    'address',
+    'address payable',
+    ...Array.from({ length: 32 }, (_v, i) => `bytes${i + 1}`), // bytes1 through bytes32
+    'bytes',
+    ...Array.from({ length: 32 }, (_v, i) => `uint${8 * (i + 1)}`), // uint8 through uint256
+    ...Array.from({ length: 32 }, (_v, i) => `int${8 * (i + 1)}`), // int8 through int256
+];
+const functionAbiVariableSchema = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    type: zod_1.z.enum(EthBaseTypes),
+    internalType: zod_1.z.enum(EthBaseTypes), // TODO: Do we need to validate this?
+})
+    .strict();
+const functionAbiSchema = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    type: zod_1.z.literal('function'),
+    inputs: zod_1.z.array(functionAbiVariableSchema).min(0),
+    outputs: zod_1.z.array(functionAbiVariableSchema).nonempty(),
+    stateMutability: zod_1.z.union([zod_1.z.literal('view'), zod_1.z.literal('pure')]),
+})
+    .strict()
+    .refine((functionAbi) => {
+    let asInterface;
+    try {
+        // `stringify` here because ethers.utils.Interface doesn't accept a Zod schema
+        asInterface = new ethers_1.ethers.utils.Interface(JSON.stringify([functionAbi]));
+    }
+    catch (e) {
+        return false;
+    }
+    const functionsInAbi = Object.values(asInterface.functions || {});
+    return functionsInAbi.length === 1;
+}, {
+    message: '"functionAbi" must contain a single function definition',
+    path: ['functionAbi'],
+})
+    .refine((functionAbi) => {
+    const asInterface = new ethers_1.ethers.utils.Interface(JSON.stringify([functionAbi]));
+    const nrOfInputs = asInterface.fragments[0].inputs.length;
+    return functionAbi.inputs.length === nrOfInputs;
+}, {
+    message: '"parameters" must have the same length as "functionAbi.inputs"',
+    path: ['parameters'],
+});
+exports.ContractConditionType = 'contract';
+exports.contractConditionSchema = rpc_1.rpcConditionSchema
+    .extend({
+    conditionType: zod_1.z
+        .literal(exports.ContractConditionType)
+        .default(exports.ContractConditionType),
+    contractAddress: shared_1.EthAddressSchema,
+    standardContractType: zod_1.z.enum(['ERC20', 'ERC721']).optional(),
+    method: zod_1.z.string(),
+    functionAbi: functionAbiSchema.optional(),
+    parameters: zod_1.z.array(context_1.paramOrContextParamSchema),
+})
+    // Adding this custom logic causes the return type to be ZodEffects instead of ZodObject
+    // https://github.com/colinhacks/zod/issues/2474
+    .refine(
+// A check to see if either 'standardContractType' or 'functionAbi' is set
+(data) => Boolean(data.standardContractType) !== Boolean(data.functionAbi), {
+    message: "At most one of the fields 'standardContractType' and 'functionAbi' must be defined",
+    path: ['standardContractType'],
+});
+//# sourceMappingURL=contract.js.map