Support prefix notation for compound conditions

src/characters/pre-recipient.ts

@@ -8,7 +8,7 @@ import {
 } from '@nucypher/nucypher-core';
 import { ethers } from 'ethers';
 
-import { ConditionSet } from '../conditions';
+import { Condition, ConditionContext } from '../conditions';
 import { Keyring } from '../keyring';
 import { PolicyMessageKit } from '../kits/message';
 import { RetrievalResult } from '../kits/retrieval';
@@ -106,8 +106,11 @@ export class PreTDecDecrypter {
       .map((condition) => JSON.parse(condition.toString()))
       .reduce((acc: Record<string, string>[], val) => acc.concat(val), []);
 
-    const conditionContext =
-      ConditionSet.fromConditionList(conditions).buildContext(provider);
+    const conditionsList = conditions.map((ele: Record<string, string>) => {
+      return Condition.fromObj(ele);
+    });
+
+    const conditionContext = new ConditionContext(conditionsList, provider);
 
     const policyMessageKits = messageKits.map((mk) =>
       PolicyMessageKit.fromMessageKit(

src/conditions/base/condition.ts

@@ -26,7 +26,6 @@ export class Condition {
     }
     return {
       ...value,
-      _class: this.constructor.name,
     };
   }
 
@@ -36,7 +35,6 @@ export class Condition {
     this: new (...args: any[]) => T,
     obj: Map
   ): T {
-    delete obj._class;
     return new this(obj);
   }
 

src/conditions/base/contract.ts

@@ -2,12 +2,12 @@ import Joi from 'joi';
 
 import { ETH_ADDRESS_REGEXP } from '../const';
 
-import { RpcCondition, rpcConditionSchema } from './rpc';
+import { RpcCondition, rpcConditionRecord } from './rpc';
 
 export const STANDARD_CONTRACT_TYPES = ['ERC20', 'ERC721'];
 
 const functionAbiVariable = Joi.object({
-  internalType: Joi.string().required(),
+  internalType: Joi.string(), // TODO is this needed?
   name: Joi.string().required(),
   type: Joi.string().required(),
 });
@@ -18,7 +18,7 @@ const functionAbiSchema = Joi.object({
   inputs: Joi.array().items(functionAbiVariable),
   outputs: Joi.array().items(functionAbiVariable),
   // TODO: Should we restrict this to 'view'?
-  // stateMutability: Joi.string().valid('view').required(),
+  stateMutability: Joi.string(),
 }).custom((functionAbi, helper) => {
   // Validate method name
   const method = helper.state.ancestors[0].method;
@@ -39,8 +39,8 @@ const functionAbiSchema = Joi.object({
   return functionAbi;
 });
 
-const contractMethodSchemas: Record<string, Joi.Schema> = {
-  ...rpcConditionSchema,
+export const contractConditionRecord: Record<string, Joi.Schema> = {
+  ...rpcConditionRecord,
   contractAddress: Joi.string().pattern(ETH_ADDRESS_REGEXP).required(),
   standardContractType: Joi.string()
     .valid(...STANDARD_CONTRACT_TYPES)
@@ -50,8 +50,10 @@ const contractMethodSchemas: Record<string, Joi.Schema> = {
   parameters: Joi.array().required(),
 };
 
+export const contractConditionSchema = Joi.object(contractConditionRecord)
+  // At most one of these keys needs to be present
+  .xor('standardContractType', 'functionAbi');
+
 export class ContractCondition extends RpcCondition {
-  public readonly schema = Joi.object(contractMethodSchemas)
-    // At most one of these keys needs to be present
-    .xor('standardContractType', 'functionAbi');
+  public readonly schema = contractConditionSchema;
 }

src/conditions/base/rpc.ts

@@ -18,7 +18,7 @@ const makeParameters = () =>
     })),
   });
 
-export const rpcConditionSchema = {
+export const rpcConditionRecord = {
   chain: Joi.number()
     .valid(...SUPPORTED_CHAINS)
     .required(),
@@ -29,6 +29,8 @@ export const rpcConditionSchema = {
   returnValueTest: returnValueTestSchema.required(),
 };
 
+export const rpcConditionSchema = Joi.object(rpcConditionRecord);
+
 export class RpcCondition extends Condition {
-  public readonly schema = Joi.object(rpcConditionSchema);
+  public readonly schema = rpcConditionSchema;
 }

src/conditions/base/time.ts

@@ -2,20 +2,22 @@ import Joi from 'joi';
 
 import { omit } from '../../utils';
 
-import { RpcCondition, rpcConditionSchema } from './rpc';
+import { RpcCondition, rpcConditionRecord } from './rpc';
 
-const BLOCKTIME_METHOD = 'blocktime';
+export const BLOCKTIME_METHOD = 'blocktime';
 
-const timeConditionSchema = {
+export const timeConditionRecord: Record<string, Joi.Schema> = {
   // TimeCondition is an RpcCondition with the method set to 'blocktime' and no parameters
-  ...omit(rpcConditionSchema, ['parameters']),
+  ...omit(rpcConditionRecord, ['parameters']),
   method: Joi.string().valid(BLOCKTIME_METHOD).required(),
 };
 
+export const timeConditionSchema = Joi.object(timeConditionRecord);
+
 export class TimeCondition extends RpcCondition {
   public readonly defaults: Record<string, unknown> = {
     method: BLOCKTIME_METHOD,
   };
 
-  public readonly schema = Joi.object(timeConditionSchema);
+  public readonly schema = timeConditionSchema;
 }

src/conditions/compound-condition.ts

@@ -0,0 +1,31 @@
+import Joi from 'joi';
+
+import { Condition } from './base/condition';
+import { contractConditionSchema } from './base/contract';
+import { rpcConditionSchema } from './base/rpc';
+import { timeConditionSchema } from './base/time';
+
+const OR_OPERATOR = 'or';
+const AND_OPERATOR = 'and';
+
+const LOGICAL_OPERATORS = [AND_OPERATOR, OR_OPERATOR];
+
+export const compoundConditionSchema = Joi.object({
+  operator: Joi.string()
+    .valid(...LOGICAL_OPERATORS)
+    .required(),
+  operands: Joi.array()
+    .min(2)
+    .items(
+      rpcConditionSchema,
+      timeConditionSchema,
+      contractConditionSchema,
+      Joi.link('#compoundCondition')
+    )
+    .required()
+    .valid(),
+}).id('compoundCondition');
+
+export class CompoundCondition extends Condition {
+  public readonly schema = compoundConditionSchema;
+}

src/conditions/condition-set.ts

@@ -1,68 +1,54 @@
 import { Conditions as WASMConditions } from '@nucypher/nucypher-core';
-import deepEqual from 'deep-equal';
 import { ethers } from 'ethers';
 
-import { toJSON } from '../utils';
+import { objectEquals, toJSON } from '../utils';
 
-import { Condition } from './base';
+import {
+  Condition,
+  ContractCondition,
+  RpcCondition,
+  TimeCondition,
+} from './base';
+import { BLOCKTIME_METHOD } from './base/time';
+import { CompoundCondition } from './compound-condition';
 import { ConditionContext } from './context';
-import { Operator } from './operator';
-
-type ConditionOrOperator = Condition | Operator;
 
 export type ConditionSetJSON = {
-  conditions: ({ operator: string } | Record<string, unknown>)[];
+  condition: Record<string, unknown>;
 };
 
 export class ConditionSet {
-  constructor(public readonly conditions: ReadonlyArray<ConditionOrOperator>) {}
+  constructor(public readonly condition: Condition) {}
 
-  public validate() {
-    // Expects [Condition, Operator, Condition, Operator, ...], where the last element is a Condition
+  public toObj(): ConditionSetJSON {
+    // TODO add version here
+    const conditionData = this.condition.toObj();
+    return { condition: conditionData };
+  }
 
-    if (this.conditions.length % 2 === 0) {
-      throw new Error(
-        'conditions must be odd length, every other element being an operator'
-      );
+  public static fromObj(obj: ConditionSetJSON): ConditionSet {
+    // version specific logic can go here
+    const underlyingConditionData = obj.condition;
+
+    if (underlyingConditionData.operator) {
+      return new ConditionSet(new CompoundCondition(underlyingConditionData));
     }
 
-    this.conditions.forEach((cndOrOp: ConditionOrOperator, index) => {
-      if (index % 2 && !(cndOrOp instanceof Operator)) {
-        throw new Error(
-          `index ${index} must be an Operator, got ${cndOrOp.constructor.name} instead`
-        );
-      }
-      if (!(index % 2) && cndOrOp instanceof Operator) {
-        throw new Error(
-          `index ${index} must be a Condition, got ${cndOrOp.constructor.name} instead`
-        );
+    if (underlyingConditionData.method) {
+      if (underlyingConditionData.method === BLOCKTIME_METHOD) {
+        return new ConditionSet(new TimeCondition(underlyingConditionData));
       }
-    });
-    return true;
-  }
 
-  public toObj(): ConditionSetJSON {
-    const conditions = this.conditions.map((cnd) => cnd.toObj());
-    return { conditions };
-  }
+      if (underlyingConditionData.contractAddress) {
+        return new ConditionSet(new ContractCondition(underlyingConditionData));
+      }
 
-  public static fromObj(obj: ConditionSetJSON): ConditionSet {
-    const conditions = obj.conditions.map((cnd) => {
-      if ('operator' in cnd) {
-        return Operator.fromObj(cnd as Record<string, string>);
+      if ((underlyingConditionData.method as string).startsWith('eth_')) {
+        return new ConditionSet(new RpcCondition(underlyingConditionData));
       }
-      return Condition.fromObj(cnd);
-    });
-    return new ConditionSet(conditions);
-  }
+    }
 
-  public static fromConditionList(list: ReadonlyArray<Record<string, string>>) {
-    return new ConditionSet(
-      list.map((ele: Record<string, string>) => {
-        if ('operator' in ele) return Operator.fromObj(ele);
-        return Condition.fromObj(ele);
-      })
-    );
+    throw new Error('Invalid condition: unrecognized condition data');
   }
 
   public toJson(): string {
@@ -80,22 +66,10 @@ export class ConditionSet {
   public buildContext(
     provider: ethers.providers.Web3Provider
   ): ConditionContext {
-    return new ConditionContext(this.toWASMConditions(), provider);
+    return new ConditionContext([this.condition], provider);
   }
 
   public equals(other: ConditionSet): boolean {
-    // TODO: This is a hack to make the equals method work for Condition
-    // TODO: Implement proper casting from Conditon to _class type
-    const thisConditions = this.conditions.map((cnd) => {
-      const asObj = cnd.toObj();
-      delete asObj._class;
-      return asObj;
-    });
-    const otherConditions = other.conditions.map((cnd) => {
-      const asObj = cnd.toObj();
-      delete asObj._class;
-      return asObj;
-    });
-    return deepEqual(thisConditions, otherConditions);
+    return objectEquals(this.condition.toObj(), other.condition.toObj());
   }
 }

src/conditions/context/context.ts

@@ -2,6 +2,7 @@ import { Conditions as WASMConditions } from '@nucypher/nucypher-core';
 import { ethers } from 'ethers';
 
 import { fromJSON, toJSON } from '../../utils';
+import { Condition } from '../base/condition';
 import { USER_ADDRESS_PARAM } from '../const';
 
 import { TypedSignature, WalletAuthenticationProvider } from './providers';
@@ -16,7 +17,7 @@ export class ConditionContext {
   private readonly walletAuthProvider: WalletAuthenticationProvider;
 
   constructor(
-    private readonly conditions: WASMConditions,
+    private readonly conditions: ReadonlyArray<Condition>,
     // TODO: We don't always need a web3 provider, only in cases where some specific context parameters are used
     // TODO: Consider making this optional or introducing a different pattern to handle that
     private readonly web3Provider: ethers.providers.Web3Provider,
@@ -42,8 +43,11 @@ export class ConditionContext {
     const requestedParameters = new Set<string>();
 
     // Search conditions for parameters
-    const { conditions } = fromJSON(this.conditions.toString());
-    for (const cond of conditions) {
+    const conditions = this.conditions.map((cnd) => cnd.toObj());
+    const conditionsToCheck = fromJSON(
+      new WASMConditions(toJSON(conditions)).toString()
+    );
+    for (const cond of conditionsToCheck) {
       // Check return value test
       const rvt = cond.returnValueTest.value;
       if (typeof rvt === 'string' && rvt.startsWith(CONTEXT_PARAM_PREFIX)) {

src/conditions/index.ts

@@ -5,6 +5,6 @@ export { predefined, base };
 export { Condition } from './base/condition';
 export type { ConditionSetJSON } from './condition-set';
 export { ConditionSet } from './condition-set';
-export { Operator } from './operator';
+export { CompoundCondition } from './compound-condition';
 export type { CustomContextParam } from './context';
 export { ConditionContext } from './context';

test/docs/cbd.test.ts

@@ -74,10 +74,10 @@ describe('Get Started (CBD PoC)', () => {
       parameters: [5954],
     });
 
-    const conditions = new ConditionSet([
-      NFTOwnership,
+    const conditions = new ConditionSet(
+      NFTOwnership
       // Other conditions can be added here
-    ]);
+    );
 
     // 4. Build a Strategy
     const newStrategy = PreStrategy.create(newCohort);
@@ -101,7 +101,7 @@ describe('Get Started (CBD PoC)', () => {
       },
     };
     const NFTBalance = new ContractCondition(NFTBalanceConfig);
-    const newConditions = new ConditionSet([NFTBalance]);
+    const newConditions = new ConditionSet(NFTBalance);
     const plaintext = 'this is a secret';
     const encrypter = newDeployed.makeEncrypter(newConditions);
     const encryptedMessageKit = encrypter.encryptMessagePre(plaintext);
@@ -123,14 +123,13 @@ describe('Get Started (CBD PoC)', () => {
     //
 
     const expectedAddresses = fakeUrsulas().map((u) => u.checksumAddress);
-    const condObj = conditions.conditions[0].toObj();
+    const condObj = conditions.condition.toObj();
     expect(newCohort.ursulaAddresses).toEqual(expectedAddresses);
     expect(condObj.parameters).toEqual([5954]);
     expect(condObj.chain).toEqual(5);
     expect(condObj.contractAddress).toEqual(
       '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'
     );
-    expect(conditions.validate()).toEqual(true);
     expect(publishToBlockchainSpy).toHaveBeenCalled();
     expect(getUrsulasSpy).toHaveBeenCalledTimes(2);
     expect(generateKFragsSpy).toHaveBeenCalled();