Separate condition deserialization from base Condition via ConditionFactory

src/conditions/base/contract.ts

@@ -67,9 +67,13 @@ const functionAbiSchema = z
 
 export type FunctionAbiProps = z.infer<typeof functionAbiSchema>;
 
+export const ContractConditionType = 'contract';
+
 export const contractConditionSchema = rpcConditionSchema
  .extend({
- conditionType: z.literal('contract').default('contract'),
+ conditionType: z
+ .literal(ContractConditionType)
+ .default(ContractConditionType),
  contractAddress: z.string().regex(ETH_ADDRESS_REGEXP),
  standardContractType: z.enum(['ERC20', 'ERC721']).optional(),
  method: z.string(),

src/conditions/base/index.ts

@@ -35,6 +35,10 @@ export class TimeCondition extends Condition {
  }
 }
 
-export { type ContractConditionProps } from './contract';
-export { type RpcConditionProps } from './rpc';
-export { type TimeConditionProps } from './time';
+export { type ContractConditionProps, ContractConditionType } from './contract';
+export { type RpcConditionProps, RpcConditionType } from './rpc';
+export {
+ type TimeConditionProps,
+ TimeConditionType,
+ TimeConditionMethod,
+} from './time';

src/conditions/base/rpc.ts

@@ -5,8 +5,10 @@ import createUnionSchema from '../zod';
 
 import { EthAddressOrUserAddressSchema, returnValueTestSchema } from './shared';
 
+export const RpcConditionType = 'rpc';
+
 export const rpcConditionSchema = z.object({
- conditionType: z.literal('rpc').default('rpc'),
+ conditionType: z.literal(RpcConditionType).default(RpcConditionType),
  chain: createUnionSchema(SUPPORTED_CHAIN_IDS),
  method: z.enum(['eth_getBalance', 'balanceOf']),
  parameters: z.array(EthAddressOrUserAddressSchema),

src/conditions/base/time.ts

@@ -6,10 +6,13 @@ import { rpcConditionSchema } from './rpc';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const { parameters: _, ...restShape } = rpcConditionSchema.shape;
 
+export const TimeConditionType = 'time';
+export const TimeConditionMethod = 'blocktime';
+
 export const timeConditionSchema = z.object({
  ...restShape,
- conditionType: z.literal('time').default('time'),
- method: z.literal('blocktime').default('blocktime'),
+ conditionType: z.literal(TimeConditionType).default(TimeConditionType),
+ method: z.literal(TimeConditionMethod).default(TimeConditionMethod),
 });
 
 export type TimeConditionProps = z.infer<typeof timeConditionSchema>;

src/conditions/compound-condition.ts

@@ -4,8 +4,12 @@ import { contractConditionSchema } from './base/contract';
 import { rpcConditionSchema } from './base/rpc';
 import { timeConditionSchema } from './base/time';
 
+export const CompoundConditionType = 'compound';
+
 export const compoundConditionSchema: z.ZodSchema = z.object({
- conditionType: z.literal('compound').default('compound'),
+ conditionType: z
+ .literal(CompoundConditionType)
+ .default(CompoundConditionType),
  operator: z.enum(['and', 'or']),
  operands: z
  .array(

src/conditions/condition.ts

@@ -6,17 +6,40 @@ import {
  CompoundCondition,
  ContractCondition,
  ContractConditionProps,
+ ContractConditionType,
  RpcCondition,
  RpcConditionProps,
+ RpcConditionType,
  TimeCondition,
  TimeConditionProps,
+ TimeConditionType,
 } from './base';
-import { CompoundConditionProps } from './compound-condition';
+import {
+ CompoundConditionProps,
+ CompoundConditionType,
+} from './compound-condition';
 import { USER_ADDRESS_PARAM } from './const';
 
 type ConditionSchema = z.ZodSchema;
 export type ConditionProps = z.infer<ConditionSchema>;
 
+class ConditionFactory {
+ public static conditionFromProps(obj: ConditionProps): Condition {
+ switch (obj.conditionType) {
+ case RpcConditionType:
+ return new RpcCondition(obj as RpcConditionProps);
+ case TimeConditionType:
+ return new TimeCondition(obj as TimeConditionProps);
+ case ContractConditionType:
+ return new ContractCondition(obj as ContractConditionProps);
+ case CompoundConditionType:
+ return new CompoundCondition(obj as CompoundConditionProps);
+ default:
+ throw new Error(`Invalid conditionType: ${obj.conditionType}`);
+ }
+ }
+}
+
 export class Condition {
  constructor(
  public readonly schema: ConditionSchema,
@@ -55,23 +78,8 @@ export class Condition {
  return data;
  }
 
- 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);
+ return ConditionFactory.conditionFromProps(obj);
  }
 
  public equals(other: Condition) {

src/conditions/index.ts

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

src/conditions/predefined/erc721.ts

@@ -1,4 +1,5 @@
 import { ContractCondition, ContractConditionProps } from '../base';
+import { ContractConditionType } from '../base/contract';
 import { USER_ADDRESS_PARAM } from '../const';
 
 // TODO: Rewrite these using Zod schemas?
@@ -9,7 +10,7 @@ const ERC721OwnershipDefaults: Omit<
  ContractConditionProps,
  ERC721OwnershipFields
 > = {
- conditionType: 'contract',
+ conditionType: ContractConditionType,
  method: 'ownerOf',
  standardContractType: 'ERC721',
  returnValueTest: {
@@ -29,7 +30,7 @@ type ERC721BalanceFields = 'contractAddress' | 'chain';
 
 const ERC721BalanceDefaults: Omit<ContractConditionProps, ERC721BalanceFields> =
  {
- conditionType: 'contract',
+ conditionType: ContractConditionType,
  method: 'balanceOf',
  parameters: [USER_ADDRESS_PARAM],
  standardContractType: 'ERC721',

test/unit/conditions/base/time.test.ts

@@ -3,7 +3,11 @@ import {
  TimeConditionProps,
 } from '../../../../src/conditions/base';
 import { ReturnValueTestProps } from '../../../../src/conditions/base/shared';
-import { timeConditionSchema } from '../../../../src/conditions/base/time';
+import {
+ TimeConditionMethod,
+ timeConditionSchema,
+ TimeConditionType,
+} from '../../../../src/conditions/base/time';
 
 describe('validation', () => {
  const returnValueTest: ReturnValueTestProps = {
@@ -14,9 +18,9 @@ describe('validation', () => {
 
  it('accepts a valid schema', () => {
  const conditionObj: TimeConditionProps = {
+ conditionType: TimeConditionType,
  returnValueTest,
- conditionType: 'time',
- method: 'blocktime',
+ method: TimeConditionMethod,
  chain: 1,
  };
  const result = TimeCondition.validate(timeConditionSchema, conditionObj);
@@ -27,7 +31,7 @@ describe('validation', () => {
 
  it('rejects an invalid schema', () => {
  const badObj = {
- conditionType: 'time',
+ conditionType: TimeConditionType,
  // Intentionally replacing `returnValueTest` with an invalid test
  returnValueTest: {
  ...returnValueTest,

test/unit/conditions/compound-condition.test.ts

@@ -1,6 +1,9 @@
 import { Condition } from '../../../src/conditions';
 import { CompoundCondition } from '../../../src/conditions/base';
-import { compoundConditionSchema } from '../../../src/conditions/compound-condition';
+import {
+ compoundConditionSchema,
+ CompoundConditionType,
+} from '../../../src/conditions/compound-condition';
 import {
  testContractConditionObj,
  testRpcConditionObj,
@@ -18,7 +21,7 @@ describe('validation', () => {
  expect(result.error).toBeUndefined();
  expect(result.data).toEqual({
  ...conditionObj,
- conditionType: 'compound',
+ conditionType: CompoundConditionType,
  });
  });
 
@@ -35,7 +38,7 @@ describe('validation', () => {
  expect(result.error).toBeUndefined();
  expect(result.data).toEqual({
  ...conditionObj,
- conditionType: 'compound',
+ conditionType: CompoundConditionType,
  });
  });
 
@@ -104,14 +107,14 @@ describe('validation', () => {
  );
  expect(result.error).toBeUndefined();
  expect(result.data).toEqual({
- conditionType: 'compound',
+ conditionType: CompoundConditionType,
  operator: 'and',
  operands: [
  testContractConditionObj,
  testTimeConditionObj,
  testRpcConditionObj,
  {
- conditionType: 'compound',
+ conditionType: CompoundConditionType,
  operator: 'or',
  operands: [testTimeConditionObj, testContractConditionObj],
  },

test/unit/conditions/condition-expr.test.ts

@@ -9,6 +9,7 @@ import {
  TimeCondition,
  TimeConditionProps,
 } from '../../../src/conditions/base';
+import { RpcConditionType } from '../../../src/conditions/base/rpc';
 import { USER_ADDRESS_PARAM } from '../../../src/conditions/const';
 import { ERC721Balance } from '../../../src/conditions/predefined';
 import { objectEquals, toJSON } from '../../../src/utils';
@@ -232,7 +233,7 @@ describe('condition set', () => {
  it('rejects a mismatched condition type', () => {
  const conditionObj = {
  ...testTimeConditionObj,
- conditionType: 'rpc',
+ conditionType: RpcConditionType,
  } as unknown as TimeConditionProps;
  expect(() => {
  ConditionExpression.fromObj({

test/unit/testVariables.ts

@@ -3,8 +3,16 @@ import {
  RpcConditionProps,
  TimeConditionProps,
 } from '../../src/conditions/base';
-import { FunctionAbiProps } from '../../src/conditions/base/contract';
+import {
+ ContractConditionType,
+ FunctionAbiProps,
+} from '../../src/conditions/base/contract';
+import { RpcConditionType } from '../../src/conditions/base/rpc';
 import { ReturnValueTestProps } from '../../src/conditions/base/shared';
+import {
+ TimeConditionMethod,
+ TimeConditionType,
+} from '../../src/conditions/base/time';
 
 export const aliceSecretKeyBytes = new Uint8Array([
  55, 82, 190, 189, 203, 164, 60, 148, 36, 86, 46, 123, 63, 152, 215, 113, 174,
@@ -28,26 +36,26 @@ export const testReturnValueTest: ReturnValueTestProps = {
 };
 
 export const testTimeConditionObj: TimeConditionProps = {
- conditionType: 'time',
+ conditionType: TimeConditionType,
  returnValueTest: {
  index: 0,
  comparator: '>',
  value: '100',
  },
- method: 'blocktime',
+ method: TimeConditionMethod,
  chain: 5,
 };
 
 export const testRpcConditionObj: RpcConditionProps = {
- conditionType: 'rpc',
+ conditionType: RpcConditionType,
  chain: TEST_CHAIN_ID,
  method: 'eth_getBalance',
  parameters: ['0x1e988ba4692e52Bc50b375bcC8585b95c48AaD77'],
  returnValueTest: testReturnValueTest,
 };
 
 export const testContractConditionObj: ContractConditionProps = {
- conditionType: 'contract',
+ conditionType: ContractConditionType,
  contractAddress: '0x0000000000000000000000000000000000000000',
  chain: 5,
  standardContractType: 'ERC20',