JsonRpcCondition

packages/taco/src/conditions/base/index.ts

@@ -3,5 +3,6 @@
 
 export * as contract from './contract';
 export * as jsonApi from './json-api';
+export * as jsonRpc from './json-rpc';
 export * as rpc from './rpc';
 export * as time from './time';

packages/taco/src/conditions/base/json-api.ts

@@ -10,7 +10,6 @@ export {
   JsonApiConditionProps,
   jsonApiConditionSchema,
   JsonApiConditionType,
-  jsonPathSchema,
 } from '../schemas/json-api';
 
 export class JsonApiCondition extends Condition {

packages/taco/src/conditions/base/json-rpc.ts

@@ -0,0 +1,22 @@
+import { Condition } from '../condition';
+import {
+  JsonRpcConditionProps,
+  jsonRpcConditionSchema,
+  JsonRpcConditionType,
+} from '../schemas/json-rpc';
+import { OmitConditionType } from '../shared';
+
+export {
+  JsonRpcConditionProps,
+  jsonRpcConditionSchema,
+  JsonRpcConditionType,
+} from '../schemas/json-rpc';
+
+export class JsonRpcCondition extends Condition {
+  constructor(value: OmitConditionType<JsonRpcConditionProps>) {
+    super(jsonRpcConditionSchema, {
+      conditionType: JsonRpcConditionType,
+      ...value,
+    });
+  }
+}

packages/taco/src/conditions/condition-factory.ts

@@ -8,6 +8,11 @@ import {
   JsonApiConditionProps,
   JsonApiConditionType,
 } from './base/json-api';
+import {
+  JsonRpcCondition,
+  JsonRpcConditionProps,
+  JsonRpcConditionType,
+} from './base/json-rpc';
 import { RpcCondition, RpcConditionProps, RpcConditionType } from './base/rpc';
 import {
   TimeCondition,
@@ -46,6 +51,8 @@ export class ConditionFactory {
         return new ContractCondition(props as ContractConditionProps);
       case JsonApiConditionType:
         return new JsonApiCondition(props as JsonApiConditionProps);
+      case JsonRpcConditionType:
+        return new JsonRpcCondition(props as JsonRpcConditionProps);
       // Logical Conditions
       case CompoundConditionType:
         return new CompoundCondition(props as CompoundConditionProps);

packages/taco/src/conditions/context/context.ts

@@ -10,7 +10,6 @@ import {
 } from '@nucypher/taco-auth';
 
 import { CoreConditions, CoreContext } from '../../types';
-import { CompoundConditionType } from '../compound-condition';
 import { Condition, ConditionProps } from '../condition';
 import { ConditionExpression } from '../condition-expr';
 import {
@@ -19,7 +18,6 @@ import {
   CONTEXT_PARAM_REGEXP,
   USER_ADDRESS_PARAMS,
 } from '../const';
-import { JsonApiConditionType } from '../schemas/json-api';
 
 export type CustomContextParam = string | number | boolean;
 export type ContextParam = CustomContextParam | AuthSignature;
@@ -143,67 +141,63 @@ export class ConditionContext {
     return !!String(param).match(CONTEXT_PARAM_FULL_MATCH_REGEXP);
   }
 
-  private static findContextParameters(condition: ConditionProps) {
-    // First, we want to find all the parameters we need to add
-    const requestedParameters = new Set<string>();
-
-    // Check return value test
-    if (condition.returnValueTest) {
-      const rvt = condition.returnValueTest.value;
-      // Return value test can be a single parameter or an array of parameters
-      if (Array.isArray(rvt)) {
-        rvt.forEach((value) => {
-          if (ConditionContext.isContextParameter(value)) {
-            requestedParameters.add(value);
-          }
-        });
-      } else if (ConditionContext.isContextParameter(rvt)) {
-        requestedParameters.add(rvt);
-      } else {
-        // Not a context parameter, we can skip
-      }
-    }
+  private static findContextParameter(value: unknown): Set<string> {
+    const includedContextVars = new Set<string>();
 
-    // Check condition parameters
-    for (const param of condition.parameters ?? []) {
-      if (this.isContextParameter(param)) {
-        requestedParameters.add(param);
-      }
+    // value not set
+    if (!value) {
+      return includedContextVars;
     }
 
-    // If it's a compound condition, check operands
-    if (condition.conditionType === CompoundConditionType) {
-      for (const key in condition.operands) {
-        const innerParams = this.findContextParameters(condition.operands[key]);
-        for (const param of innerParams) {
-          requestedParameters.add(param);
-        }
-      }
-    }
-    // If it's a JSON API condition, check url and query
-    if (condition.conditionType === JsonApiConditionType) {
-      const urlComponents = condition.endpoint
-        .replace('https://', '')
-        .split('/');
-      for (const param of urlComponents ?? []) {
-        if (this.isContextParameter(param)) {
-          requestedParameters.add(param);
-        }
-      }
-      if (condition.query) {
-        const queryParams = condition.query.match(CONTEXT_PARAM_REGEXP);
-        if (queryParams) {
-          for (const param of queryParams) {
-            requestedParameters.add(param);
+    if (typeof value === 'string') {
+      if (this.isContextParameter(value)) {
+        // entire string is context parameter
+        includedContextVars.add(String(value));
+      } else {
+        // context var could be substring; find all matches
+        const contextVarMatches = value.match(
+          // RegExp with 'g' is stateful, so new instance needed every time
+          new RegExp(CONTEXT_PARAM_REGEXP.source, 'g'),
+        );
+        if (contextVarMatches) {
+          for (const match of contextVarMatches) {
+            includedContextVars.add(match);
           }
         }
       }
-      // always a context variable, so simply check whether defined
-      if (condition.authorizationToken) {
-        requestedParameters.add(condition.authorizationToken);
+    } else if (Array.isArray(value)) {
+      // array
+      value.forEach((subValue) => {
+        const contextVarsForValue = this.findContextParameter(subValue);
+        contextVarsForValue.forEach((contextVar) => {
+          includedContextVars.add(contextVar);
+        });
+      });
+    } else if (typeof value === 'object') {
+      // dictionary (Record<string, T> - complex object eg. Condition, ConditionVariable, ReturnValueTest etc.)
+      for (const [, entry] of Object.entries(value)) {
+        const contextVarsForValue = this.findContextParameter(entry);
+        contextVarsForValue.forEach((contextVar) => {
+          includedContextVars.add(contextVar);
+        });
       }
     }
 
+    return includedContextVars;
+  }
+
+  private static findContextParameters(condition: ConditionProps) {
+    // find all the context variables we need
+    const requestedParameters = new Set<string>();
+
+    // iterate through all properties in ConditionProps
+    const properties = Object.keys(condition) as (keyof typeof condition)[];
+    properties.forEach((prop) => {
+      this.findContextParameter(condition[prop]).forEach((contextVar) => {
+        requestedParameters.add(contextVar);
+      });
+    });
+
     return requestedParameters;
   }
 

packages/taco/src/conditions/schemas/common.ts

@@ -1,10 +1,11 @@
+import { JSONPath } from '@astronautlabs/jsonpath';
 import {
   USER_ADDRESS_PARAM_DEFAULT,
   USER_ADDRESS_PARAM_EXTERNAL_EIP4361,
 } from '@nucypher/taco-auth';
 import { Primitive, z, ZodLiteral } from 'zod';
 
-import { CONTEXT_PARAM_PREFIX } from '../const';
+import { CONTEXT_PARAM_PREFIX, CONTEXT_PARAM_REGEXP } from '../const';
 
 // We want to discriminate between ContextParams and plain strings
 // If a string starts with `:`, it's a ContextParam
@@ -55,3 +56,36 @@ function createUnionSchema<T extends readonly Primitive[]>(values: T) {
 }
 
 export default createUnionSchema;
+
+const validateJSONPath = (jsonPath: string): boolean => {
+  // account for embedded context variables
+  if (CONTEXT_PARAM_REGEXP.test(jsonPath)) {
+    // skip validation
+    return true;
+  }
+
+  try {
+    JSONPath.parse(jsonPath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+export const jsonPathSchema = z
+  .string()
+  .refine((val) => validateJSONPath(val), {
+    message: 'Invalid JSONPath expression',
+  });
+
+const validateHttpsURL = (url: string): boolean => {
+  return URL.canParse(url) && url.startsWith('https://');
+};
+
+// Use our own URL refinement check due to https://github.com/colinhacks/zod/issues/2236
+export const httpsURLSchema = z
+  .string()
+  .url()
+  .refine((url) => validateHttpsURL(url), {
+    message: 'Invalid URL',
+  });

packages/taco/src/conditions/schemas/json-api.ts

@@ -1,37 +1,14 @@
-import { JSONPath } from '@astronautlabs/jsonpath';
 import { z } from 'zod';
 
-import { CONTEXT_PARAM_REGEXP } from '../const';
-
+import { baseConditionSchema, httpsURLSchema, jsonPathSchema } from './common';
 import { contextParamSchema } from './context';
 import { returnValueTestSchema } from './return-value-test';
 
 export const JsonApiConditionType = 'json-api';
 
-const validateJSONPath = (jsonPath: string): boolean => {
-  // account for embedded context variables
-  if (CONTEXT_PARAM_REGEXP.test(jsonPath)) {
-    // skip validation
-    return true;
-  }
-
-  try {
-    JSONPath.parse(jsonPath);
-    return true;
-  } catch (error) {
-    return false;
-  }
-};
-
-export const jsonPathSchema = z
-  .string()
-  .refine((val) => validateJSONPath(val), {
-    message: 'Invalid JSONPath expression',
-  });
-
-export const jsonApiConditionSchema = z.object({
+export const jsonApiConditionSchema = baseConditionSchema.extend({
   conditionType: z.literal(JsonApiConditionType).default(JsonApiConditionType),
-  endpoint: z.string().url(),
+  endpoint: httpsURLSchema,
   parameters: z.record(z.string(), z.unknown()).optional(),
   query: jsonPathSchema.optional(),
   authorizationToken: contextParamSchema.optional(),

packages/taco/src/conditions/schemas/json-rpc.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+import { baseConditionSchema, httpsURLSchema, jsonPathSchema } from './common';
+import { contextParamSchema } from './context';
+import { returnValueTestSchema } from './return-value-test';
+
+export const JsonRpcConditionType = 'json-rpc';
+
+export const jsonRpcConditionSchema = baseConditionSchema.extend({
+  conditionType: z.literal(JsonRpcConditionType).default(JsonRpcConditionType),
+  endpoint: httpsURLSchema,
+  method: z.string(),
+  // list or dictionary
+  params: z
+    .union([z.array(z.unknown()), z.record(z.string(), z.unknown())])
+    .optional(),
+  query: jsonPathSchema.optional(),
+  authorizationToken: contextParamSchema.optional(),
+  returnValueTest: returnValueTestSchema,
+});
+
+export type JsonRpcConditionProps = z.infer<typeof jsonRpcConditionSchema>;

packages/taco/src/conditions/schemas/rpc.ts

@@ -1,10 +1,7 @@
 import { BlockIdentifierSchema, EthAddressSchema } from '@nucypher/shared';
 import { z } from 'zod';
 
-import {
-  baseConditionSchema,
-  UserAddressSchema,
-} from './common';
+import { baseConditionSchema, UserAddressSchema } from './common';
 import { contextParamSchema } from './context';
 import { returnValueTestSchema } from './return-value-test';
 

packages/taco/src/conditions/schemas/utils.ts

@@ -5,6 +5,7 @@ import { compoundConditionSchema } from '../compound-condition';
 import { contractConditionSchema } from './contract';
 import { ifThenElseConditionSchema } from './if-then-else';
 import { jsonApiConditionSchema } from './json-api';
+import { jsonRpcConditionSchema } from './json-rpc';
 import { rpcConditionSchema } from './rpc';
 import { sequentialConditionSchema } from './sequential';
 import { timeConditionSchema } from './time';
@@ -16,6 +17,7 @@ export const anyConditionSchema: z.ZodSchema = z.lazy(() =>
     contractConditionSchema,
     compoundConditionSchema,
     jsonApiConditionSchema,
+    jsonRpcConditionSchema,
     sequentialConditionSchema,
     ifThenElseConditionSchema,
   ]),

packages/taco/test/conditions/base/condition.test.ts

@@ -40,9 +40,7 @@ describe('validation', () => {
     expect(result.data).toBeUndefined();
     expect(result.error?.format()).toMatchObject({
       chain: {
-        _errors: [
-          "Expected number, received string",
-        ],
+        _errors: ['Expected number, received string'],
       },
     });
   });