@cofhe/sdk 0.6.0 → 0.7.0

package/acps/test/localstorage.test.ts

@@ -0,0 +1,105 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { getACP, setACP, removeACP, getActiveACPHash, setActiveACPHash, ACPUtils, acpStore } from '../index.js';
+import { createMockACP } from '../test-utils.js';
+
+// Type declarations for happy-dom environment
+declare const localStorage: {
+  clear: () => void;
+  getItem: (name: string) => string | null;
+  setItem: (name: string, value: string) => void;
+};
+
+describe('ACPs localStorage Tests', () => {
+  const chainId = 1;
+  const account = '0x1234567890123456789012345678901234567890';
+
+  beforeEach(() => {
+    // Clear localStorage and reset store state
+    localStorage.clear();
+    acpStore.resetStore();
+  });
+
+  afterEach(() => {
+    // Clean up after each test
+    localStorage.clear();
+    acpStore.resetStore();
+  });
+
+  it('should persist acps to localStorage', async () => {
+    const acp = await createMockACP();
+
+    setACP(chainId, account, acp);
+
+    // Verify data is stored in localStorage
+    const storedData = localStorage.getItem('cofhesdk-acps');
+    expect(storedData).toBeDefined();
+
+    const parsedData = JSON.parse(storedData!);
+    expect(parsedData.state.acps[chainId][account][acp.hash]).toBeDefined();
+  });
+
+  it('should persist active acp hash to localStorage', async () => {
+    const acp = await createMockACP();
+
+    setACP(chainId, account, acp);
+    setActiveACPHash(chainId, account, acp.hash);
+
+    // Verify active acp hash is stored
+    const storedData = localStorage.getItem('cofhesdk-acps');
+    expect(storedData).toBeDefined();
+
+    const parsedData = JSON.parse(storedData!);
+    expect(parsedData.state.activeACPHash[chainId][account]).toBe(acp.hash);
+  });
+
+  it('should restore acps from localStorage', async () => {
+    const acp = await createMockACP();
+
+    // Add acp to localStorage
+    setACP(chainId, account, acp);
+    setActiveACPHash(chainId, account, acp.hash);
+    const serializedACP = ACPUtils.serialize(acp);
+
+    // Verify data is restored
+    const retrievedACP = getACP(chainId, account, acp.hash);
+    expect(retrievedACP).toBeDefined();
+    expect(ACPUtils.serialize(retrievedACP!)).toEqual(serializedACP);
+
+    const activeHash = getActiveACPHash(chainId, account);
+    expect(activeHash).toBe(acp.hash);
+  });
+
+  it('should handle corrupted localStorage data gracefully', () => {
+    // Set invalid JSON in localStorage
+    localStorage.setItem('cofhesdk-acps', 'invalid json');
+
+    // Store should handle this gracefully
+    expect(() => {
+      acpStore.store.getState();
+    }).not.toThrow();
+  });
+
+  it('should clean up localStorage when acps are removed', async () => {
+    const acp = await createMockACP();
+
+    setACP(chainId, account, acp);
+    setActiveACPHash(chainId, account, acp.hash);
+
+    // Verify data exists
+    let storedData = localStorage.getItem('cofhesdk-acps');
+    expect(storedData).toBeDefined();
+
+    // Remove acp
+    removeACP(chainId, account, acp.hash);
+
+    // Verify data is cleaned up
+    storedData = localStorage.getItem('cofhesdk-acps');
+    const parsedData = JSON.parse(storedData!);
+    expect(parsedData.state.acps[chainId][account][acp.hash]).toBeUndefined();
+    expect(parsedData.state.activeACPHash[chainId][account]).toBeUndefined();
+  });
+});

package/acps/test/sealing.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { GenerateSealingKey, seal, unsealWithPrivateKey } from '../index.js';
+
+describe('seal / unsealWithPrivateKey', () => {
+  it('should seal data into EthEncryptedData shape', () => {
+    const publicKey = `0x${'b'.repeat(64)}`;
+    const value = BigInt(12345);
+
+    const encryptedData = seal(value, publicKey);
+
+    expect(encryptedData).toHaveProperty('data');
+    expect(encryptedData).toHaveProperty('public_key');
+    expect(encryptedData).toHaveProperty('nonce');
+    expect(encryptedData.data).toBeInstanceOf(Uint8Array);
+    expect(encryptedData.public_key).toBeInstanceOf(Uint8Array);
+    expect(encryptedData.nonce).toBeInstanceOf(Uint8Array);
+  });
+
+  it('should round-trip: seal for a generated key, unseal with its private key', () => {
+    const pair = GenerateSealingKey();
+    const value = BigInt(987654321);
+
+    const sealed = seal(value, pair.publicKey);
+    const unsealed = unsealWithPrivateKey(pair.privateKey, sealed);
+
+    expect(unsealed).toBe(value);
+  });
+
+  it('accepts keys with or without the 0x prefix', () => {
+    const pair = GenerateSealingKey();
+    const value = BigInt(42);
+
+    const sealed = seal(value, pair.publicKey.slice(2));
+    expect(unsealWithPrivateKey(pair.privateKey.slice(2), sealed)).toBe(value);
+  });
+
+  it('should throw error for invalid public key in seal', () => {
+    expect(() => {
+      seal(BigInt(12345), 'invalid');
+    }).toThrow('Public key must be of length 64');
+  });
+
+  it('should throw error for invalid private key in unseal', () => {
+    const pair = GenerateSealingKey();
+    const sealed = seal(BigInt(1), pair.publicKey);
+
+    expect(() => {
+      unsealWithPrivateKey('deadbeef', sealed);
+    }).toThrow('Private key must be of length 64');
+  });
+
+  it('should throw error for invalid value in seal', () => {
+    const publicKey = `0x${'b'.repeat(64)}`;
+
+    expect(() => {
+      // @ts-expect-error - invalid value
+      seal('not a number', publicKey);
+    }).toThrow('Value not a number is not a number or bigint: string');
+  });
+});
+
+describe('GenerateSealingKey', () => {
+  it('should generate a 0x-prefixed 32-byte hex pair', () => {
+    const pair = GenerateSealingKey();
+
+    expect(pair.privateKey).toMatch(/^0x[0-9a-f]{64}$/);
+    expect(pair.publicKey).toMatch(/^0x[0-9a-f]{64}$/);
+  });
+
+  it('should generate different keys on each call', () => {
+    const key1 = GenerateSealingKey();
+    const key2 = GenerateSealingKey();
+
+    expect(key1.privateKey).not.toBe(key2.privateKey);
+    expect(key1.publicKey).not.toBe(key2.publicKey);
+  });
+});

package/acps/test/store.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  acpStore,
+  getACP,
+  getActiveACP,
+  getACPs,
+  setACP,
+  removeACP,
+  getActiveACPHash,
+  setActiveACPHash,
+  ACPUtils,
+} from '../index.js';
+
+import { createMockACP } from '../test-utils.js';
+
+describe('Storage Tests', () => {
+  const chainId = 1;
+  const account = '0x1234567890123456789012345678901234567890';
+
+  beforeEach(() => {
+    acpStore.resetStore();
+  });
+
+  afterEach(() => {
+    acpStore.resetStore();
+  });
+
+  describe('ACP Storage', () => {
+    it('should store and retrieve acps', async () => {
+      const acp = await createMockACP();
+
+      setACP(chainId, account, acp);
+      const retrieved = getACP(chainId, account, acp.hash);
+
+      expect(retrieved).toBeDefined();
+      expect(ACPUtils.serialize(retrieved!)).toEqual(ACPUtils.serialize(acp));
+    });
+
+    it('should handle multiple acps per account', async () => {
+      const acp1 = await createMockACP();
+      const acp2 = await createMockACP({
+        issuer: '0x0987654321098765432109876543210987654321' as `0x${string}`,
+      });
+
+      setACP(chainId, account, acp1);
+      setACP(chainId, account, acp2);
+
+      const acps = getACPs(chainId, account);
+      expect(Object.keys(acps)).toHaveLength(2);
+
+      expect(ACPUtils.serialize(acps[acp1.hash])).toEqual(ACPUtils.serialize(acp1));
+      expect(ACPUtils.serialize(acps[acp2.hash])).toEqual(ACPUtils.serialize(acp2));
+    });
+
+    it('should handle active acp hash', async () => {
+      const acp = await createMockACP();
+
+      setACP(chainId, account, acp);
+      setActiveACPHash(chainId, account, acp.hash);
+
+      const activeHash = getActiveACPHash(chainId, account);
+      expect(activeHash).toBe(acp.hash);
+
+      const activeACP = getActiveACP(chainId, account);
+      expect(activeACP).toBeDefined();
+      expect(ACPUtils.serialize(activeACP!)).toEqual(ACPUtils.serialize(acp));
+    });
+
+    it('should remove acps', async () => {
+      const acp = await createMockACP();
+
+      setACP(chainId, account, acp);
+      setActiveACPHash(chainId, account, acp.hash);
+
+      removeACP(chainId, account, acp.hash);
+
+      const retrieved = getACP(chainId, account, acp.hash);
+      expect(retrieved).toBeUndefined();
+
+      const activeHash = getActiveACPHash(chainId, account);
+      expect(activeHash).toBeUndefined();
+    });
+  });
+});

package/acps/test/validation.test.ts

@@ -0,0 +1,361 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ValidationUtils,
+  validateSelfACPOptions,
+  validateSharingACPOptions,
+  validateImportACPOptions,
+  validateSelfACP,
+  validateSharingACP,
+  validateImportACP,
+  type ACP,
+  type CreateSelfACPOptions,
+  type CreateSharingACPOptions,
+  type ImportSharedACPOptions,
+} from '../index.js';
+import { createMockACP } from '../test-utils.js';
+
+describe('Validation Tests', () => {
+  describe('validateSelfACPOptions', () => {
+    it('should validate valid self acp options', () => {
+      const options: CreateSelfACPOptions = {
+        type: 'self',
+        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+        name: 'Test ACP',
+      };
+
+      expect(() => validateSelfACPOptions(options)).not.toThrow();
+      const result = validateSelfACPOptions(options);
+      expect(result).toBeDefined();
+    });
+
+    it('should reject invalid address', () => {
+      const options: CreateSelfACPOptions = {
+        type: 'self',
+        issuer: 'invalid-address',
+        name: 'Test ACP',
+      };
+
+      expect(() => validateSelfACPOptions(options)).toThrow();
+    });
+
+    it('should reject zero address', () => {
+      const options: CreateSelfACPOptions = {
+        type: 'self',
+        issuer: '0x0000000000000000000000000000000000000000',
+        name: 'Test ACP',
+      };
+
+      expect(() => validateSelfACPOptions(options)).toThrow();
+    });
+  });
+
+  describe('validateSharingACPOptions', () => {
+    it('should validate valid sharing acp options', () => {
+      const options: CreateSharingACPOptions = {
+        type: 'sharing',
+        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
+        name: 'Sharing ACP',
+      };
+
+      expect(() => validateSharingACPOptions(options)).not.toThrow();
+    });
+
+    it('should reject sharing acp with zero recipient', () => {
+      const options: CreateSharingACPOptions = {
+        type: 'sharing',
+        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+        recipient: '0x0000000000000000000000000000000000000000',
+        name: 'Sharing ACP',
+      };
+
+      expect(() => validateSharingACPOptions(options)).toThrow();
+    });
+
+    it('should reject sharing acp with invalid recipient', () => {
+      const options: CreateSharingACPOptions = {
+        type: 'sharing',
+        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+        recipient: 'invalid-address',
+        name: 'Sharing ACP',
+      };
+
+      expect(() => validateSharingACPOptions(options)).toThrow();
+    });
+  });
+
+  describe('validateImportACPOptions', () => {
+    it('should validate valid import acp options', () => {
+      const options: ImportSharedACPOptions = {
+        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 ACP',
+      };
+
+      expect(() => validateImportACPOptions(options)).not.toThrow();
+    });
+
+    it('should reject import acp with missing expiration', () => {
+      const options = {
+        issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+        recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8', // Alice's address
+        issuerSignature: '0x1234567890abcdef',
+        name: 'Import ACP',
+      };
+      expect(() => validateImportACPOptions(options)).toThrow();
+    });
+
+    it('should reject import acp with empty signature', () => {
+      const options: ImportSharedACPOptions = {
+        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 ACP',
+      };
+
+      expect(() => validateImportACPOptions(options)).toThrow();
+    });
+
+    it('should reject import acp with invalid signature', () => {
+      const options: ImportSharedACPOptions = {
+        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 ACP',
+      };
+
+      expect(() => validateImportACPOptions(options)).toThrow();
+    });
+  });
+
+  describe('validateSelfACP', () => {
+    it('should validate valid self acp', async () => {
+      const acp = await createMockACP();
+      acp.type = 'self';
+      acp.issuerSignature = '0x1234567890abcdef';
+
+      expect(() => validateSelfACP(acp)).not.toThrow();
+    });
+
+    it('should reject self acp with missing sealing pair', async () => {
+      const acp = { ...(await createMockACP()), sealingPrivateKey: undefined };
+      acp.type = 'self';
+      expect(() => validateSelfACP(acp as unknown as ACP)).toThrow();
+    });
+  });
+
+  describe('validateSharingACP', () => {
+    it('should validate valid sharing acp', async () => {
+      const acp = await createMockACP();
+      acp.type = 'sharing';
+      acp.issuerSignature = '0x1234567890abcdef';
+      acp.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
+
+      expect(() => validateSharingACP(acp)).not.toThrow();
+    });
+
+    it('should reject sharing acp with zero recipient', async () => {
+      const acp = await createMockACP();
+      acp.type = 'sharing';
+      acp.issuerSignature = '0x1234567890abcdef';
+      acp.recipient = '0x0000000000000000000000000000000000000000';
+
+      expect(() => validateSharingACP(acp)).toThrow();
+    });
+  });
+
+  describe('validateImportACP', () => {
+    it('should validate valid import acp', async () => {
+      const acp = await createMockACP();
+      acp.type = 'recipient';
+      acp.issuerSignature = '0x1234567890abcdef';
+      acp.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
+      acp.recipientSignature = '0xabcdef1234567890';
+
+      expect(() => validateImportACP(acp)).not.toThrow();
+    });
+
+    it('should reject import acp with empty recipient signature', async () => {
+      const acp = await createMockACP();
+      acp.type = 'recipient';
+      acp.issuerSignature = '0x1234567890abcdef';
+      acp.recipient = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8'; // Alice's address
+      acp.recipientSignature = '0x';
+
+      expect(() => validateImportACP(acp)).toThrow();
+    });
+  });
+
+  describe('ValidationUtils', () => {
+    describe('isExpired', () => {
+      it('should return true for expired acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
+        };
+        expect(ValidationUtils.isExpired(acp)).toBe(true);
+      });
+
+      it('should return false for non-expired acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+        };
+        expect(ValidationUtils.isExpired(acp)).toBe(false);
+      });
+    });
+
+    describe('isSigned', () => {
+      it('should return true for signed self acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          type: 'self' as const,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        expect(ValidationUtils.isSigned(acp)).toBe(true);
+      });
+
+      it('should return false for unsigned self acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          type: 'self' as const,
+          issuerSignature: '0x' as `0x${string}`,
+        };
+        expect(ValidationUtils.isSigned(acp)).toBe(false);
+      });
+
+      it('should return true for signed recipient acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          type: 'recipient' as const,
+          recipientSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        expect(ValidationUtils.isSigned(acp)).toBe(true);
+      });
+
+      it('should return false for unsigned recipient acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          type: 'recipient' as const,
+          recipientSignature: '0x' as `0x${string}`,
+        };
+        expect(ValidationUtils.isSigned(acp)).toBe(false);
+      });
+    });
+
+    describe('isSignedAndNotExpired', () => {
+      it('should return valid for valid acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) + 3600,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        const result = ValidationUtils.isSignedAndNotExpired(acp);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeNull();
+      });
+
+      it('should return invalid for expired acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) - 3600,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        const result = ValidationUtils.isSignedAndNotExpired(acp);
+        expect(result.valid).toBe(false);
+        expect(result.error).toBe('expired');
+      });
+
+      it('should return invalid for unsigned acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) + 3600,
+          issuerSignature: '0x' as `0x${string}`,
+        };
+        const result = ValidationUtils.isSignedAndNotExpired(acp);
+        expect(result.valid).toBe(false);
+        expect(result.error).toBe('not-signed');
+      });
+    });
+
+    describe('assertSignedAndNotExpired', () => {
+      it('should not throw for valid acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) + 3600,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        expect(() => ValidationUtils.assertSignedAndNotExpired(acp)).not.toThrow();
+      });
+
+      it('should throw for expired acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) - 3600,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+        };
+        expect(() => ValidationUtils.assertSignedAndNotExpired(acp)).toThrow('ACP is expired');
+      });
+
+      it('should throw for unsigned acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          expiration: Math.floor(Date.now() / 1000) + 3600,
+          issuerSignature: '0x' as `0x${string}`,
+        };
+        expect(() => ValidationUtils.assertSignedAndNotExpired(acp)).toThrow('ACP is not signed');
+      });
+    });
+
+    describe('isValid', () => {
+      it('should return invalid-schema for schema-invalid acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          type: 'self' as const,
+          expiration: Math.floor(Date.now() / 1000) + 3600,
+          issuerSignature: '0x1234567890abcdef' as `0x${string}`,
+          // Self acps must have recipient == zeroAddress per schema.
+          recipient: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8' as `0x${string}`,
+        };
+
+        const result = ValidationUtils.isValid(acp as unknown as ACP);
+        expect(result.valid).toBe(false);
+        expect(result.error).toBe('invalid-schema');
+      });
+
+      it('should return expired for expired but otherwise schema-valid acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          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(acp as unknown as ACP);
+        expect(result.valid).toBe(false);
+        expect(result.error).toBe('expired');
+      });
+
+      it('should return valid for schema-valid, signed, non-expired acp', async () => {
+        const acp = {
+          ...(await createMockACP()),
+          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(acp as unknown as ACP);
+        expect(result.valid).toBe(true);
+        expect(result.error).toBeNull();
+      });
+    });
+  });
+});

package/acps/test-utils.ts

@@ -0,0 +1,32 @@
+import { type ACP, type SerializedACP, GenerateSealingKey, ACPUtils } from './index.js';
+
+// Mock acp for testing - using Bob's address as issuer
+export const createMockACP = async (overrides: Partial<ACP> = {}): Promise<ACP> => {
+  const sealingPair = GenerateSealingKey();
+
+  const fields = {
+    name: 'Test ACP',
+    type: 'self',
+    issuer: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', // Bob's address
+    expiration: 1000000000000,
+    recipient: '0x0000000000000000000000000000000000000000',
+    revokerData: 0,
+    revokerContract: '0x0000000000000000000000000000000000000000',
+    scope: 0,
+    contracts: [] as ACP['contracts'],
+    handles: [] as ACP['handles'],
+    sealingPrivateKey: sealingPair.privateKey,
+    sealingKey: sealingPair.publicKey,
+    issuerSignature: '0x',
+    recipientSignature: '0x',
+    _signedDomain: undefined,
+    ...overrides,
+  } as const;
+
+  const serializedACP: SerializedACP = {
+    hash: ACPUtils.getHash(fields),
+    ...fields,
+  };
+
+  return ACPUtils.deserialize(serializedACP);
+};