@cofhe/sdk 0.6.1 → 0.7.0

package/core/decrypt/tnSealOutputV2.ts

@@ -1,10 +1,12 @@
-import { type Permission, type EthEncryptedData } from '@/permits';
+import { type ACPPublic, type EthEncryptedData } from '@/acps';
 import { cofheFetch } from '../debug.js';
 
 import { CofheError, CofheErrorCode } from '../error.js';
 import { type DecryptPollCallbackFunction } from '../types.js';
 import { computeMinuteRampPollIntervalMs } from './polling.js';
+import { mapApiErrorCodeToCofheErrorCode, parseApiErrorResponseBody } from './apiError.js';
 import { classifySubmitResponse, normalize404RetryTimeoutMs, throwIfSubmitRetryTimedOut } from './submitRetry.js';
+import {} from './tnDecryptUtils.js';
 
 // Polling configuration
 const POLL_INTERVAL_MS = 1000; // 1 second
@@ -136,7 +138,7 @@ async function submitSealOutputRequest(
   thresholdNetworkUrl: string,
   ctHash: bigint | string,
   chainId: number,
-  permission: Permission,
+  acp: ACPPublic,
   overallStartTime: number,
   retry404TimeoutMs: number,
   onPoll?: DecryptPollCallbackFunction
@@ -144,9 +146,10 @@ async function submitSealOutputRequest(
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, '0'),
     host_chain_id: chainId,
-    permit: permission,
+    acp,
   };
   let attemptIndex = 0;
+  let last404ApiErrorMessage: string | undefined;
 
   for (;;) {
     let response: Response;
@@ -175,17 +178,20 @@ async function submitSealOutputRequest(
       });
     }
 
-    const responseClassification = await classifySubmitResponse({ response });
+    const responseClassification = await classifySubmitResponse({
+      response,
+      fallbackErrorCode: CofheErrorCode.SealOutputFailed,
+    });
 
     if (responseClassification.kind === 'fatal-http') {
       throw new CofheError({
-        code: CofheErrorCode.SealOutputFailed,
+        code: responseClassification.cofheErrorCode,
+        apiErrorCode: responseClassification.apiErrorCode,
         message: `sealOutput request failed: ${responseClassification.errorMessage}`,
         hint: 'Check the threshold network URL and request parameters.',
         context: {
           thresholdNetworkUrl,
-          status: response.status,
-          statusText: response.statusText,
+          status: responseClassification.status,
           body,
           attemptIndex,
         },
@@ -236,6 +242,10 @@ async function submitSealOutputRequest(
       });
     }
 
+    if (responseClassification.status === 404) {
+      last404ApiErrorMessage = responseClassification.apiErrorMessage;
+    }
+
     const elapsedMs = Date.now() - overallStartTime;
 
     throwIfSubmitRetryTimedOut({
@@ -248,6 +258,7 @@ async function submitSealOutputRequest(
       thresholdNetworkUrl,
       body,
       attemptIndex,
+      lastKnownErrorMessage: last404ApiErrorMessage,
     });
 
     onPoll?.({
@@ -344,16 +355,11 @@ async function pollSealOutputStatus(
 
     // Handle other non-200 status codes
     if (!response.ok) {
-      let errorMessage = `HTTP ${response.status}`;
-      try {
-        const errorBody = await response.json();
-        errorMessage = errorBody.error_message || errorBody.message || errorMessage;
-      } catch {
-        errorMessage = response.statusText || errorMessage;
-      }
+      const { apiErrorCode, errorMessage } = await parseApiErrorResponseBody(response);
 
       throw new CofheError({
-        code: CofheErrorCode.SealOutputFailed,
+        code: mapApiErrorCodeToCofheErrorCode(apiErrorCode, CofheErrorCode.SealOutputFailed),
+        apiErrorCode,
         message: `sealOutput status poll failed: ${errorMessage}`,
         context: {
           thresholdNetworkUrl,
@@ -407,12 +413,12 @@ async function pollSealOutputStatus(
 export async function tnSealOutputV2(params: {
   ctHash: bigint | string;
   chainId: number;
-  permission: Permission;
+  acp: ACPPublic;
   thresholdNetworkUrl: string;
   retry404TimeoutMs?: number;
   onPoll?: DecryptPollCallbackFunction;
 }): Promise<EthEncryptedData> {
-  const { thresholdNetworkUrl, ctHash, chainId, permission, retry404TimeoutMs, onPoll } = params;
+  const { thresholdNetworkUrl, ctHash, chainId, acp, retry404TimeoutMs, onPoll } = params;
   const normalized404RetryTimeoutMs = normalize404RetryTimeoutMs({
     timeoutMs: retry404TimeoutMs,
     operationLabel: 'sealOutput',
@@ -425,7 +431,7 @@ export async function tnSealOutputV2(params: {
     thresholdNetworkUrl,
     ctHash,
     chainId,
-    permission,
+    acp,
     overallStartTime,
     normalized404RetryTimeoutMs,
     onPoll

package/core/encrypt/cofheMocksZkVerifySign.ts

@@ -1,15 +1,6 @@
 import { type EncryptableItem, FheTypes } from '../types.js';
-import { type VerifyResult } from './zkPackProveVerify.js';
-import {
-  createWalletClient,
-  http,
-  encodePacked,
-  keccak256,
-  hashMessage,
-  toBytes,
-  type PublicClient,
-  type WalletClient,
-} from 'viem';
+import { type VerifyBatchResult } from './zkPackProveVerify.js';
+import { createWalletClient, http, encodePacked, keccak256, type PublicClient, type WalletClient } from 'viem';
 import { MockZkVerifierAbi } from './MockZkVerifierAbi.js';
 import { hardhat } from 'viem/chains';
 import { CofheError, CofheErrorCode } from '../error.js';
@@ -178,89 +169,80 @@ async function insertCtHashes(items: EncryptableItemWithCtHash[], walletClient:
 }
 
 /**
- * The mocks verify the EncryptedInputs' signature against the known proof signer account.
- * Locally, we create the proof signatures from the known proof signer account.
+ * The mocks verify a batch's signature against the known verifier signer account.
+ * Locally, we create the single batch signature from the known signer account, over
+ * keccak256(h_0 || h_1 || ... || h_n), where each h_i is the same per-item message hash
+ * used by the on-chain digest (`ctHash || utype || securityZone || sender || chainId ||
+ * consumingContract`, per cofhe-contracts#77's contract-binding fix). This is the one
+ * canonical signer implementation used by the mocks - there is no separate per-item signing
+ * path.
  */
-async function createProofSignatures(
+async function createBatchProofSignature(
   items: EncryptableItemWithCtHash[],
   securityZone: number,
-  account: string
-): Promise<`0x${string}`[]> {
-  let signatures: `0x${string}`[] = [];
-
-  // Create wallet client for the encrypted input signer
-  // This wallet won't send a transaction, so gas isn't needed
-  // This wallet doesn't need to be connected to the network
-  let encInputSignerClient: WalletClient | undefined;
-
-  try {
-    encInputSignerClient = createMockZkVerifierSigner();
-  } catch (err) {
-    throw new CofheError({
-      code: CofheErrorCode.ZkMocksCreateProofSignatureFailed,
-      message: `mockZkVerifySign createProofSignatures failed while creating wallet client`,
-      cause: err instanceof Error ? err : undefined,
-      context: {
-        MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
-      },
-    });
-  }
-
+  account: string,
+  consumingContract: string
+): Promise<`0x${string}`> {
   try {
-    for (const item of items) {
-      // Pack the data into bytes and hash it
-      const packedData = encodePacked(
-        ['uint256', 'uint8', 'uint8', 'address', 'uint256'],
-        [BigInt(item.ctHash), item.utype, securityZone, account as `0x${string}`, BigInt(hardhat.id)]
-      );
-      const messageHash = keccak256(packedData);
+    // Compute each item's per-item message hash h_i
+    const itemHashes = items.map((item) =>
+      keccak256(
+        encodePacked(
+          ['uint256', 'uint8', 'uint8', 'address', 'uint256', 'address'],
+          [
+            BigInt(item.ctHash),
+            item.utype,
+            securityZone,
+            account as `0x${string}`,
+            BigInt(hardhat.id),
+            consumingContract as `0x${string}`,
+          ]
+        )
+      )
+    );
 
-      const signature = await sign({
-        hash: messageHash,
-        privateKey: MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
-        to: 'hex',
-      });
+    // Fold into one batch digest: keccak256(h_0 || h_1 || ... || h_n)
+    const batchDigest = keccak256(
+      encodePacked(
+        itemHashes.map(() => 'bytes32' as const),
+        itemHashes
+      )
+    );
 
-      signatures.push(signature);
-    }
+    // Sign once for the whole batch
+    return await sign({
+      hash: batchDigest,
+      privateKey: MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
+      to: 'hex',
+    });
   } catch (err) {
     throw new CofheError({
       code: CofheErrorCode.ZkMocksCreateProofSignatureFailed,
-      message: `mockZkVerifySign createProofSignatures failed while calling signMessage`,
+      message: `mockZkVerifySign createBatchProofSignature failed while signing the batch digest`,
       cause: err instanceof Error ? err : undefined,
       context: {
         items,
         securityZone,
+        consumingContract,
       },
     });
   }
-
-  if (signatures.length !== items.length) {
-    throw new CofheError({
-      code: CofheErrorCode.ZkMocksCreateProofSignatureFailed,
-      message: `mockZkVerifySign createProofSignatures returned incorrect number of signatures`,
-      context: {
-        items,
-        securityZone,
-      },
-    });
-  }
-
-  return signatures;
 }
 
 /**
- * Transforms the encryptable items into EncryptedInputs ready to be used in a transaction on the hardhat chain.
- * The EncryptedInputs are returned in the same format as from CoFHE, and include on-chain verifiable signatures.
+ * Transforms the encryptable items into a batch-verified result ready to be used in a
+ * transaction on the hardhat chain. Mirrors the shape returned by CoFHE's `/verifyBatch`:
+ * per-item ctHash/ctType, plus one shared on-chain verifiable signature for the whole batch.
  */
 export async function cofheMocksZkVerifySign(
   items: EncryptableItem[],
   account: string,
   securityZone: number,
+  consumingContract: string,
   publicClient: PublicClient,
   walletClient: WalletClient,
   zkvWalletClient: WalletClient | undefined
-): Promise<VerifyResult[]> {
+): Promise<VerifyBatchResult> {
   // Use config._internal?.zkvWalletClient if provided, otherwise use a mock zk verifier signer
   const _walletClient = zkvWalletClient ?? createMockZkVerifierSigner();
 
@@ -270,12 +252,15 @@ export async function cofheMocksZkVerifySign(
   // Insert the ctHashes into the MockZkVerifier contract
   await insertCtHashes(encryptableItems, _walletClient);
 
-  // Locally create the proof signatures from the known proof signer account
-  const signatures = await createProofSignatures(encryptableItems, securityZone, account);
+  // Locally create the single batch signature from the known signer account
+  const signature = await createBatchProofSignature(encryptableItems, securityZone, account, consumingContract);
 
-  // Return the ctHashes and signatures in the same format as CoFHE
-  return encryptableItems.map((item, index) => ({
-    ct_hash: item.ctHash.toString(),
-    signature: signatures[index],
-  }));
+  // Return the ctHashes/ctTypes and the batch signature, in the same shape as CoFHE's /verifyBatch
+  return {
+    outputs: encryptableItems.map((item) => ({
+      ct_hash: item.ctHash.toString(),
+      ct_type: item.utype,
+    })),
+    signature,
+  };
 }

package/core/encrypt/encryptInputsBuilder.ts

@@ -1,10 +1,11 @@
 import {
   type ZkBuilderAndCrsGenerator,
   type ZkProveWorkerFunction,
+  type VerifyBatchResult,
   zkPack,
   zkProve,
   zkProveWithWorker,
-  zkVerify,
+  zkVerifyBatch,
   constructZkPoKMetadata,
 } from './zkPackProveVerify.js';
 import { CofheError, CofheErrorCode } from '../error.js';
@@ -12,8 +13,6 @@ import {
   type EncryptStepCallbackFunction,
   EncryptStep,
   type EncryptableItem,
-  type EncryptedItemInput,
-  type EncryptedItemInputs,
   type TfheInitializer,
   type EncryptStepCallbackContext,
   type HashPlusProofResult,
@@ -48,11 +47,20 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
  */
 
-export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
+/**
+ * The builder as returned by `client.encryptInputs(...)`, before a consuming contract has been set.
+ *
+ * `execute()` is intentionally absent: the verifier binds the consuming contract into the signed
+ * digest, so no batch can be produced until the caller commits to the contract that will consume it.
+ * `setConsumingContract(...)` returns the full {@link EncryptInputsBuilder}, unlocking `execute()`.
+ */
+export type EncryptInputsBuilderUnset<T extends EncryptableItem[]> = Omit<EncryptInputsBuilder<T>, 'execute'>;
+
+export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
   private securityZone: number;
+  protected consumingContract: string | undefined;
   private stepCallback?: EncryptStepCallbackFunction;
   private inputItems: [...T];
-  private hpp: boolean = false;
 
   private zkvWalletClient: WalletClient | undefined;
 
@@ -156,7 +164,9 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setAccount(account: string): EncryptInputsBuilder<T, HPP> {
+  setAccount(this: EncryptInputsBuilder<T>, account: string): EncryptInputsBuilder<T>;
+  setAccount(this: EncryptInputsBuilderUnset<T>, account: string): EncryptInputsBuilderUnset<T>;
+  setAccount(account: string): EncryptInputsBuilder<T> {
     this.account = account;
     return this;
   }
@@ -179,7 +189,9 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setChainId(chainId: number): EncryptInputsBuilder<T, HPP> {
+  setChainId(this: EncryptInputsBuilder<T>, chainId: number): EncryptInputsBuilder<T>;
+  setChainId(this: EncryptInputsBuilderUnset<T>, chainId: number): EncryptInputsBuilderUnset<T>;
+  setChainId(chainId: number): EncryptInputsBuilder<T> {
     this.chainId = chainId;
     return this;
   }
@@ -202,7 +214,9 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP> {
+  setSecurityZone(this: EncryptInputsBuilder<T>, securityZone: number): EncryptInputsBuilder<T>;
+  setSecurityZone(this: EncryptInputsBuilderUnset<T>, securityZone: number): EncryptInputsBuilderUnset<T>;
+  setSecurityZone(securityZone: number): EncryptInputsBuilder<T> {
     this.securityZone = securityZone;
     return this;
   }
@@ -212,18 +226,44 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
   }
 
   /**
+   * @param address - The contract that will consume the resulting hashes+signature (i.e. the
+   * contract that will call `FHE.asEuint*`/`FHE.asEuint*s` with them).
+   *
+   * Required before `execute()` - the verifier binds this address into the signed digest, so a
+   * batch signed for one contract cannot be replayed into another.
+   *
    * Example:
    * ```typescript
    * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
-   *   .asHashPlusProof()
+   *   .setConsumingContract("0x123...890")
    *   .execute();
    * ```
    *
-   * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+   * @returns The chainable EncryptInputsBuilder instance.
    */
-  asHashPlusProof(): EncryptInputsBuilder<T, true> {
-    this.hpp = true;
-    return this as unknown as EncryptInputsBuilder<T, true>;
+  setConsumingContract(address: string): EncryptInputsBuilder<T> {
+    this.consumingContract = address;
+    return this;
+  }
+
+  getConsumingContract(): string | undefined {
+    return this.consumingContract;
+  }
+
+  /**
+   * Asserts that this.consumingContract is populated
+   * @throws {CofheError} If consumingContract is not set
+   */
+  private assertConsumingContract(): asserts this is this & { consumingContract: string } {
+    if (this.consumingContract) return;
+    throw new CofheError({
+      code: CofheErrorCode.ConsumingContractUninitialized,
+      message: 'Consuming contract is not set',
+      hint: 'Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.',
+      context: {
+        consumingContract: this.consumingContract,
+      },
+    });
   }
 
   /**
@@ -240,7 +280,9 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP> {
+  setUseWorker(this: EncryptInputsBuilder<T>, useWorker: boolean): EncryptInputsBuilder<T>;
+  setUseWorker(this: EncryptInputsBuilderUnset<T>, useWorker: boolean): EncryptInputsBuilderUnset<T>;
+  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T> {
     this.useWorker = useWorker;
     return this;
   }
@@ -277,7 +319,9 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The EncryptInputsBuilder instance.
    */
-  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP> {
+  onStep(this: EncryptInputsBuilder<T>, callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T>;
+  onStep(this: EncryptInputsBuilderUnset<T>, callback: EncryptStepCallbackFunction): EncryptInputsBuilderUnset<T>;
+  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T> {
     this.stepCallback = callback;
     return this;
   }
@@ -433,10 +477,11 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    * cofheMocksInsertPackedHashes - stores the ctHashes and their plaintext values for on-chain mocking of FHE operations.
    * cofheMocksZkCreateProofSignatures - creates signatures to be included in the encrypted inputs. The signers address is known and verified in the mock contracts.
    */
-  private async mocksExecute(): Promise<[...EncryptedItemInputs<T>]> {
+  private async mocksExecute(): Promise<VerifyBatchResult> {
     this.assertAccount();
     this.assertPublicClient();
     this.assertWalletClient();
+    this.assertConsumingContract();
 
     const [initTfheDelay, fetchKeysDelay, packDelay, proveDelay, verifyDelay] = this.resolveEncryptDelays();
 
@@ -468,31 +513,27 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
 
     this.fireStepStart(EncryptStep.Verify);
     await sleep(verifyDelay);
-    const signedResults = await cofheMocksZkVerifySign(
+    const result = await cofheMocksZkVerifySign(
       this.inputItems,
       this.account,
       this.securityZone,
+      this.consumingContract,
       this.publicClient,
       this.walletClient,
       this.zkvWalletClient
     );
-    const encryptedInputs: EncryptedItemInput[] = signedResults.map(({ ct_hash, signature }, index) => ({
-      ctHash: BigInt(ct_hash),
-      securityZone: this.securityZone,
-      utype: this.inputItems[index].utype,
-      signature,
-    }));
     this.fireStepEnd(EncryptStep.Verify, { isMocks: true, mockSleep: verifyDelay });
 
-    return encryptedInputs as [...EncryptedItemInputs<T>];
+    return result;
   }
 
   /**
    * In the production context, perform a true encryption with the CoFHE coprocessor.
    */
-  private async productionExecute(): Promise<[...EncryptedItemInputs<T>]> {
+  private async productionExecute(): Promise<VerifyBatchResult> {
     this.assertAccount();
     this.assertChainId();
+    this.assertConsumingContract();
 
     this.fireStepStart(EncryptStep.InitTfhe);
 
@@ -555,32 +596,28 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
 
     const zkVerifierUrl = await this.getZkVerifierUrl();
 
-    const verifyResults = await zkVerify(zkVerifierUrl, proof, this.account, this.securityZone, this.chainId);
-    // Add securityZone and utype to the verify results
-    const encryptedInputs: EncryptedItemInput[] = verifyResults.map(
-      ({ ct_hash, signature }: { ct_hash: string; signature: `0x${string}` }, index: number) => ({
-        ctHash: BigInt(ct_hash),
-        securityZone: this.securityZone,
-        utype: this.inputItems[index].utype,
-        signature,
-      })
+    const result = await zkVerifyBatch(
+      zkVerifierUrl,
+      proof,
+      this.account,
+      this.securityZone,
+      this.chainId,
+      this.consumingContract
     );
 
     this.fireStepEnd(EncryptStep.Verify);
 
-    return encryptedInputs as [...EncryptedItemInputs<T>];
+    return result;
   }
 
-  private structsToHashPlusProof(inItems: [...EncryptedItemInputs<T>]): HashPlusProofResult<T> {
-    let hashes: string[] = [];
-    let proof: string = '';
-
-    for (const item of inItems) {
-      hashes.push('0x' + item.ctHash.toString(16).padStart(64, '0'));
-      proof += item.signature;
-    }
+  /**
+   * Converts a batch-verified result (per-item ctHash/ctType + one shared signature) into the
+   * tuple returned by `execute()`: per-item hashes in input order, followed by the single signature.
+   */
+  private buildBatchResult(result: VerifyBatchResult): HashPlusProofResult<T> {
+    const hashes = result.outputs.map((output) => '0x' + BigInt(output.ct_hash).toString(16).padStart(64, '0'));
 
-    return [...hashes, proof] as unknown as HashPlusProofResult<T>;
+    return [...hashes, result.signature] as unknown as HashPlusProofResult<T>;
   }
 
   /**
@@ -602,17 +639,14 @@ export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boole
    *
    * @returns The encrypted inputs.
    */
-  async execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]> {
-    type Result = HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>];
-
-    let items: [...EncryptedItemInputs<T>];
+  async execute(): Promise<HashPlusProofResult<T>> {
+    let result: VerifyBatchResult;
 
     // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
-    if (this.chainId === hardhat.id) items = await this.mocksExecute();
+    if (this.chainId === hardhat.id) result = await this.mocksExecute();
     // On other chains, interact with CoFHE coprocessor
-    else items = await this.productionExecute();
+    else result = await this.productionExecute();
 
-    if (this.hpp) return this.structsToHashPlusProof(items) as unknown as Result;
-    return items as unknown as Result;
+    return this.buildBatchResult(result);
   }
 }

package/core/encrypt/zkPackProveVerify.ts

@@ -41,14 +41,19 @@ export interface ZkProveWorkerResponse {
   error?: string;
 }
 
-export type VerifyResultRaw = {
+export type VerifyBatchOutputRaw = {
   ct_hash: string;
+  ct_type: number;
+};
+
+export type VerifyBatchResultRaw = {
+  ciphertexts: VerifyBatchOutputRaw[];
   signature: string;
   recid: number;
 };
 
-export type VerifyResult = {
-  ct_hash: string;
+export type VerifyBatchResult = {
+  outputs: VerifyBatchOutputRaw[];
   signature: `0x${string}`;
 };
 
@@ -256,13 +261,14 @@ export const constructZkPoKMetadata = (accountAddr: string, securityZone: number
   return metadata;
 };
 
-export const zkVerify = async (
+export const zkVerifyBatch = async (
   verifierUrl: string,
   serializedBytes: Uint8Array,
   address: string,
   securityZone: number,
-  chainId: number
-): Promise<VerifyResult[]> => {
+  chainId: number,
+  consumingContract: string
+): Promise<VerifyBatchResult> => {
   // Convert bytearray to hex string
   const packed_list = toHexString(serializedBytes);
 
@@ -274,13 +280,14 @@ export const zkVerify = async (
     account_addr: address,
     security_zone: sz_byte[0],
     chain_id: chainId,
+    contract_address: consumingContract,
   };
 
   const body = JSON.stringify(payload);
 
   // Send request to verification server
   try {
-    const response = await fetch(`${verifierUrl}/verify`, {
+    const response = await fetch(`${verifierUrl}/verifyBatch`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -293,34 +300,34 @@ export const zkVerify = async (
       const errorBody = await response.text();
       throw new CofheError({
         code: CofheErrorCode.ZkVerifyFailed,
-        message: `HTTP error! ZK proof verification failed - ${errorBody}`,
+        message: `HTTP error! ZK batch proof verification failed - ${errorBody}`,
       });
     }
 
-    const json = (await response.json()) as { status: string; data: VerifyResultRaw[]; error: string };
+    const json = (await response.json()) as { status: string; data: VerifyBatchResultRaw; error: string };
 
     if (json.status !== 'success') {
       throw new CofheError({
         code: CofheErrorCode.ZkVerifyFailed,
-        message: `ZK proof verification response malformed - ${json.error}`,
+        message: `ZK batch proof verification response malformed - ${json.error}`,
       });
     }
 
-    return json.data.map(({ ct_hash, signature, recid }) => {
-      return {
-        ct_hash,
-        signature: concatSigRecid(signature, recid),
-      };
-    });
+    const { ciphertexts, signature, recid } = json.data;
+
+    return {
+      outputs: ciphertexts,
+      signature: concatSigRecid(signature, recid),
+    };
   } catch (e) {
     throw new CofheError({
       code: CofheErrorCode.ZkVerifyFailed,
-      message: `ZK proof verification failed`,
+      message: `ZK batch proof verification failed`,
       cause: e instanceof Error ? e : undefined,
     });
   }
 };
 
-const concatSigRecid = (signature: string, recid: number): `0x${string}` => {
+export const concatSigRecid = (signature: string, recid: number): `0x${string}` => {
   return `${signature}${(recid + 27).toString(16).padStart(2, '0')}` as `0x${string}`;
 };