[EPIC] v0.6.x

CONTRIBUTING.md

@@ -24,8 +24,8 @@ pnpm fix
 Build and publish documentation with:
 
 ```bash
-pnpm doc
-pnpm doc:publish
+pnpm typedoc
+pnpm typedoc:publish
 ```
 
 ## Publishing

packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nucypher/shared",
-  "version": "0.4.0",
+  "version": "0.5.0-alpha.1",
   "keywords": [
     "pre",
     "taco",

packages/shared/src/schemas.ts

@@ -1,8 +1,6 @@
 import { ethers } from 'ethers';
 import { z } from 'zod';
 
-export const ETH_ADDRESS_REGEXP = new RegExp('^0x[a-fA-F0-9]{40}$');
-
 const isAddress = (address: string) => {
   try {
     return ethers.utils.getAddress(address);
@@ -13,5 +11,15 @@ const isAddress = (address: string) => {
 
 export const EthAddressSchema = z
   .string()
-  .regex(ETH_ADDRESS_REGEXP)
   .refine(isAddress, { message: 'Invalid Ethereum address' });
+
+const BLOCK_HASH_REGEXP = new RegExp('^0x[a-fA-F0-9]{64}$');
+const BlockNumber = z.number().int().nonnegative();
+const BlockHash = z.string().regex(BLOCK_HASH_REGEXP, 'Invalid block hash');
+const BlockTag = z.enum(['earliest', 'finalized', 'safe', 'latest', 'pending']);
+
+export const BlockIdentifierSchema = z.union([
+  BlockNumber,
+  BlockHash,
+  BlockTag,
+]);

packages/shared/test/schemas.test.ts

@@ -1,15 +1,70 @@
 import { describe, expect, it } from 'vitest';
 
-import { EthAddressSchema } from '../src';
+import { BlockIdentifierSchema, EthAddressSchema } from '../src';
 
 describe('ethereum address schema', () => {
   it('should accept valid ethereum address', () => {
     const validAddress = '0x1234567890123456789012345678901234567890';
     EthAddressSchema.parse(validAddress);
   });
 
-  it('should reject invalid ethereum address', () => {
+  it('should accept unchecksummed ethereum address', () => {
+    const validAddress = '0x0123456789abcdefedcb0123456789abcdefedcb';
+    EthAddressSchema.parse(validAddress);
+  });
+
+  it('should accept checksummed ethereum address', () => {
+    const validAddress = '0x0123456789aBcDeFEdCb0123456789abcdEfeDcb';
+    EthAddressSchema.parse(validAddress);
+  });
+
+  it('should reject invalid ethereum address (shorter)', () => {
     const invalidAddress = '0x123456789012345678901234567890123456789';
     expect(() => EthAddressSchema.parse(invalidAddress)).toThrow();
   });
+
+  it('should reject invalid ethereum address (longer)', () => {
+    const invalidAddress = '0x12345678901234567890123456789012345678901';
+    expect(() => EthAddressSchema.parse(invalidAddress)).toThrow();
+  });
+});
+
+describe('block identifier address schema', () => {
+  it('should accept valid block numbers (ints >= 0)', () => {
+    BlockIdentifierSchema.parse(0);
+    BlockIdentifierSchema.parse(1);
+    BlockIdentifierSchema.parse(1234);
+    BlockIdentifierSchema.parse(9007199254740991); // Max safe integer
+  });
+
+  it('should accept valid block tags', () => {
+    BlockIdentifierSchema.parse('earliest');
+    BlockIdentifierSchema.parse('finalized');
+    BlockIdentifierSchema.parse('safe');
+    BlockIdentifierSchema.parse('latest');
+    BlockIdentifierSchema.parse('pending');
+  });
+
+  it('should accept valid block hashes', () => {
+    const validBlockHash =
+      '0x1234567890123456789012345678901234567890123456789012345678901234';
+    BlockIdentifierSchema.parse(validBlockHash);
+  });
+
+  it('should reject invalid block numbers (e.g., negative ints)', () => {
+    expect(() => BlockIdentifierSchema.parse(-42)).toThrow();
+  });
+
+  it('should reject invalid block numbers (e.g., float)', () => {
+    expect(() => BlockIdentifierSchema.parse(34.56)).toThrow();
+  });
+
+  it('should reject invalid block identifiers', () => {
+    expect(() => BlockIdentifierSchema.parse('foo')).toThrow();
+  });
+
+  it('should reject invalid block hashes', () => {
+    const invalidBlockHash = '0x1234';
+    expect(() => BlockIdentifierSchema.parse(invalidBlockHash)).toThrow();
+  });
 });

packages/taco-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nucypher/taco-auth",
-  "version": "0.2.0",
+  "version": "0.3.0-alpha.1",
   "keywords": [
     "pre",
     "threshold",

packages/taco-auth/test/auth-provider.test.ts

@@ -77,6 +77,7 @@ describe('auth provider caching', () => {
   it('caches auth signature, but regenerates when expired', async () => {
     const createAuthSignatureSpy = vi.spyOn(
       eip4361Provider,
+      // @ts-expect-error -- spying on private function
       'createSIWEAuthMessage',
     );
 

packages/taco/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nucypher/taco",
-  "version": "0.5.0",
+  "version": "0.6.0-alpha.1",
   "keywords": [
     "taco",
     "threshold",
@@ -39,6 +39,7 @@
     "typedoc": "typedoc"
   },
   "dependencies": {
+    "@astronautlabs/jsonpath": "^1.1.2",
     "@nucypher/nucypher-core": "*",
     "@nucypher/shared": "workspace:*",
     "@nucypher/taco-auth": "workspace:*",

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

@@ -1,103 +1,17 @@
-import { ETH_ADDRESS_REGEXP } from '@nucypher/shared';
-import { ethers } from 'ethers';
-import { z } from 'zod';
-
 import { Condition } from '../condition';
-import { OmitConditionType, paramOrContextParamSchema } from '../shared';
-
-import { rpcConditionSchema } from './rpc';
-
-// TODO: Consider replacing with `z.unknown`:
-//    Since Solidity types are tied to Solidity version, we may not be able to accurately represent them in Zod.
-//    Alternatively, find a TS Solidity type lib.
-const EthBaseTypes: [string, ...string[]] = [
-  'bool',
-  'string',
-  'address',
-  'address payable',
-  ...Array.from({ length: 32 }, (_v, i) => `bytes${i + 1}`), // bytes1 through bytes32
-  'bytes',
-  ...Array.from({ length: 32 }, (_v, i) => `uint${8 * (i + 1)}`), // uint8 through uint256
-  ...Array.from({ length: 32 }, (_v, i) => `int${8 * (i + 1)}`), // int8 through int256
-];
-
-const functionAbiVariableSchema = z
-  .object({
-    name: z.string(),
-    type: z.enum(EthBaseTypes),
-    internalType: z.enum(EthBaseTypes), // TODO: Do we need to validate this?
-  })
-  .strict();
-
-const functionAbiSchema = z
-  .object({
-    name: z.string(),
-    type: z.literal('function'),
-    inputs: z.array(functionAbiVariableSchema).min(0),
-    outputs: z.array(functionAbiVariableSchema).nonempty(),
-    stateMutability: z.union([z.literal('view'), z.literal('pure')]),
-  })
-  .strict()
-  .refine(
-    (functionAbi) => {
-      let asInterface;
-      try {
-        // `stringify` here because ethers.utils.Interface doesn't accept a Zod schema
-        asInterface = new ethers.utils.Interface(JSON.stringify([functionAbi]));
-      } catch (e) {
-        return false;
-      }
-
-      const functionsInAbi = Object.values(asInterface.functions || {});
-      return functionsInAbi.length === 1;
-    },
-    {
-      message: '"functionAbi" must contain a single function definition',
-      path: ['functionAbi'],
-    },
-  )
-  .refine(
-    (functionAbi) => {
-      const asInterface = new ethers.utils.Interface(
-        JSON.stringify([functionAbi]),
-      );
-      const nrOfInputs = asInterface.fragments[0].inputs.length;
-      return functionAbi.inputs.length === nrOfInputs;
-    },
-    {
-      message: '"parameters" must have the same length as "functionAbi.inputs"',
-      path: ['parameters'],
-    },
-  );
-
-export type FunctionAbiProps = z.infer<typeof functionAbiSchema>;
-
-export const ContractConditionType = 'contract';
-
-export const contractConditionSchema = rpcConditionSchema
-  .extend({
-    conditionType: z
-      .literal(ContractConditionType)
-      .default(ContractConditionType),
-    contractAddress: z.string().regex(ETH_ADDRESS_REGEXP).length(42),
-    standardContractType: z.enum(['ERC20', 'ERC721']).optional(),
-    method: z.string(),
-    functionAbi: functionAbiSchema.optional(),
-    parameters: z.array(paramOrContextParamSchema),
-  })
-  // Adding this custom logic causes the return type to be ZodEffects instead of ZodObject
-  // https://github.com/colinhacks/zod/issues/2474
-  .refine(
-    // A check to see if either 'standardContractType' or 'functionAbi' is set
-    (data) => Boolean(data.standardContractType) !== Boolean(data.functionAbi),
-    {
-      message:
-        "At most one of the fields 'standardContractType' and 'functionAbi' must be defined",
-      path: ['standardContractType'],
-    },
-  );
-
-export type ContractConditionProps = z.infer<typeof contractConditionSchema>;
+import {
+  ContractConditionProps,
+  contractConditionSchema,
+  ContractConditionType,
+} from '../schemas/contract';
+import { OmitConditionType } from '../shared';
+
+export {
+  ContractConditionProps,
+  contractConditionSchema,
+  ContractConditionType,
+  FunctionAbiProps,
+} from '../schemas/contract';
 
 export class ContractCondition extends Condition {
   constructor(value: OmitConditionType<ContractConditionProps>) {

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

@@ -2,5 +2,7 @@
 // avoid circular dependency on Condition class.
 
 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

@@ -0,0 +1,22 @@
+import { Condition } from '../condition';
+import {
+  JsonApiConditionProps,
+  jsonApiConditionSchema,
+  JsonApiConditionType,
+} from '../schemas/json-api';
+import { OmitConditionType } from '../shared';
+
+export {
+  JsonApiConditionProps,
+  jsonApiConditionSchema,
+  JsonApiConditionType,
+} from '../schemas/json-api';
+
+export class JsonApiCondition extends Condition {
+  constructor(value: OmitConditionType<JsonApiConditionProps>) {
+    super(jsonApiConditionSchema, {
+      conditionType: JsonApiConditionType,
+      ...value,
+    });
+  }
+}

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/base/rpc.ts

@@ -1,30 +1,16 @@
-import { z } from 'zod';
-
 import { Condition } from '../condition';
-import { SUPPORTED_CHAIN_IDS } from '../const';
 import {
-  EthAddressOrUserAddressSchema,
-  OmitConditionType,
-  paramOrContextParamSchema,
-  returnValueTestSchema,
-} from '../shared';
-import createUnionSchema from '../zod';
-
-export const RpcConditionType = 'rpc';
-
-export const rpcConditionSchema = z.object({
-  conditionType: z.literal(RpcConditionType).default(RpcConditionType),
-  chain: createUnionSchema(SUPPORTED_CHAIN_IDS),
-  method: z.enum(['eth_getBalance']),
-  parameters: z.union([
-    z.array(EthAddressOrUserAddressSchema).nonempty(),
-    // Using tuple here because ordering matters
-    z.tuple([EthAddressOrUserAddressSchema, paramOrContextParamSchema]),
-  ]),
-  returnValueTest: returnValueTestSchema, // Update to allow multiple return values after expanding supported methods
-});
+  RpcConditionProps,
+  rpcConditionSchema,
+  RpcConditionType,
+} from '../schemas/rpc';
+import { OmitConditionType } from '../shared';
 
-export type RpcConditionProps = z.infer<typeof rpcConditionSchema>;
+export {
+  RpcConditionProps,
+  rpcConditionSchema,
+  RpcConditionType,
+} from '../schemas/rpc';
 
 export class RpcCondition extends Condition {
   constructor(value: OmitConditionType<RpcConditionProps>) {

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

@@ -1,24 +1,17 @@
-import { z } from 'zod';
-
 import { Condition } from '../condition';
+import {
+  TimeConditionProps,
+  timeConditionSchema,
+  TimeConditionType,
+} from '../schemas/time';
 import { OmitConditionType } from '../shared';
 
-import { rpcConditionSchema } from './rpc';
-
-// TimeCondition is an RpcCondition with the method set to 'blocktime' and no parameters
-// 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(TimeConditionType).default(TimeConditionType),
-  method: z.literal(TimeConditionMethod).default(TimeConditionMethod),
-});
-
-export type TimeConditionProps = z.infer<typeof timeConditionSchema>;
+export {
+  TimeConditionMethod,
+  TimeConditionProps,
+  timeConditionSchema,
+  TimeConditionType,
+} from '../schemas/time';
 
 export class TimeCondition extends Condition {
   constructor(value: OmitConditionType<TimeConditionProps>) {