@fhevm/sdk 1.0.0-alpha.4 → 1.0.0-alpha.6

package/core/actions/chain/index.ts

@@ -12,16 +12,16 @@ export {
 } from './fetchFheEncryptionKeyBytes.js';
 
 export {
-  type ParseTransportKeypairParameters,
-  type ParseTransportKeypairReturnType,
-  parseTransportKeypair,
-} from './parseTransportKeypair.js';
+  type ParseTransportKeyPairParameters,
+  type ParseTransportKeyPairReturnType,
+  parseTransportKeyPair,
+} from './parseTransportKeyPair.js';
 
 export {
-  type SerializeTransportKeypairParameters,
-  type SerializeTransportKeypairReturnType,
-  serializeTransportKeypair,
-} from './serializeTransportKeypair.js';
+  type SerializeTransportKeyPairParameters,
+  type SerializeTransportKeyPairReturnType,
+  serializeTransportKeyPair,
+} from './serializeTransportKeyPair.js';
 
 export {
   type CreateKmsDelegatedUserDecryptEip712Parameters,

package/core/actions/chain/parseSignedDecryptionPermit.ts

@@ -1,7 +1,7 @@
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { KmsDecryptEip712Like } from '../../types/kms.js';
 import { parseSignedDecryptionPermit as parseSignedDecryptionPermit_ } from '../../kms/SignedDecryptionPermit-p.js';
 
@@ -14,8 +14,8 @@ export type ParseSignedDecryptionPermitParameters = {
     readonly signature: string;
     readonly signerAddress: string;
   };
-  /** The transport keypair that was used when signing the permit. */
-  readonly transportKeypair: TransportKeypair;
+  /** The transport key pair that was used when signing the permit. */
+  readonly transportKeyPair: TransportKeyPair;
 };
 
 export type ParseSignedDecryptionPermitReturnType = SignedDecryptionPermit;
@@ -24,7 +24,7 @@ export type ParseSignedDecryptionPermitReturnType = SignedDecryptionPermit;
  * Parses and verifies a previously serialized signed decryption permit.
  *
  * Validates the EIP-712 structure, verifies the signature against the on-chain
- * verifier, and checks the permit's public key matches the provided keypair.
+ * verifier, and checks the permit's public key matches the provided key pair.
  *
  * @throws If the permit is malformed, expired, or the signature is invalid.
  */
@@ -32,7 +32,7 @@ export async function parseSignedDecryptionPermit(
   fhevm: Fhevm<FhevmChain>,
   parameters: ParseSignedDecryptionPermitParameters,
 ): Promise<ParseSignedDecryptionPermitReturnType> {
-  const { serializedPermit, transportKeypair } = parameters;
+  const { serializedPermit, transportKeyPair: transportKeyPair } = parameters;
 
-  return parseSignedDecryptionPermit_(fhevm, transportKeypair, serializedPermit);
+  return parseSignedDecryptionPermit_(fhevm, transportKeyPair, serializedPermit);
 }

package/core/actions/chain/{parseTransportKeypair.ts → parseTransportKeyPair.ts}

@@ -1,20 +1,20 @@
 import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
 import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import { toTransportKeypair, type TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import { toTransportKeyPair, type TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type ParseTransportKeypairParameters = {
+export type ParseTransportKeyPairParameters = {
   readonly publicKey: string;
   readonly privateKey: string;
 };
 
-export type ParseTransportKeypairReturnType = TransportKeypair;
+export type ParseTransportKeyPairReturnType = TransportKeyPair;
 
-export async function parseTransportKeypair(
+export async function parseTransportKeyPair(
   fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
-  parameters: ParseTransportKeypairParameters,
-): Promise<ParseTransportKeypairReturnType> {
-  return toTransportKeypair(fhevm, parameters);
+  parameters: ParseTransportKeyPairParameters,
+): Promise<ParseTransportKeyPairReturnType> {
+  return toTransportKeyPair(fhevm, parameters);
 }

package/core/actions/chain/{serializeTransportKeypair.ts → serializeTransportKeyPair.ts}

@@ -3,24 +3,24 @@ import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { BytesHex } from '../../types/primitives.js';
 import {
-  serializeTransportKeypair as serializeTransportKeypair_,
-  type TransportKeypair,
-} from '../../kms/TransportKeypair-p.js';
+  serializeTransportKeyPair as serializeTransportKeyPair_,
+  type TransportKeyPair,
+} from '../../kms/TransportKeyPair-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type SerializeTransportKeypairParameters = {
-  readonly transportKeypair: TransportKeypair;
+export type SerializeTransportKeyPairParameters = {
+  readonly transportKeyPair: TransportKeyPair;
 };
 
-export type SerializeTransportKeypairReturnType = {
+export type SerializeTransportKeyPairReturnType = {
   publicKey: BytesHex;
   privateKey: BytesHex;
 };
 
-export function serializeTransportKeypair(
+export function serializeTransportKeyPair(
   _fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
-  parameters: SerializeTransportKeypairParameters,
-): SerializeTransportKeypairReturnType {
-  return serializeTransportKeypair_(parameters.transportKeypair);
+  parameters: SerializeTransportKeyPairParameters,
+): SerializeTransportKeyPairReturnType {
+  return serializeTransportKeyPair_(parameters.transportKeyPair);
 }

package/core/actions/decrypt/canDecryptValue.ts

@@ -5,7 +5,7 @@ import type {
   SignedDelegatedDecryptionPermit,
   SignedSelfDecryptionPermit,
 } from '../../types/signedDecryptionPermit.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { canDecryptValuesFromPairs as canDecryptValuesFromPairs_ } from '../../host-contracts/canDecryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -24,7 +24,7 @@ export type CanDecryptValueWithUserAddressParameters = CanDecryptValueParameters
 
 export type CanDecryptValueWithPermitParameters = CanDecryptValueParametersBase & {
   readonly signedPermit: SignedSelfDecryptionPermit | SignedDelegatedDecryptionPermit;
-  readonly transportKeypair?: TransportKeypair | undefined;
+  readonly transportKeyPair?: TransportKeyPair | undefined;
 };
 
 export type CanDecryptValueReturnType = {
@@ -54,9 +54,9 @@ export type CanDecryptValueReturnType = {
  * - the current time is within the permit validity window
  * - the permit is scoped to the requested `contractAddress`
  *
- * When both a `SignedDecryptionPermit` and an `transportKeypair` are provided,
+ * When both a `SignedDecryptionPermit` and an `transportKeyPair` are provided,
  * the function also checks that the permit is scoped to the corresponding
- * `transportKeypair.publicKey`.
+ * `transportKeyPair.publicKey`.
  *
  * A permit is scoped to:
  * - a user

package/core/actions/decrypt/canDecryptValues.ts

@@ -5,7 +5,7 @@ import type {
   SignedDelegatedDecryptionPermit,
   SignedSelfDecryptionPermit,
 } from '../../types/signedDecryptionPermit.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { canDecryptValuesFromPairs as canDecryptValuesFromPairs_ } from '../../host-contracts/canDecryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -24,7 +24,7 @@ export type CanDecryptValuesWithUserAddressParameters = CanDecryptValuesParamete
 
 export type CanDecryptValuesWithPermitParameters = CanDecryptValuesParametersBase & {
   readonly signedPermit: SignedSelfDecryptionPermit | SignedDelegatedDecryptionPermit;
-  readonly transportKeypair?: TransportKeypair | undefined;
+  readonly transportKeyPair?: TransportKeyPair | undefined;
 };
 
 export type CanDecryptValuesReturnType = {

package/core/actions/decrypt/canDecryptValuesFromPairs.ts

@@ -5,7 +5,7 @@ import type {
   SignedDelegatedDecryptionPermit,
   SignedSelfDecryptionPermit,
 } from '../../types/signedDecryptionPermit.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { canDecryptValuesFromPairs as canDecryptValuesFromPairs_ } from '../../host-contracts/canDecryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -26,7 +26,7 @@ export type CanDecryptValuesFromPairsWithUserAddressParameters = CanDecryptValue
 
 export type CanDecryptValuesFromPairsWithPermitParameters = CanDecryptValuesFromPairsParametersBase & {
   readonly signedPermit: SignedSelfDecryptionPermit | SignedDelegatedDecryptionPermit;
-  readonly transportKeypair?: TransportKeypair | undefined;
+  readonly transportKeyPair?: TransportKeyPair | undefined;
 };
 
 export type CanDecryptValuesFromPairsReturnType = {

package/core/actions/decrypt/decryptKmsSignedcryptedShares.ts

@@ -2,7 +2,7 @@ import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { KmsSigncryptedShares } from '../../types/kms.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { TypedValue } from '../../types/primitives.js';
 import { decryptKmsSignedcryptedShares as decryptKmsSignedcryptedShares_ } from '../../kms/decryptKmsSignedcryptedShares-p.js';
 import { clearValueToTypedValue } from '../../handle/ClearValue.js';
@@ -13,7 +13,7 @@ import { clearValueToTypedValue } from '../../handle/ClearValue.js';
 
 export type DecryptKmsSignedcryptedSharesParameters = {
   readonly kmsSigncryptedShares: KmsSigncryptedShares;
-  readonly transportKeypair: TransportKeypair;
+  readonly transportKeyPair: TransportKeyPair;
 };
 
 export type DecryptKmsSignedcryptedSharesReturnType = readonly TypedValue[];

package/core/actions/decrypt/decryptValue.ts

@@ -4,7 +4,7 @@ import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { decryptValuesFromPairs as decryptValuesFromPairs_ } from '../../kms/decryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -15,7 +15,7 @@ import { toFhevmHandle } from '../../handle/FhevmHandle.js';
 export type DecryptValueParameters = {
   readonly encryptedValue: EncryptedValueLike;
   readonly contractAddress: string;
-  readonly transportKeypair: TransportKeypair;
+  readonly transportKeyPair: TransportKeyPair;
   readonly signedPermit: SignedDecryptionPermit;
   readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };

package/core/actions/decrypt/decryptValues.ts

@@ -4,7 +4,7 @@ import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { decryptValuesFromPairs as decryptValuesFromPairs_ } from '../../kms/decryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -15,7 +15,7 @@ import { toFhevmHandle } from '../../handle/FhevmHandle.js';
 export type DecryptValuesParameters = {
   readonly encryptedValues: readonly EncryptedValueLike[];
   readonly contractAddress: string;
-  readonly transportKeypair: TransportKeypair;
+  readonly transportKeyPair: TransportKeyPair;
   readonly signedPermit: SignedDecryptionPermit;
   readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };

package/core/actions/decrypt/decryptValuesFromPairs.ts

@@ -4,7 +4,7 @@ import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
 import { decryptValuesFromPairs as decryptValuesFromPairs_ } from '../../kms/decryptValuesFromPairs.js';
 import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
@@ -17,7 +17,7 @@ export type DecryptValuesFromPairsParameters = {
     readonly encryptedValue: EncryptedValueLike;
     readonly contractAddress: string;
   }>;
-  readonly transportKeypair: TransportKeypair;
+  readonly transportKeyPair: TransportKeyPair;
   readonly signedPermit: SignedDecryptionPermit;
   readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };

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/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/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/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/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;
-}