@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/coprocessor/ZkProofBuilder-p.ts

@@ -0,0 +1,295 @@
+import type { Bytes20, Bytes32, ChecksummedAddress, UintNumber } from '../types/primitives.js';
+import type { ZkProof } from '../types/zkProof-p.js';
+import type { EncryptionBits, FheType } from '../types/fheType.js';
+import type { ZkProofBuilder } from '../types/zkProofBuilder.js';
+import type { WithEncrypt } from '../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../types/fhevmChain.js';
+import type {
+  TypedValue,
+  Uint32ValueLike,
+  Uint64ValueLike,
+  Uint128ValueLike,
+  Uint256ValueLike,
+  Uint8ValueLike,
+  Uint16ValueLike,
+  BoolValueLike,
+  AddressValueLike,
+} from '../types/primitives.js';
+import { assert } from '../base/errors/InternalError.js';
+import { isUint64, uint256ToBytes32 } from '../base/uint.js';
+import { isAddress } from '../base/address.js';
+import { hexToBytes20 } from '../base/bytes.js';
+import { ZkProofError } from '../errors/ZkProofError.js';
+import { createTypedValue, TypedValueArrayBuilder } from '../base/typedValue.js';
+import { toZkProof } from './ZkProof-p.js';
+import { encryptionBitsFromFheType, fheTypeNameFromTypeName } from '../handle/FheType.js';
+import { fetchFheEncryptionKeyWasm } from '../key/fetchFheEncryptionKey.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly chain: FhevmChain;
+  readonly runtime: WithEncrypt;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+const PRIVATE_TOKEN = Symbol('ZkProofBuilder.token');
+
+////////////////////////////////////////////////////////////////////////////////
+
+export const TFHE_CRS_BITS_CAPACITY = 2048 as UintNumber;
+export const TFHE_ZKPROOF_CIPHERTEXT_CAPACITY = 256 as UintNumber;
+
+////////////////////////////////////////////////////////////////////////////////
+// ZkProofBuilder
+////////////////////////////////////////////////////////////////////////////////
+
+class ZkProofBuilderImpl implements ZkProofBuilder {
+  #totalBits: number = 0;
+  readonly #bits: EncryptionBits[] = [];
+  readonly #bitsCapacity: UintNumber;
+  readonly #ciphertextCapacity: UintNumber;
+  readonly #builder = new TypedValueArrayBuilder();
+
+  constructor(
+    privateToken: symbol,
+    parameters: {
+      readonly ciphertextCapacity: UintNumber;
+      readonly bitsCapacity: UintNumber;
+    },
+  ) {
+    if (privateToken !== PRIVATE_TOKEN) {
+      throw new Error('Unauthorized');
+    }
+
+    this.#bitsCapacity = parameters.bitsCapacity;
+    this.#ciphertextCapacity = parameters.ciphertextCapacity;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Public API
+  //////////////////////////////////////////////////////////////////////////////
+
+  public get count(): number {
+    return this.#bits.length;
+  }
+
+  public get totalBits(): number {
+    return this.#totalBits;
+  }
+
+  public getBits(): EncryptionBits[] {
+    return [...this.#bits];
+  }
+
+  public addTypedValue(typedValue: TypedValue): this {
+    this.#builder.addTypedValue(typedValue);
+    this.#addType(fheTypeNameFromTypeName(typedValue.type));
+    return this;
+  }
+
+  public addBool(value: boolean | number | bigint | BoolValueLike): this {
+    this.#builder.addBool(value);
+    this.#addType(fheTypeNameFromTypeName('bool'));
+    return this;
+  }
+
+  public addUint8(value: number | bigint | Uint8ValueLike): this {
+    this.#builder.addUint8(value);
+    this.#addType(fheTypeNameFromTypeName('uint8'));
+    return this;
+  }
+
+  public addUint16(value: number | bigint | Uint16ValueLike): this {
+    this.#builder.addUint16(value);
+    this.#addType(fheTypeNameFromTypeName('uint16'));
+    return this;
+  }
+
+  public addUint32(value: number | bigint | Uint32ValueLike): this {
+    this.#builder.addUint32(value);
+    this.#addType(fheTypeNameFromTypeName('uint32'));
+    return this;
+  }
+
+  public addUint64(value: number | bigint | Uint64ValueLike): this {
+    this.#builder.addUint64(value);
+    this.#addType(fheTypeNameFromTypeName('uint64'));
+    return this;
+  }
+
+  public addUint128(value: number | bigint | Uint128ValueLike): this {
+    this.#builder.addUint128(value);
+    this.#addType(fheTypeNameFromTypeName('uint128'));
+    return this;
+  }
+
+  public addUint256(value: number | bigint | Uint256ValueLike): this {
+    this.#builder.addUint256(value);
+    this.#addType(fheTypeNameFromTypeName('uint256'));
+    return this;
+  }
+
+  public addAddress(value: string | AddressValueLike): this {
+    this.#builder.addAddress(value);
+    this.#addType(fheTypeNameFromTypeName('address'));
+    return this;
+  }
+
+  public async build(
+    context: Context,
+    {
+      contractAddress,
+      userAddress,
+    }: {
+      readonly contractAddress: string;
+      readonly userAddress: string;
+    },
+  ): Promise<ZkProof> {
+    // Fetch the FheEncryptionKey (in wasm format) from the global cache.
+    const fheEncryptionKeyWasm = await fetchFheEncryptionKeyWasm(context);
+
+    if (this.#totalBits === 0) {
+      throw new ZkProofError({
+        message: `Encrypted input must contain at least one value`,
+      });
+    }
+
+    // should be guaranteed at this point
+    assert(this.#totalBits <= this.#bitsCapacity);
+
+    if (!isAddress(contractAddress)) {
+      throw new ZkProofError({
+        message: `Invalid contract address: ${contractAddress}`,
+      });
+    }
+    if (!isAddress(userAddress)) {
+      throw new ZkProofError({
+        message: `Invalid user address: ${userAddress}`,
+      });
+    }
+
+    const aclContractAddress = context.chain.fhevm.contracts.acl.address;
+    const chainId = context.chain.id;
+
+    if (!isAddress(aclContractAddress)) {
+      throw new ZkProofError({
+        message: `Invalid ACL address: ${aclContractAddress}`,
+      });
+    }
+    if (!isUint64(chainId)) {
+      throw new ZkProofError({
+        message: `Invalid chain ID uint64: ${chainId}`,
+      });
+    }
+
+    // Note about hexToBytes(<address>)
+    // ================================
+    // All addresses are 42 characters long strings.
+    // hexToBytes(<42-characters hex string>) always returns a 20-byte long Uint8Array
+
+    // Bytes20
+    const contractAddressBytes20: Bytes20 = hexToBytes20(contractAddress);
+
+    // Bytes20
+    const userAddressBytes20: Bytes20 = hexToBytes20(userAddress);
+
+    // Bytes20
+    const aclContractAddressBytes20: Bytes20 = hexToBytes20(aclContractAddress);
+
+    // Bytes32
+    const chainIdBytes32: Bytes32 = uint256ToBytes32(chainId);
+
+    const metaDataLength = 3 * 20 + 32;
+    const metaData = new Uint8Array(metaDataLength);
+
+    metaData.set(contractAddressBytes20, 0);
+    metaData.set(userAddressBytes20, 20);
+    metaData.set(aclContractAddressBytes20, 40);
+    metaData.set(chainIdBytes32, 60);
+
+    assert(metaData.length - chainIdBytes32.length === 60);
+
+    const ciphertextWithZKProofBytes: Uint8Array = await context.runtime.encrypt.buildWithProofPacked({
+      typedValues: [...this.#builder.build()],
+      fheEncryptionKey: fheEncryptionKeyWasm,
+      metaData,
+    });
+
+    return toZkProof(
+      {
+        chainId: BigInt(chainId),
+        aclContractAddress,
+        contractAddress,
+        userAddress,
+        ciphertextWithZkProof: ciphertextWithZKProofBytes,
+        encryptionBits: this.#bits,
+      },
+      { copy: false }, // Take ownership
+    );
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Private helpers
+  //////////////////////////////////////////////////////////////////////////////
+
+  #checkLimit(encryptionBits: EncryptionBits): void {
+    if (this.#totalBits + encryptionBits > this.#bitsCapacity) {
+      throw new ZkProofError({
+        message: `Packing more than ${this.#bitsCapacity.toString()} bits in a single input ciphertext is unsupported`,
+      });
+    }
+    if (this.#bits.length >= this.#ciphertextCapacity) {
+      throw new ZkProofError({
+        message: `Packing more than ${this.#ciphertextCapacity.toString()} variables in a single input ciphertext is unsupported`,
+      });
+    }
+  }
+
+  #addType(fheTypeName: FheType): void {
+    // encryptionBits is guaranteed to be >= 2
+    const encryptionBits = encryptionBitsFromFheType(fheTypeName);
+    this.#checkLimit(encryptionBits);
+    this.#totalBits += encryptionBits;
+    this.#bits.push(encryptionBits);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+export function createZkProofBuilder(): ZkProofBuilder {
+  return new ZkProofBuilderImpl(PRIVATE_TOKEN, {
+    ciphertextCapacity: TFHE_ZKPROOF_CIPHERTEXT_CAPACITY,
+    bitsCapacity: TFHE_CRS_BITS_CAPACITY,
+  });
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+export async function createZkProof(
+  context: Context,
+  parameters: {
+    readonly values: readonly TypedValue[];
+    readonly contractAddress: ChecksummedAddress;
+    readonly userAddress: ChecksummedAddress;
+  },
+): Promise<ZkProof> {
+  const { contractAddress, userAddress, values } = parameters;
+
+  const builder = new ZkProofBuilderImpl(PRIVATE_TOKEN, {
+    ciphertextCapacity: TFHE_ZKPROOF_CIPHERTEXT_CAPACITY,
+    bitsCapacity: TFHE_CRS_BITS_CAPACITY,
+  });
+
+  for (const value of values) {
+    builder.addTypedValue(createTypedValue(value));
+  }
+
+  const zkProof = await builder.build(context, {
+    contractAddress,
+    userAddress,
+  });
+
+  return zkProof;
+}

package/core/coprocessor/assertIsCoprocessorEip712Domain.ts

@@ -0,0 +1,23 @@
+import type { ErrorMetadataParams } from '../base/errors/ErrorBase.js';
+import type { CoprocessorEip712Domain } from '../types/coprocessor.js';
+import { assertRecordChecksummedAddressProperty } from '../base/address.js';
+import { assertRecordStringProperty } from '../base/string.js';
+import { assertRecordUintBigIntProperty } from '../base/uint.js';
+
+export function assertIsCoprocessorEip712Domain(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is CoprocessorEip712Domain {
+  type T = CoprocessorEip712Domain;
+  assertRecordStringProperty(value, 'name' satisfies keyof T, name, {
+    expectedValue: 'InputVerification' satisfies T['name'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'version' satisfies keyof T, name, {
+    expectedValue: '1' satisfies T['version'],
+    ...options,
+  });
+  assertRecordUintBigIntProperty(value, 'chainId' satisfies keyof T, name, options);
+  assertRecordChecksummedAddressProperty(value, 'verifyingContract' satisfies keyof T, name, options);
+}

package/core/coprocessor/coprocessorEip712Types.ts

@@ -0,0 +1,39 @@
+import type { CoprocessorEip712Types } from '../types/coprocessor.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// CoprocessorEip712Types
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    const EIP712DomainType = [
+      { name: 'name', type: 'string' },
+      { name: 'version', type: 'string' },
+      { name: 'chainId', type: 'uint256' },
+      { name: 'verifyingContract', type: 'address' },
+    ];
+*/
+
+export const coprocessorEip712PrimaryType = 'CiphertextVerification' satisfies keyof CoprocessorEip712Types;
+
+export const coprocessorEip712Types: CoprocessorEip712Types = {
+  // EIP712Domain: [
+  //   { name: 'name', type: 'string' },
+  //   { name: 'version', type: 'string' },
+  //   { name: 'chainId', type: 'uint256' },
+  //   { name: 'verifyingContract', type: 'address' },
+  // ] as const,
+  // CRITICAL: Field order is authoritative — it determines the EIP-712 type hash.
+  // Changing the order will produce a different signature and break on-chain verification.
+  // Must match the Solidity struct definition exactly.
+  CiphertextVerification: [
+    { name: 'ctHandles', type: 'bytes32[]' },
+    { name: 'userAddress', type: 'address' },
+    { name: 'contractAddress', type: 'address' },
+    { name: 'contractChainId', type: 'uint256' },
+    { name: 'extraData', type: 'bytes' },
+  ],
+} as const;
+
+Object.freeze(coprocessorEip712Types);
+Object.freeze(coprocessorEip712Types.CiphertextVerification);
+coprocessorEip712Types.CiphertextVerification.forEach(Object.freeze);

package/core/coprocessor/createCoprocessorEip712.ts

@@ -0,0 +1,69 @@
+import type { Uint64BigInt } from '../types/primitives.js';
+import type { CoprocessorEip712 } from '../types/coprocessor.js';
+import type { InputHandle } from '../types/encryptedTypes-p.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../base/address.js';
+import { assertIsUint64 } from '../base/uint.js';
+import { assertIsBytesHex } from '../base/bytes.js';
+import { coprocessorEip712Types } from './coprocessorEip712Types.js';
+import { createCoprocessorEip712Domain } from './createCoprocessorEip712Domain.js';
+import { assertIsInputHandle } from '../handle/FhevmHandle.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type CreateCoprocessorEip712Parameters = {
+  readonly gatewayChainId: number | bigint;
+  readonly verifyingContractAddressInputVerification: string;
+  readonly inputHandles: readonly InputHandle[];
+  readonly contractChainId: number | bigint;
+  readonly contractAddress: string;
+  readonly userAddress: string;
+  readonly extraData: string;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// createCoprocessorEip712
+////////////////////////////////////////////////////////////////////////////////
+
+export function createCoprocessorEip712({
+  gatewayChainId,
+  verifyingContractAddressInputVerification,
+  inputHandles,
+  contractChainId,
+  contractAddress,
+  userAddress,
+  extraData,
+}: CreateCoprocessorEip712Parameters): CoprocessorEip712 {
+  assertIsAddress(userAddress, {});
+  assertIsAddress(contractAddress, {});
+  assertIsUint64(contractChainId, {});
+  assertIsBytesHex(extraData, {});
+
+  const domain = createCoprocessorEip712Domain({
+    gatewayChainId,
+    verifyingContractAddressInputVerification,
+  });
+
+  const eip712 = {
+    domain,
+    types: coprocessorEip712Types,
+    message: {
+      ctHandles: inputHandles.map((inputHandle) => {
+        assertIsInputHandle(inputHandle, {});
+        return inputHandle.bytes32Hex;
+      }),
+      userAddress: addressToChecksummedAddress(userAddress),
+      contractAddress: addressToChecksummedAddress(contractAddress),
+      contractChainId: BigInt(contractChainId) as Uint64BigInt,
+      extraData,
+    },
+  };
+
+  Object.freeze(eip712);
+  Object.freeze(eip712.domain);
+  Object.freeze(eip712.types);
+  Object.freeze(eip712.types.CiphertextVerification);
+  Object.freeze(eip712.message);
+  Object.freeze(eip712.message.ctHandles);
+
+  return eip712;
+}

package/core/coprocessor/createCoprocessorEip712Domain.ts

@@ -0,0 +1,25 @@
+import type { CoprocessorEip712Domain } from '../types/coprocessor.js';
+import type { Uint64BigInt } from '../types/primitives.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../base/address.js';
+import { assertIsUint64 } from '../base/uint.js';
+
+export function createCoprocessorEip712Domain({
+  gatewayChainId,
+  verifyingContractAddressInputVerification,
+}: {
+  readonly gatewayChainId: number | bigint;
+  readonly verifyingContractAddressInputVerification: string;
+}): CoprocessorEip712Domain {
+  assertIsUint64(gatewayChainId, {});
+  assertIsAddress(verifyingContractAddressInputVerification, {});
+
+  const domain = {
+    name: 'InputVerification',
+    version: '1',
+    chainId: BigInt(gatewayChainId) as Uint64BigInt,
+    verifyingContract: addressToChecksummedAddress(verifyingContractAddressInputVerification),
+  } as const;
+  Object.freeze(domain);
+
+  return domain;
+}

package/core/coprocessor/encrypt.ts

@@ -0,0 +1,48 @@
+import type { WithEncrypt } from '../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../types/fhevmChain.js';
+import type { BytesHex, ChecksummedAddress, TypedValue } from '../types/primitives.js';
+import type { RelayerInputProofOptions } from '../types/relayer.js';
+import type { InputHandle } from '../types/encryptedTypes-p.js';
+import { asBytesHex } from '../base/bytes.js';
+import { fetchVerifiedInputProof } from './fetchVerifiedInputProof.js';
+import { createZkProof } from './ZkProofBuilder-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly chain: FhevmChain;
+  readonly runtime: WithEncrypt;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly contractAddress: ChecksummedAddress;
+  readonly userAddress: ChecksummedAddress;
+  readonly values: readonly TypedValue[];
+  readonly options?: RelayerInputProofOptions | undefined;
+};
+
+type ReturnType = {
+  readonly inputHandles: readonly InputHandle[];
+  readonly inputProof: BytesHex;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function encrypt(context: Context, parameters: Parameters): Promise<ReturnType> {
+  const hardCodedExtraData = '0x00' as BytesHex;
+
+  const zkProof = await createZkProof(context, parameters);
+
+  const inputProof = await fetchVerifiedInputProof(context, {
+    zkProof,
+    extraData: asBytesHex(hardCodedExtraData),
+    options: parameters.options,
+  });
+
+  return {
+    inputHandles: inputProof.inputHandles,
+    inputProof: inputProof.bytesHex,
+  };
+}

package/core/coprocessor/fetchVerifiedInputProof.ts

@@ -0,0 +1,84 @@
+import type { RelayerInputProofOptions } from '../types/relayer.js';
+import type { FhevmChain } from '../types/fhevmChain.js';
+import type { VerifiedInputProof } from '../types/inputProof.js';
+import type { BytesHex } from '../types/primitives.js';
+import type { ZkProof } from '../types/zkProof-p.js';
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import type { InputHandle } from '../types/encryptedTypes-p.js';
+import { InputProofError } from '../errors/InputProofError.js';
+import { assertHandleArrayEquals } from '../handle/FhevmHandle.js';
+import { createInputProofFromInputHandles } from './InputProof-p.js';
+import { verifyInputProof } from './verifyInputProof.js';
+import { assertIsZkProof } from './ZkProof-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly chain: FhevmChain;
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly zkProof: ZkProof;
+  readonly extraData: BytesHex;
+  readonly options?: RelayerInputProofOptions | undefined;
+};
+
+type ReturnType = VerifiedInputProof;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchVerifiedInputProof(context: Context, parameters: Parameters): Promise<ReturnType> {
+  const { zkProof, extraData, options } = parameters;
+
+  assertIsZkProof(zkProof, {});
+
+  // Caller-provided options override runtime config defaults (e.g. auth)
+  const relayerOptions: RelayerInputProofOptions = {
+    auth: context.runtime.config.auth,
+    ...options,
+  };
+
+  // 1. extract FhevmHandles from the given ZK proof
+  const inputHandles: readonly InputHandle[] = zkProof.getInputHandles();
+
+  if (inputHandles.length === 0) {
+    throw new InputProofError({
+      message: `Input proof must contain at least one external handle`,
+    });
+  }
+
+  // 2. Request coprocessor signatures from the relayer for the given ZK proof
+  const { handles: coprocessorSignedHandles, coprocessorEip712Signatures: coprocessorSignatures } =
+    await context.runtime.relayer.fetchCoprocessorSignatures(
+      { relayerUrl: context.chain.fhevm.relayerUrl, chainId: context.chain.id },
+      {
+        payload: {
+          zkProof,
+          extraData,
+        },
+        options: relayerOptions,
+      },
+    );
+
+  // 3. Check that the handles and the one in the fetch result
+  // Note: this check is theoretically unnecessary
+  // We prefer to perform this test since we do not trust the relayer
+  // The purpose is to check if the relayer is possibly malicious
+  assertHandleArrayEquals(inputHandles, coprocessorSignedHandles);
+
+  // 4. Verify ZK proof and Compute the final Input proof
+  const inputProof = createInputProofFromInputHandles({
+    coprocessorEip712Signatures: coprocessorSignatures,
+    inputHandles,
+    extraData,
+    signedHandleAccess: {
+      userAddress: zkProof.userAddress,
+      contractAddress: zkProof.contractAddress,
+    },
+  });
+
+  return await verifyInputProof(context, { inputProof });
+}

package/core/coprocessor/verifyHandlesCoprocessorSignatures.ts

@@ -0,0 +1,66 @@
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import type { CoprocessorEip712Domain, CoprocessorEip712Message } from '../types/coprocessor.js';
+import type { CoprocessorSignersContext } from '../types/coprocessorSignersContext.js';
+import type { FhevmChain } from '../types/fhevmChain.js';
+import type { Bytes65Hex, BytesHex, ChecksummedAddress, Uint64BigInt } from '../types/primitives.js';
+import type { InputHandle } from '../types/encryptedTypes-p.js';
+import { recoverSigners } from '../utils-p/runtime/recoverSigners.js';
+import { coprocessorEip712PrimaryType, coprocessorEip712Types } from './coprocessorEip712Types.js';
+import { createCoprocessorEip712Domain } from './createCoprocessorEip712Domain.js';
+import { assertCoprocessorSignerThreshold } from '../host-contracts/CoprocessorSignersContext-p.js';
+import { readCoprocessorSignersContext } from '../host-contracts/readCoprocessorSignersContext-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly chain: FhevmChain;
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly coprocessorSignatures: readonly Bytes65Hex[];
+  readonly handles: readonly InputHandle[];
+  readonly userAddress: ChecksummedAddress;
+  readonly contractAddress: ChecksummedAddress;
+  readonly chainId: Uint64BigInt;
+  readonly extraData: BytesHex;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// verifyHandlesCoprocessorSignatures
+////////////////////////////////////////////////////////////////////////////////
+
+export async function verifyHandlesCoprocessorSignatures(context: Context, parameters: Parameters): Promise<void> {
+  // Use hex strings (not Uint8Array) for EIP-712 message fields.
+  // viem's hashTypedData expects hex strings for bytes32 fields.
+  const message: CoprocessorEip712Message = {
+    ctHandles: parameters.handles.map((h) => h.bytes32Hex),
+    userAddress: parameters.userAddress,
+    contractAddress: parameters.contractAddress,
+    contractChainId: parameters.chainId,
+    extraData: parameters.extraData,
+  };
+
+  const domain: CoprocessorEip712Domain = createCoprocessorEip712Domain({
+    gatewayChainId: context.chain.fhevm.gateway.id,
+    verifyingContractAddressInputVerification: context.chain.fhevm.gateway.contracts.inputVerification.address,
+  });
+
+  // 1. Verify signatures
+  const recoveredAddresses = await recoverSigners(context, {
+    domain,
+    primaryType: coprocessorEip712PrimaryType,
+    types: coprocessorEip712Types,
+    signatures: parameters.coprocessorSignatures,
+    message,
+  });
+
+  const coprocessorSignersContext: CoprocessorSignersContext = await readCoprocessorSignersContext(context, {
+    address: context.chain.fhevm.contracts.inputVerifier.address as ChecksummedAddress,
+  });
+
+  // 2. Verify signature threshold is reached
+  assertCoprocessorSignerThreshold(coprocessorSignersContext, recoveredAddresses);
+}