Versioned Conditions (#229)

package.json

@@ -57,7 +57,8 @@
     "deep-equal": "^2.2.1",
     "ethers": "^5.4.1",
     "joi": "^17.7.0",
-    "qs": "^6.10.1"
+    "qs": "^6.10.1",
+    "semver": "^7.5.2"
   },
   "devDependencies": {
     "@babel/core": "^7.18.10",
@@ -67,6 +68,7 @@
     "@types/deep-equal": "^1.0.1",
     "@types/jest": "^26.0.24",
     "@types/qs": "^6.9.7",
+    "@types/semver": "^7.5.0",
     "@typescript-eslint/eslint-plugin": "^4.0.1",
     "@typescript-eslint/parser": "^4.0.1",
     "cz-conventional-changelog": "^3.0.1",

src/characters/cbd-recipient.ts

@@ -15,7 +15,7 @@ import {
 import { ethers } from 'ethers';
 
 import { DkgCoordinatorAgent, DkgParticipant } from '../agents/coordinator';
-import { ConditionSet } from '../conditions';
+import { ConditionExpression } from '../conditions';
 import {
   DkgRitual,
   getCombineDecryptionSharesFunction,
@@ -54,14 +54,14 @@ export class CbdTDecDecrypter {
   // Retrieve and decrypt ciphertext using provider and condition set
   public async retrieveAndDecrypt(
     provider: ethers.providers.Web3Provider,
-    conditionSet: ConditionSet,
+    conditionExpr: ConditionExpression,
     variant: number,
     ciphertext: Ciphertext,
     aad: Uint8Array
   ): Promise<readonly Uint8Array[]> {
     const decryptionShares = await this.retrieve(
       provider,
-      conditionSet,
+      conditionExpr,
       variant,
       ciphertext
     );
@@ -82,20 +82,20 @@ export class CbdTDecDecrypter {
   // Retrieve decryption shares
   public async retrieve(
     provider: ethers.providers.Web3Provider,
-    conditionSet: ConditionSet,
+    conditionExpr: ConditionExpression,
     variant: number,
     ciphertext: Ciphertext
   ): Promise<DecryptionSharePrecomputed[] | DecryptionShareSimple[]> {
     const dkgParticipants = await DkgCoordinatorAgent.getParticipants(
       provider,
       this.ritualId
     );
-    const contextStr = await conditionSet.buildContext(provider).toJson();
+    const contextStr = await conditionExpr.buildContext(provider).toJson();
     const { sharedSecrets, encryptedRequests } = this.makeDecryptionRequests(
       this.ritualId,
       variant,
       ciphertext,
-      conditionSet,
+      conditionExpr,
       contextStr,
       dkgParticipants
     );
@@ -150,7 +150,7 @@ export class CbdTDecDecrypter {
     ritualId: number,
     variant: number,
     ciphertext: Ciphertext,
-    conditionSet: ConditionSet,
+    conditionExpr: ConditionExpression,
     contextStr: string,
     dkgParticipants: Array<DkgParticipant>
   ): {
@@ -161,7 +161,7 @@ export class CbdTDecDecrypter {
       ritualId,
       variant,
       ciphertext,
-      conditionSet.toWASMConditions(),
+      conditionExpr.toWASMConditions(),
       new Context(contextStr)
     );
 

src/characters/enrico.ts

@@ -7,19 +7,19 @@ import {
   SecretKey,
 } from '@nucypher/nucypher-core';
 
-import { ConditionSet } from '../conditions';
+import { ConditionExpression } from '../conditions';
 import { Keyring } from '../keyring';
 import { toBytes } from '../utils';
 
 export class Enrico {
   public readonly encryptingKey: PublicKey | DkgPublicKey;
   private readonly keyring: Keyring;
-  public conditions?: ConditionSet;
+  public conditions?: ConditionExpression;
 
   constructor(
     encryptingKey: PublicKey | DkgPublicKey,
     verifyingKey?: SecretKey,
-    conditions?: ConditionSet
+    conditions?: ConditionExpression
   ) {
     this.encryptingKey = encryptingKey;
     this.keyring = new Keyring(verifyingKey ?? SecretKey.random());
@@ -32,7 +32,7 @@ export class Enrico {
 
   public encryptMessagePre(
     plaintext: Uint8Array | string,
-    withConditions?: ConditionSet
+    withConditions?: ConditionExpression
   ): MessageKit {
     if (!withConditions) {
       withConditions = this.conditions;
@@ -51,7 +51,7 @@ export class Enrico {
 
   public encryptMessageCbd(
     plaintext: Uint8Array | string,
-    withConditions?: ConditionSet
+    withConditions?: ConditionExpression
   ): { ciphertext: Ciphertext; aad: Uint8Array } {
     if (!withConditions) {
       withConditions = this.conditions;

src/conditions/base/rpc.ts

@@ -3,7 +3,10 @@ import Joi from 'joi';
 import { SUPPORTED_CHAINS } from '../const';
 
 import { Condition } from './condition';
-import { ethAddressOrUserAddressSchema, returnValueTestSchema } from './schema';
+import {
+  ethAddressOrUserAddressSchema,
+  returnValueTestSchema,
+} from './return-value';
 
 const rpcMethodSchemas: Record<string, Joi.Schema> = {
   eth_getBalance: Joi.array().items(ethAddressOrUserAddressSchema).required(),

src/conditions/condition-expr.ts

@@ -0,0 +1,99 @@
+import { Conditions as WASMConditions } from '@nucypher/nucypher-core';
+import { ethers } from 'ethers';
+import { SemVer } from 'semver';
+
+import { objectEquals, toJSON } from '../utils';
+
+import {
+  Condition,
+  ContractCondition,
+  RpcCondition,
+  TimeCondition,
+} from './base';
+import { BLOCKTIME_METHOD } from './base/time';
+import { CompoundCondition } from './compound-condition';
+import { ConditionContext } from './context';
+
+export type ConditionExpressionJSON = {
+  version: string;
+  condition: Record<string, unknown>;
+};
+
+export class ConditionExpression {
+  static VERSION = '1.0.0';
+
+  constructor(
+    public readonly condition: Condition,
+    public readonly version: string = ConditionExpression.VERSION
+  ) {}
+
+  public toObj(): ConditionExpressionJSON {
+    const conditionData = this.condition.toObj();
+    return {
+      version: this.version,
+      condition: conditionData,
+    };
+  }
+
+  public static fromObj(obj: ConditionExpressionJSON): ConditionExpression {
+    const receivedVersion = new SemVer(obj.version);
+    const currentVersion = new SemVer(ConditionExpression.VERSION);
+    if (receivedVersion.major > currentVersion.major) {
+      throw new Error(
+        `Version provided, ${obj.version}, is incompatible with current version, ${ConditionExpression.VERSION}`
+      );
+    }
+
+    const underlyingConditionData = obj.condition;
+    let condition: Condition | undefined;
+
+    if (underlyingConditionData.operator) {
+      condition = new CompoundCondition(underlyingConditionData);
+    } else if (underlyingConditionData.method) {
+      if (underlyingConditionData.method === BLOCKTIME_METHOD) {
+        condition = new TimeCondition(underlyingConditionData);
+      } else if (underlyingConditionData.contractAddress) {
+        condition = new ContractCondition(underlyingConditionData);
+      } else if (
+        (underlyingConditionData.method as string).startsWith('eth_')
+      ) {
+        condition = new RpcCondition(underlyingConditionData);
+      }
+    }
+
+    if (!condition) {
+      throw new Error(
+        `Invalid condition: unrecognized condition data ${JSON.stringify(
+          underlyingConditionData
+        )}`
+      );
+    }
+
+    return new ConditionExpression(condition, obj.version);
+  }
+
+  public toJson(): string {
+    return toJSON(this.toObj());
+  }
+
+  public static fromJSON(json: string): ConditionExpression {
+    return ConditionExpression.fromObj(JSON.parse(json));
+  }
+
+  public toWASMConditions(): WASMConditions {
+    return new WASMConditions(toJSON(this.toObj()));
+  }
+
+  public buildContext(
+    provider: ethers.providers.Web3Provider
+  ): ConditionContext {
+    return new ConditionContext([this.condition], provider);
+  }
+
+  public equals(other: ConditionExpression): boolean {
+    return (
+      this.version === other.version &&
+      objectEquals(this.condition.toObj(), other.condition.toObj())
+    );
+  }
+}

src/conditions/index.ts

@@ -3,8 +3,8 @@ import * as predefined from './predefined';
 
 export { predefined, base };
 export { Condition } from './base/condition';
-export type { ConditionSetJSON } from './condition-set';
-export { ConditionSet } from './condition-set';
+export type { ConditionExpressionJSON } from './condition-expr';
+export { ConditionExpression } from './condition-expr';
 export { CompoundCondition } from './compound-condition';
 export type { CustomContextParam } from './context';
 export { ConditionContext } from './context';

src/sdk/strategy/cbd-strategy.ts

@@ -7,14 +7,14 @@ import {
   CbdTDecDecrypterJSON,
 } from '../../characters/cbd-recipient';
 import { Enrico } from '../../characters/enrico';
-import { ConditionSet, ConditionSetJSON } from '../../conditions';
+import { ConditionExpression, ConditionExpressionJSON } from '../../conditions';
 import { DkgClient, DkgRitual } from '../../dkg';
 import { fromJSON, toJSON } from '../../utils';
 import { Cohort, CohortJSON } from '../cohort';
 
 export type CbdStrategyJSON = {
   cohort: CohortJSON;
-  conditionSet?: ConditionSetJSON | undefined;
+  conditionExpr?: ConditionExpressionJSON | undefined;
 };
 
 export type DeployedStrategyJSON = {
@@ -81,8 +81,8 @@ export class DeployedCbdStrategy {
     return new DeployedCbdStrategy(decrypter, dkgRitual.dkgPublicKey);
   }
 
-  public makeEncrypter(conditionSet: ConditionSet): Enrico {
-    return new Enrico(this.dkgPublicKey, undefined, conditionSet);
+  public makeEncrypter(conditionExpr: ConditionExpression): Enrico {
+    return new Enrico(this.dkgPublicKey, undefined, conditionExpr);
   }
 
   public static fromJSON(json: string) {

src/sdk/strategy/pre-strategy.ts

@@ -8,7 +8,7 @@ import {
   PreTDecDecrypter,
   PreTDecDecrypterJSON,
 } from '../../characters/pre-recipient';
-import { ConditionSet } from '../../conditions';
+import { ConditionExpression } from '../../conditions';
 import { EnactedPolicy } from '../../policies/policy';
 import { base64ToU8Receiver, bytesEquals, toJSON } from '../../utils';
 import { Cohort, CohortJSON } from '../cohort';
@@ -165,8 +165,8 @@ export class DeployedPreStrategy {
     return new DeployedPreStrategy(cohort, decrypter, policy.policyKey);
   }
 
-  public makeEncrypter(conditionSet: ConditionSet): Enrico {
-    return new Enrico(this.policyKey, undefined, conditionSet);
+  public makeEncrypter(conditionExpr: ConditionExpression): Enrico {
+    return new Enrico(this.policyKey, undefined, conditionExpr);
   }
 
   public static fromJSON(json: string) {