apply pr suggestions

src/agents/contracts.ts

@@ -1,4 +1,5 @@
-import { ChainId, ChecksumAddress } from '../types';
+import { ChecksumAddress } from '../types';
+import { ChainId } from '../web3';
 
 type Contracts = {
   readonly SUBSCRIPTION_MANAGER: ChecksumAddress | undefined;

src/conditions/base/index.ts

@@ -35,9 +35,6 @@ export class TimeCondition extends Condition {
   }
 }
 
-export {
-  contractConditionSchema,
-  type ContractConditionProps,
-} from './contract';
-export { rpcConditionSchema, type RpcConditionProps } from './rpc';
-export { timeConditionSchema, type TimeConditionProps } from './time';
+export { type ContractConditionProps } from './contract';
+export { type RpcConditionProps } from './rpc';
+export { type TimeConditionProps } from './time';

src/conditions/base/rpc.ts

@@ -1,29 +1,15 @@
 import { z } from 'zod';
 
-import { ETH_ADDRESS_REGEXP, USER_ADDRESS_PARAM } from '../const';
+import { SUPPORTED_CHAIN_IDS } from '../const';
+import createUnionSchema from '../zod';
 
-export const returnValueTestSchema = z.object({
-  index: z.number().optional(),
-  comparator: z.enum(['==', '>', '<', '>=', '<=', '!=']),
-  value: z.union([z.string(), z.number(), z.boolean()]),
-});
-
-export type ReturnValueTestProps = z.infer<typeof returnValueTestSchema>;
-
-const EthAddressOrUserAddressSchema = z.array(
-  z.union([z.string().regex(ETH_ADDRESS_REGEXP), z.literal(USER_ADDRESS_PARAM)])
-);
+import { EthAddressOrUserAddressSchema, returnValueTestSchema } from './shared';
 
 export const rpcConditionSchema = z.object({
   conditionType: z.literal('rpc').default('rpc'),
-  chain: z.union([
-    z.literal(137),
-    z.literal(80001),
-    z.literal(5),
-    z.literal(1),
-  ]),
+  chain: createUnionSchema(SUPPORTED_CHAIN_IDS),
   method: z.enum(['eth_getBalance', 'balanceOf']),
-  parameters: EthAddressOrUserAddressSchema,
+  parameters: z.array(EthAddressOrUserAddressSchema),
   returnValueTest: returnValueTestSchema,
 });
 

src/conditions/base/shared.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+import { ETH_ADDRESS_REGEXP, USER_ADDRESS_PARAM } from '../const';
+
+export const returnValueTestSchema = z.object({
+  index: z.number().optional(),
+  comparator: z.enum(['==', '>', '<', '>=', '<=', '!=']),
+  value: z.unknown(),
+});
+
+export type ReturnValueTestProps = z.infer<typeof returnValueTestSchema>;
+
+const EthAddressSchema = z.string().regex(ETH_ADDRESS_REGEXP);
+const UserAddressSchema = z.literal(USER_ADDRESS_PARAM);
+export const EthAddressOrUserAddressSchema = z.union([
+  EthAddressSchema,
+  UserAddressSchema,
+]);

src/conditions/compound-condition.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 
-import { contractConditionSchema } from './base';
-import { rpcConditionSchema } from './base';
-import { timeConditionSchema } from './base';
+import { contractConditionSchema } from './base/contract';
+import { rpcConditionSchema } from './base/rpc';
+import { timeConditionSchema } from './base/time';
 
 export const compoundConditionSchema: z.ZodSchema = z.object({
   conditionType: z.literal('compound').default('compound'),

src/conditions/condition-expr.ts

@@ -4,17 +4,7 @@ import { SemVer } from 'semver';
 
 import { toBytes, toJSON } from '../utils';
 
-import {
-  CompoundCondition,
-  ContractCondition,
-  ContractConditionProps,
-  RpcCondition,
-  RpcConditionProps,
-  TimeCondition,
-  TimeConditionProps,
-} from './base';
-import { CompoundConditionProps } from './compound-condition';
-import { Condition, ConditionProps } from './condition';
+import { Condition } from './condition';
 import { ConditionContext, CustomContextParam } from './context';
 
 export type ConditionExpressionJSON = {
@@ -38,21 +28,6 @@ export class ConditionExpression {
     };
   }
 
-  private static conditionFromObject(obj: ConditionProps): Condition {
-    switch (obj.conditionType) {
-      case 'rpc':
-        return new RpcCondition(obj as RpcConditionProps);
-      case 'time':
-        return new TimeCondition(obj as TimeConditionProps);
-      case 'contract':
-        return new ContractCondition(obj as ContractConditionProps);
-      case 'compound':
-        return new CompoundCondition(obj as CompoundConditionProps);
-      default:
-        throw new Error(`Invalid conditionType: ${obj.conditionType}`);
-    }
-  }
-
   public static fromObj(obj: ConditionExpressionJSON): ConditionExpression {
     const receivedVersion = new SemVer(obj.version);
     const currentVersion = new SemVer(ConditionExpression.VERSION);
@@ -70,7 +45,7 @@ export class ConditionExpression {
       );
     }
 
-    const condition = this.conditionFromObject(obj.condition as ConditionProps);
+    const condition = Condition.fromObj(obj.condition);
     return new ConditionExpression(condition, obj.version);
   }
 

src/conditions/condition.ts

@@ -3,40 +3,40 @@ import { z } from 'zod';
 import { objectEquals } from '../utils';
 
 import {
+  CompoundCondition,
+  ContractCondition,
   ContractConditionProps,
+  RpcCondition,
   RpcConditionProps,
+  TimeCondition,
   TimeConditionProps,
 } from './base';
 import { CompoundConditionProps } from './compound-condition';
 import { USER_ADDRESS_PARAM } from './const';
 
-// Not using discriminated union because of inconsistent Zod types
-// Some conditions have ZodEffect types because of .refine() calls
-export type ConditionProps =
-  | RpcConditionProps
-  | TimeConditionProps
-  | ContractConditionProps
-  | CompoundConditionProps;
+type ConditionSchema = z.ZodSchema;
+export type ConditionProps = z.infer<ConditionSchema>;
 
 export class Condition {
   constructor(
-    public readonly schema: z.ZodSchema,
-    public readonly value:
-      | RpcConditionProps
-      | TimeConditionProps
-      | ContractConditionProps
-      | CompoundConditionProps
-  ) {}
+    public readonly schema: ConditionSchema,
+    public readonly value: ConditionProps
+  ) {
+    const { data, error } = Condition.validate(schema, value);
+    if (error) {
+      throw new Error(`Invalid condition: ${JSON.stringify(error.issues)}`);
+    }
+    this.value = data;
+  }
 
-  public validate(override: Partial<ConditionProps> = {}): {
+  public static validate(
+    schema: ConditionSchema,
+    value: ConditionProps
+  ): {
     data?: ConditionProps;
     error?: z.ZodError;
   } {
-    const newValue = {
-      ...this.value,
-      ...override,
-    };
-    const result = this.schema.safeParse(newValue);
+    const result = schema.safeParse(value);
     if (result.success) {
       return { data: result.data };
     }
@@ -48,18 +48,30 @@ export class Condition {
   }
 
   public toObj() {
-    const { data, error } = this.validate(this.value);
+    const { data, error } = Condition.validate(this.schema, this.value);
     if (error) {
       throw new Error(`Invalid condition: ${JSON.stringify(error.issues)}`);
     }
     return data;
   }
 
-  public static fromObj<T extends Condition>(
-    this: new (...args: unknown[]) => T,
-    obj: Record<string, unknown>
-  ): T {
-    return new this(obj);
+  private static conditionFromObject(obj: ConditionProps): Condition {
+    switch (obj.conditionType) {
+      case 'rpc':
+        return new RpcCondition(obj as RpcConditionProps);
+      case 'time':
+        return new TimeCondition(obj as TimeConditionProps);
+      case 'contract':
+        return new ContractCondition(obj as ContractConditionProps);
+      case 'compound':
+        return new CompoundCondition(obj as CompoundConditionProps);
+      default:
+        throw new Error(`Invalid conditionType: ${obj.conditionType}`);
+    }
+  }
+
+  public static fromObj(obj: ConditionProps): Condition {
+    return Condition.conditionFromObject(obj);
   }
 
   public equals(other: Condition) {

src/conditions/const.ts

@@ -1,3 +1,12 @@
+import { ChainId } from '../web3';
+
 export const USER_ADDRESS_PARAM = ':userAddress';
 
 export const ETH_ADDRESS_REGEXP = new RegExp('^0x[a-fA-F0-9]{40}$');
+
+export const SUPPORTED_CHAIN_IDS = [
+  ChainId.POLYGON,
+  ChainId.MUMBAI,
+  ChainId.GOERLI,
+  ChainId.MAINNET,
+];

src/conditions/index.ts

@@ -8,7 +8,4 @@ export {
 } from './condition-expr';
 export { ConditionContext, type CustomContextParam } from './context';
 export { Condition, type ConditionProps } from './condition';
-export {
-  compoundConditionSchema,
-  type CompoundConditionProps,
-} from './compound-condition';
+export { type CompoundConditionProps } from './compound-condition';

src/conditions/zod.ts

@@ -0,0 +1,31 @@
+import { Primitive, z, ZodLiteral } from 'zod';
+
+// Source: https://github.com/colinhacks/zod/issues/831#issuecomment-1063481764
+const createUnion = <
+  T extends Readonly<[Primitive, Primitive, ...Primitive[]]>
+>(
+  values: T
+) => {
+  const zodLiterals = values.map((value) => z.literal(value)) as unknown as [
+    ZodLiteral<Primitive>,
+    ZodLiteral<Primitive>,
+    ...ZodLiteral<Primitive>[]
+  ];
+  return z.union(zodLiterals);
+};
+
+function createUnionSchema<T extends readonly Primitive[]>(values: T) {
+  if (values.length === 0) {
+    return z.never();
+  }
+
+  if (values.length === 1) {
+    return z.literal(values[0]);
+  }
+
+  return createUnion(
+    values as unknown as Readonly<[Primitive, Primitive, ...Primitive[]]>
+  );
+}
+
+export default createUnionSchema;

src/types.ts

@@ -1,10 +1,3 @@
 export type ChecksumAddress = string;
 export type HexEncodedBytes = string;
 export type Base64EncodedBytes = string;
-
-export enum ChainId {
-  POLYGON = 137,
-  MUMBAI = 80001,
-  GOERLI = 5,
-  MAINNET = 1,
-}

src/web3.ts

@@ -1,4 +1,12 @@
 import { fromHexString } from './utils';
+
+export enum ChainId {
+  POLYGON = 137,
+  MUMBAI = 80001,
+  GOERLI = 5,
+  MAINNET = 1,
+}
+
 export const toCanonicalAddress = (address: string): Uint8Array => {
   const ETH_ADDRESS_STRING_PREFIX = '0x';
   const nonPrefixed = address.startsWith(ETH_ADDRESS_STRING_PREFIX)

test/unit/conditions/base/condition.test.ts

@@ -1,3 +1,4 @@
+import { Condition } from '../../../../src/conditions';
 import { ContractCondition } from '../../../../src/conditions/base';
 import {
   ERC721Balance,
@@ -6,7 +7,6 @@ import {
 import {
   TEST_CHAIN_ID,
   TEST_CONTRACT_ADDR,
-  TEST_CONTRACT_ADDR_2,
   testContractConditionObj,
 } from '../../testVariables';
 
@@ -17,40 +17,10 @@ describe('validation', () => {
   });
 
   it('accepts a correct schema', async () => {
-    const result = condition.validate();
+    const result = Condition.validate(condition.schema, condition.value);
     expect(result.error).toBeUndefined();
     expect(result.data.contractAddress).toEqual(TEST_CONTRACT_ADDR);
   });
-
-  it('accepts on a valid value override', async () => {
-    const validOverride = {
-      chain: TEST_CHAIN_ID,
-      contractAddress: TEST_CONTRACT_ADDR_2,
-    };
-    const result = condition.validate(validOverride);
-    expect(result.error).toBeUndefined();
-    expect(result.data).toMatchObject(validOverride);
-  });
-
-  it('rejects on an invalid value override', async () => {
-    const invalidOverride = {
-      chain: -1,
-      contractAddress: TEST_CONTRACT_ADDR,
-    };
-    const result = condition.validate(invalidOverride);
-    expect(result.error).toBeDefined();
-    expect(result.data).toBeUndefined();
-    expect(result.error?.format()).toMatchObject({
-      chain: {
-        _errors: [
-          'Invalid literal value, expected 137',
-          'Invalid literal value, expected 80001',
-          'Invalid literal value, expected 5',
-          'Invalid literal value, expected 1',
-        ],
-      },
-    });
-  });
 });
 
 describe('serialization', () => {