@fhevm/sdk 1.0.0-alpha.3 → 1.0.0-alpha.5

package/core/actions/decrypt/{generateTransportKeypair.ts → generateTransportKeyPair.ts}

@@ -2,18 +2,18 @@ import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import {
-  generateTransportKeypair as generateTransportKeypair_,
-  type TransportKeypair,
-} from '../../kms/TransportKeypair-p.js';
+  generateTransportKeyPair as generateTransportKeyPair_,
+  type TransportKeyPair,
+} from '../../kms/TransportKeyPair-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type GenerateTransportKeypairReturnType = TransportKeypair;
+export type GenerateTransportKeyPairReturnType = TransportKeyPair;
 
-export async function generateTransportKeypair(
+export async function generateTransportKeyPair(
   fhevm: Fhevm<FhevmChain | undefined, WithDecrypt, OptionalNativeClient>,
-): Promise<GenerateTransportKeypairReturnType> {
-  return await generateTransportKeypair_(fhevm);
+): Promise<GenerateTransportKeyPairReturnType> {
+  return await generateTransportKeyPair_(fhevm);
 }
 
 ////////////////////////////////////////////////////////////////////////////////

package/core/actions/decrypt/index.ts

@@ -4,10 +4,7 @@ export type {
   RelayerDelegatedUserDecryptProgressArgs,
 } from '../../types/relayer.js';
 
-export {
-  type GenerateTransportKeypairReturnType as GenerateE2eTransportKeypairReturnType,
-  generateTransportKeypair as generateE2eTransportKeypair,
-} from './generateTransportKeypair.js';
+export { type GenerateTransportKeyPairReturnType, generateTransportKeyPair } from './generateTransportKeyPair.js';
 
 export {
   type DecryptValuesFromPairsParameters,
@@ -45,3 +42,10 @@ export {
   type CanDecryptValueReturnType,
   canDecryptValue,
 } from './canDecryptValue.js';
+
+export { type TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
+
+export {
+  type SignDecryptionPermitParameters,
+  type SignDecryptionPermitReturnType,
+} from '../base/signDecryptionPermit.js';

package/core/actions/encrypt/encryptValue.ts

@@ -2,7 +2,7 @@ import type { RelayerInputProofOptions } from '../../types/relayer.js';
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { BytesHex, TypedValueLike } from '../../types/primitives.js';
+import type { BytesHex } from '../../types/primitives.js';
 import type { EncryptedValue } from '../../types/encryptedTypes.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
 import { toArray } from '../../base/object.js';
@@ -12,7 +12,7 @@ import { encrypt as encrypt_ } from '../../coprocessor/encrypt.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export type EncryptValueParameters = {
-  readonly value: TypedValueLike;
+  readonly value: { readonly type: string; readonly value: boolean | bigint | number | string };
   readonly contractAddress: string;
   readonly userAddress: string;
   readonly options?: RelayerInputProofOptions | undefined;

package/core/actions/encrypt/encryptValues.ts

@@ -2,7 +2,7 @@ import type { RelayerInputProofOptions } from '../../types/relayer.js';
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { BytesHex, TypedValueLike } from '../../types/primitives.js';
+import type { BytesHex } from '../../types/primitives.js';
 import type { EncryptedValue } from '../../types/encryptedTypes.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
 import { createTypedValue } from '../../base/typedValue.js';
@@ -11,7 +11,7 @@ import { encrypt as encrypt_ } from '../../coprocessor/encrypt.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export type EncryptValuesParameters = {
-  readonly values: readonly TypedValueLike[];
+  readonly values: ReadonlyArray<{ readonly type: string; readonly value: boolean | bigint | number | string }>;
   readonly contractAddress: string;
   readonly userAddress: string;
   readonly options?: RelayerInputProofOptions | undefined;

package/core/actions/encrypt/generateZkProof.ts

@@ -1,7 +1,6 @@
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { TypedValueLike } from '../../types/primitives.js';
 import type { ZkProof } from '../../types/zkProof-p.js';
 import { createTypedValue } from '../../base/typedValue.js';
 import { createZkProofBuilder } from '../../coprocessor/ZkProofBuilder-p.js';
@@ -11,7 +10,7 @@ import { createZkProofBuilder } from '../../coprocessor/ZkProofBuilder-p.js';
 export type GenerateZkProofParameters = {
   readonly contractAddress: string;
   readonly userAddress: string;
-  readonly values: readonly TypedValueLike[];
+  readonly values: ReadonlyArray<{ readonly type: string; readonly value: boolean | bigint | number | string }>;
 };
 
 export type GenerateZkProofReturnType = ZkProof;

package/core/base/address.ts

@@ -1,4 +1,4 @@
-import type { Address, Bytes20, Bytes20HexNo0x, ChecksummedAddress } from '../types/primitives.js';
+import type { Address, Bytes20, ChecksummedAddress } from '../types/primitives.js';
 import type {
   RecordAddressPropertyType,
   RecordChecksummedAddressArrayPropertyType,
@@ -117,7 +117,7 @@ export function isAddress(value: unknown): value is Address {
     return false;
   }
 
-  const hexNo0x = remove0x(value) as Bytes20HexNo0x;
+  const hexNo0x = remove0x(value);
   const hexNo0xLowerCase = hexNo0x.toLowerCase();
 
   if (hexNo0x === hexNo0xLowerCase) {

package/core/base/errors/InvalidTypeError.ts

@@ -4,7 +4,7 @@ import { ErrorBase } from './ErrorBase.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export type ExpectedTypeParams = {
-  expectedType: string | string[];
+  expectedType: string | readonly string[];
 };
 
 ////////////////////////////////////////////////////////////////////////////////

package/core/base/fetch.ts

@@ -219,8 +219,8 @@ export async function fetchWithRetry(
 ): Promise<Response> {
   let lastError: unknown;
 
-  const retries = args.retries ?? 3;
-  const retryDelayMs = args.retryDelayMs ?? 1000;
+  const retries = Math.max(0, Math.min(1000, args.retries ?? 3));
+  const retryDelayMs = Math.max(100, args.retryDelayMs ?? 1000);
   const { url, init } = args;
 
   for (let attempt = 0; attempt <= retries; attempt++) {

package/core/base/index.ts

@@ -1 +0,0 @@
-export { createTypedValue, createTypedValueArray } from './typedValue.js';

package/core/base/sign.ts

@@ -1,20 +1,28 @@
 import type { Address, Bytes65Hex, BytesHex, ChecksummedAddress } from '../types/primitives.js';
-import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { addressToChecksummedAddress } from './address.js';
-import { bytesToHex } from './bytes.js';
+import { bytesToHex, bytesToHexNo0x, hexToBytes } from './bytes.js';
 
 export function sign({ hash, privateKey }: { readonly hash: BytesHex; readonly privateKey: BytesHex }): Bytes65Hex {
-  const sig = secp256k1.sign(hash.slice(2), privateKey.slice(2), {
+  const sig = secp256k1.sign(hexToBytes(hash), hexToBytes(privateKey), {
+    prehash: false,
     lowS: true,
     extraEntropy: true,
+    format: 'recovered',
   });
 
-  if (sig.recovery !== 0 && sig.recovery !== 1) {
+  if (sig.length !== 65) {
+    throw new Error('Unexpected signature length');
+  }
+
+  // @noble/curves v2 'recovered' format: [recovery (1 byte)] || [r (32 bytes)] || [s (32 bytes)]
+  const recovery = sig[0];
+  if (recovery !== 0 && recovery !== 1) {
     throw new Error('Unexpected signature recovery value');
   }
 
-  const signatureHex = `0x${sig.toCompactHex()}${sig.recovery === 0 ? '1b' : '1c'}` as BytesHex;
+  const signatureHex = `0x${bytesToHexNo0x(sig.subarray(1, 65))}${recovery === 0 ? '1b' : '1c'}` as BytesHex;
 
   if (signatureHex.length !== 2 + 130) {
     throw new Error('Unexpected signature length');
@@ -48,10 +56,10 @@ function _recoverPublicKey(parameters: { readonly hash: BytesHex; readonly signa
     throw new Error(`Invalid v value: ${v}`);
   }
 
-  const sig = secp256k1.Signature.fromCompact(compactHex).addRecoveryBit(recoveryBit);
+  const sig = secp256k1.Signature.fromBytes(hexToBytes(compactHex), 'compact').addRecoveryBit(recoveryBit);
 
-  // toRawBytes(false) → uncompressed encoding: 0x04 || X (32) || Y (32) = 65 bytes.
-  return sig.recoverPublicKey(hash.slice(2)).toRawBytes(false);
+  // toBytes(false) → uncompressed encoding: 0x04 || X (32) || Y (32) = 65 bytes.
+  return sig.recoverPublicKey(hexToBytes(hash)).toBytes(false);
 }
 
 function _keccak256(bytes: Uint8Array): Uint8Array {

package/core/base/typedValue.ts

@@ -3,8 +3,8 @@ import type {
   AddressValueLike,
   BoolValueLike,
   Bytes32Hex,
+  RawTypedValue,
   TypedValue,
-  TypedValueFrom,
   TypedValueLike,
   TypedValueOfBase,
   Uint128ValueLike,
@@ -20,7 +20,7 @@ import type {
 import { asAddress } from './address.js';
 import { toBoolean } from './boolean.js';
 import { InvalidTypeError } from './errors/InvalidTypeError.js';
-import { asUintForType, normalizeUintForType } from './uint.js';
+import { assertIsUintTypeName, asUintForType, normalizeUintForType } from './uint.js';
 import { bigIntToBytesHex } from './bytes.js';
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -184,15 +184,13 @@ export function assertIsTypedValueArray(
  * // Type: TypedValue<'address', ChecksummedAddress>
  * ```
  */
-export function createTypedValue<InputType extends TypedValueLike>(
-  input: InputType,
-): TypedValue & { readonly type: InputType['type'] } {
-  if ((input as unknown) == null || typeof input !== 'object') {
+export function createTypedValue(input: RawTypedValue): TypedValue {
+  if ((input as unknown) == null || typeof input !== 'object' || (input as unknown) === undefined) {
     throw new InvalidTypeError(
       {
         subject: 'input',
         type: typeof input,
-        expectedType: 'InputTypedValue ({ type, value })',
+        expectedType: '{ type, value }',
       },
       {},
     );
@@ -205,27 +203,36 @@ export function createTypedValue<InputType extends TypedValueLike>(
   const expectedType = input.type;
 
   let validatedValue: ValueType;
+  let resolvedType: ValueTypeName;
 
   if (expectedType === 'bool') {
+    resolvedType = 'bool';
     validatedValue = toBoolean(input.value, {});
-  } else if (expectedType === 'address') {
-    validatedValue = asAddress(input.value);
+  } else if (expectedType === 'address' || expectedType === 'uint160') {
+    // uint160 and address share a 160-bit width; canonicalize uint160 → address.
+    resolvedType = 'address';
+    if (typeof input.value === 'string') {
+      validatedValue = asAddress(input.value);
+    } else {
+      const u = asUintForType(input.value, 'uint160', {});
+      validatedValue = asAddress(bigIntToBytesHex(BigInt(u), { byteLength: 20 }));
+    }
   } else {
+    assertIsUintTypeName(expectedType, {});
+    if (expectedType === 'uint160') {
+      // Unreachable: handled by the address branch above. Re-checked here
+      // because `assertIsUintTypeName` widens the type back to include 'uint160'.
+      throw new InvalidTypeError({ subject: 'input.type', type: expectedType, expectedType: 'ValueTypeName' }, {});
+    }
+    resolvedType = expectedType;
     validatedValue = normalizeUintForType(asUintForType(input.value, expectedType, {}), expectedType);
   }
 
-  const v: TypedValueOfBase<typeof expectedType> = new TypedValueImpl(validatedValue, expectedType);
+  const v = new TypedValueImpl(validatedValue, resolvedType);
   Object.freeze(v);
-  return v as TypedValueFrom<InputType>;
-}
 
-/**
- * Mapped tuple type that preserves per-element type narrowing.
- * @internal
- */
-type TypedValueArrayFrom<T extends readonly TypedValueLike[]> = {
-  [K in keyof T]: TypedValueFrom<T[K]>;
-};
+  return v as TypedValue;
+}
 
 /**
  * Creates an array of validated {@link TypedValueOf}s from a tuple of inputs.
@@ -239,8 +246,8 @@ type TypedValueArrayFrom<T extends readonly TypedValueLike[]> = {
  * // b: BoolValue, n: Uint8Value
  * ```
  */
-export function createTypedValueArray<T extends readonly TypedValueLike[]>(inputs: [...T]): TypedValueArrayFrom<T> {
-  return inputs.map(createTypedValue) as unknown as TypedValueArrayFrom<T>;
+export function createTypedValueArray(inputs: readonly RawTypedValue[]): TypedValue[] {
+  return inputs.map(createTypedValue);
 }
 
 /**
@@ -300,10 +307,10 @@ export class TypedValueArrayBuilder {
     return this;
   }
 
-  #push(typeName: ValueTypeName, value: unknown): this {
+  #push(typeName: ValueTypeName, value: TypedValueLike | RawTypedValue['value']): this {
     if (isTypedValue(value, { type: typeName })) {
       this.#arr.push(value);
-    } else if (typeof value === 'object' && value !== null) {
+    } else if (typeof value === 'object') {
       const tv = value as TypedValue;
       if (tv.type !== typeName) {
         throw new InvalidTypeError(
@@ -315,9 +322,9 @@ export class TypedValueArrayBuilder {
           {},
         );
       }
-      this.#arr.push(createTypedValue({ type: typeName, value: tv.value } as TypedValueLike));
+      this.#arr.push(createTypedValue({ type: typeName, value: tv.value }));
     } else {
-      this.#arr.push(createTypedValue({ type: typeName, value } as TypedValueLike));
+      this.#arr.push(createTypedValue({ type: typeName, value }));
     }
     return this;
   }

package/core/base/uint.ts

@@ -444,6 +444,36 @@ export function normalizeUintForType<T extends UintTypeName>(value: Uint, typeNa
   }
 }
 
+const UINT_TYPE_NAMES = [
+  'uint8',
+  'uint16',
+  'uint32',
+  'uint64',
+  'uint128',
+  'uint160',
+  'uint256',
+] as const satisfies readonly UintTypeName[];
+
+export function isUintTypeName(value: unknown): value is UintTypeName {
+  return typeof value === 'string' && (UINT_TYPE_NAMES as readonly string[]).includes(value);
+}
+
+export function assertIsUintTypeName(
+  value: unknown,
+  options: { subject?: string } & ErrorMetadataParams = {},
+): asserts value is UintTypeName {
+  if (!isUintTypeName(value)) {
+    throw new InvalidTypeError(
+      {
+        subject: options.subject,
+        type: typeof value,
+        expectedType: UINT_TYPE_NAMES,
+      },
+      options,
+    );
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // asUintXX
 ////////////////////////////////////////////////////////////////////////////////

package/core/base/wasm.ts

@@ -52,7 +52,7 @@ export async function isomorphicCompileWasm(wasmUrl: URL): Promise<WebAssembly.M
     // ArrayBufferLike (includes SharedArrayBuffer), making it incompatible with
     // BufferSource. At runtime Buffer is always backed by ArrayBuffer, so the
     // cast at WebAssembly.compile is safe and avoids copying.
-    bytes = (await readFile(fileURLToPath(wasmUrl))) as BufferSource;
+    bytes = await readFile(fileURLToPath(wasmUrl));
   } else {
     // fetch wasm
     const res = await fetch(wasmUrl);

package/core/clients/decorators/base.ts

@@ -5,9 +5,9 @@ import type {
   SignedDelegatedDecryptionPermit,
 } from '../../types/signedDecryptionPermit.js';
 import type {
-  SerializeTransportKeypairParameters,
-  SerializeTransportKeypairReturnType,
-} from '../../actions/chain/serializeTransportKeypair.js';
+  SerializeTransportKeyPairParameters,
+  SerializeTransportKeyPairReturnType,
+} from '../../actions/chain/serializeTransportKeyPair.js';
 import { assertIsFhevmBaseClient } from '../../runtime/CoreFhevm-p.js';
 import {
   signDecryptionPermit,
@@ -15,16 +15,16 @@ import {
   type SignDelegatedDecryptionPermitParameters,
 } from '../../actions/base/signDecryptionPermit.js';
 import {
-  parseTransportKeypair,
-  type ParseTransportKeypairParameters,
-  type ParseTransportKeypairReturnType,
-} from '../../actions/chain/parseTransportKeypair.js';
+  parseTransportKeyPair,
+  type ParseTransportKeyPairParameters,
+  type ParseTransportKeyPairReturnType,
+} from '../../actions/chain/parseTransportKeyPair.js';
 import {
   fetchFheEncryptionKeyBytes,
   type FetchFheEncryptionKeyBytesParameters,
   type FetchFheEncryptionKeyBytesReturnType,
 } from '../../actions/chain/fetchFheEncryptionKeyBytes.js';
-import { serializeTransportKeypair } from '../../actions/chain/serializeTransportKeypair.js';
+import { serializeTransportKeyPair } from '../../actions/chain/serializeTransportKeyPair.js';
 import {
   serializeSignedDecryptionPermit,
   type SerializeSignedDecryptionPermitParameters,
@@ -147,14 +147,14 @@ export type BaseActions = {
      */
     (parameters: SignDelegatedDecryptionPermitParameters): Promise<SignedDelegatedDecryptionPermit>;
   };
-  /** Deserializes a previously serialized e2e transport keypair back into a usable keypair. */
-  readonly parseTransportKeypair: (
-    parameters: ParseTransportKeypairParameters,
-  ) => Promise<ParseTransportKeypairReturnType>;
-  /** Serializes an e2e transport keypair to hex strings for storage. */
-  readonly serializeTransportKeypair: (
-    parameters: SerializeTransportKeypairParameters,
-  ) => SerializeTransportKeypairReturnType;
+  /** Deserializes a previously serialized e2e transport key pair back into a usable key pair. */
+  readonly parseTransportKeyPair: (
+    parameters: ParseTransportKeyPairParameters,
+  ) => Promise<ParseTransportKeyPairReturnType>;
+  /** Serializes an e2e transport key pair to hex strings for storage. */
+  readonly serializeTransportKeyPair: (
+    parameters: SerializeTransportKeyPairParameters,
+  ) => SerializeTransportKeyPairReturnType;
   /** Serializes a signed decryption permit to a plain object for storage or transmission. */
   readonly serializeSignedDecryptionPermit: (
     parameters: SerializeSignedDecryptionPermitParameters,
@@ -183,8 +183,8 @@ function _baseActions(fhevm: Fhevm<FhevmChain>): BaseActions {
         fhevm,
         parameters as SignSelfDecryptionPermitParameters,
       )) as BaseActions['signDecryptionPermit'],
-    parseTransportKeypair: (parameters) => parseTransportKeypair(fhevm, parameters),
-    serializeTransportKeypair: (parameters) => serializeTransportKeypair(fhevm, parameters),
+    parseTransportKeyPair: (parameters) => parseTransportKeyPair(fhevm, parameters),
+    serializeTransportKeyPair: (parameters) => serializeTransportKeyPair(fhevm, parameters),
     serializeSignedDecryptionPermit: (parameters) => serializeSignedDecryptionPermit(fhevm, parameters),
     parseSignedDecryptionPermit: (parameters) => parseSignedDecryptionPermit(fhevm, parameters),
     fetchFheEncryptionKeyBytes: (parameters) => fetchFheEncryptionKeyBytes(fhevm, parameters),

package/core/clients/decorators/decrypt.ts

@@ -1,10 +1,10 @@
 import type { Fhevm, FhevmBase, FhevmExtension, OptionalNativeClient } from '../../types/coreFhevmClient.js';
 import type { FhevmRuntime, WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { GenerateTransportKeypairReturnType } from '../../actions/decrypt/generateTransportKeypair.js';
+import type { GenerateTransportKeyPairReturnType } from '../../actions/decrypt/generateTransportKeyPair.js';
 import type { DecryptModuleFactory } from '../../modules/decrypt/types.js';
 import { asFhevmClientWith, assertIsFhevmClientWith } from '../../runtime/CoreFhevm-p.js';
-import { generateTransportKeypair } from '../../kms/TransportKeypair-p.js';
+import { generateTransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import {
   decryptValue,
   type DecryptValueParameters,
@@ -30,7 +30,7 @@ export type DecryptActions = {
   readonly decryptValuesFromPairs: (
     parameters: DecryptValuesFromPairsParameters,
   ) => Promise<DecryptValuesFromPairsReturnType>;
-  readonly generateTransportKeypair: () => Promise<GenerateTransportKeypairReturnType>;
+  readonly generateTransportKeyPair: () => Promise<GenerateTransportKeyPairReturnType>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -42,7 +42,7 @@ function _decryptActions(fhevm: Fhevm<FhevmChain, WithDecrypt>): DecryptActions
     decryptValue: (parameters) => decryptValue(fhevm, parameters),
     decryptValues: (parameters) => decryptValues(fhevm, parameters),
     decryptValuesFromPairs: (parameters) => decryptValuesFromPairs(fhevm, parameters),
-    generateTransportKeypair: () => generateTransportKeypair(fhevm),
+    generateTransportKeyPair: () => generateTransportKeyPair(fhevm),
   };
 }
 

package/core/coprocessor/ZkProof-p.ts

@@ -6,7 +6,6 @@ import type {
   Bytes32,
   Uint64,
   Bytes21Hex,
-  Uint8Number,
   BytesHex,
 } from '../types/primitives.js';
 import type { ZkProofLike, ZkProof } from '../types/zkProof-p.js';
@@ -23,7 +22,7 @@ import {
 import { bytes32ToHex, bytesToHexLarge, concatBytes, hexToBytes32, toBytes } from '../base/bytes.js';
 import { assertIsUint64, assertIsUint8, asUint64BigInt, uint64ToBytes32 } from '../base/uint.js';
 import { ZkProofError } from '../errors/ZkProofError.js';
-import { assertIsEncryptionBitsArray, fheTypeIdFromEncryptionBits } from '../handle/FheType.js';
+import { asEncryptionBits, assertIsEncryptionBitsArray, fheTypeIdFromEncryptionBits } from '../handle/FheType.js';
 import { buildHandle } from '../handle/FhevmHandle.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { InvalidTypeError } from '../base/errors/InvalidTypeError.js';
@@ -74,7 +73,7 @@ class ZkProofImpl implements ZkProof {
     this.#userAddress = parameters.userAddress;
     this.#ciphertextWithZkProof = parameters.ciphertextWithZkProof;
     this.#encryptionBits = Object.freeze([...parameters.encryptionBits]);
-    this.#fheTypeIds = Object.freeze(this.#encryptionBits.map(fheTypeIdFromEncryptionBits));
+    this.#fheTypeIds = Object.freeze(this.#encryptionBits.map((w) => fheTypeIdFromEncryptionBits(asEncryptionBits(w))));
     this.#extraData = parameters.extraData;
     Object.freeze(this);
   }
@@ -105,7 +104,7 @@ class ZkProofImpl implements ZkProof {
 
   /** The ciphertext with Zk proof (guaranteed non-empty). Returns a copy. */
   public get ciphertextWithZkProof(): Bytes {
-    return new Uint8Array(this.#ciphertextWithZkProof) as Bytes;
+    return new Uint8Array(this.#ciphertextWithZkProof);
   }
 
   /** The encryption bit sizes for each encrypted value in the proof. */
@@ -197,7 +196,7 @@ export function isZkProof(value: unknown): value is ZkProof {
 
 export function assertIsZkProof(
   value: unknown,
-  options: { subject?: string } & ErrorMetadataParams,
+  options: { readonly subject?: string; readonly metaMessages?: string[] | undefined } & ErrorMetadataParams,
 ): asserts value is ZkProof {
   if (!isZkProof(value)) {
     throw new InvalidTypeError(
@@ -205,6 +204,7 @@ export function assertIsZkProof(
         subject: options.subject,
         type: typeof value,
         expectedType: 'ZkProof',
+        metaMessages: options.metaMessages,
       },
       options,
     );
@@ -379,7 +379,7 @@ function _zkProofToInputHandles(
         chainId: args.chainId,
         fheTypeId,
         ...(options?.version !== undefined ? { version: options.version } : {}),
-        index: i as Uint8Number,
+        index: i,
       }),
     );
   }

package/core/handle/EncryptedValue.ts

@@ -23,7 +23,3 @@ export function asEncryptedValue(value: unknown): EncryptedValue {
   assertIsEncryptedValue(value);
   return value;
 }
-
-export function toEncryptedValue(value: unknown): EncryptedValue {
-  return toFhevmHandle(value).bytes32Hex as unknown as EncryptedValue;
-}

package/core/handle/FheType.ts

@@ -316,8 +316,6 @@ export function assertIsEncryptionBitsArray(
 
 /**
  * Converts an encryption bit width to its corresponding FheTypeId.
- * Accepts loose `number` input; validates internally via `isEncryptionBits`.
- * @throws A {@link FheTypeError} If bitwidth is not a valid encryption bit width.
  * @example fheTypeIdFromEncryptionBits(8) // 2 (euint8)
  */
 export function fheTypeIdFromEncryptionBits(bitwidth: EncryptionBits): FheTypeId {
@@ -326,8 +324,6 @@ export function fheTypeIdFromEncryptionBits(bitwidth: EncryptionBits): FheTypeId
 
 /**
  * Converts an FheType to its corresponding FheTypeId.
- * Accepts loose `string` input; validates internally via `isFheType`.
- * @throws A {@link FheTypeError} If name is not a valid FheType.
  * @example fheTypeIdFromName('euint8') // 2
  */
 export function fheTypeIdFromName(name: FheType): FheTypeId {
@@ -336,7 +332,6 @@ export function fheTypeIdFromName(name: FheType): FheTypeId {
 
 /**
  * Converts an FheTypeId to its corresponding FheType.
- * @throws A {@link FheTypeError} If id is not a valid FheTypeId.
  * @example fheTypeNameFromId(2) // 'euint8'
  */
 export function fheTypeNameFromId(typeId: FheTypeId): FheType {
@@ -353,7 +348,7 @@ export function fheTypeNameFromTypeName(typeName: ValueTypeName): FheType {
 
 /**
  * Converts a FheType to its corresponding TypeName.
- * @example fheTypeNameFromTypeName('euint8') // 'uint8'
+ * @example typeNameFromFheTypeName('euint8') // 'uint8'
  */
 export function typeNameFromFheTypeName(fheType: FheType): ValueTypeName {
   return fheType.substring(1) as ValueTypeName;
@@ -365,7 +360,6 @@ export function typeNameFromFheTypeName(fheType: FheType): ValueTypeName {
 
 /**
  * Returns the Solidity primitive type name for an FheTypeId.
- * Accepts loose `number` input; validates internally via `isFheTypeId`.
  * @example solidityPrimitiveTypeNameFromFheTypeId(0) // 'bool'
  * @example solidityPrimitiveTypeNameFromFheTypeId(7) // 'address'
  * @example solidityPrimitiveTypeNameFromFheTypeId(2) // 'uint256'
@@ -398,9 +392,9 @@ export function encryptionBitsFromFheTypeId(typeId: FheTypeId): EncryptionBits {
  * Returns the encryption bit width for an FheType name.
  * @param name - The FHE type name (e.g., 'ebool', 'euint32', 'eaddress')
  * @returns The encryption bit width (always \>= 2)
- * @example encryptionBitsFromFheTypeName('ebool') // 2
- * @example encryptionBitsFromFheTypeName('euint32') // 32
- * @example encryptionBitsFromFheTypeName('eaddress') // 160
+ * @example encryptionBitsFromFheType('ebool') // 2
+ * @example encryptionBitsFromFheType('euint32') // 32
+ * @example encryptionBitsFromFheType('eaddress') // 160
  */
 export function encryptionBitsFromFheType(name: FheType): EncryptionBits {
   const bw = FheTypeIdToEncryptionBits[FheTypeNameToId[name]];
@@ -463,11 +457,11 @@ export function bytesToClearValueType<etype extends FheType>(fheType: etype, byt
  * and returns it narrowed. No conversion is performed.
  *
  * - `ebool` → `boolean`
- * - `eaddress` → `string` (checksummed address)
+ * - `eaddress` → `string` (validated address)
  * - `euint8/16/32` → `number`
  * - `euint64/128/256` → `bigint`
  *
- * @throws If `value` is not the expected JS type or exceeds the type's range.
+ * @throws If `value` is not the expected JS type.
  */
 export function asClearValueType<etype extends FheType>(
   fheTypeName: etype,
@@ -504,14 +498,13 @@ export function asClearValueType<etype extends FheType>(
 
 /**
  * Converts `value` to the correct JS type for the given `fheTypeName`.
- * Accepts any uint-like input (number, bigint, string) and coerces it.
  *
- * - `ebool` → `boolean`
+ * - `ebool` → `boolean` (value must already be a `boolean`; no coercion)
  * - `eaddress` → `string` (validated address)
- * - `euint8/16/32` → coerced to `number` via `Number()`
- * - `euint64/128/256` → coerced to `bigint` via `BigInt()`
+ * - `euint8/16/32` → coerced to `number` via `Number()` (accepts `number` or `bigint`)
+ * - `euint64/128/256` → coerced to `bigint` via `BigInt()` (accepts `number` or `bigint`)
  *
- * @throws If `value` cannot be converted or exceeds the type's range.
+ * @throws If `value` is not the expected JS type or cannot be coerced.
  */
 export function toClearValueType<etype extends FheType>(
   fheTypeName: etype,