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

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

package/core/modules/ethereum/types-ct.ts

@@ -0,0 +1,89 @@
+import type { Bytes65Hex, BytesHex, ChecksummedAddress } from '../../types/primitives.js';
+import type { Prettify } from '../../types/utils.js';
+import type { EthereumModule } from './types.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// mnemonicToAccount
+////////////////////////////////////////////////////////////////////////////////
+
+export type MnemonicToAccountParameters = Readonly<{
+  mnemonic: string;
+  path: `m/44'/60'/${string}`;
+}>;
+
+export type MnemonicToAccountReturnType = { readonly privateKey: BytesHex; readonly address: ChecksummedAddress };
+
+export type MnemonicToAccountModuleFunction = {
+  mnemonicToAccount(parameters: MnemonicToAccountParameters): MnemonicToAccountReturnType;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// sign
+////////////////////////////////////////////////////////////////////////////////
+
+export type SignParameters = Readonly<{
+  hash: BytesHex;
+  privateKey: BytesHex;
+}>;
+
+export type SignReturnType = Bytes65Hex;
+
+export type SignModuleFunction = {
+  sign(parameters: SignParameters): Promise<SignReturnType>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// generatePrivateKey
+////////////////////////////////////////////////////////////////////////////////
+
+export type GeneratePrivateKeyReturnType = BytesHex;
+
+export type GeneratePrivateKeyModuleFunction = {
+  generatePrivateKey(): GeneratePrivateKeyReturnType;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// getPublicKey
+////////////////////////////////////////////////////////////////////////////////
+
+export type GetPublicKeyParameters = Readonly<{
+  privateKey: BytesHex;
+}>;
+
+export type GetPublicKeyReturnType = BytesHex;
+
+export type GetPublicKeyModuleFunction = {
+  getPublicKey(parameters: GetPublicKeyParameters): GetPublicKeyReturnType;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// recoverAddress
+////////////////////////////////////////////////////////////////////////////////
+
+export type RecoverAddressParameters = Readonly<{
+  hash: BytesHex;
+  signature: Bytes65Hex;
+}>;
+
+export type RecoverAddressReturnType = ChecksummedAddress;
+
+export type RecoverAddressModuleFunction = {
+  recoverAddress(parameters: RecoverAddressParameters): Promise<RecoverAddressReturnType>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// cleartextEthereumModule
+////////////////////////////////////////////////////////////////////////////////
+
+export type CleartextEthereumModule = EthereumModule &
+  Prettify<
+    MnemonicToAccountModuleFunction &
+      SignModuleFunction &
+      GeneratePrivateKeyModuleFunction &
+      GetPublicKeyModuleFunction &
+      RecoverAddressModuleFunction
+  >;
+
+export type CleartextEthereumModuleFactory = () => {
+  readonly ethereum: CleartextEthereumModule;
+};

package/core/modules/relayer/cleartext/fetchCoprocessorSignatures.ts

@@ -0,0 +1,94 @@
+import type { Bytes65Hex, BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
+import type {
+  FetchCoprocessorSignaturesParameters,
+  FetchCoprocessorSignaturesReturnType,
+  RelayerClientWithRuntime,
+} from '../types.js';
+import { asUint32BigInt, randomUniqueUints } from '../../../base/uint.js';
+import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
+import { getCoprocessorSignersPrivateKeyMap } from './signers.js';
+
+/*
+export type FetchCoprocessorSignaturesReturnType = {
+  readonly handles: readonly InputHandle[];
+  readonly coprocessorEip712Signatures: readonly Bytes65Hex[];
+  readonly extraData: BytesHex;
+};
+
+*/
+const inputProofAbi = [
+  {
+    type: 'function',
+    name: 'inputProof',
+    inputs: [
+      {
+        name: 'ctHandles',
+        type: 'bytes32[]',
+        internalType: 'bytes32[]',
+      },
+      { name: 'userAddress', type: 'address', internalType: 'address' },
+      {
+        name: 'contractAddress',
+        type: 'address',
+        internalType: 'address',
+      },
+      { name: 'extraData', type: 'bytes', internalType: 'bytes' },
+    ],
+    outputs: [
+      { name: 'digest', type: 'bytes32', internalType: 'bytes32' },
+      { name: 'signers', type: 'address[]', internalType: 'address[]' },
+      { name: 'threshold', type: 'uint256', internalType: 'uint256' },
+    ],
+    stateMutability: 'view',
+  },
+] as const;
+
+export async function fetchCoprocessorSignatures(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchCoprocessorSignaturesParameters,
+): Promise<FetchCoprocessorSignaturesReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { payload } = parameters;
+
+  const trustedClient = getTrustedClient(relayerClient);
+  const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
+    abi: inputProofAbi,
+    address: relayerClient.chain.fhevm.contracts.inputVerifier.address as ChecksummedAddress,
+    args: [
+      payload.zkProof.getInputHandles().map((h) => h.bytes32Hex),
+      payload.zkProof.userAddress,
+      payload.zkProof.contractAddress,
+      payload.zkProof.getExtraData(),
+    ],
+    functionName: inputProofAbi[0].name,
+  })) as unknown[];
+
+  const digest = res[0] as BytesHex;
+  const signersAddress = res[1] as ChecksummedAddress[];
+  const threshold = asUint32BigInt(res[2]);
+  const signers = getCoprocessorSignersPrivateKeyMap(relayerClient);
+
+  const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (i) => signersAddress[i]!,
+  );
+
+  const coprocessorEip712Signatures: Bytes65Hex[] = [];
+
+  for (const signerAddress of randomSignersAddress) {
+    const privateKey = signers.get(signerAddress);
+    if (privateKey === undefined) {
+      throw new Error(`Unable to find KMS signer for address ${signerAddress}`);
+    }
+
+    const signature = await cleartextEthereumModule.sign({ hash: digest, privateKey });
+    coprocessorEip712Signatures.push(signature);
+  }
+
+  return Promise.resolve({
+    extraData: payload.zkProof.getExtraData(),
+    handles: payload.zkProof.getInputHandles(),
+    coprocessorEip712Signatures,
+  });
+}