@cofhe/sdk 0.6.0 → 0.7.0

package/permits/test/store.test.ts

@@ -1,88 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  permitStore,
-  getPermit,
-  getActivePermit,
-  getPermits,
-  setPermit,
-  removePermit,
-  getActivePermitHash,
-  setActivePermitHash,
-  PermitUtils,
-} from '../index.js';
-
-import { createMockPermit } from '../test-utils.js';
-
-describe('Storage Tests', () => {
-  const chainId = 1;
-  const account = '0x1234567890123456789012345678901234567890';
-
-  beforeEach(() => {
-    permitStore.resetStore();
-  });
-
-  afterEach(() => {
-    permitStore.resetStore();
-  });
-
-  describe('Permit Storage', () => {
-    it('should store and retrieve permits', async () => {
-      const permit = await createMockPermit();
-
-      setPermit(chainId, account, permit);
-      const retrieved = getPermit(chainId, account, permit.hash);
-
-      expect(retrieved).toBeDefined();
-      expect(PermitUtils.serialize(retrieved!)).toEqual(PermitUtils.serialize(permit));
-    });
-
-    it('should handle multiple permits per account', async () => {
-      const permit1 = await createMockPermit();
-      const permit2 = await createMockPermit({
-        issuer: '0x0987654321098765432109876543210987654321' as `0x${string}`,
-      });
-
-      setPermit(chainId, account, permit1);
-      setPermit(chainId, account, permit2);
-
-      const permits = getPermits(chainId, account);
-      expect(Object.keys(permits)).toHaveLength(2);
-
-      expect(PermitUtils.serialize(permits[permit1.hash])).toEqual(PermitUtils.serialize(permit1));
-      expect(PermitUtils.serialize(permits[permit2.hash])).toEqual(PermitUtils.serialize(permit2));
-    });
-
-    it('should handle active permit hash', async () => {
-      const permit = await createMockPermit();
-
-      setPermit(chainId, account, permit);
-      setActivePermitHash(chainId, account, permit.hash);
-
-      const activeHash = getActivePermitHash(chainId, account);
-      expect(activeHash).toBe(permit.hash);
-
-      const activePermit = getActivePermit(chainId, account);
-      expect(activePermit).toBeDefined();
-      expect(PermitUtils.serialize(activePermit!)).toEqual(PermitUtils.serialize(permit));
-    });
-
-    it('should remove permits', async () => {
-      const permit = await createMockPermit();
-
-      setPermit(chainId, account, permit);
-      setActivePermitHash(chainId, account, permit.hash);
-
-      removePermit(chainId, account, permit.hash);
-
-      const retrieved = getPermit(chainId, account, permit.hash);
-      expect(retrieved).toBeUndefined();
-
-      const activeHash = getActivePermitHash(chainId, account);
-      expect(activeHash).toBeUndefined();
-    });
-  });
-});

package/permits/test/validation.test.ts

@@ -1,361 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  ValidationUtils,
-  validateSelfPermitOptions,
-  validateSharingPermitOptions,
-  validateImportPermitOptions,
-  validateSelfPermit,
-  validateSharingPermit,
-  validateImportPermit,
-  type Permit,
-  type CreateSelfPermitOptions,
-  type CreateSharingPermitOptions,
-  type ImportSharedPermitOptions,
-} from '../index.js';
-import { createMockPermit } from '../test-utils.js';
-
-describe('Validation Tests', () => {
-  describe('validateSelfPermitOptions', () => {
-    it('should validate valid self permit options', () => {
-      const options: CreateSelfPermitOptions = {
-        type: 'self',
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        name: 'Test Permit',
-      };
-
-      expect(() => validateSelfPermitOptions(options)).not.toThrow();
-      const result = validateSelfPermitOptions(options);
-      expect(result).toBeDefined();
-    });
-
-    it('should reject invalid address', () => {
-      const options: CreateSelfPermitOptions = {
-        type: 'self',
-        issuer: 'invalid-address',
-        name: 'Test Permit',
-      };
-
-      expect(() => validateSelfPermitOptions(options)).toThrow();
-    });
-
-    it('should reject zero address', () => {
-      const options: CreateSelfPermitOptions = {
-        type: 'self',
-        issuer: '0x0000000000000000000000000000000000000000',
-        name: 'Test Permit',
-      };
-
-      expect(() => validateSelfPermitOptions(options)).toThrow();
-    });
-  });
-
-  describe('validateSharingPermitOptions', () => {
-    it('should validate valid sharing permit options', () => {
-      const options: CreateSharingPermitOptions = {
-        type: 'sharing',
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
-        name: 'Sharing Permit',
-      };
-
-      expect(() => validateSharingPermitOptions(options)).not.toThrow();
-    });
-
-    it('should reject sharing permit with zero recipient', () => {
-      const options: CreateSharingPermitOptions = {
-        type: 'sharing',
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        recipient: '0x0000000000000000000000000000000000000000',
-        name: 'Sharing Permit',
-      };
-
-      expect(() => validateSharingPermitOptions(options)).toThrow();
-    });
-
-    it('should reject sharing permit with invalid recipient', () => {
-      const options: CreateSharingPermitOptions = {
-        type: 'sharing',
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        recipient: 'invalid-address',
-        name: 'Sharing Permit',
-      };
-
-      expect(() => validateSharingPermitOptions(options)).toThrow();
-    });
-  });
-
-  describe('validateImportPermitOptions', () => {
-    it('should validate valid import permit options', () => {
-      const options: ImportSharedPermitOptions = {
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
-        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
-        issuerSignature: '0x1234567890abcdef',
-        name: 'Import Permit',
-      };
-
-      expect(() => validateImportPermitOptions(options)).not.toThrow();
-    });
-
-    it('should reject import permit with missing expiration', () => {
-      const options = {
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
-        issuerSignature: '0x1234567890abcdef',
-        name: 'Import Permit',
-      };
-      expect(() => validateImportPermitOptions(options)).toThrow();
-    });
-
-    it('should reject import permit with empty signature', () => {
-      const options: ImportSharedPermitOptions = {
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
-        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
-        issuerSignature: '0x',
-        name: 'Import Permit',
-      };
-
-      expect(() => validateImportPermitOptions(options)).toThrow();
-    });
-
-    it('should reject import permit with invalid signature', () => {
-      const options: ImportSharedPermitOptions = {
-        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
-        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
-        issuerSignature: '0x',
-        name: 'Import Permit',
-      };
-
-      expect(() => validateImportPermitOptions(options)).toThrow();
-    });
-  });
-
-  describe('validateSelfPermit', () => {
-    it('should validate valid self permit', async () => {
-      const permit = await createMockPermit();
-      permit.type = 'self';
-      permit.issuerSignature = '0x1234567890abcdef';
-
-      expect(() => validateSelfPermit(permit)).not.toThrow();
-    });
-
-    it('should reject self permit with missing sealing pair', async () => {
-      const permit = { ...(await createMockPermit()), sealingPair: undefined };
-      permit.type = 'self';
-      expect(() => validateSelfPermit(permit as unknown as Permit)).toThrow();
-    });
-  });
-
-  describe('validateSharingPermit', () => {
-    it('should validate valid sharing permit', async () => {
-      const permit = await createMockPermit();
-      permit.type = 'sharing';
-      permit.issuerSignature = '0x1234567890abcdef';
-      permit.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
-
-      expect(() => validateSharingPermit(permit)).not.toThrow();
-    });
-
-    it('should reject sharing permit with zero recipient', async () => {
-      const permit = await createMockPermit();
-      permit.type = 'sharing';
-      permit.issuerSignature = '0x1234567890abcdef';
-      permit.recipient = '0x0000000000000000000000000000000000000000';
-
-      expect(() => validateSharingPermit(permit)).toThrow();
-    });
-  });
-
-  describe('validateImportPermit', () => {
-    it('should validate valid import permit', async () => {
-      const permit = await createMockPermit();
-      permit.type = 'recipient';
-      permit.issuerSignature = '0x1234567890abcdef';
-      permit.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
-      permit.recipientSignature = '0xabcdef1234567890';
-
-      expect(() => validateImportPermit(permit)).not.toThrow();
-    });
-
-    it('should reject import permit with empty recipient signature', async () => {
-      const permit = await createMockPermit();
-      permit.type = 'recipient';
-      permit.issuerSignature = '0x1234567890abcdef';
-      permit.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
-      permit.recipientSignature = '0x';
-
-      expect(() => validateImportPermit(permit)).toThrow();
-    });
-  });
-
-  describe('ValidationUtils', () => {
-    describe('isExpired', () => {
-      it('should return true for expired permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
-        };
-        expect(ValidationUtils.isExpired(permit)).toBe(true);
-      });
-
-      it('should return false for non-expired permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
-        };
-        expect(ValidationUtils.isExpired(permit)).toBe(false);
-      });
-    });
-
-    describe('isSigned', () => {
-      it('should return true for signed self permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'self' as const,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        expect(ValidationUtils.isSigned(permit)).toBe(true);
-      });
-
-      it('should return false for unsigned self permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'self' as const,
-          issuerSignature: '0x' as `0x${string}`,
-        };
-        expect(ValidationUtils.isSigned(permit)).toBe(false);
-      });
-
-      it('should return true for signed recipient permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'recipient' as const,
-          recipientSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        expect(ValidationUtils.isSigned(permit)).toBe(true);
-      });
-
-      it('should return false for unsigned recipient permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'recipient' as const,
-          recipientSignature: '0x' as `0x${string}`,
-        };
-        expect(ValidationUtils.isSigned(permit)).toBe(false);
-      });
-    });
-
-    describe('isSignedAndNotExpired', () => {
-      it('should return valid for valid permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        const result = ValidationUtils.isSignedAndNotExpired(permit);
-        expect(result.valid).toBe(true);
-        expect(result.error).toBeNull();
-      });
-
-      it('should return invalid for expired permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) - 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        const result = ValidationUtils.isSignedAndNotExpired(permit);
-        expect(result.valid).toBe(false);
-        expect(result.error).toBe('expired');
-      });
-
-      it('should return invalid for unsigned permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x' as `0x${string}`,
-        };
-        const result = ValidationUtils.isSignedAndNotExpired(permit);
-        expect(result.valid).toBe(false);
-        expect(result.error).toBe('not-signed');
-      });
-    });
-
-    describe('assertSignedAndNotExpired', () => {
-      it('should not throw for valid permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        expect(() => ValidationUtils.assertSignedAndNotExpired(permit)).not.toThrow();
-      });
-
-      it('should throw for expired permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) - 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-        };
-        expect(() => ValidationUtils.assertSignedAndNotExpired(permit)).toThrow('Permit is expired');
-      });
-
-      it('should throw for unsigned permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x' as `0x${string}`,
-        };
-        expect(() => ValidationUtils.assertSignedAndNotExpired(permit)).toThrow('Permit is not signed');
-      });
-    });
-
-    describe('isValid', () => {
-      it('should return invalid-schema for schema-invalid permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'self' as const,
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-          // Self permits must have recipient == zeroAddress per schema.
-          recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8' as `0x${string}`,
-        };
-
-        const result = ValidationUtils.isValid(permit as unknown as Permit);
-        expect(result.valid).toBe(false);
-        expect(result.error).toBe('invalid-schema');
-      });
-
-      it('should return expired for expired but otherwise schema-valid permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'self' as const,
-          expiration: Math.floor(Date.now() / 1000) - 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-          recipient: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          recipientSignature: '0x' as `0x${string}`,
-        };
-
-        const result = ValidationUtils.isValid(permit as unknown as Permit);
-        expect(result.valid).toBe(false);
-        expect(result.error).toBe('expired');
-      });
-
-      it('should return valid for schema-valid, signed, non-expired permit', async () => {
-        const permit = {
-          ...(await createMockPermit()),
-          type: 'self' as const,
-          expiration: Math.floor(Date.now() / 1000) + 3600,
-          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
-          recipient: '0x0000000000000000000000000000000000000000' as `0x${string}`,
-          recipientSignature: '0x' as `0x${string}`,
-        };
-
-        const result = ValidationUtils.isValid(permit as unknown as Permit);
-        expect(result.valid).toBe(true);
-        expect(result.error).toBeNull();
-      });
-    });
-  });
-});

package/permits/test-utils.ts

@@ -1,28 +0,0 @@
-import { type Permit, type SerializedPermit, GenerateSealingKey, PermitUtils } from './index.js';
-
-// Mock permit for testing - using Bob's address as issuer
-export const createMockPermit = async (overrides: Partial<Permit> = {}): Promise<Permit> => {
-  const sealingPair = GenerateSealingKey();
-
-  const fields = {
-    name: 'Test Permit',
-    type: 'self',
-    issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
-    expiration: 1000000000000,
-    recipient: '0x0000000000000000000000000000000000000000',
-    validatorId: 0,
-    validatorContract: '0x0000000000000000000000000000000000000000',
-    sealingPair: sealingPair.serialize(),
-    issuerSignature: '0x',
-    recipientSignature: '0x',
-    _signedDomain: undefined,
-    ...overrides,
-  } as const;
-
-  const serializedPermit: SerializedPermit = {
-    hash: PermitUtils.getHash(fields),
-    ...fields,
-  };
-
-  return PermitUtils.deserialize(serializedPermit);
-};

package/permits/types.ts

@@ -1,204 +0,0 @@
-import { SealingKey as SealingKeyClass, type EthEncryptedData } from './sealing.js';
-import { type Hex } from 'viem';
-
-/**
- * EIP712 related types
- */
-export type EIP712Type = { name: string; type: string };
-export type EIP712Types = Record<string, EIP712Type[]>;
-export type EIP712Message = Record<string, string>;
-export type EIP712Domain = {
-  chainId: number;
-  name: string;
-  verifyingContract: Hex;
-  version: string;
-};
-
-/**
- * Sealing key type - using the actual SealingKey class
- */
-export type SealingKey = SealingKeyClass;
-
-/**
- * Re-export EthEncryptedData from sealing module
- */
-export type { EthEncryptedData };
-
-// Viem client types will be imported from viem package
-
-/**
- * Core Permit interface - immutable design for React compatibility
- */
-export interface Permit {
-  /**
-   * Stable hash of relevant permit data, used as key in storage
-   */
-  hash: string;
-  /**
-   * Name for this permit, for organization and UI usage, not included in signature.
-   */
-  name: string;
-  /**
-   * The type of the Permit (self / sharing)
-   * (self) Permit that will be signed and used by the issuer
-   * (sharing) Permit that is signed by the issuer, but intended to be shared with recipient
-   * (recipient) Permit that has been received, and signed by the recipient
-   */
-  type: 'self' | 'sharing' | 'recipient';
-  /**
-   * (base) User that initially created the permission, target of data fetching
-   */
-  issuer: Hex;
-  /**
-   * (base) Expiration timestamp
-   */
-  expiration: number;
-  /**
-   * (sharing) The user that this permission will be shared with
-   * ** optional, use `address(0)` to disable **
-   */
-  recipient: Hex;
-  /**
-   * (issuer defined validation) An id used to query a contract to check this permissions validity
-   * ** optional, use `0` to disable **
-   */
-  validatorId: number;
-  /**
-   * (issuer defined validation) The contract to query to determine permission validity
-   * ** optional, user `address(0)` to disable **
-   */
-  validatorContract: Hex;
-  /**
-   * (base) The publicKey of a sealingPair used to re-encrypt `issuer`s confidential data
-   *   (non-sharing) Populated by `issuer`
-   *   (sharing)     Populated by `recipient`
-   */
-  sealingPair: SealingKey;
-  /**
-   * (base) `signTypedData` signature created by `issuer`.
-   * (base) Shared- and Self- permissions differ in signature format: (`sealingKey` absent in shared signature)
-   *   (non-sharing) < issuer, expiration, recipient, validatorId, validatorContract, sealingKey >
-   *   (sharing)     < issuer, expiration, recipient, validatorId, validatorContract >
-   */
-  issuerSignature: Hex;
-  /**
-   * (sharing) `signTypedData` signature created by `recipient` with format:
-   * (sharing) < sealingKey, issuerSignature>
-   * ** required for shared permits **
-   */
-  recipientSignature: Hex;
-  /**
-   * EIP712 domain used to sign this permit.
-   * Should not be set manually, included in metadata as part of serialization flows.
-   */
-  _signedDomain?: EIP712Domain;
-}
-
-/**
- * Permit discriminant helpers
- */
-export type PermitType = Permit['type'];
-
-/**
- * Utility type to narrow a permit to a specific discriminant.
- *
- * Note: this only narrows the `type` field. Runtime/validation constraints
- * (e.g. recipient == zeroAddress for self permits) are enforced elsewhere.
- */
-export type PermitOf<T extends PermitType> = Expand<Omit<Permit, 'type'> & { type: T }>;
-
-export type SelfPermit = PermitOf<'self'>;
-export type SharingPermit = PermitOf<'sharing'>;
-export type RecipientPermit = PermitOf<'recipient'>;
-
-/**
- * Optional additional metadata of a Permit
- * Can be passed into the constructor, but not necessary
- * Useful for deserialization
- */
-export interface PermitMetadata {
-  /**
-   * EIP712 domain used to sign this permit.
-   * Should not be set manually, included in metadata as part of serialization flows.
-   */
-  _signedDomain?: EIP712Domain;
-}
-
-/**
- * Utility types for permit creation
- */
-
-// Specific option types for each permit creation method
-export type CreateSelfPermitOptions = {
-  type?: 'self';
-  issuer: string;
-  name?: string;
-  expiration?: number;
-  validatorId?: number;
-  validatorContract?: string;
-};
-
-export type CreateSharingPermitOptions = {
-  type?: 'sharing';
-  issuer: string;
-  recipient: string;
-  name?: string;
-  expiration?: number;
-  validatorId?: number;
-  validatorContract?: string;
-};
-
-export type ImportSharedPermitOptions = {
-  type?: 'sharing';
-  issuer: string;
-  recipient: string;
-  issuerSignature: string;
-  name?: string;
-  expiration: number;
-  validatorId?: number;
-  validatorContract?: string;
-};
-
-export type SerializedPermit = Omit<Permit, 'sealingPair'> & {
-  _signedDomain?: EIP712Domain;
-  sealingPair: {
-    privateKey: string;
-    publicKey: string;
-  };
-};
-
-/**
- * A type representing the Permission struct that is passed to Permissioned.sol to grant encrypted data access.
- */
-export type Permission = Expand<
-  Omit<Permit, 'name' | 'type' | 'sealingPair' | 'hash'> & {
-    sealingKey: Hex;
-  }
->;
-
-/**
- * A type representing the permit fields that are used to generate the hash
- */
-export type PermitHashFields = Pick<
-  Permit,
-  'type' | 'issuer' | 'expiration' | 'recipient' | 'validatorId' | 'validatorContract'
->;
-
-/**
- * Validation result type
- */
-export interface ValidationResult {
-  valid: boolean;
-  error: 'invalid-schema' | 'expired' | 'not-signed' | null;
-}
-
-/**
- * Signature types for EIP712 signing
- */
-export type PermitSignaturePrimaryType =
-  | 'PermissionedV2IssuerSelf'
-  | 'PermissionedV2IssuerShared'
-  | 'PermissionedV2Recipient';
-
-// Utils
-export type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;