@cofhe/sdk 0.1.1 → 0.2.1

package/permits/validation.ts

@@ -1,42 +1,48 @@
 import { z } from 'zod';
-import { isAddress, zeroAddress } from 'viem';
-import { type Permit, type ValidationResult } from './types.js';
-import { is0xPrefixed } from './utils.js';
+import { getAddress, isAddress, isHex, zeroAddress, type Hex } from 'viem';
+import type { Permit, ValidationResult } from './types.js';
 
 const SerializedSealingPair = z.object({
   privateKey: z.string(),
   publicKey: z.string(),
 });
 
+export const addressSchema = z
+  .string()
+  .refine((val) => isAddress(val), {
+    error: 'Invalid address',
+  })
+  .transform((val): Hex => getAddress(val));
+
+export const addressNotZeroSchema = addressSchema.refine((val) => val !== zeroAddress, {
+  error: 'Must not be zeroAddress',
+});
+
+export const bytesSchema = z.custom<Hex>(
+  (val) => {
+    return typeof val === 'string' && isHex(val);
+  },
+  {
+    message: 'Invalid hex value',
+  }
+);
+
+export const bytesNotEmptySchema = bytesSchema.refine((val) => val !== '0x', {
+  error: 'Must not be empty',
+});
+
+const DEFAULT_EXPIRATION_FN = () => Math.round(Date.now() / 1000) + 7 * 24 * 60 * 60; // 7 days from now
+
 const zPermitWithDefaults = z.object({
   name: z.string().optional().default('Unnamed Permit'),
   type: z.enum(['self', 'sharing', 'recipient']),
-  issuer: z
-    .string()
-    .refine((val) => isAddress(val), {
-      message: 'Permit issuer :: invalid address',
-    })
-    .refine((val) => val !== zeroAddress, {
-      message: 'Permit issuer :: must not be zeroAddress',
-    }),
-  expiration: z.number().optional().default(1000000000000),
-  recipient: z
-    .string()
-    .optional()
-    .default(zeroAddress)
-    .refine((val) => isAddress(val), {
-      message: 'Permit recipient :: invalid address',
-    }),
-  validatorId: z.number().optional().default(0),
-  validatorContract: z
-    .string()
-    .optional()
-    .default(zeroAddress)
-    .refine((val) => isAddress(val), {
-      message: 'Permit validatorContract :: invalid address',
-    }),
-  issuerSignature: z.string().optional().default('0x'),
-  recipientSignature: z.string().optional().default('0x'),
+  issuer: addressNotZeroSchema,
+  expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
+  recipient: addressSchema.optional().default(zeroAddress),
+  validatorId: z.int().optional().default(0),
+  validatorContract: addressSchema.optional().default(zeroAddress),
+  issuerSignature: bytesSchema.optional().default('0x'),
+  recipientSignature: bytesSchema.optional().default('0x'),
 });
 
 const zPermitWithSealingPair = zPermitWithDefaults.extend({
@@ -50,16 +56,27 @@ type zPermitType = z.infer<typeof zPermitWithDefaults>;
  * this check ensures that IF an external validator is applied, that both `validatorId` and `validatorContract` are populated,
  * ELSE ensures that both `validatorId` and `validatorContract` are empty
  */
-const ValidatorContractRefinement = [
+const ExternalValidatorRefinement = [
   (data: zPermitType) =>
     (data.validatorId !== 0 && data.validatorContract !== zeroAddress) ||
     (data.validatorId === 0 && data.validatorContract === zeroAddress),
   {
-    message: 'Permit external validator :: validatorId and validatorContract must either both be set or both be unset.',
+    error: 'Permit external validator :: validatorId and validatorContract must either both be set or both be unset.',
     path: ['validatorId', 'validatorContract'] as string[],
   },
 ] as const;
 
+/**
+ * Prevents sharable permit from having the same issuer and recipient
+ */
+const RecipientRefinement = [
+  (data: zPermitType) => data.issuer !== data.recipient,
+  {
+    error: 'Sharing permit :: issuer and recipient must not be the same',
+    path: ['issuer', 'recipient'] as string[],
+  },
+] as const;
+
 // ============================================================================
 // SELF PERMIT VALIDATORS
 // ============================================================================
@@ -70,68 +87,34 @@ const ValidatorContractRefinement = [
 export const SelfPermitOptionsValidator = z
   .object({
     type: z.literal('self').optional().default('self'),
-    issuer: z
-      .string()
-      .refine((val) => isAddress(val), {
-        message: 'Self permit issuer :: invalid address',
-      })
-      .refine((val) => val !== zeroAddress, {
-        message: 'Self permit issuer :: must not be zeroAddress',
-      }),
+    issuer: addressNotZeroSchema,
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
-    recipient: z
-      .string()
-      .optional()
-      .default(zeroAddress)
-      .refine((val) => isAddress(val), {
-        message: 'Self permit recipient :: invalid address',
-      })
-      .refine((val) => val === zeroAddress, {
-        message: 'Self permit recipient :: must be zeroAddress',
-      }),
-    validatorId: z.number().optional().default(0),
-    validatorContract: z
-      .string()
-      .optional()
-      .default(zeroAddress)
-      .refine((val) => isAddress(val), {
-        message: 'Self permit validatorContract :: invalid address',
-      }),
-    issuerSignature: z
-      .string()
-      .optional()
-      .default('0x')
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Self permit issuerSignature :: must be 0x prefixed',
-      }),
-    recipientSignature: z
-      .string()
-      .optional()
-      .default('0x')
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Self permit recipientSignature :: must be 0x prefixed',
-      }),
+    expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
+    recipient: addressSchema.optional().default(zeroAddress),
+    validatorId: z.int().optional().default(0),
+    validatorContract: addressSchema.optional().default(zeroAddress),
+    issuerSignature: bytesSchema.optional().default('0x'),
+    recipientSignature: bytesSchema.optional().default('0x'),
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...ExternalValidatorRefinement);
 
 /**
  * Validator for fully formed self permits
  */
 export const SelfPermitValidator = zPermitWithSealingPair
   .refine((data) => data.type === 'self', {
-    message: "Self permit :: type must be 'self'",
+    error: "Type must be 'self'",
   })
   .refine((data) => data.recipient === zeroAddress, {
-    message: 'Self permit :: recipient must be zeroAddress',
+    error: 'Recipient must be zeroAddress',
   })
   .refine((data) => data.issuerSignature !== '0x', {
-    message: 'Self permit :: issuerSignature must be populated',
+    error: 'IssuerSignature must be populated',
   })
   .refine((data) => data.recipientSignature === '0x', {
-    message: 'Self permit :: recipientSignature must be empty',
+    error: 'RecipientSignature must be empty',
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...ExternalValidatorRefinement);
 
 // ============================================================================
 // SHARING PERMIT VALIDATORS
@@ -143,66 +126,35 @@ export const SelfPermitValidator = zPermitWithSealingPair
 export const SharingPermitOptionsValidator = z
   .object({
     type: z.literal('sharing').optional().default('sharing'),
-    issuer: z
-      .string()
-      .refine((val) => isAddress(val), {
-        message: 'Sharing permit issuer :: invalid address',
-      })
-      .refine((val) => val !== zeroAddress, {
-        message: 'Sharing permit issuer :: must not be zeroAddress',
-      }),
-    recipient: z
-      .string()
-      .refine((val) => isAddress(val), {
-        message: 'Sharing permit recipient :: invalid address',
-      })
-      .refine((val) => val !== zeroAddress, {
-        message: 'Sharing permit recipient :: must not be zeroAddress',
-      }),
+    issuer: addressNotZeroSchema,
+    recipient: addressNotZeroSchema,
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
-    validatorId: z.number().optional().default(0),
-    validatorContract: z
-      .string()
-      .optional()
-      .default(zeroAddress)
-      .refine((val) => isAddress(val), {
-        message: 'Sharing permit validatorContract :: invalid address',
-      }),
-    issuerSignature: z
-      .string()
-      .optional()
-      .default('0x')
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Sharing permit issuerSignature :: must be 0x prefixed',
-      }),
-    recipientSignature: z
-      .string()
-      .optional()
-      .default('0x')
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Sharing permit recipientSignature :: must be 0x prefixed',
-      }),
+    expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
+    validatorId: z.int().optional().default(0),
+    validatorContract: addressSchema.optional().default(zeroAddress),
+    issuerSignature: bytesSchema.optional().default('0x'),
+    recipientSignature: bytesSchema.optional().default('0x'),
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...RecipientRefinement)
+  .refine(...ExternalValidatorRefinement);
 
 /**
  * Validator for fully formed sharing permits
  */
 export const SharingPermitValidator = zPermitWithSealingPair
   .refine((data) => data.type === 'sharing', {
-    message: "Sharing permit :: type must be 'sharing'",
+    error: "Type must be 'sharing'",
   })
   .refine((data) => data.recipient !== zeroAddress, {
-    message: 'Sharing permit :: recipient must not be zeroAddress',
+    error: 'Recipient must not be zeroAddress',
   })
   .refine((data) => data.issuerSignature !== '0x', {
-    message: 'Sharing permit :: issuerSignature must be populated',
+    error: 'IssuerSignature must be populated',
   })
   .refine((data) => data.recipientSignature === '0x', {
-    message: 'Sharing permit :: recipientSignature must be empty',
+    error: 'RecipientSignature must be empty',
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...ExternalValidatorRefinement);
 
 // ============================================================================
 // IMPORT/RECIPIENT PERMIT VALIDATORS
@@ -214,101 +166,87 @@ export const SharingPermitValidator = zPermitWithSealingPair
 export const ImportPermitOptionsValidator = z
   .object({
     type: z.literal('recipient').optional().default('recipient'),
-    issuer: z
-      .string()
-      .refine((val) => isAddress(val), {
-        message: 'Import permit issuer :: invalid address',
-      })
-      .refine((val) => val !== zeroAddress, {
-        message: 'Import permit issuer :: must not be zeroAddress',
-      }),
-    recipient: z
-      .string()
-      .refine((val) => isAddress(val), {
-        message: 'Import permit recipient :: invalid address',
-      })
-      .refine((val) => val !== zeroAddress, {
-        message: 'Import permit recipient :: must not be zeroAddress',
-      }),
-    issuerSignature: z
-      .string()
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Import permit issuerSignature :: must be 0x prefixed',
-      })
-      .refine((val) => val !== '0x', {
-        message: 'Import permit :: issuerSignature must be provided',
-      }),
+    issuer: addressNotZeroSchema,
+    recipient: addressNotZeroSchema,
     name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.number().optional().default(1000000000000),
-    validatorId: z.number().optional().default(0),
-    validatorContract: z
-      .string()
-      .optional()
-      .default(zeroAddress)
-      .refine((val) => isAddress(val), {
-        message: 'Import permit validatorContract :: invalid address',
-      }),
-    recipientSignature: z
-      .string()
-      .optional()
-      .default('0x')
-      .refine((val) => is0xPrefixed(val), {
-        message: 'Import permit recipientSignature :: must be 0x prefixed',
-      }),
+    expiration: z.int(),
+    validatorId: z.int().optional().default(0),
+    validatorContract: addressSchema.optional().default(zeroAddress),
+    issuerSignature: bytesNotEmptySchema,
+    recipientSignature: bytesSchema.optional().default('0x'),
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...ExternalValidatorRefinement);
 
 /**
  * Validator for fully formed import/recipient permits
  */
 export const ImportPermitValidator = zPermitWithSealingPair
   .refine((data) => data.type === 'recipient', {
-    message: "Import permit :: type must be 'recipient'",
+    error: "Type must be 'recipient'",
   })
   .refine((data) => data.recipient !== zeroAddress, {
-    message: 'Import permit :: recipient must not be zeroAddress',
+    error: 'Recipient must not be zeroAddress',
   })
   .refine((data) => data.issuerSignature !== '0x', {
-    message: 'Import permit :: issuerSignature must be populated',
+    error: 'IssuerSignature must be populated',
   })
   .refine((data) => data.recipientSignature !== '0x', {
-    message: 'Import permit :: recipientSignature must be populated',
+    error: 'RecipientSignature must be populated',
   })
-  .refine(...ValidatorContractRefinement);
+  .refine(...ExternalValidatorRefinement);
 
 // ============================================================================
 // VALIDATION FUNCTIONS
 // ============================================================================
 
+const safeParseAndThrowFormatted = <T extends z.ZodTypeAny>(schema: T, data: unknown, message: string): z.output<T> => {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`${message}: ${z.prettifyError(result.error)}`, { cause: result.error });
+  }
+  return result.data;
+};
+
 /**
  * Validates self permit creation options
  */
-export const validateSelfPermitOptions = (options: any) => SelfPermitOptionsValidator.safeParse(options);
-
+export const validateSelfPermitOptions = (options: any) => {
+  return safeParseAndThrowFormatted(SelfPermitOptionsValidator, options, 'Invalid self permit options');
+};
 /**
  * Validates sharing permit creation options
  */
-export const validateSharingPermitOptions = (options: any) => SharingPermitOptionsValidator.safeParse(options);
+export const validateSharingPermitOptions = (options: any) => {
+  return safeParseAndThrowFormatted(SharingPermitOptionsValidator, options, 'Invalid sharing permit options');
+};
 
 /**
  * Validates import permit creation options
  */
-export const validateImportPermitOptions = (options: any) => ImportPermitOptionsValidator.safeParse(options);
+export const validateImportPermitOptions = (options: any) => {
+  return safeParseAndThrowFormatted(ImportPermitOptionsValidator, options, 'Invalid import permit options');
+};
 
 /**
  * Validates a fully formed self permit
  */
-export const validateSelfPermit = (permit: any) => SelfPermitValidator.safeParse(permit);
+export const validateSelfPermit = (permit: any) => {
+  return safeParseAndThrowFormatted(SelfPermitValidator, permit, 'Invalid self permit');
+};
 
 /**
  * Validates a fully formed sharing permit
  */
-export const validateSharingPermit = (permit: any) => SharingPermitValidator.safeParse(permit);
+export const validateSharingPermit = (permit: any) => {
+  return safeParseAndThrowFormatted(SharingPermitValidator, permit, 'Invalid sharing permit');
+};
 
 /**
  * Validates a fully formed import/recipient permit
  */
-export const validateImportPermit = (permit: any) => ImportPermitValidator.safeParse(permit);
+export const validateImportPermit = (permit: any) => {
+  return safeParseAndThrowFormatted(ImportPermitValidator, permit, 'Invalid import permit');
+};
 
 /**
  * Simple validation functions for common checks

package/web/client.web.test.ts

@@ -1,4 +1,4 @@
-import { type CofhesdkClient } from '@/core';
+import { CofhesdkErrorCode, CofhesdkError, type CofhesdkClient } from '@/core';
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach, vi } from 'vitest';
@@ -60,11 +60,16 @@ describe('@cofhe/web - Client', () => {
     });
   });
 
+  describe('Environment', () => {
+    it('should have the correct environment', () => {
+      expect(cofhesdkClient.config.environment).toBe('web');
+    });
+  });
+
   describe('Connection', () => {
     it('should connect to real chain', async () => {
-      const result = await cofhesdkClient.connect(publicClient, walletClient);
+      await cofhesdkClient.connect(publicClient, walletClient);
 
-      expect(result.success).toBe(true);
       expect(cofhesdkClient.connected).toBe(true);
 
       const snapshot = cofhesdkClient.getSnapshot();
@@ -74,15 +79,17 @@ describe('@cofhe/web - Client', () => {
     }, 30000);
 
     it('should handle network errors', async () => {
-      const result = await cofhesdkClient.connect(
-        {
-          getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
-        } as unknown as PublicClient,
-        walletClient
-      );
-
-      expect(result.success).toBe(false);
-      expect(cofhesdkClient.connected).toBe(false);
+      try {
+        await cofhesdkClient.connect(
+          {
+            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
+          } as unknown as PublicClient,
+          walletClient
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.PublicWalletGetChainIdFailed);
+      }
     }, 30000);
   });
 
@@ -113,23 +120,11 @@ describe('@cofhe/web - Client', () => {
     }, 30000);
   });
 
-  describe('Initialization Results', () => {
-    it('should have keyFetchResult promise', () => {
-      expect(cofhesdkClient.initializationResults).toBeDefined();
-      expect(cofhesdkClient.initializationResults.keyFetchResult).toBeInstanceOf(Promise);
-    });
-
-    it('should resolve keyFetchResult', async () => {
-      const result = await cofhesdkClient.initializationResults.keyFetchResult;
-      expect(result.success).toBe(true);
-    });
-  });
-
   describe('Builder Creation', () => {
     it('should create encrypt builder after connection', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
-      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2 }]);
+      const builder = cofhesdkClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
 
       expect(builder).toBeDefined();
       expect(typeof builder.setChainId).toBe('function');

package/web/config.web.test.ts

@@ -42,14 +42,12 @@ describe('@cofhe/web - Config', () => {
     it('should preserve all other config options', () => {
       const config = createCofhesdkConfig({
         supportedChains: [arbSepolia],
-        fheKeysPrefetching: 'OFF',
         mocks: {
           sealOutputDelay: 500,
         },
       });
 
       expect(config.supportedChains).toEqual([arbSepolia]);
-      expect(config.fheKeysPrefetching).toBe('OFF');
       expect(config.mocks.sealOutputDelay).toBe(500);
       expect(config.fheKeyStorage).toBeDefined();
     });

package/web/encryptInputs.web.test.ts

@@ -1,5 +1,5 @@
 import { arbSepolia as cofhesdkArbSepolia } from '@/chains';
-import { Encryptable, FheTypes, type CofhesdkClient, type Result, CofhesdkErrorCode, CofhesdkError } from '@/core';
+import { Encryptable, FheTypes, type CofhesdkClient, CofhesdkErrorCode, CofhesdkError } from '@/core';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
 import type { PublicClient, WalletClient } from 'viem';
@@ -11,22 +11,6 @@ import { createCofhesdkClient, createCofhesdkConfig } from './index.js';
 // Real test setup - runs in browser with real tfhe
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
-const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success, `Result error: ${result.error?.toString()}`).toBe(true);
-  return result.data!;
-};
-
-const expectResultError = <T>(result: Result<T>, errorCode?: CofhesdkErrorCode): void => {
-  expect(result.success).toBe(false);
-  expect(result.data).toBe(null);
-  expect(result.error).not.toBe(null);
-  const error = result.error as CofhesdkError;
-  expect(error).toBeInstanceOf(CofhesdkError);
-  if (errorCode) {
-    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
-  }
-};
-
 describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
   let cofhesdkClient: CofhesdkClient;
   let publicClient: PublicClient;
@@ -60,22 +44,19 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
 
       // This will trigger real TFHE initialization in browser
       const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      const encrypted = expectResultSuccess(result);
 
       // If we get here, TFHE was initialized successfully
-      expect(encrypted).toBeDefined();
+      expect(result).toBeDefined();
     }, 60000); // Longer timeout for real operations
 
     it('should handle multiple encryptions without re-initializing', async () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       // First encryption
-      const result1 = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-      expectResultSuccess(result1);
+      expect(cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt()).resolves.not.toThrow();
 
       // Second encryption should reuse initialization
-      const result2 = await cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt();
-      expectResultSuccess(result2);
+      expect(cofhesdkClient.encryptInputs([Encryptable.uint64(50n)]).encrypt()).resolves.not.toThrow();
     }, 60000);
   });
 
@@ -84,15 +65,15 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       const result = await cofhesdkClient.encryptInputs([Encryptable.bool(true)]).encrypt();
-      const encrypted = expectResultSuccess(result);
 
-      expect(encrypted.length).toBe(1);
-      expect(encrypted[0].utype).toBe(FheTypes.Bool);
-      expect(encrypted[0].ctHash).toBeDefined();
-      expect(typeof encrypted[0].ctHash).toBe('bigint');
-      expect(encrypted[0].signature).toBeDefined();
-      expect(typeof encrypted[0].signature).toBe('string');
-      expect(encrypted[0].securityZone).toBe(0);
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+      expect(result[0].utype).toBe(FheTypes.Bool);
+      expect(result[0].ctHash).toBeDefined();
+      expect(typeof result[0].ctHash).toBe('bigint');
+      expect(result[0].signature).toBeDefined();
+      expect(typeof result[0].signature).toBe('string');
+      expect(result[0].securityZone).toBe(0);
     }, 60000);
 
     it('should encrypt all supported types together', async () => {
@@ -109,17 +90,17 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       ];
 
       const result = await cofhesdkClient.encryptInputs(inputs).encrypt();
-      const encrypted = expectResultSuccess(result);
+      expect(result).toBeDefined();
 
-      expect(encrypted.length).toBe(7);
+      expect(result.length).toBe(7);
       // Verify each type
-      expect(encrypted[0].utype).toBe(FheTypes.Bool);
-      expect(encrypted[1].utype).toBe(FheTypes.Uint8);
-      expect(encrypted[2].utype).toBe(FheTypes.Uint16);
-      expect(encrypted[3].utype).toBe(FheTypes.Uint32);
-      expect(encrypted[4].utype).toBe(FheTypes.Uint64);
-      expect(encrypted[5].utype).toBe(FheTypes.Uint128);
-      expect(encrypted[6].utype).toBe(FheTypes.Uint160);
+      expect(result[0].utype).toBe(FheTypes.Bool);
+      expect(result[1].utype).toBe(FheTypes.Uint8);
+      expect(result[2].utype).toBe(FheTypes.Uint16);
+      expect(result[3].utype).toBe(FheTypes.Uint32);
+      expect(result[4].utype).toBe(FheTypes.Uint64);
+      expect(result[5].utype).toBe(FheTypes.Uint128);
+      expect(result[6].utype).toBe(FheTypes.Uint160);
     }, 90000); // Longer timeout for multiple encryptions
   });
 
@@ -128,14 +109,13 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
       await cofhesdkClient.connect(publicClient, walletClient);
 
       const snapshot = cofhesdkClient.getSnapshot();
-      const result = await cofhesdkClient
+      const encrypted = await cofhesdkClient
         .encryptInputs([Encryptable.uint128(100n)])
         .setChainId(snapshot.chainId!)
         .setAccount(snapshot.account!)
         .setSecurityZone(0)
         .encrypt();
 
-      const encrypted = expectResultSuccess(result);
       expect(encrypted.length).toBe(1);
       expect(encrypted[0].utype).toBe(FheTypes.Uint128);
     }, 60000);
@@ -144,9 +124,12 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
   describe('Browser Error Handling', () => {
     it('should fail gracefully when not connected', async () => {
       // Don't connect the client
-      const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expectResultError(result, CofhesdkErrorCode.NotConnected);
+      try {
+        const promise = cofhesdkClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofhesdkError);
+        expect((error as CofhesdkError).code).toBe(CofhesdkErrorCode.NotConnected);
+      }
     }, 30000);
 
     it('should handle invalid CoFHE URL', async () => {
@@ -158,18 +141,13 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
             verifierUrl: 'http://invalid-verifier-url.local',
           },
         ],
-        fheKeysPrefetching: 'OFF',
       });
 
       const badClient = createCofhesdkClient(badConfig);
       await badClient.connect(publicClient, walletClient);
 
-      const result = await badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
-
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error).toBeDefined();
-      }
+      const promise = badClient.encryptInputs([Encryptable.uint128(100n)]).encrypt();
+      expect(promise).rejects.toThrow();
     }, 60000);
   });
 
@@ -181,8 +159,7 @@ describe('@cofhe/web - Encrypt Inputs Browser Tests', () => {
 
       // Perform 5 encryptions
       for (let i = 0; i < 5; i++) {
-        const result = await cofhesdkClient.encryptInputs([Encryptable.uint128(BigInt(i))]).encrypt();
-        expectResultSuccess(result);
+        await cofhesdkClient.encryptInputs([Encryptable.uint128(BigInt(i))]).encrypt();
       }
 
       const duration = Date.now() - start;