@cofhe/sdk 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @cofhe/sdk Changelog
 
+## 0.2.1
+
+### Patch Changes
+
+- 409bfdf: Add `hash` field to permits, calculated at permit creation time. Replaces `PermitUtils.getHash(permit)` with `permit.hash`.
+- ac47e2f: Add `PermitUtils.checkValidityOnChain` to validate permits against the on-chain deployed ACL (source of truth).
+- 8af1b70: Updated to Zod 4 for improved performance and type safety. Includes internal changes to validation schemas and error handling that should not affect external API usage.
+
 ## 0.2.0
 
 ### Minor Changes

package/chains/defineChain.ts

@@ -1,4 +1,5 @@
 import { CofheChainSchema, type CofheChain } from './types.js';
+import { z } from 'zod';
 
 /**
  * Defines and validates a CofheChain configuration
@@ -10,8 +11,7 @@ export function defineChain(chainConfig: CofheChain): CofheChain {
   const result = CofheChainSchema.safeParse(chainConfig);
 
   if (!result.success) {
-    const errorMessages = result.error.errors.map((err) => `${err.path.join('.')}: ${err.message}`);
-    throw new Error(`Invalid chain configuration: ${errorMessages.join(', ')}`);
+    throw new Error(`Invalid chain configuration: ${z.prettifyError(result.error)}`, { cause: result.error });
   }
 
   return result.data;

package/chains/types.ts

@@ -16,11 +16,11 @@ export const CofheChainSchema = z.object({
   /** Network identifier */
   network: z.string().min(1),
   /** coFhe service URL */
-  coFheUrl: z.string().url(),
+  coFheUrl: z.url(),
   /** Verifier service URL */
-  verifierUrl: z.string().url(),
+  verifierUrl: z.url(),
   /** Threshold network service URL */
-  thresholdNetworkUrl: z.string().url(),
+  thresholdNetworkUrl: z.url(),
   /** Environment type */
   environment: EnvironmentSchema,
 });

package/core/client.test.ts

@@ -176,6 +176,97 @@ describe('createCofhesdkClientBase', () => {
       await promise1;
     });
 
+    it('should ensure the latest connection attempt wins when connecting twice', async () => {
+      let resolveChainId1: (value: number) => void;
+      let resolveAddresses1: (value: string[]) => void;
+      let resolveChainId2: (value: number) => void;
+      let resolveAddresses2: (value: string[]) => void;
+
+      const chainIdPromise1 = new Promise<number>((resolve) => {
+        resolveChainId1 = resolve;
+      });
+      const addressesPromise1 = new Promise<string[]>((resolve) => {
+        resolveAddresses1 = resolve;
+      });
+
+      const chainIdPromise2 = new Promise<number>((resolve) => {
+        resolveChainId2 = resolve;
+      });
+      const addressesPromise2 = new Promise<string[]>((resolve) => {
+        resolveAddresses2 = resolve;
+      });
+
+      const publicClient1 = createMockPublicClient() as any;
+      publicClient1.getChainId = vi.fn().mockReturnValue(chainIdPromise1);
+      const walletClient1 = createMockWalletClient() as any;
+      walletClient1.getAddresses = vi.fn().mockReturnValue(addressesPromise1);
+
+      const publicClient2 = createMockPublicClient() as any;
+      publicClient2.getChainId = vi.fn().mockReturnValue(chainIdPromise2);
+      const walletClient2 = createMockWalletClient() as any;
+      walletClient2.getAddresses = vi.fn().mockReturnValue(addressesPromise2);
+
+      const promise1 = client.connect(publicClient1, walletClient1);
+      expect(client.connecting).toBe(true);
+
+      const promise2 = client.connect(publicClient2, walletClient2);
+
+      // Resolve the second connect first
+      resolveChainId2!(222);
+      resolveAddresses2!(['0x2222222222222222222222222222222222222222']);
+      await promise2;
+
+      expect(client.connected).toBe(true);
+      expect(client.connecting).toBe(false);
+      expect(client.getSnapshot().chainId).toBe(222);
+      expect(client.getSnapshot().account).toBe('0x2222222222222222222222222222222222222222');
+      expect(client.getSnapshot().publicClient).toBe(publicClient2);
+      expect(client.getSnapshot().walletClient).toBe(walletClient2);
+
+      // Now resolve the first connect; it must not overwrite the latest state.
+      resolveChainId1!(111);
+      resolveAddresses1!(['0x1111111111111111111111111111111111111111']);
+      await promise1;
+
+      expect(client.getSnapshot().chainId).toBe(222);
+      expect(client.getSnapshot().account).toBe('0x2222222222222222222222222222222222222222');
+      expect(client.getSnapshot().publicClient).toBe(publicClient2);
+      expect(client.getSnapshot().walletClient).toBe(walletClient2);
+    });
+
+    it('should allow disconnect while connecting and never end up connected afterwards', async () => {
+      let resolveChainId: (value: number) => void;
+      let resolveAddresses: (value: string[]) => void;
+
+      const chainIdPromise = new Promise<number>((resolve) => {
+        resolveChainId = resolve;
+      });
+      const addressesPromise = new Promise<string[]>((resolve) => {
+        resolveAddresses = resolve;
+      });
+
+      const publicClient = createMockPublicClient() as any;
+      publicClient.getChainId = vi.fn().mockReturnValue(chainIdPromise);
+
+      const walletClient = createMockWalletClient() as any;
+      walletClient.getAddresses = vi.fn().mockReturnValue(addressesPromise);
+
+      const connectPromise = client.connect(publicClient, walletClient);
+      expect(client.connecting).toBe(true);
+
+      client.disconnect();
+      expect(client.connected).toBe(false);
+      expect(client.connecting).toBe(false);
+
+      resolveChainId!(11155111);
+      resolveAddresses!(['0x1234567890123456789012345678901234567890']);
+
+      await connectPromise;
+
+      expect(client.connected).toBe(false);
+      expect(client.connecting).toBe(false);
+    });
+
     it('should handle publicClient.getChainId throwing an error', async () => {
       const publicClient = createMockPublicClient();
       const getChainIdError = new Error('Network error');
@@ -264,6 +355,26 @@ describe('createCofhesdkClientBase', () => {
         expect((error as CofhesdkError).cause).toBe(getChainIdError);
       }
     });
+
+    it('should disconnect and clear connection state', async () => {
+      const publicClient = createMockPublicClient(11155111);
+      const walletClient = createMockWalletClient(['0xabcd']);
+
+      await client.connect(publicClient, walletClient);
+      expect(client.connected).toBe(true);
+
+      client.disconnect();
+
+      expect(client.connected).toBe(false);
+      expect(client.connecting).toBe(false);
+
+      const snapshot = client.getSnapshot();
+      expect(snapshot.chainId).toBe(undefined);
+      expect(snapshot.account).toBe(undefined);
+      expect(snapshot.publicClient).toBe(undefined);
+      expect(snapshot.walletClient).toBe(undefined);
+      expect(snapshot.connectError).toBe(undefined);
+    });
   });
 
   describe('encryptInputs', () => {

package/core/client.ts

@@ -42,6 +42,10 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
 
   const connectStore = createStore<CofhesdkClientConnectionState>(() => InitialConnectStore);
 
+  // Minimal cancellation mechanism: incremented on each connect/disconnect.
+  // If a connect finishes after a disconnect, it must not overwrite the disconnected state.
+  let connectAttemptId = 0;
+
   // Helper to update state
   const updateConnectState = (partial: Partial<CofhesdkClientConnectionState>) => {
     connectStore.setState((state) => ({ ...state, ...partial }));
@@ -76,6 +80,9 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
     // Exit if already connected and clients are the same
     if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient) return;
 
+    connectAttemptId += 1;
+    const localAttemptId = connectAttemptId;
+
     // Set connecting state
     updateConnectState({
       ...InitialConnectStore,
@@ -86,6 +93,10 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
     try {
       const chainId = await getPublicClientChainID(publicClient);
       const account = await getWalletClientAccount(walletClient);
+
+      // If a disconnect (or a newer connect) happened while awaiting, ignore this completion.
+      if (localAttemptId !== connectAttemptId) return;
+
       updateConnectState({
         connected: true,
         connecting: false,
@@ -96,6 +107,9 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
         walletClient,
       });
     } catch (e) {
+      // Ignore stale errors too.
+      if (localAttemptId !== connectAttemptId) return;
+
       updateConnectState({
         ...InitialConnectStore,
         connectError: e,
@@ -104,6 +118,11 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
     }
   }
 
+  function disconnect() {
+    connectAttemptId += 1;
+    updateConnectState({ ...InitialConnectStore });
+  }
+
   // CLIENT OPERATIONS
 
   function encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilder<[...T]> {
@@ -245,9 +264,9 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
       return permits.selectActivePermit(_chainId, _account, hash);
     },
 
-    removePermit: async (hash: string, chainId?: number, account?: string, force?: boolean) => {
+    removePermit: async (hash: string, chainId?: number, account?: string) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
-      return permits.removePermit(_chainId, _account, hash, force);
+      return permits.removePermit(_chainId, _account, hash);
     },
 
     removeActivePermit: async (chainId?: number, account?: string) => {
@@ -278,6 +297,7 @@ export function createCofhesdkClientBase<TConfig extends CofhesdkConfig>(
     config: opts.config,
 
     connect,
+    disconnect,
     encryptInputs,
     decryptHandle,
     permits: clientPermits,

package/core/clientTypes.ts

@@ -33,6 +33,12 @@ export type CofhesdkClient<TConfig extends CofhesdkConfig = CofhesdkConfig> = {
   readonly config: TConfig;
 
   connect(publicClient: PublicClient, walletClient: WalletClient): Promise<void>;
+  /**
+   * Clears the current connection state (account/chainId/clients) and marks the client as disconnected.
+   *
+   * This does not delete persisted permits or stored FHE keys; it only resets the in-memory connection.
+   */
+  disconnect(): void;
   /**
    * Types docstring
    */
@@ -89,7 +95,7 @@ export type CofhesdkClientPermits = {
 
   // Mutation methods (chainId/account optional)
   selectActivePermit: (hash: string, chainId?: number, account?: string) => void;
-  removePermit: (hash: string, chainId?: number, account?: string, force?: boolean) => void;
+  removePermit: (hash: string, chainId?: number, account?: string) => void;
   removeActivePermit: (chainId?: number, account?: string) => void;
 
   // Utils

package/core/config.test.ts

@@ -126,6 +126,14 @@ describe('createCofhesdkConfigBase', () => {
     expect(getItemCalled).toBe(true);
     expect(setItemCalled).toBe(true);
     expect(removeItemCalled).toBe(true);
+
+    const invalidStorageNotAFunction = {
+      getItem: 'not-a-function',
+      setItem: 'not-a-function',
+      removeItem: 'not-a-function',
+    };
+
+    expectInvalidConfigItem('fheKeyStorage', invalidStorageNotAFunction);
   });
 
   it('mocks', () => {

package/core/config.ts

@@ -70,9 +70,15 @@ export const CofhesdkConfigSchema = z.object({
   /** Storage method for fhe keys (defaults to indexedDB on web, filesystem on node) */
   fheKeyStorage: z
     .object({
-      getItem: z.function().args(z.string()).returns(z.promise(z.any())),
-      setItem: z.function().args(z.string(), z.any()).returns(z.promise(z.void())),
-      removeItem: z.function().args(z.string()).returns(z.promise(z.void())),
+      getItem: z.custom<IStorage['getItem']>((val) => typeof val === 'function', {
+        message: 'getItem must be a function',
+      }),
+      setItem: z.custom<IStorage['setItem']>((val) => typeof val === 'function', {
+        message: 'setItem must be a function',
+      }),
+      removeItem: z.custom<IStorage['removeItem']>((val) => typeof val === 'function', {
+        message: 'removeItem must be a function',
+      }),
     })
     .or(z.null())
     .default(null),
@@ -108,7 +114,7 @@ export function createCofhesdkConfigBase(config: CofhesdkInputConfig): CofhesdkC
   const result = CofhesdkConfigSchema.safeParse(config);
 
   if (!result.success) {
-    throw new Error(`Invalid cofhesdk configuration: ${result.error.message}`);
+    throw new Error(`Invalid cofhesdk configuration: ${z.prettifyError(result.error)}`, { cause: result.error });
   }
 
   return result.data;

package/core/consts.ts

@@ -0,0 +1,18 @@
+/** Main Task Manager contract address */
+export const TASK_MANAGER_ADDRESS = '0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9' as const;
+
+/** Mock ZK Verifier contract address (used for testing) */
+export const MOCKS_ZK_VERIFIER_ADDRESS = '0x0000000000000000000000000000000000005001' as const;
+
+/** Mock Query Decrypter contract address (used for testing) */
+export const MOCKS_QUERY_DECRYPTER_ADDRESS = '0x0000000000000000000000000000000000005002' as const;
+
+/** Test Bed contract address (used for testing) */
+export const TEST_BED_ADDRESS = '0x0000000000000000000000000000000000005003' as const;
+
+/** Private key for the Mock ZK Verifier signer account */
+export const MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY =
+  '0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512' as const;
+
+/** Address for the Mock ZK Verifier signer account */
+export const MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = '0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2' as const;

package/core/decrypt/cofheMocksSealOutput.ts

@@ -5,9 +5,7 @@ import { sleep } from '../utils.js';
 import { MockQueryDecrypterAbi } from './MockQueryDecrypterAbi.js';
 import { FheTypes } from '../types.js';
 import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
-
-// Address the Mock Query Decrypter contract is deployed to on the Hardhat chain
-export const MockQueryDecrypterAddress = '0x0000000000000000000000000000000000000200';
+import { MOCKS_QUERY_DECRYPTER_ADDRESS } from '../consts.js';
 
 export async function cofheMocksSealOutput(
   ctHash: bigint,
@@ -29,7 +27,7 @@ export async function cofheMocksSealOutput(
   };
 
   const [allowed, error, result] = await publicClient.readContract({
-    address: MockQueryDecrypterAddress,
+    address: MOCKS_QUERY_DECRYPTER_ADDRESS,
     abi: MockQueryDecrypterAbi,
     functionName: 'querySealOutput',
     args: [ctHash, BigInt(utype), permissionWithBigInts],

package/core/encrypt/cofheMocksZkVerifySign.ts

@@ -14,14 +14,7 @@ import { MockZkVerifierAbi } from './MockZkVerifierAbi.js';
 import { hardhat } from 'viem/chains';
 import { CofhesdkError, CofhesdkErrorCode } from '../error.js';
 import { privateKeyToAccount } from 'viem/accounts';
-
-// Address the Mock ZkVerifier contract is deployed to on the Hardhat chain
-export const MocksZkVerifierAddress = '0x0000000000000000000000000000000000000100';
-
-// PK & address pair for zk verifier
-export const MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY =
-  '0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512';
-export const MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = '0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2';
+import { MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from '../consts.js';
 
 type EncryptableItemWithCtHash = EncryptableItem & {
   ctHash: bigint;
@@ -111,7 +104,7 @@ async function calcCtHashes(
 
   try {
     ctHashes = (await publicClient.readContract({
-      address: MocksZkVerifierAddress,
+      address: MOCKS_ZK_VERIFIER_ADDRESS,
       abi: MockZkVerifierAbi,
       functionName: 'zkVerifyCalcCtHashesPacked',
       args: calcCtHashesArgs,
@@ -122,7 +115,7 @@ async function calcCtHashes(
       message: `mockZkVerifySign calcCtHashes failed while calling zkVerifyCalcCtHashesPacked`,
       cause: err instanceof Error ? err : undefined,
       context: {
-        address: MocksZkVerifierAddress,
+        address: MOCKS_ZK_VERIFIER_ADDRESS,
         items,
         account,
         securityZone,
@@ -163,7 +156,7 @@ async function insertCtHashes(items: EncryptableItemWithCtHash[], walletClient:
     const account = walletClient.account!;
 
     await walletClient.writeContract({
-      address: MocksZkVerifierAddress,
+      address: MOCKS_ZK_VERIFIER_ADDRESS,
       abi: MockZkVerifierAbi,
       functionName: 'insertPackedCtHashes',
       args: insertPackedCtHashesArgs,

package/core/index.ts

@@ -83,7 +83,15 @@ export type {
 } from './encrypt/zkPackProveVerify.js';
 export { zkProveWithWorker } from './encrypt/zkPackProveVerify.js';
 
-export { MOCKS_ZK_VERIFIER_SIGNER_ADDRESS } from './encrypt/cofheMocksZkVerifySign.js';
+// Contract addresses
+export {
+  TASK_MANAGER_ADDRESS,
+  MOCKS_ZK_VERIFIER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
+  MOCKS_QUERY_DECRYPTER_ADDRESS,
+  TEST_BED_ADDRESS,
+} from './consts.js';
 
 // Utils
 export { fheTypeToString } from './utils.js';

package/core/permits.test.ts

@@ -151,7 +151,7 @@ describe('Core Permits Tests', () => {
         publicClient,
         bobWalletClient
       );
-      permitHash = permits.getHash(createdPermit);
+      permitHash = createdPermit.hash;
     });
 
     it('should get permit by hash', async () => {
@@ -195,9 +195,8 @@ describe('Core Permits Tests', () => {
       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);
+      expect(parsedData.state.permits[chainId][bobAddress][createdPermit.hash]).toEqual(serializedPermit);
     });
   });
 
@@ -272,7 +271,7 @@ describe('Core Permits Tests', () => {
       });
 
       expect(permit.name).toBe('First Self Permit');
-      expect(permits.getHash(permit)).toBe(permits.getHash(firstPermit));
+      expect(permit.hash).toBe(firstPermit.hash);
 
       // Verify no new permit was created
       const allPermits = await permits.getPermits(chainId, bobAddress);
@@ -381,7 +380,7 @@ describe('Core Permits Tests', () => {
       );
 
       expect(permit.name).toBe('First Sharing Permit');
-      expect(permits.getHash(permit)).toBe(permits.getHash(firstPermit));
+      expect(permit.hash).toBe(firstPermit.hash);
 
       // Verify no new permit was created
       const allPermits = await permits.getPermits(chainId, bobAddress);
@@ -483,7 +482,7 @@ describe('Core Permits Tests', () => {
       });
 
       // Should be the same permit
-      expect(permits.getHash(permit1)).toBe(permits.getHash(permit2));
+      expect(permit1.hash).toBe(permit2.hash);
       expect(permit2.name).toBe('Permit 1'); // Original name
 
       // Only one permit should exist

package/core/permits.ts

@@ -9,6 +9,7 @@ import {
   type SelfPermit,
   type RecipientPermit,
   type SharingPermit,
+  type PermitHashFields,
 } from '@/permits';
 
 import { type PublicClient, type WalletClient } from 'viem';
@@ -21,7 +22,7 @@ const storeActivePermit = async (permit: Permit, publicClient: any, walletClient
   const account = walletClient.account!.address;
 
   permitStore.setPermit(chainId, account, permit);
-  permitStore.setActivePermitHash(chainId, account, PermitUtils.getHash(permit));
+  permitStore.setActivePermitHash(chainId, account, permit.hash);
 };
 
 // Generic function to handle permit creation with error handling
@@ -70,7 +71,7 @@ const importShared = async (
 
 // PERMIT UTILS
 
-const getHash = (permit: Permit) => {
+const getHash = (permit: PermitHashFields) => {
   return PermitUtils.getHash(permit);
 };
 
@@ -167,8 +168,8 @@ const getOrCreateSharingPermit = async (
 
 // REMOVE
 
-const removePermit = async (chainId: number, account: string, hash: string, force?: boolean): Promise<void> =>
-  permitStore.removePermit(chainId, account, hash, force);
+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);

package/dist/chains.cjs

@@ -12,21 +12,18 @@ var CofheChainSchema = zod.z.object({
   /** Network identifier */
   network: zod.z.string().min(1),
   /** coFhe service URL */
-  coFheUrl: zod.z.string().url(),
+  coFheUrl: zod.z.url(),
   /** Verifier service URL */
-  verifierUrl: zod.z.string().url(),
+  verifierUrl: zod.z.url(),
   /** Threshold network service URL */
-  thresholdNetworkUrl: zod.z.string().url(),
+  thresholdNetworkUrl: zod.z.url(),
   /** Environment type */
   environment: EnvironmentSchema
 });
-
-// chains/defineChain.ts
 function defineChain(chainConfig) {
   const result = CofheChainSchema.safeParse(chainConfig);
   if (!result.success) {
-    const errorMessages = result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`);
-    throw new Error(`Invalid chain configuration: ${errorMessages.join(", ")}`);
+    throw new Error(`Invalid chain configuration: ${zod.z.prettifyError(result.error)}`, { cause: result.error });
   }
   return result.data;
 }

package/dist/chains.d.cts

@@ -1,13 +1,13 @@
-import { C as CofheChain } from './types-KImPrEIe.cjs';
-export { E as Environment } from './types-KImPrEIe.cjs';
+import { C as CofheChain } from './types-YiAC4gig.cjs';
+export { E as Environment } from './types-YiAC4gig.cjs';
 import 'zod';
 
 /**
  * Sepolia testnet chain configuration
  */
 declare const sepolia: {
-    name: string;
     id: number;
+    name: string;
     network: string;
     coFheUrl: string;
     verifierUrl: string;
@@ -19,8 +19,8 @@ declare const sepolia: {
  * Arbitrum Sepolia testnet chain configuration
  */
 declare const arbSepolia: {
-    name: string;
     id: number;
+    name: string;
     network: string;
     coFheUrl: string;
     verifierUrl: string;
@@ -32,8 +32,8 @@ declare const arbSepolia: {
  * Base Sepolia testnet chain configuration
  */
 declare const baseSepolia: {
-    name: string;
     id: number;
+    name: string;
     network: string;
     coFheUrl: string;
     verifierUrl: string;
@@ -45,8 +45,8 @@ declare const baseSepolia: {
  * Hardhat local development chain configuration
  */
 declare const hardhat: {
-    name: string;
     id: number;
+    name: string;
     network: string;
     coFheUrl: string;
     verifierUrl: string;
@@ -58,8 +58,8 @@ declare const hardhat: {
  * Localcofhe chain configuration
  */
 declare const localcofhe: {
-    name: string;
     id: number;
+    name: string;
     network: string;
     coFheUrl: string;
     verifierUrl: string;
@@ -69,8 +69,8 @@ declare const localcofhe: {
 
 declare const chains: {
     readonly sepolia: {
-        name: string;
         id: number;
+        name: string;
         network: string;
         coFheUrl: string;
         verifierUrl: string;
@@ -78,8 +78,8 @@ declare const chains: {
         environment: "MOCK" | "TESTNET" | "MAINNET";
     };
     readonly arbSepolia: {
-        name: string;
         id: number;
+        name: string;
         network: string;
         coFheUrl: string;
         verifierUrl: string;
@@ -87,8 +87,8 @@ declare const chains: {
         environment: "MOCK" | "TESTNET" | "MAINNET";
     };
     readonly baseSepolia: {
-        name: string;
         id: number;
+        name: string;
         network: string;
         coFheUrl: string;
         verifierUrl: string;
@@ -96,8 +96,8 @@ declare const chains: {
         environment: "MOCK" | "TESTNET" | "MAINNET";
     };
     readonly hardhat: {
-        name: string;
         id: number;
+        name: string;
         network: string;
         coFheUrl: string;
         verifierUrl: string;
@@ -105,8 +105,8 @@ declare const chains: {
         environment: "MOCK" | "TESTNET" | "MAINNET";
     };
     readonly localcofhe: {
-        name: string;
         id: number;
+        name: string;
         network: string;
         coFheUrl: string;
         verifierUrl: string;