@cofhe/sdk 0.6.1 → 0.7.0

package/web/test/worker.output.web.test.ts

@@ -1,4 +1,5 @@
-import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
+import { arbSepolia as cofheArbSepolia, stagingCofhe } from '@/chains';
 import { Encryptable } from '@/core';
 
 import { describe, it, expect, beforeAll } from 'vitest';
@@ -10,33 +11,38 @@ import { createCofheClient, createCofheConfig } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : viemArbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 describe('@cofhe/sdk/web - Worker vs Main Thread Output Validation', () => {
   let publicClient: PublicClient;
   let walletClient: WalletClient;
+  let consumingContract: `0x${string}`;
 
   beforeAll(() => {
     publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     const account = privateKeyToAccount(TEST_PRIVATE_KEY);
     walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account,
     });
+    consumingContract = account.address;
   });
 
   it('should produce consistent output format regardless of worker usage', async () => {
     // Create two clients - one with workers, one without
     const configWithWorker = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
       useWorkers: true,
     });
 
     const configWithoutWorker = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
       useWorkers: false,
     });
 
@@ -49,34 +55,29 @@ describe('@cofhe/sdk/web - Worker vs Main Thread Output Validation', () => {
     const value = Encryptable.uint128(12345n);
 
     const [resultWithWorker, resultWithoutWorker] = await Promise.all([
-      clientWithWorker.encryptInputs([value]).execute(),
-      clientWithoutWorker.encryptInputs([value]).execute(),
+      clientWithWorker.encryptInputs([value]).setConsumingContract(consumingContract).execute(),
+      clientWithoutWorker.encryptInputs([value]).setConsumingContract(consumingContract).execute(),
     ]);
 
     // Both should succeed
     expect(resultWithWorker).toBeDefined();
     expect(resultWithoutWorker).toBeDefined();
 
-    // Both should have same structure (but different encrypted values)
-    const withWorker = resultWithWorker[0];
-    const withoutWorker = resultWithoutWorker[0];
+    // Both should have same structure (but different encrypted values):
+    // [hash, signature] - one hash per input, followed by the shared batch signature.
+    expect(resultWithWorker.length).toBe(2);
+    expect(resultWithoutWorker.length).toBe(2);
 
-    expect(withWorker).toHaveProperty('ctHash');
-    expect(withWorker).toHaveProperty('signature');
-    expect(withWorker).toHaveProperty('utype');
-    expect(withWorker).toHaveProperty('securityZone');
-    expect(withoutWorker).toHaveProperty('ctHash');
-    expect(withoutWorker).toHaveProperty('signature');
-    expect(withoutWorker).toHaveProperty('utype');
-    expect(withoutWorker).toHaveProperty('securityZone');
+    const [hashWithWorker, signatureWithWorker] = resultWithWorker;
+    const [hashWithoutWorker, signatureWithoutWorker] = resultWithoutWorker;
 
     // Format should be identical
-    expect(typeof withWorker.ctHash).toBe('bigint');
-    expect(typeof withoutWorker.ctHash).toBe('bigint');
-    expect(withWorker.signature.startsWith('0x')).toBe(true);
-    expect(withoutWorker.signature.startsWith('0x')).toBe(true);
-    expect(typeof withWorker.utype).toBe('number');
-    expect(typeof withoutWorker.utype).toBe('number');
+    expect(typeof hashWithWorker).toBe('string');
+    expect(typeof hashWithoutWorker).toBe('string');
+    expect(hashWithWorker.startsWith('0x')).toBe(true);
+    expect(hashWithoutWorker.startsWith('0x')).toBe(true);
+    expect(signatureWithWorker.startsWith('0x')).toBe(true);
+    expect(signatureWithoutWorker.startsWith('0x')).toBe(true);
 
     // Note: The actual encrypted values will differ because of randomness
     // in the encryption process, so we don't check equality

package/core/encrypt/encryptUtils.ts

@@ -1,67 +0,0 @@
-/* eslint-disable no-redeclare */
-import {
-  type EncryptableItem,
-  isEncryptableItem,
-  type EncryptedItemInput,
-  type EncryptedItemInputs,
-} from '../types.js';
-
-export function encryptExtract<T>(item: T): EncryptableItem[];
-export function encryptExtract<T extends any[]>(item: [...T]): EncryptableItem[];
-export function encryptExtract<T>(item: T) {
-  if (isEncryptableItem(item)) {
-    return item;
-  }
-
-  // Object | Array
-  if (typeof item === 'object' && item !== null) {
-    if (Array.isArray(item)) {
-      // Array - recurse
-      return item.flatMap((nestedItem) => encryptExtract(nestedItem));
-    } else {
-      // Object - recurse
-      return Object.values(item).flatMap((value) => encryptExtract(value));
-    }
-  }
-
-  return [];
-}
-
-export function encryptReplace<T>(
-  item: T,
-  encryptedItems: EncryptedItemInput[]
-): [EncryptedItemInputs<T>, EncryptedItemInput[]];
-export function encryptReplace<T extends any[]>(
-  item: [...T],
-  encryptedItems: EncryptedItemInput[]
-): [...EncryptedItemInputs<T>, EncryptedItemInput[]];
-export function encryptReplace<T>(item: T, encryptedItems: EncryptedItemInput[]) {
-  if (isEncryptableItem(item)) {
-    return [encryptedItems[0], encryptedItems.slice(1)];
-  }
-
-  // Object | Array
-  if (typeof item === 'object' && item !== null) {
-    if (Array.isArray(item)) {
-      // Array - recurse
-      return item.reduce<[any[], EncryptedItemInput[]]>(
-        ([acc, remaining], item) => {
-          const [newItem, newRemaining] = encryptReplace(item, remaining);
-          return [[...acc, newItem], newRemaining];
-        },
-        [[], encryptedItems]
-      );
-    } else {
-      // Object - recurse
-      return Object.entries(item).reduce<[Record<string, any>, EncryptedItemInput[]]>(
-        ([acc, remaining], [key, value]) => {
-          const [newValue, newRemaining] = encryptReplace(value, remaining);
-          return [{ ...acc, [key]: newValue }, newRemaining];
-        },
-        [{}, encryptedItems]
-      );
-    }
-  }
-
-  return [item, encryptedItems];
-}

package/core/permits.ts

@@ -1,216 +0,0 @@
-import {
-  type ImportSharedPermitOptions,
-  PermitUtils,
-  type CreateSelfPermitOptions,
-  type CreateSharingPermitOptions,
-  type Permit,
-  permitStore,
-  type SerializedPermit,
-  type SelfPermit,
-  type RecipientPermit,
-  type SharingPermit,
-  type PermitHashFields,
-} 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, permit.hash);
-};
-
-// Generic function to handle permit creation with error handling
-const createPermitWithSign = async <T, TPermit extends Permit>(
-  options: T,
-  publicClient: PublicClient,
-  walletClient: WalletClient,
-  permitMethod: (options: T, publicClient: PublicClient, walletClient: WalletClient) => Promise<TPermit>
-): Promise<TPermit> => {
-  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<SelfPermit> => {
-  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSelfAndSign);
-};
-
-const createSharing = async (
-  options: CreateSharingPermitOptions,
-  publicClient: PublicClient,
-  walletClient: WalletClient
-): Promise<SharingPermit> => {
-  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSharingAndSign);
-};
-
-const importShared = async (
-  options: ImportSharedPermitOptions | string,
-  publicClient: PublicClient,
-  walletClient: WalletClient
-): Promise<RecipientPermit> => {
-  return createPermitWithSign(options, publicClient, walletClient, PermitUtils.importSharedAndSign);
-};
-
-// PERMIT UTILS
-
-const getHash = (permit: PermitHashFields) => {
-  return PermitUtils.getHash(permit);
-};
-
-const exportShared = (permit: Permit) => {
-  return PermitUtils.export(permit);
-};
-
-const serialize = (permit: Permit) => {
-  return PermitUtils.serialize(permit);
-};
-
-const deserialize = (serialized: SerializedPermit) => {
-  return PermitUtils.deserialize(serialized);
-};
-
-// GET
-
-const getPermit = (chainId: number, account: string, hash: string): Permit | undefined => {
-  return permitStore.getPermit(chainId, account, hash);
-};
-
-const getPermits = (chainId: number, account: string): Record<string, Permit> => {
-  return permitStore.getPermits(chainId, account);
-};
-
-const getActivePermit = (chainId: number, account: string): Permit | undefined => {
-  return permitStore.getActivePermit(chainId, account);
-};
-
-const getActivePermitHash = (chainId: number, account: string): string | undefined => {
-  return permitStore.getActivePermitHash(chainId, account);
-};
-
-const selectActivePermit = (chainId: number, account: string, hash: string): void => {
-  permitStore.setActivePermitHash(chainId, account, hash);
-};
-
-// GET OR CREATE
-
-/**
- * Get the active self permit if a valid one exists, otherwise create a new one.
- *
- * An active permit is reused only when it is a self permit and is still valid
- * (signed and not expired). An expired or otherwise invalid active permit is
- * treated as missing and a fresh permit is created.
- *
- * @param publicClient - The public client
- * @param walletClient - The wallet client
- * @param chainId - Optional chain ID (will use publicClient if not provided)
- * @param account - Optional account (will use walletClient if not provided)
- * @param options - The options for creating a self permit
- * @returns The existing valid permit or a newly created one
- */
-const getOrCreateSelfPermit = async (
-  publicClient: PublicClient,
-  walletClient: WalletClient,
-  chainId?: number,
-  account?: string,
-  options?: CreateSelfPermitOptions
-): Promise<Permit> => {
-  const _chainId = chainId ?? (await publicClient.getChainId());
-  const _account = account ?? walletClient.account!.address;
-
-  // Try to get active permit first
-  const activePermit = await getActivePermit(_chainId, _account);
-
-  if (activePermit && activePermit.type === 'self' && PermitUtils.isValid(activePermit).valid) {
-    return activePermit;
-  }
-
-  // No active permit, wrong type, or expired/invalid - create new one
-  return createSelf(options ?? { issuer: _account, name: 'Autogenerated Self Permit' }, publicClient, walletClient);
-};
-
-/**
- * Get the active sharing permit if a valid one exists, otherwise create a new one.
- *
- * An active permit is reused only when it is a sharing permit and is still valid
- * (signed and not expired). An expired or otherwise invalid active permit is
- * treated as missing and a fresh permit is created.
- *
- * @param publicClient - The public client
- * @param walletClient - The wallet client
- * @param options - The options for creating a sharing permit (required)
- * @param chainId - Optional chain ID (will use publicClient if not provided)
- * @param account - Optional account (will use walletClient if not provided)
- * @returns The existing valid permit or a newly created one
- */
-const getOrCreateSharingPermit = async (
-  publicClient: PublicClient,
-  walletClient: WalletClient,
-  options: CreateSharingPermitOptions,
-  chainId?: number,
-  account?: string
-): Promise<Permit> => {
-  const _chainId = chainId ?? (await publicClient.getChainId());
-  const _account = account ?? walletClient.account!.address;
-
-  // Try to get active permit first
-  const activePermit = await getActivePermit(_chainId, _account);
-
-  if (activePermit && activePermit.type === 'sharing' && PermitUtils.isValid(activePermit).valid) {
-    return activePermit;
-  }
-
-  return createSharing(options, publicClient, walletClient);
-};
-
-// REMOVE
-
-const removePermit = async (chainId: number, account: string, hash: string): Promise<void> =>
-  permitStore.removePermit(chainId, account, hash);
-
-const removeActivePermit = async (chainId: number, account: string): Promise<void> =>
-  permitStore.removeActivePermitHash(chainId, account);
-
-// EXPORT
-
-export const permits = {
-  getSnapshot: permitStore.store.getState,
-  subscribe: permitStore.store.subscribe,
-
-  createSelf,
-  createSharing,
-  importShared,
-
-  getOrCreateSelfPermit,
-  getOrCreateSharingPermit,
-
-  getHash,
-  export: exportShared,
-  serialize,
-  deserialize,
-
-  getPermit,
-  getPermits,
-  getActivePermit,
-  getActivePermitHash,
-  removePermit,
-  selectActivePermit,
-  removeActivePermit,
-};