@cofhe/sdk 0.0.0-beta-20251027110729

package/core/permits.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @vitest-environment happy-dom
+ */
+/* eslint-disable no-unused-vars */
+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 = permits.getHash(createdPermit);
+    });
+
+    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 permitHash = permits.getHash(createdPermit);
+      const serializedPermit = permits.serialize(createdPermit);
+      expect(parsedData.state.permits[chainId][bobAddress][permitHash]).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');
+    });
+  });
+});

package/core/permits.ts

@@ -0,0 +1,136 @@
+/* eslint-disable no-unused-vars */
+import {
+  type ImportSharedPermitOptions,
+  PermitUtils,
+  type CreateSelfPermitOptions,
+  type CreateSharingPermitOptions,
+  type Permit,
+  permitStore,
+  type SerializedPermit,
+} from '@/permits';
+
+import { type PublicClient, type WalletClient } from 'viem';
+
+// HELPERS
+
+// Helper function to store permit as active permit
+const storeActivePermit = async (permit: Permit, publicClient: any, walletClient: any) => {
+  const chainId = await publicClient.getChainId();
+  const account = walletClient.account!.address;
+
+  permitStore.setPermit(chainId, account, permit);
+  permitStore.setActivePermitHash(chainId, account, PermitUtils.getHash(permit));
+};
+
+// Generic function to handle permit creation with error handling
+const createPermitWithSign = async <T>(
+  options: T,
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  permitMethod: (options: T, publicClient: PublicClient, walletClient: WalletClient) => Promise<Permit>
+): Promise<Permit> => {
+  const permit = await permitMethod(options, publicClient, walletClient);
+  await storeActivePermit(permit, publicClient, walletClient);
+  return permit;
+};
+
+// CREATE
+
+/**
+ * Create a permit usable by the connected user
+ * Stores the permit and selects it as the active permit
+ * @param options - The options for creating a self permit
+ * @returns The created permit or error
+ */
+const createSelf = async (
+  options: CreateSelfPermitOptions,
+  publicClient: PublicClient,
+  walletClient: WalletClient
+): Promise<Permit> => {
+  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSelfAndSign);
+};
+
+const createSharing = async (
+  options: CreateSharingPermitOptions,
+  publicClient: PublicClient,
+  walletClient: WalletClient
+): Promise<Permit> => {
+  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSharingAndSign);
+};
+
+const importShared = async (
+  options: ImportSharedPermitOptions | any | string,
+  publicClient: PublicClient,
+  walletClient: WalletClient
+): Promise<Permit> => {
+  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.importSharedAndSign);
+};
+
+// PERMIT UTILS
+
+const getHash = (permit: Permit) => {
+  return PermitUtils.getHash(permit);
+};
+
+const serialize = (permit: Permit) => {
+  return PermitUtils.serialize(permit);
+};
+
+const deserialize = (serialized: SerializedPermit) => {
+  return PermitUtils.deserialize(serialized);
+};
+
+// GET
+
+const getPermit = async (chainId: number, account: string, hash: string): Promise<Permit | undefined> => {
+  return permitStore.getPermit(chainId, account, hash);
+};
+
+const getPermits = async (chainId: number, account: string): Promise<Record<string, Permit>> => {
+  return permitStore.getPermits(chainId, account);
+};
+
+const getActivePermit = async (chainId: number, account: string): Promise<Permit | undefined> => {
+  return permitStore.getActivePermit(chainId, account);
+};
+
+const getActivePermitHash = async (chainId: number, account: string): Promise<string | undefined> => {
+  return permitStore.getActivePermitHash(chainId, account);
+};
+
+const selectActivePermit = async (chainId: number, account: string, hash: string): Promise<void> => {
+  await permitStore.setActivePermitHash(chainId, account, hash);
+};
+
+// REMOVE
+
+const removePermit = async (chainId: number, account: string, hash: string): Promise<void> => {
+  await permitStore.removePermit(chainId, account, hash);
+};
+
+const removeActivePermit = async (chainId: number, account: string): Promise<void> => {
+  await permitStore.removeActivePermitHash(chainId, account);
+};
+
+// EXPORT
+
+export const permits = {
+  getSnapshot: permitStore.store.getState,
+  subscribe: permitStore.store.subscribe,
+
+  createSelf,
+  createSharing,
+  importShared,
+
+  getHash,
+  serialize,
+  deserialize,
+
+  getPermit,
+  getPermits,
+  getActivePermit,
+  getActivePermitHash,
+  removePermit,
+  selectActivePermit,
+  removeActivePermit,
+};

package/core/result.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest';
+import { ResultOk, ResultErr, ResultErrOrInternal, resultWrapper, resultWrapperSync, type Result } from './result.js';
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
+
+export const expectResultError = <T>(result: Result<T>, errorPartial: string) => {
+  expect(result.success).to.eq(false, 'Result should be an error');
+  expect(result.error!.message).to.include(errorPartial, `Error should contain error partial: ${errorPartial}`);
+};
+
+export const expectResultSuccess = <T>(result: Result<T>): T => {
+  expect(result.success).to.eq(true, 'Result should be a success');
+  return result.data!;
+};
+
+export const expectResultValue = <T>(result: Result<T>, value: T): T => {
+  expect(result.success).to.eq(true, 'Result should be a success');
+  expect(result.data).to.eq(value, `Result should have the expected value ${value}`);
+  return result.data!;
+};
+
+describe('Result Type', () => {
+  describe('ResultOk', () => {
+    it('should create a successful result', () => {
+      const result = ResultOk('test data');
+      expect(result.success).toBe(true);
+      expect(result.data).toBe('test data');
+      expect(result.error).toBe(null);
+    });
+
+    it('should handle different data types', () => {
+      const stringResult = ResultOk('string');
+      const numberResult = ResultOk(42);
+      const objectResult = ResultOk({ key: 'value' });
+      const nullResult = ResultOk(null);
+
+      expect(stringResult.data).toBe('string');
+      expect(numberResult.data).toBe(42);
+      expect(objectResult.data).toEqual({ key: 'value' });
+      expect(nullResult.data).toBe(null);
+    });
+  });
+
+  describe('ResultErr', () => {
+    it('should create an error result', () => {
+      const error = new CofhesdkError({
+        code: CofhesdkErrorCode.InternalError,
+        message: 'Test error',
+      });
+      const result = ResultErr(error);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(null);
+      expect(result.error).toBe(error);
+    });
+  });
+});
+
+describe('Error Utilities', () => {
+  describe('ResultErrOrInternal', () => {
+    it('should wrap unknown errors as internal errors', () => {
+      const result = ResultErrOrInternal(new Error('string error'));
+      expect(result.success).toBe(false);
+      expect(result.error!).toBeInstanceOf(CofhesdkError);
+      expect(result.error!.code).toBe(CofhesdkErrorCode.InternalError);
+      expect(result.error!.message).toBe('An internal error occurred | Caused by: string error');
+    });
+
+    it('should preserve CofhesdkError instances', () => {
+      const originalError = new CofhesdkError({
+        code: CofhesdkErrorCode.MissingPublicClient,
+        message: 'Public client missing',
+      });
+      const result = ResultErrOrInternal(originalError);
+      expect(result.success).toBe(false);
+      expect(result.error!).toBe(originalError);
+    });
+
+    it('should handle Error instances', () => {
+      const error = new Error('Standard error');
+      const result = ResultErrOrInternal(error);
+      expect(result.success).toBe(false);
+      expect(result.error!).toBeInstanceOf(CofhesdkError);
+      expect(result.error!.cause).toBe(error);
+    });
+  });
+});
+
+describe('Result Wrappers', () => {
+  describe('resultWrapperSync', () => {
+    it('should wrap successful sync function', () => {
+      const result = resultWrapperSync(() => 'success');
+      expect(result.success).toBe(true);
+      expect(result.data).toBe('success');
+    });
+
+    it('should wrap failing sync function', () => {
+      const result = resultWrapperSync(() => {
+        throw new Error('Sync error');
+      });
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(CofhesdkError);
+    });
+  });
+
+  describe('resultWrapper', () => {
+    it('should wrap successful async function', async () => {
+      const result = await resultWrapper(async () => 'async success');
+      expect(result.success).toBe(true);
+      expect(result.data).toBe('async success');
+    });
+
+    it('should wrap failing async function', async () => {
+      const result = await resultWrapper(async () => {
+        throw new Error('Async error');
+      });
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(CofhesdkError);
+    });
+
+    it('should handle async operations', async () => {
+      const result = await resultWrapper(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return 'delayed result';
+      });
+      expect(result.success).toBe(true);
+      expect(result.data).toBe('delayed result');
+    });
+
+    it('should handle Promise rejections', async () => {
+      const result = await resultWrapper(async () => {
+        return Promise.reject(new Error('Promise rejection'));
+      });
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(CofhesdkError);
+    });
+  });
+});
+
+describe('Result Type Guards', () => {
+  it('should correctly identify success results', () => {
+    const successResult = ResultOk('data');
+    expect(successResult.success).toBe(true);
+    expect(successResult.data).toBe('data');
+    expect(successResult.error).toBe(null);
+  });
+
+  it('should correctly identify error results', () => {
+    const errorResult = ResultErr(
+      new CofhesdkError({
+        code: CofhesdkErrorCode.InternalError,
+        message: 'Test error',
+      })
+    );
+    expect(errorResult.success).toBe(false);
+    expect(errorResult.data).toBe(null);
+    expect(errorResult.error).toBeInstanceOf(CofhesdkError);
+  });
+});
+
+describe('Result Test Utilities', () => {
+  it('expectResultSuccess should return data for success', () => {
+    const result = ResultOk('data');
+    expect(expectResultSuccess(result)).toBe('data');
+  });
+
+  it('expectResultValue should validate and return matching data', () => {
+    const result = ResultOk('expected');
+    expect(expectResultValue(result, 'expected')).toBe('expected');
+  });
+
+  it('expectResultError should validate error messages', () => {
+    const result = ResultErr(
+      new CofhesdkError({
+        code: CofhesdkErrorCode.InternalError,
+        message: 'Test error message',
+      })
+    );
+    expectResultError(result, 'Test error');
+  });
+});

package/core/result.ts

@@ -0,0 +1,67 @@
+/* eslint-disable no-unused-vars */
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
+
+export type Result<T> = { success: true; data: T; error: null } | { success: false; data: null; error: CofhesdkError };
+
+export const ResultErr = <T>(error: CofhesdkError): Result<T> => ({
+  success: false,
+  data: null,
+  error,
+});
+
+export const ResultOk = <T>(data: T): Result<T> => ({
+  success: true,
+  data,
+  error: null,
+});
+
+export const ResultErrOrInternal = <T>(error: unknown): Result<T> => {
+  return ResultErr(CofhesdkError.fromError(error));
+};
+
+export const ResultHttpError = (error: unknown, url: string, status?: number): CofhesdkError => {
+  if (error instanceof CofhesdkError) return error;
+
+  const message = status ? `HTTP error ${status} from ${url}` : `HTTP request failed for ${url}`;
+
+  return new CofhesdkError({
+    code: CofhesdkErrorCode.InternalError,
+    message,
+    cause: error instanceof Error ? error : undefined,
+  });
+};
+
+export const ResultValidationError = (message: string): CofhesdkError => {
+  return new CofhesdkError({
+    code: CofhesdkErrorCode.InvalidPermitData,
+    message,
+  });
+};
+
+// Async resultWrapper
+export const resultWrapper = async <T>(
+  tryFn: () => Promise<T>,
+  catchFn?: (error: CofhesdkError) => void,
+  finallyFn?: () => void
+): Promise<Result<T>> => {
+  try {
+    const result = await tryFn();
+    return ResultOk(result);
+  } catch (error) {
+    const result = ResultErrOrInternal(error);
+    catchFn?.(result.error!);
+    return result as Result<T>;
+  } finally {
+    finallyFn?.();
+  }
+};
+
+// Sync resultWrapper
+export const resultWrapperSync = <T>(fn: () => T): Result<T> => {
+  try {
+    const result = fn();
+    return ResultOk(result);
+  } catch (error) {
+    return ResultErrOrInternal(error);
+  }
+};

package/core/test-utils.ts

@@ -0,0 +1,45 @@
+import { expect } from 'vitest';
+import { type Result } from './result.js';
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
+
+/**
+ * Assert that a Result is successful and return its data
+ * Useful for type narrowing in tests
+ */
+export const expectResultSuccess = <T>(result: Result<T>): NonNullable<T> => {
+  expect(result.error, `Result error: ${result.error?.toString()}`).toBe(null);
+  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(true);
+  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
+  return result.data!;
+};
+
+/**
+ * Assert that a Result is an error and optionally verify the error details
+ */
+export const expectResultError = <T>(
+  result: Result<T>,
+  errorCode?: CofhesdkErrorCode,
+  errorMessage?: string
+): CofhesdkError => {
+  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(false);
+  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).toBe(null);
+  expect(result.error, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
+  const error = result.error as CofhesdkError;
+  expect(error, `Result error: ${result.error?.toString()}`).toBeInstanceOf(CofhesdkError);
+  if (errorCode) {
+    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
+  }
+  if (errorMessage) {
+    expect(error.message, `Result error: ${result.error?.toString()}`).toBe(errorMessage);
+  }
+  return error;
+};
+
+const bigintSafeJsonStringify = (value: unknown): string => {
+  return JSON.stringify(value, (key, value) => {
+    if (typeof value === 'bigint') {
+      return `${value}n`;
+    }
+    return value;
+  });
+};