@cofhe/sdk 0.6.1 → 0.7.0

package/core/test/permits.test.ts

@@ -1,596 +0,0 @@
-/**
- * @vitest-environment happy-dom
- */
-import { permitStore } from '@/permits';
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createPublicClient, createWalletClient, http, type PublicClient, type WalletClient } from 'viem';
-import { arbitrumSepolia } from 'viem/chains';
-import { privateKeyToAccount } from 'viem/accounts';
-import { permits } from '../permits.js';
-
-// Type declarations for happy-dom environment
-declare const localStorage: {
-  clear: () => void;
-  getItem: (name: string) => string | null;
-  setItem: (name: string, value: string) => void;
-};
-
-// Test private keys (well-known test keys from Anvil/Hardhat)
-const BOB_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'; // Bob - always issuer
-const ALICE_PRIVATE_KEY = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d'; // Alice - always recipient
-
-// Create real viem clients for Arbitrum Sepolia
-const publicClient: PublicClient = createPublicClient({
-  chain: arbitrumSepolia,
-  transport: http(),
-});
-
-const bobWalletClient: WalletClient = createWalletClient({
-  chain: arbitrumSepolia,
-  transport: http(),
-  account: privateKeyToAccount(BOB_PRIVATE_KEY),
-});
-
-const aliceWalletClient: WalletClient = createWalletClient({
-  chain: arbitrumSepolia,
-  transport: http(),
-  account: privateKeyToAccount(ALICE_PRIVATE_KEY),
-});
-
-// Helper to get the wallet addresses
-const bobAddress = bobWalletClient.account!.address;
-const aliceAddress = aliceWalletClient.account!.address;
-const chainId = 421614; // Arbitrum Sepolia
-
-describe('Core Permits Tests', () => {
-  beforeEach(() => {
-    // Clear localStorage and reset stores
-    localStorage.clear();
-    permitStore.store.setState({ permits: {}, activePermitHash: {} });
-  });
-
-  afterEach(() => {
-    localStorage.clear();
-    permitStore.store.setState({ permits: {}, activePermitHash: {} });
-  });
-
-  describe('Permit Creation', () => {
-    it('should create and store self permit', async () => {
-      const permit = await permits.createSelf(
-        { name: 'Test Self Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-
-      expect(permit).toBeDefined();
-      expect(permit.name).toBe('Test Self Permit');
-      expect(permit.type).toBe('self');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.issuerSignature).toBeDefined();
-      expect(permit.issuerSignature).not.toBe('0x');
-
-      // Verify localStorage
-      const storedData = localStorage.getItem('cofhesdk-permits');
-      expect(storedData).toBeDefined();
-      const parsedData = JSON.parse(storedData!);
-      expect(parsedData.state.permits[chainId][bobAddress]).toBeDefined();
-      expect(parsedData.state.activePermitHash[chainId][bobAddress]).toBeDefined();
-    });
-
-    it('should create and store sharing permit', async () => {
-      const permit = await permits.createSharing(
-        {
-          name: 'Test Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      expect(permit.name).toBe('Test Sharing Permit');
-      expect(permit.type).toBe('sharing');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.recipient).toBe(aliceAddress);
-      expect(permit.issuerSignature).toBeDefined();
-      expect(permit.issuerSignature).not.toBe('0x');
-
-      // Verify localStorage
-      const storedData = localStorage.getItem('cofhesdk-permits');
-      expect(storedData).toBeDefined();
-      const parsedData = JSON.parse(storedData!);
-      expect(parsedData.state.permits[chainId][bobAddress]).toBeDefined();
-      expect(parsedData.state.activePermitHash[chainId][bobAddress]).toBeDefined();
-    });
-
-    it('should import shared permit from JSON string', async () => {
-      // First create a sharing permit to import
-      const sharingPermit = await permits.createSharing(
-        {
-          name: 'Original Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Export the permit as JSON string
-      const permitJson = JSON.stringify({
-        name: sharingPermit.name,
-        type: sharingPermit.type,
-        issuer: sharingPermit.issuer,
-        expiration: sharingPermit.expiration,
-        recipient: sharingPermit.recipient,
-        validatorId: sharingPermit.validatorId,
-        validatorContract: sharingPermit.validatorContract,
-        issuerSignature: sharingPermit.issuerSignature,
-      });
-
-      // Import the permit as Alice (recipient)
-      const permit = await permits.importShared(permitJson, publicClient, aliceWalletClient);
-
-      expect(permit.name).toBe('Original Sharing Permit');
-      expect(permit.type).toBe('recipient');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.recipient).toBe(aliceAddress);
-      expect(permit.recipientSignature).toBeDefined();
-      expect(permit.recipientSignature).not.toBe('0x');
-    });
-  });
-
-  describe('Permit Retrieval', () => {
-    let createdPermit: any;
-    let permitHash: string;
-
-    beforeEach(async () => {
-      // Create a real permit for testing
-      createdPermit = await permits.createSelf(
-        { name: 'Test Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-      permitHash = createdPermit.hash;
-    });
-
-    it('should get permit by hash', async () => {
-      const permit = await permits.getPermit(chainId, bobAddress, permitHash);
-      expect(permit?.name).toBe('Test Permit');
-      expect(permit?.type).toBe('self');
-    });
-
-    it('should get all permits', async () => {
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBeGreaterThan(0);
-    });
-
-    it('should get active permit', async () => {
-      const permit = await permits.getActivePermit(chainId, bobAddress);
-      expect(permit?.name).toBe('Test Permit');
-    });
-
-    it('should get active permit hash', async () => {
-      const hash = await permits.getActivePermitHash(chainId, bobAddress);
-      expect(typeof hash).toBe('string');
-    });
-  });
-
-  describe('localStorage Integration', () => {
-    it('should persist permits to localStorage', async () => {
-      const createdPermit = await permits.createSelf(
-        { name: 'Test Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-
-      const storedData = localStorage.getItem('cofhesdk-permits');
-      expect(storedData).toBeDefined();
-
-      const parsedData = JSON.parse(storedData!);
-      expect(parsedData.state.permits[chainId][bobAddress]).toBeDefined();
-      expect(parsedData.state.activePermitHash[chainId][bobAddress]).toBeDefined();
-
-      // Verify the permit data structure
-      const permitKeys = Object.keys(parsedData.state.permits[chainId][bobAddress]);
-      expect(permitKeys.length).toBeGreaterThan(0);
-
-      const serializedPermit = permits.serialize(createdPermit);
-      expect(parsedData.state.permits[chainId][bobAddress][createdPermit.hash]).toEqual(serializedPermit);
-    });
-  });
-
-  describe('Real Network Integration', () => {
-    it('should create permit with real EIP712 domain from Arbitrum Sepolia', async () => {
-      const permit = await permits.createSelf(
-        { name: 'Real Network Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-
-      expect(permit._signedDomain).toBeDefined();
-      expect(permit._signedDomain?.chainId).toBe(chainId);
-      expect(permit._signedDomain?.name).toBeDefined();
-      expect(permit._signedDomain?.version).toBeDefined();
-      expect(permit._signedDomain?.verifyingContract).toBeDefined();
-    });
-
-    it('should handle multiple permits on real network', async () => {
-      // Create multiple permits
-      await permits.createSelf({ name: 'Permit 1', issuer: bobAddress }, publicClient, bobWalletClient);
-      await permits.createSharing(
-        {
-          name: 'Permit 2',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Verify both permits exist
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBeGreaterThanOrEqual(2);
-
-      // Verify active permit is the last created one
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.name).toBe('Permit 2');
-    });
-  });
-
-  describe('getOrCreateSelfPermit', () => {
-    it('should create a new self permit when none exists', async () => {
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'New Self Permit',
-      });
-
-      expect(permit).toBeDefined();
-      expect(permit.name).toBe('New Self Permit');
-      expect(permit.type).toBe('self');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.issuerSignature).toBeDefined();
-
-      // Verify it was stored and set as active
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.name).toBe('New Self Permit');
-    });
-
-    it('should return existing self permit when one exists', async () => {
-      // Create an initial self permit
-      const firstPermit = await permits.createSelf(
-        { name: 'First Self Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Call getOrCreateSelfPermit - should return existing
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'Should Not Create This',
-      });
-
-      expect(permit.name).toBe('First Self Permit');
-      expect(permit.hash).toBe(firstPermit.hash);
-
-      // Verify no new permit was created
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(1);
-    });
-
-    it('should create new self permit when active permit is sharing type', async () => {
-      // Create a sharing permit first
-      await permits.createSharing(
-        {
-          name: 'Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Call getOrCreateSelfPermit - should create new since active is sharing type
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'New Self Permit',
-      });
-
-      expect(permit.name).toBe('New Self Permit');
-      expect(permit.type).toBe('self');
-
-      // Verify two permits exist now
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(2);
-    });
-
-    it('should create a new self permit when active permit is expired', async () => {
-      // Create an expired self permit (expiration in the past)
-      const expiredPermit = await permits.createSelf(
-        { name: 'Expired Self Permit', issuer: bobAddress, expiration: Math.floor(Date.now() / 1000) - 3600 },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Sanity check - it is the active permit and is expired
-      const activeBefore = await permits.getActivePermit(chainId, bobAddress);
-      expect(activeBefore?.hash).toBe(expiredPermit.hash);
-
-      // getOrCreateSelfPermit should treat the expired permit as missing and create a fresh one
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'Fresh Self Permit',
-      });
-
-      expect(permit.name).toBe('Fresh Self Permit');
-      expect(permit.type).toBe('self');
-      expect(permit.hash).not.toBe(expiredPermit.hash);
-
-      // The fresh permit should now be active
-      const activeAfter = await permits.getActivePermit(chainId, bobAddress);
-      expect(activeAfter?.hash).toBe(permit.hash);
-    });
-
-    it('should use default options when none provided', async () => {
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress);
-
-      expect(permit).toBeDefined();
-      expect(permit.type).toBe('self');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.name).toBe('Autogenerated Self Permit');
-    });
-
-    it('should use default chainId and account when not provided', async () => {
-      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, undefined, undefined, {
-        issuer: bobAddress,
-        name: 'Test Permit',
-      });
-
-      expect(permit).toBeDefined();
-      expect(permit.issuer).toBe(bobAddress);
-
-      // Verify it was stored with the chain's actual chainId
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.name).toBe('Test Permit');
-    });
-  });
-
-  describe('getOrCreateSharingPermit', () => {
-    it('should create a new sharing permit when none exists', async () => {
-      const permit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'New Sharing Permit',
-        },
-        chainId,
-        bobAddress
-      );
-
-      expect(permit).toBeDefined();
-      expect(permit.name).toBe('New Sharing Permit');
-      expect(permit.type).toBe('sharing');
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.recipient).toBe(aliceAddress);
-      expect(permit.issuerSignature).toBeDefined();
-
-      // Verify it was stored and set as active
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.name).toBe('New Sharing Permit');
-    });
-
-    it('should return existing sharing permit when one exists', async () => {
-      // Create an initial sharing permit
-      const firstPermit = await permits.createSharing(
-        {
-          name: 'First Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      // Call getOrCreateSharingPermit - should return existing
-      const permit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'Should Not Create This',
-        },
-        chainId,
-        bobAddress
-      );
-
-      expect(permit.name).toBe('First Sharing Permit');
-      expect(permit.hash).toBe(firstPermit.hash);
-
-      // Verify no new permit was created
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(1);
-    });
-
-    it('should create new sharing permit when active permit is self type', async () => {
-      // Create a self permit first
-      await permits.createSelf({ name: 'Self Permit', issuer: bobAddress }, publicClient, bobWalletClient);
-
-      // Call getOrCreateSharingPermit - should create new since active is self type
-      const permit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'New Sharing Permit',
-        },
-        chainId,
-        bobAddress
-      );
-
-      expect(permit.name).toBe('New Sharing Permit');
-      expect(permit.type).toBe('sharing');
-
-      // Verify two permits exist now
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(2);
-    });
-
-    it('should create a new sharing permit when active permit is expired', async () => {
-      // Create an expired sharing permit (expiration in the past)
-      const expiredPermit = await permits.createSharing(
-        {
-          name: 'Expired Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          expiration: Math.floor(Date.now() / 1000) - 3600,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      // getOrCreateSharingPermit should treat the expired permit as missing and create a fresh one
-      const permit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'Fresh Sharing Permit',
-        },
-        chainId,
-        bobAddress
-      );
-
-      expect(permit.name).toBe('Fresh Sharing Permit');
-      expect(permit.type).toBe('sharing');
-      expect(permit.hash).not.toBe(expiredPermit.hash);
-
-      // The fresh permit should now be active
-      const activeAfter = await permits.getActivePermit(chainId, bobAddress);
-      expect(activeAfter?.hash).toBe(permit.hash);
-    });
-
-    it('should use default chainId and account when not provided', async () => {
-      const permit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'Test Sharing Permit',
-        },
-        undefined,
-        undefined
-      );
-
-      expect(permit).toBeDefined();
-      expect(permit.issuer).toBe(bobAddress);
-      expect(permit.recipient).toBe(aliceAddress);
-
-      // Verify it was stored with the chain's actual chainId
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.name).toBe('Test Sharing Permit');
-    });
-  });
-
-  describe('Export', () => {
-    it('should export self permit data without sensitive fields', async () => {
-      const permit = await permits.createSelf(
-        { name: 'Test Self Permit', issuer: bobAddress },
-        publicClient,
-        bobWalletClient
-      );
-
-      const exported = permits.export(permit);
-      const parsed = JSON.parse(exported);
-
-      expect(parsed.name).toBe('Test Self Permit');
-      expect(parsed.issuer).toBe(bobAddress);
-      expect(parsed).not.toHaveProperty('sealingPair');
-      expect(parsed).not.toHaveProperty('issuerSignature');
-    });
-
-    it('should export sharing permit data with recipient and issuerSignature', async () => {
-      const permit = await permits.createSharing(
-        {
-          name: 'Test Sharing Permit',
-          issuer: bobAddress,
-          recipient: aliceAddress,
-        },
-        publicClient,
-        bobWalletClient
-      );
-
-      const exported = permits.export(permit);
-      const parsed = JSON.parse(exported);
-
-      expect(parsed.name).toBe('Test Sharing Permit');
-      expect(parsed.type).toBe('sharing');
-      expect(parsed.issuer).toBe(bobAddress);
-      expect(parsed.recipient).toBe(aliceAddress);
-      expect(parsed.issuerSignature).toBeDefined();
-      expect(parsed.issuerSignature).not.toBe('0x');
-      expect(parsed).not.toHaveProperty('sealingPair');
-    });
-  });
-
-  describe('getOrCreate - Multiple Types Scenarios', () => {
-    it('should handle switching between self and sharing permits', async () => {
-      // Create self permit
-      const selfPermit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'Self Permit',
-      });
-      expect(selfPermit.type).toBe('self');
-
-      // Create sharing permit (should create new one)
-      const sharingPermit = await permits.getOrCreateSharingPermit(
-        publicClient,
-        bobWalletClient,
-        {
-          issuer: bobAddress,
-          recipient: aliceAddress,
-          name: 'Sharing Permit',
-        },
-        chainId,
-        bobAddress
-      );
-      expect(sharingPermit.type).toBe('sharing');
-
-      // Both should exist
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(2);
-
-      // Active permit should be the sharing one
-      const activePermit = await permits.getActivePermit(chainId, bobAddress);
-      expect(activePermit?.type).toBe('sharing');
-      expect(activePermit?.name).toBe('Sharing Permit');
-    });
-
-    it('should correctly handle sequential getOrCreate calls', async () => {
-      // First call - creates new
-      const permit1 = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'Permit 1',
-      });
-
-      // Second call - returns existing
-      const permit2 = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
-        issuer: bobAddress,
-        name: 'Permit 2',
-      });
-
-      // Should be the same permit
-      expect(permit1.hash).toBe(permit2.hash);
-      expect(permit2.name).toBe('Permit 1'); // Original name
-
-      // Only one permit should exist
-      const allPermits = await permits.getPermits(chainId, bobAddress);
-      expect(Object.keys(allPermits).length).toBe(1);
-    });
-  });
-});