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

package/core/kms/fetchKmsSignedcryptedShares-p.ts

@@ -15,6 +15,7 @@ import { assertKmsDecryptionBitLimit } from './utils.js';
 import { checkPersistAllowed } from '../host-contracts/checkPersistAllowed.js';
 import { assertExtraDataMatchesKmsSingersContext } from '../host-contracts/KmsSignersContext-p.js';
 import { createKmsEip712Domain } from './createKmsEip712Domain.js';
+import { checkDelegation } from '../host-contracts/checkDelegation.js';
 
 /*
     See: in KMS (eip712Domain)
@@ -118,11 +119,20 @@ export async function fetchKmsSignedcryptedShares(context: Context, parameters:
   signedPermit.assertNotExpired();
 
   // 7. Check: ACL permissions (user is signer or delegatorAddress)
-  await checkPersistAllowed(context, {
-    address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
-    userAddress: encryptedDataOwnerAddress,
-    handleContractPairs,
-  });
+  if (signedPermit.isDelegated) {
+    await checkDelegation(context, {
+      address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
+      delegate: signerAddress,
+      delegator: encryptedDataOwnerAddress,
+      handleContractPairs,
+    });
+  } else {
+    await checkPersistAllowed(context, {
+      address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
+      userAddress: encryptedDataOwnerAddress,
+      handleContractPairs,
+    });
+  }
 
   // 8. Verify the EIP712 signature
   // Not required because a signedPermit is guaranteed to be verified.
@@ -157,36 +167,28 @@ export async function fetchKmsSignedcryptedShares(context: Context, parameters:
   // Safe casts: the discriminated union on parameters guarantees
   // that options type matches signedPermit type, but TS can't prove
   // it after destructuring (nested discriminant limitation).
-  const relayerUrl = context.chain.fhevm.relayerUrl;
-
   let shares: readonly KmsSigncryptedShare[];
 
   if (signedPermit.isDelegated) {
-    shares = await context.runtime.relayer.fetchDelegatedUserDecrypt(
-      { relayerUrl, chainId: context.chain.id },
-      {
-        payload: {
-          handleContractPairs,
-          kmsDecryptEip712Signer: signerAddress,
-          kmsDecryptEip712Message: signedPermit.eip712.message,
-          kmsDecryptEip712Signature: signature,
-        },
-        options: relayerOptions as RelayerDelegatedUserDecryptOptions,
+    shares = await context.runtime.relayer.fetchDelegatedUserDecrypt(context, {
+      payload: {
+        handleContractPairs,
+        kmsDecryptEip712Signer: signerAddress,
+        kmsDecryptEip712Message: signedPermit.eip712.message,
+        kmsDecryptEip712Signature: signature,
       },
-    );
+      options: relayerOptions as RelayerDelegatedUserDecryptOptions,
+    });
   } else {
-    shares = await context.runtime.relayer.fetchUserDecrypt(
-      { relayerUrl, chainId: context.chain.id },
-      {
-        payload: {
-          handleContractPairs,
-          kmsDecryptEip712Signer: signerAddress,
-          kmsDecryptEip712Message: signedPermit.eip712.message,
-          kmsDecryptEip712Signature: signature,
-        },
-        options: relayerOptions as RelayerUserDecryptOptions,
+    shares = await context.runtime.relayer.fetchUserDecrypt(context, {
+      payload: {
+        handleContractPairs,
+        kmsDecryptEip712Signer: signerAddress,
+        kmsDecryptEip712Message: signedPermit.eip712.message,
+        kmsDecryptEip712Signature: signature,
       },
-    );
+      options: relayerOptions as RelayerUserDecryptOptions,
+    });
   }
 
   // 11. Build and verify the sealed validated `KmsSigncryptedShares` object

package/core/kms/publicDecrypt.ts

@@ -74,19 +74,13 @@ export async function publicDecrypt(context: Context, parameters: Parameters): P
     orderedAbiEncodedClearValues,
     kmsPublicDecryptEIP712Signatures,
     extraData: relayerExtraData,
-  } = await context.runtime.relayer.fetchPublicDecrypt(
-    {
-      relayerUrl: context.chain.fhevm.relayerUrl,
-      chainId: context.chain.id,
+  } = await context.runtime.relayer.fetchPublicDecrypt(context, {
+    payload: {
+      orderedHandles,
+      extraData: requestedExtraData,
     },
-    {
-      payload: {
-        orderedHandles,
-        extraData: requestedExtraData,
-      },
-      options: relayerOptions,
-    },
-  );
+    options: relayerOptions,
+  });
 
   // 6. Reconcile KMS signer context using 'loose' mode
   const reconciledKmsSignersContext: KmsSignersContext = await reconcileKmsSignersContext(context, {

package/core/modules/decrypt/mock.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/require-await */
 import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 import type {
   DecryptAndReconstructParameters,
@@ -16,24 +15,129 @@ import type {
   DecryptModuleFactory,
   UserDecryptModuleFactory,
 } from './types.js';
+import type { CleartextEthereumModule } from '../ethereum/types-ct.js';
+import type { TkmsPrivateKey } from '../../types/tkms-p.js';
+import type { BytesHex } from '../../types/primitives.js';
+import type { KmsSigncryptedShare, KmsSigncryptedSharesMetadata } from '../../types/kms-p.js';
+import type { ClearValue } from '../../types/encryptedTypes-p.js';
+import { assertIsKmsExtraData } from '../../kms/kmsExtraData.js';
+import { ensure0x, remove0x } from '../../base/string.js';
+import { getMetadata, getShares } from '../../kms/KmsSigncryptedShares-p.js';
+import { asBytesHex, bytesToHex, hexToBytes } from '../../base/bytes.js';
+import { bigintToClearValueType } from '../../handle/FheType.js';
+import { createClearValue } from '../../handle/ClearValue.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+const PRIVATE_CLEARTEXT_TKMS_LIB_TOKEN = Symbol('CleartextTKMSLib.token');
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _xorUnmaskWithPublicKey(publicKey: BytesHex, maskedCleartexts: readonly bigint[]): bigint[] {
+  const hex = remove0x(publicKey);
+  if (hex.length < 64) {
+    throw new Error(`PublicKeyTooShort: publicKey has ${hex.length / 2} bytes, need >= 32`);
+  }
+  const mask = BigInt('0x' + hex.slice(0, 64));
+  return maskedCleartexts.map((c) => c ^ mask);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // decryptAndReconstruct
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function decryptAndReconstruct(
-  _runtime: FhevmRuntime,
-  _parameters: DecryptAndReconstructParameters,
+  runtime: FhevmRuntime,
+  parameters: DecryptAndReconstructParameters,
 ): Promise<DecryptAndReconstructReturnType> {
-  throw new Error('Not yet implemented');
+  const cleartextEthereumModule = runtime.ethereum as CleartextEthereumModule;
+  const { tkmsPrivateKey, shares } = parameters;
+
+  const privateKeySecp256k1 = asBytesHex(tkmsPrivateKey as unknown);
+  const publicKeySecp256k1 = cleartextEthereumModule.getPublicKey({ privateKey: privateKeySecp256k1 });
+
+  const metadata: KmsSigncryptedSharesMetadata = getMetadata(shares);
+  const sharesArray: readonly KmsSigncryptedShare[] = getShares(shares);
+
+  const firstShare = sharesArray[0];
+  if (firstShare === undefined) {
+    throw new Error('Expected at least one signcrypted share.');
+  }
+
+  const firstExtraData = firstShare.extraData;
+  for (let i = 1; i < sharesArray.length; i++) {
+    const share = sharesArray[i];
+    if (share !== undefined && share.extraData !== firstExtraData) {
+      throw new Error(
+        `Mismatched extraData across shares: share[0]="${firstExtraData}" vs share[${i}]="${share.extraData}".`,
+      );
+    }
+  }
+
+  const extraData: BytesHex = ensure0x(firstExtraData);
+  assertIsKmsExtraData(extraData, {});
+
+  for (let i = 0; i < sharesArray.length; ++i) {
+    const s = sharesArray[i];
+    if (!s) {
+      throw new Error('Internal error');
+    }
+    const recoveredAddress = await cleartextEthereumModule.recoverAddress({
+      hash: ensure0x(s.payload),
+      signature: ensure0x(s.signature),
+    });
+    if (!metadata.kmsSignersContext.has(recoveredAddress)) {
+      throw new Error(
+        `Unknown KMS signer: recovered address ${recoveredAddress} from share[${i}] is not a registered KMS signer.`,
+      );
+    }
+  }
+
+  const decoded = cleartextEthereumModule.decode({
+    encodedData: ensure0x(firstShare.payload),
+    types: ['uint256[]', 'bytes'],
+  });
+
+  if (decoded.length !== 2) {
+    throw new Error('Invalid decrypted result.');
+  }
+
+  const maskedCleartexts = decoded[0] as bigint[];
+  const signedExtraData = decoded[1] as BytesHex;
+
+  const cleartexts: bigint[] = _xorUnmaskWithPublicKey(publicKeySecp256k1, maskedCleartexts);
+
+  if (extraData !== signedExtraData) {
+    throw new Error(
+      `extraData mismatch: share extraData="${extraData}" does not match the signed payload's extraData="${signedExtraData}".`,
+    );
+  }
+
+  // 2. Build an unforgeable structure that contains the decrypted FhevmHandles
+  const orderedClearValues: readonly ClearValue[] = cleartexts.map((plaintext: bigint, idx: number) => {
+    const fhevmHandle = metadata.handles[idx];
+    if (fhevmHandle === undefined) {
+      throw new Error('Internal error');
+    }
+    return createClearValue({
+      value: bigintToClearValueType(fhevmHandle.fheType, plaintext),
+      handle: fhevmHandle,
+      originToken: PRIVATE_CLEARTEXT_TKMS_LIB_TOKEN, // origin token for authenticity assertion
+    });
+  });
+  Object.freeze(orderedClearValues);
+
+  return orderedClearValues;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // generateTkmsPrivateKey
 //////////////////////////////////////////////////////////////////////////////
 
-export async function generateTkmsPrivateKey(_runtime: FhevmRuntime): Promise<GenerateTkmsPrivateKeyReturnType> {
-  throw new Error('Not yet implemented');
+export async function generateTkmsPrivateKey(runtime: FhevmRuntime): Promise<GenerateTkmsPrivateKeyReturnType> {
+  const cleartextEthereumModule = runtime.ethereum as CleartextEthereumModule;
+  const privateKeySecp256k1 = cleartextEthereumModule.generatePrivateKey();
+  return Promise.resolve(privateKeySecp256k1 as unknown as TkmsPrivateKey);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -41,10 +145,14 @@ export async function generateTkmsPrivateKey(_runtime: FhevmRuntime): Promise<Ge
 //////////////////////////////////////////////////////////////////////////////
 
 export async function getTkmsPublicKeyHex(
-  _runtime: FhevmRuntime,
-  _parameters: GetTkmsPublicKeyHexParameters,
+  runtime: FhevmRuntime,
+  parameters: GetTkmsPublicKeyHexParameters,
 ): Promise<GetTkmsPublicKeyHexReturnType> {
-  throw new Error('Not yet implemented');
+  const { tkmsPrivateKey } = parameters;
+  const privateKeySecp256k1 = asBytesHex(tkmsPrivateKey as unknown);
+  const cleartextEthereumModule = runtime.ethereum as CleartextEthereumModule;
+  const publicKeySecp256k1 = cleartextEthereumModule.getPublicKey({ privateKey: privateKeySecp256k1 });
+  return Promise.resolve(publicKeySecp256k1);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -53,9 +161,12 @@ export async function getTkmsPublicKeyHex(
 
 export async function serializeTkmsPrivateKey(
   _runtime: FhevmRuntime,
-  _parameters: SerializeTkmsPrivateKeyParameters,
+  parameters: SerializeTkmsPrivateKeyParameters,
 ): Promise<SerializeTkmsPrivateKeyReturnType> {
-  throw new Error('Not yet implemented');
+  const { tkmsPrivateKey } = parameters;
+  const privateKeySecp256k1 = asBytesHex(tkmsPrivateKey as unknown);
+  const privateKeySecp256k1Bytes = hexToBytes(privateKeySecp256k1);
+  return Promise.resolve(privateKeySecp256k1Bytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -64,9 +175,11 @@ export async function serializeTkmsPrivateKey(
 
 export async function deserializeTkmsPrivateKey(
   _runtime: FhevmRuntime,
-  _parameters: DeserializeTkmsPrivateKeyParameters,
+  parameters: DeserializeTkmsPrivateKeyParameters,
 ): Promise<DeserializeTkmsPrivateKeyReturnType> {
-  throw new Error('Not yet implemented');
+  const { tkmsPrivateKeyBytes } = parameters;
+  const privateKeySecp256k1 = bytesToHex(tkmsPrivateKeyBytes);
+  return Promise.resolve(privateKeySecp256k1 as unknown as TkmsPrivateKey);
 }
 
 //////////////////////////////////////////////////////////////////////////////

package/core/modules/encrypt/mock.ts

@@ -1,5 +1,18 @@
 /* eslint-disable @typescript-eslint/require-await */
+import { concatBytes, hexToBytes32 } from '../../base/bytes.js';
+import { remove0x } from '../../base/string.js';
+import { typedValueToBytes32Hex } from '../../base/typedValue.js';
 import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type {
+  FheEncryptionCrs,
+  FheEncryptionCrsBrand,
+  FheEncryptionCrsBytes,
+  FheEncryptionKeyBytes,
+  FheEncryptionPublicKey,
+  FheEncryptionPublicKeyBrand,
+  FheEncryptionPublicKeyBytes,
+} from '../../types/fheEncryptionKey.js';
+import type { Bytes, BytesHex, UintNumber } from '../../types/primitives.js';
 import type {
   BuildWithProofPackedReturnTypeParameters,
   BuildWithProofPackedReturnType,
@@ -18,6 +31,83 @@ import type {
   DeserializeFheEncryptionCrsReturnType,
 } from './types.js';
 
+////////////////////////////////////////////////////////////////////////////////
+
+const GET_NATIVE_FUNC = Symbol('CleartextTFHELib.getNative');
+const PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN = Symbol('CleartextTFHELib.token');
+
+////////////////////////////////////////////////////////////////////////////////
+// TfheCompactPublicKeyImpl
+////////////////////////////////////////////////////////////////////////////////
+
+class CleartextTfheCompactPublicKeyImpl implements FheEncryptionPublicKey {
+  declare readonly [FheEncryptionPublicKeyBrand]: never;
+
+  readonly #id: string;
+  readonly #tfheCompactPublicKeyWasmType: Bytes;
+
+  constructor(token: symbol, id: string, publicEncKeyMlKem512Wasm: Bytes) {
+    if (token !== PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN) {
+      throw new Error('Unauthorized');
+    }
+    this.#id = id;
+    this.#tfheCompactPublicKeyWasmType = publicEncKeyMlKem512Wasm;
+  }
+
+  public get id(): string {
+    return this.#id;
+  }
+
+  public static [GET_NATIVE_FUNC](key: unknown, token: symbol): Bytes {
+    if (token !== PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN) {
+      throw new Error('Unauthorized');
+    }
+    if (!(key instanceof CleartextTfheCompactPublicKeyImpl)) {
+      throw new Error('Unauthorized');
+    }
+    return key.#tfheCompactPublicKeyWasmType;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TfheCompactPkeCrsImpl
+////////////////////////////////////////////////////////////////////////////////
+
+class CleartextTfheCompactPkeCrsImpl implements FheEncryptionCrs {
+  declare readonly [FheEncryptionCrsBrand]: never;
+
+  readonly #id: string;
+  readonly #capacity: UintNumber;
+  readonly #compactPublicKeyWasmType: Bytes;
+
+  constructor(token: symbol, id: string, capacity: UintNumber, compactPublicKeyWasmType: Bytes) {
+    if (token !== PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN) {
+      throw new Error('Unauthorized');
+    }
+    this.#id = id;
+    this.#capacity = capacity;
+    this.#compactPublicKeyWasmType = compactPublicKeyWasmType;
+  }
+
+  public get id(): string {
+    return this.#id;
+  }
+
+  public get capacity(): UintNumber {
+    return this.#capacity;
+  }
+
+  public static [GET_NATIVE_FUNC](key: unknown, token: symbol): Bytes {
+    if (token !== PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN) {
+      throw new Error('Unauthorized');
+    }
+    if (!(key instanceof CleartextTfheCompactPkeCrsImpl)) {
+      throw new Error('Unauthorized');
+    }
+    return key.#compactPublicKeyWasmType;
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // parseTFHEProvenCompactCiphertextList
 ////////////////////////////////////////////////////////////////////////////////
@@ -33,9 +123,36 @@ export async function parseTFHEProvenCompactCiphertextList(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function buildWithProofPacked(
-  _parameters: BuildWithProofPackedReturnTypeParameters,
+  parameters: BuildWithProofPackedReturnTypeParameters,
 ): Promise<BuildWithProofPackedReturnType> {
-  throw new Error('Not yet implemented');
+  const { fheEncryptionKey: publicEncryptionParams, metaData, typedValues, extraData } = parameters;
+
+  const tfheCompactPublicKeyImpl = publicEncryptionParams.publicKey;
+  const tfheCompactPkeCrsImpl = publicEncryptionParams.crs;
+
+  if (!(tfheCompactPublicKeyImpl instanceof CleartextTfheCompactPublicKeyImpl)) {
+    throw new Error('Invalid tfhePublicKey');
+  }
+  if (!(tfheCompactPkeCrsImpl instanceof CleartextTfheCompactPkeCrsImpl)) {
+    throw new Error('Invalid tfheCrs');
+  }
+
+  const typedValuesBytes32HexNo0x = typedValues.map(typedValueToBytes32Hex).map(remove0x).join('');
+  const cleartextExtraData = `0x${typedValuesBytes32HexNo0x}${remove0x(extraData)}` as BytesHex;
+
+  // Per typedValue: random nonce (8 bytes) || metaData || value bytes (32).
+  const perValueBlobs = typedValues.map((tv) => {
+    const nonce = crypto.getRandomValues(new Uint8Array(new ArrayBuffer(8)));
+    const valueBytes = hexToBytes32(typedValueToBytes32Hex(tv));
+    return concatBytes(nonce, metaData, valueBytes);
+  });
+
+  const ciphertextWithZKProofBytes = concatBytes(...perValueBlobs);
+
+  return {
+    ciphertextWithZKProofBytes,
+    extraData: cleartextExtraData,
+  };
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -43,9 +160,40 @@ export async function buildWithProofPacked(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function serializeFheEncryptionKey(
-  _parameters: SerializeFheEncryptionKeyParameters,
+  parameters: SerializeFheEncryptionKeyParameters,
 ): Promise<SerializeFheEncryptionKeyReturnType> {
-  throw new Error('Not yet implemented');
+  const { fheEncryptionKey: publicEncryptionParams } = parameters;
+
+  const tfheCompactPublicKeyImpl = publicEncryptionParams.publicKey;
+  const tfheCompactPkeCrsImpl = publicEncryptionParams.crs;
+
+  if (!(tfheCompactPublicKeyImpl instanceof CleartextTfheCompactPublicKeyImpl)) {
+    throw new Error('Invalid tfhePublicKey');
+  }
+  if (!(tfheCompactPkeCrsImpl instanceof CleartextTfheCompactPkeCrsImpl)) {
+    throw new Error('Invalid tfheCrs');
+  }
+
+  const tfhePublicKeyBytes: Bytes = CleartextTfheCompactPublicKeyImpl[GET_NATIVE_FUNC](
+    tfheCompactPublicKeyImpl,
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+  );
+  const tfheCrsBytes: Bytes = CleartextTfheCompactPkeCrsImpl[GET_NATIVE_FUNC](
+    tfheCompactPkeCrsImpl,
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+  );
+
+  return Object.freeze({
+    publicKeyBytes: Object.freeze({
+      id: publicEncryptionParams.publicKey.id,
+      bytes: tfhePublicKeyBytes,
+    }),
+    crsBytes: Object.freeze({
+      id: publicEncryptionParams.crs.id,
+      capacity: publicEncryptionParams.crs.capacity,
+      bytes: tfheCrsBytes,
+    }),
+  }) as FheEncryptionKeyBytes;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -53,9 +201,25 @@ export async function serializeFheEncryptionKey(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function serializeFheEncryptionPublicKey(
-  _parameters: SerializeFheEncryptionPublicKeyParameters,
+  parameters: SerializeFheEncryptionPublicKeyParameters,
 ): Promise<SerializeFheEncryptionPublicKeyReturnType> {
-  throw new Error('Not yet implemented');
+  const { publicKey: tfhePublicKey } = parameters;
+
+  const tfheCompactPublicKeyImpl = tfhePublicKey;
+
+  if (!(tfheCompactPublicKeyImpl instanceof CleartextTfheCompactPublicKeyImpl)) {
+    throw new Error('Invalid tfhePublicKey');
+  }
+
+  const tfhePublicKeyBytes: Bytes = CleartextTfheCompactPublicKeyImpl[GET_NATIVE_FUNC](
+    tfheCompactPublicKeyImpl,
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+  );
+
+  return Object.freeze({
+    id: tfhePublicKey.id,
+    bytes: tfhePublicKeyBytes,
+  }) as FheEncryptionPublicKeyBytes;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -63,9 +227,26 @@ export async function serializeFheEncryptionPublicKey(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function serializeFheEncryptionCrs(
-  _parameters: SerializeFheEncryptionCrsParameters,
+  parameters: SerializeFheEncryptionCrsParameters,
 ): Promise<SerializeFheEncryptionCrsReturnType> {
-  throw new Error('Not yet implemented');
+  const { crs: tfheCrs } = parameters;
+
+  const tfheCompactPkeCrsImpl = tfheCrs;
+
+  if (!(tfheCompactPkeCrsImpl instanceof CleartextTfheCompactPkeCrsImpl)) {
+    throw new Error('Invalid tfheCrs');
+  }
+
+  const tfheCrsBytes: Bytes = CleartextTfheCompactPkeCrsImpl[GET_NATIVE_FUNC](
+    tfheCompactPkeCrsImpl,
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+  );
+
+  return Object.freeze({
+    id: tfheCrs.id,
+    capacity: tfheCrs.capacity,
+    bytes: tfheCrsBytes,
+  }) as FheEncryptionCrsBytes;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -73,9 +254,16 @@ export async function serializeFheEncryptionCrs(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function deserializeFheEncryptionCrs(
-  _parameters: DeserializeFheEncryptionCrsParameters,
+  parameters: DeserializeFheEncryptionCrsParameters,
 ): Promise<DeserializeFheEncryptionCrsReturnType> {
-  throw new Error('Not yet implemented');
+  const { crsBytes: globalFheCrsBytes } = parameters;
+
+  return new CleartextTfheCompactPkeCrsImpl(
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+    globalFheCrsBytes.id,
+    globalFheCrsBytes.capacity,
+    globalFheCrsBytes.bytes,
+  );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -83,9 +271,15 @@ export async function deserializeFheEncryptionCrs(
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function deserializeFheEncryptionPublicKey(
-  _parameters: DeserializeFheEncryptionPublicKeyParameters,
+  parameters: DeserializeFheEncryptionPublicKeyParameters,
 ): Promise<DeserializeFheEncryptionPublicKeyReturnType> {
-  throw new Error('Not yet implemented');
+  const { publicKeyBytes: globalFhePublicKeyBytes } = parameters;
+
+  return new CleartextTfheCompactPublicKeyImpl(
+    PRIVATE_CLEARTEXT_TFHE_LIB_TOKEN,
+    globalFhePublicKeyBytes.id,
+    globalFhePublicKeyBytes.bytes,
+  );
 }
 
 ////////////////////////////////////////////////////////////////////////////////

package/core/modules/encrypt/module/api-p.ts

@@ -40,6 +40,7 @@ import { encryptionBitsFromFheTypeId, isFheTypeId } from '../../../handle/FheTyp
 import { EncryptionError } from '../../../errors/EncryptionError.js';
 import { getErrorMessage } from '../../../base/errors/utils.js';
 import { initTfheModule } from './init-p.js';
+import { assertIsTypedValue } from '../../../base/typedValue.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -198,7 +199,7 @@ export async function buildWithProofPacked(
 ): Promise<BuildWithProofPackedReturnType> {
   await initTfheModule(runtime);
 
-  const { fheEncryptionKey: publicEncryptionParams, metaData, typedValues } = parameters;
+  const { fheEncryptionKey: publicEncryptionParams, metaData, typedValues, extraData } = parameters;
 
   const tfheCompactPublicKeyImpl = publicEncryptionParams.publicKey;
   const tfheCompactPkeCrsImpl = publicEncryptionParams.crs;
@@ -228,6 +229,7 @@ export async function buildWithProofPacked(
     fheCompactCiphertextListBuilderWasm = CompactCiphertextList.builder(tfheCompactPublicKeyWasm);
 
     for (const typedValue of typedValues) {
+      assertIsTypedValue(typedValue, {});
       switch (typedValue.type) {
         case 'uint8':
           fheCompactCiphertextListBuilderWasm.push_u8(typedValue.value);
@@ -264,7 +266,10 @@ export async function buildWithProofPacked(
 
     ciphertextWithZKProofBytes = tfheProvenCompactCiphertextList.safe_serialize(SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
 
-    return ciphertextWithZKProofBytes;
+    return Object.freeze({
+      ciphertextWithZKProofBytes,
+      extraData,
+    });
   } finally {
     try {
       if (tfheProvenCompactCiphertextList !== undefined) {

package/core/modules/encrypt/types.ts

@@ -1,4 +1,4 @@
-import type { TypedValue } from '../../types/primitives.js';
+import type { BytesHex, TypedValue } from '../../types/primitives.js';
 import type { EncryptionBits, FheTypeId } from '../../types/fheType.js';
 import type {
   FheEncryptionCrs,
@@ -112,9 +112,13 @@ export type BuildWithProofPackedReturnTypeParameters = {
   readonly fheEncryptionKey: FheEncryptionKeyWasm;
   readonly typedValues: TypedValue[];
   readonly metaData: Uint8Array;
+  readonly extraData: BytesHex;
 };
 
-export type BuildWithProofPackedReturnType = Uint8Array;
+export type BuildWithProofPackedReturnType = {
+  readonly ciphertextWithZKProofBytes: Uint8Array;
+  readonly extraData: BytesHex;
+};
 
 export type BuildWithProofPackedModuleFunction = {
   buildWithProofPacked(parameters: BuildWithProofPackedReturnTypeParameters): Promise<BuildWithProofPackedReturnType>;