@cofhe/sdk 1.1.0-alpha.1 → 1.1.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @cofhe/sdk Changelog
 
+## 1.0.1
+
+### Patch Changes
+
+- fcc819c: **Breaking:** `encryptInputs(...).execute()` now binds the consuming contract into the ZK proof itself, and the CoFHE verifier requires it. Upgrade to 1.0.1: 1.0.0 is deprecated because of an issue in ZK verification, and once the verifier is updated a proof from 1.0.0 fails with `ZK_VERIFY_FAILED`. No code change is needed beyond the upgrade; `setConsumingContract(...)` was already required.
+
+  `execute()` now throws `CofheError` with code `CONSUMING_CONTRACT_INVALID` when `setConsumingContract(...)` was given something that is not an address, before TFHE is initialised or any proving starts. The check is byte-level, 20 bytes of hex in any case, and does not validate the EIP-55 checksum, so every address 1.0.0 accepted still passes. Previously the bad address reached the verifier and failed there, after the proof was generated. `CofheErrorCode` gains `ConsumingContractInvalid`; an exhaustive `switch` over the enum needs the new arm.
+
 ## 1.0.0
 
 ### Major Changes

package/core/encrypt/encryptInputsBuilder.ts

@@ -21,7 +21,7 @@ import { cofheMocksCheckEncryptableBits, cofheMocksZkVerifySign } from './cofheM
 import { hardhat } from 'viem/chains';
 import { fetchKeys, type FheKeyDeserializer } from '../fetchKeys.js';
 import { getZkVerifierUrlOrThrow } from '../config.js';
-import { type WalletClient } from 'viem';
+import { type WalletClient, isAddress } from 'viem';
 import { sleep } from '../utils.js';
 import { BaseBuilder, type BaseBuilderParams } from '../baseBuilder.js';
 import { type KeysStorage } from '../keyStore.js';
@@ -256,19 +256,37 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
   }
 
   /**
-   * Asserts that this.consumingContract is populated
-   * @throws {CofheError} If consumingContract is not set
+   * Asserts that this.consumingContract is populated and is an address.
+   * Runs before TFHE init, key fetching and proving, so a bad address costs
+   * nothing: the contract is bound into the proof, and a proof built for a
+   * non-address could only fail at the verifier, after the expensive step.
+   * @throws {CofheError} If consumingContract is not set or is not an address
    */
   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,
-      },
-    });
+    if (!this.consumingContract) {
+      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,
+        },
+      });
+    }
+    // strict: false — 20 bytes of hex in any case, no EIP-55 checksum check. The
+    // verifier decodes the address case-insensitively and the chain compares bytes,
+    // so a mixed-case address with a wrong checksum works end to end and a patch
+    // release must keep accepting it.
+    if (!isAddress(this.consumingContract, { strict: false })) {
+      throw new CofheError({
+        code: CofheErrorCode.ConsumingContractInvalid,
+        message: 'Consuming contract is not an address',
+        hint: 'setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.',
+        context: {
+          consumingContract: this.consumingContract,
+        },
+      });
+    }
   }
 
   /**
@@ -567,7 +585,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     this.fireStepStart(EncryptStep.Prove);
 
     // Construct metadata once (used by both worker and main thread paths)
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
 
     let proof: Uint8Array | null = null;
     let usedWorker = false;

package/core/encrypt/zkPackProveVerify.ts

@@ -239,13 +239,24 @@ export const zkProve = async (
 };
 
 /**
- * Constructs the ZK Proof of Knowledge metadata for the proof
+ * Constructs the ZK Proof of Knowledge metadata for the proof:
+ * `securityZone (1) || account (20) || chainId (32, big-endian) || consumingContract (20)`.
+ *
+ * The verifier rebuilds the same bytes from the request fields before it checks the proof, so the
+ * proof is bound to the consuming contract itself, not only to the signature the verifier returns.
  * @internal - Used internally within the encrypt module
  */
-export const constructZkPoKMetadata = (accountAddr: string, securityZone: number, chainId: number): Uint8Array => {
-  // Decode the account address from hex
+export const constructZkPoKMetadata = (
+  accountAddr: string,
+  securityZone: number,
+  chainId: number,
+  consumingContract: string
+): Uint8Array => {
+  // Decode the account and contract addresses from hex
   const accountAddrNoPrefix = accountAddr.startsWith('0x') ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
+  const contractNoPrefix = consumingContract.startsWith('0x') ? consumingContract.slice(2) : consumingContract;
+  const contractBytes = hexToBytes(contractNoPrefix);
 
   // Encode chainId as 32 bytes (u256) in big-endian format
   const chainIdBytes = new Uint8Array(32);
@@ -259,10 +270,11 @@ export const constructZkPoKMetadata = (accountAddr: string, securityZone: number
     value = value >>> 8;
   }
 
-  const metadata = new Uint8Array(1 + accountBytes.length + 32);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
+  metadata.set(contractBytes, 1 + accountBytes.length + 32);
 
   return metadata;
 };

package/core/error.ts

@@ -16,6 +16,7 @@ export enum CofheErrorCode {
   AccountUninitialized = 'ACCOUNT_UNINITIALIZED',
   ChainIdUninitialized = 'CHAIN_ID_UNINITIALIZED',
   ConsumingContractUninitialized = 'CONSUMING_CONTRACT_UNINITIALIZED',
+  ConsumingContractInvalid = 'CONSUMING_CONTRACT_INVALID',
   SealOutputFailed = 'SEAL_OUTPUT_FAILED',
   SealOutputReturnedNull = 'SEAL_OUTPUT_RETURNED_NULL',
   InvalidUtype = 'INVALID_UTYPE',

package/core/test/encryptInputsBuilder.test.ts

@@ -10,7 +10,7 @@ import {
 } from '../types.js';
 import { CofheError, CofheErrorCode } from '../error.js';
 import { fromHexString, toHexString } from '../utils.js';
-import { type PublicClient, createPublicClient, http, type WalletClient, createWalletClient } from 'viem';
+import { type PublicClient, createPublicClient, http, type WalletClient, createWalletClient, isAddress } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia } from 'viem/chains';
 import { type CofheConfig, createCofheConfigBase } from '../config.js';
@@ -53,9 +53,9 @@ const unpackMetadata = (metadata: string) => {
 
 export const deconstructZkPoKMetadata = (
   metadata: Uint8Array
-): { accountAddr: string; securityZone: number; chainId: number } => {
-  if (metadata.length < 53) {
-    // 1 + 20 + 32 = 53 bytes minimum
+): { accountAddr: string; securityZone: number; chainId: number; contractAddr: string } => {
+  if (metadata.length < 73) {
+    // 1 + 20 + 32 + 20 = 73 bytes minimum
     throw new CofheError({
       code: CofheErrorCode.InternalError,
       message: 'Invalid metadata: insufficient length',
@@ -78,10 +78,14 @@ export const deconstructZkPoKMetadata = (
     chainId = (chainId << 8) | chainIdBytes[i];
   }
 
+  // Extract the consuming contract (last 20 bytes)
+  const contractAddr = '0x' + toHexString(metadata.slice(53, 73));
+
   return {
     accountAddr,
     securityZone,
     chainId,
+    contractAddr,
   };
 };
 
@@ -445,6 +449,38 @@ describe('EncryptInputsBuilder', () => {
         expect((error as CofheError).code).toBe(CofheErrorCode.ConsumingContractUninitialized);
       }
     });
+
+    it('accepts a mixed-case consuming contract whose checksum is wrong', async () => {
+      // The verifier decodes the address case-insensitively and the chain compares
+      // 20 bytes, so a 1.0.0 dApp with such an address must keep working.
+      const wrongChecksum = '0xBEEFbeefBEEFbeefBEEFbeefBEEFbeefBEEFbeef';
+      expect(isAddress(wrongChecksum)).toBe(false);
+      expect(isAddress(wrongChecksum, { strict: false })).toBe(true);
+
+      const result = await new EncryptInputsBuilder(createDefaultParams())
+        .setConsumingContract(wrongChecksum)
+        .execute();
+
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('rejects a consuming contract that is not an address before any encrypt step runs', async () => {
+      for (const notAnAddress of ['0x0', 'not-an-address', '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbee']) {
+        const steps = vi.fn();
+        const invalid = new EncryptInputsBuilder(createDefaultParams())
+          .setConsumingContract(notAnAddress)
+          .onStep(steps);
+        try {
+          await invalid.execute();
+          expect.unreachable(`execute() should have thrown for ${notAnAddress}`);
+        } catch (error) {
+          expect(error, notAnAddress).toBeInstanceOf(CofheError);
+          expect((error as CofheError).code, notAnAddress).toBe(CofheErrorCode.ConsumingContractInvalid);
+        }
+        // Rejected before initTfhe, so no step (and no proving) ever started.
+        expect(steps, notAnAddress).not.toHaveBeenCalled();
+      }
+    });
   });
 
   describe('zkVerifierUrl', () => {
@@ -595,6 +631,22 @@ describe('EncryptInputsBuilder', () => {
       expect(encryptedMetadata.chainId).toBe(defaultChainId);
     });
 
+    it('binds the consuming contract into the proof metadata', async () => {
+      mockFetch.mockClear();
+
+      await builder.execute();
+
+      const verifyCall = mockFetch.mock.calls.find(([url]) => url === `${MockZkVerifierUrl}/verifyBatch`);
+      expect(verifyCall).toBeDefined();
+      const body = JSON.parse(verifyCall![1].body as string);
+      const { metadata } = parseWithBigInt(new TextDecoder().decode(fromHexString(body.packed_list)));
+      const embedded = deconstructZkPoKMetadata(Uint8Array.from(Object.values(metadata) as number[]));
+      expect(embedded.accountAddr).toBe(defaultSender);
+      expect(embedded.securityZone).toBe(0);
+      expect(embedded.chainId).toBe(defaultChainId);
+      expect(embedded.contractAddr).toBe(defaultConsumingContract);
+    });
+
     it('should use overridden account when set', async () => {
       const overriddenSender = '0x5555555555555555555555555555555555555555';
       builder.setAccount(overriddenSender);

package/core/test/zkPoKMetadata.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { constructZkPoKMetadata } from '../encrypt/zkPackProveVerify.js';
+import { toHexString } from '../utils.js';
+
+describe('constructZkPoKMetadata', () => {
+  const account = '0x1234567890123456789012345678901234567890';
+  const contract = '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef';
+
+  it('lays out security zone, account, chain id and the consuming contract', () => {
+    const metadata = constructZkPoKMetadata(account, 3, 0x010203, contract);
+
+    expect(metadata.length).toBe(1 + 20 + 32 + 20);
+    expect(metadata[0]).toBe(3);
+    expect('0x' + toHexString(metadata.slice(1, 21))).toBe(account);
+    const chainId = metadata.slice(21, 53);
+    expect(Array.from(chainId.slice(0, 29))).toEqual(new Array(29).fill(0));
+    expect(Array.from(chainId.slice(29))).toEqual([1, 2, 3]);
+    expect('0x' + toHexString(metadata.slice(53))).toBe(contract);
+  });
+
+  it('accepts the consuming contract with or without the 0x prefix', () => {
+    const withPrefix = constructZkPoKMetadata(account, 0, 1, contract);
+    const withoutPrefix = constructZkPoKMetadata(account, 0, 1, contract.slice(2));
+
+    expect(Array.from(withoutPrefix)).toEqual(Array.from(withPrefix));
+  });
+});

package/dist/acps.js

@@ -1,2 +1,2 @@
-export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-3L2IVPMI.js';
-import './chunk-J23FYAI2.js';
+export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-WAA2U7CT.js';
+import './chunk-OC5TGQGG.js';

package/dist/{chunk-WJGTPW7K.js → chunk-3SD2UCRE.js}

@@ -1,4 +1,4 @@
-import { CofheError } from './chunk-J23FYAI2.js';
+import { CofheError } from './chunk-OC5TGQGG.js';
 import 'viem';
 
 // core/types.ts

package/dist/{chunk-VE7DKXSF.js → chunk-KHM6LYLU.js}

@@ -1,9 +1,9 @@
 import { hardhat as hardhat$1 } from './chunk-UKQAJK4N.js';
-import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACP_SHARE_REGISTRY_ABI, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-3L2IVPMI.js';
-import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-WJGTPW7K.js';
-import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-J23FYAI2.js';
+import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACP_SHARE_REGISTRY_ABI, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-WAA2U7CT.js';
+import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-3SD2UCRE.js';
+import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-OC5TGQGG.js';
 import { createStore } from 'zustand/vanilla';
-import { parseAbi, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
+import { parseAbi, isAddress, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';
 import { sign, privateKeyToAccount } from 'viem/accounts';
 import { z } from 'zod';
@@ -110,19 +110,22 @@ var zkProve = async (builder, crs, metadata) => {
     }, 0);
   });
 };
-var constructZkPoKMetadata = (accountAddr, securityZone, chainId) => {
+var constructZkPoKMetadata = (accountAddr, securityZone, chainId, consumingContract) => {
   const accountAddrNoPrefix = accountAddr.startsWith("0x") ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
+  const contractNoPrefix = consumingContract.startsWith("0x") ? consumingContract.slice(2) : consumingContract;
+  const contractBytes = hexToBytes(contractNoPrefix);
   const chainIdBytes = new Uint8Array(32);
   let value = chainId;
   for (let i = 31; i >= 0 && value > 0; i--) {
     chainIdBytes[i] = value & 255;
     value = value >>> 8;
   }
-  const metadata = new Uint8Array(1 + accountBytes.length + 32);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
+  metadata.set(contractBytes, 1 + accountBytes.length + 32);
   return metadata;
 };
 var zkVerifyBatch = async (verifierUrl, serializedBytes, address, securityZone, chainId, consumingContract) => {
@@ -1002,20 +1005,33 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return this.consumingContract;
   }
   /**
-   * Asserts that this.consumingContract is populated
-   * @throws {CofheError} If consumingContract is not set
+   * Asserts that this.consumingContract is populated and is an address.
+   * Runs before TFHE init, key fetching and proving, so a bad address costs
+   * nothing: the contract is bound into the proof, and a proof built for a
+   * non-address could only fail at the verifier, after the expensive step.
+   * @throws {CofheError} If consumingContract is not set or is not an address
    */
   assertConsumingContract() {
-    if (this.consumingContract)
-      return;
-    throw new CofheError({
-      code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
-      message: "Consuming contract is not set",
-      hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
-      context: {
-        consumingContract: this.consumingContract
-      }
-    });
+    if (!this.consumingContract) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
+        message: "Consuming contract is not set",
+        hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
+    if (!isAddress(this.consumingContract, { strict: false })) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_INVALID" /* ConsumingContractInvalid */,
+        message: "Consuming contract is not an address",
+        hint: "setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
   }
   setUseWorker(useWorker) {
     this.useWorker = useWorker;
@@ -1231,7 +1247,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     zkBuilder = zkPack(this.inputItems, zkBuilder);
     this.fireStepEnd("pack" /* Pack */);
     this.fireStepStart("prove" /* Prove */);
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
     let proof = null;
     let usedWorker = false;
     let workerFailedError;

package/dist/{chunk-J23FYAI2.js → chunk-OC5TGQGG.js}

@@ -17,6 +17,7 @@ var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
   CofheErrorCode2["AccountUninitialized"] = "ACCOUNT_UNINITIALIZED";
   CofheErrorCode2["ChainIdUninitialized"] = "CHAIN_ID_UNINITIALIZED";
   CofheErrorCode2["ConsumingContractUninitialized"] = "CONSUMING_CONTRACT_UNINITIALIZED";
+  CofheErrorCode2["ConsumingContractInvalid"] = "CONSUMING_CONTRACT_INVALID";
   CofheErrorCode2["SealOutputFailed"] = "SEAL_OUTPUT_FAILED";
   CofheErrorCode2["SealOutputReturnedNull"] = "SEAL_OUTPUT_RETURNED_NULL";
   CofheErrorCode2["InvalidUtype"] = "INVALID_UTYPE";

package/dist/{chunk-3L2IVPMI.js → chunk-WAA2U7CT.js}

@@ -1,4 +1,4 @@
-import { CofheError, TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-J23FYAI2.js';
+import { CofheError, TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-OC5TGQGG.js';
 import { isAddress, getAddress, zeroAddress, isHex, parseAbi, keccak256, padHex, numberToHex, concatHex, toFunctionSelector, size, sliceHex, toHex, encodeAbiParameters, hexToBigInt, stringToHex, hexToNumber, toEventSignature, toFunctionSignature, decodeErrorResult, toEventSelector, decodeAbiParameters } from 'viem';
 import nacl from 'tweetnacl';
 import { z } from 'zod';

package/dist/{clientTypes-D2djRDoH.d.cts → clientTypes-BCAMwrqk.d.cts}

@@ -911,8 +911,11 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
     setConsumingContract(address: string): EncryptInputsBuilder<T>;
     getConsumingContract(): string | undefined;
     /**
-     * Asserts that this.consumingContract is populated
-     * @throws {CofheError} If consumingContract is not set
+     * Asserts that this.consumingContract is populated and is an address.
+     * Runs before TFHE init, key fetching and proving, so a bad address costs
+     * nothing: the contract is bound into the proof, and a proof built for a
+     * non-address could only fail at the verifier, after the expensive step.
+     * @throws {CofheError} If consumingContract is not set or is not an address
      */
     private assertConsumingContract;
     /**

package/dist/{clientTypes-B-qOZCx0.d.ts → clientTypes-LvslG7o0.d.ts}

@@ -911,8 +911,11 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuil
     setConsumingContract(address: string): EncryptInputsBuilder<T>;
     getConsumingContract(): string | undefined;
     /**
-     * Asserts that this.consumingContract is populated
-     * @throws {CofheError} If consumingContract is not set
+     * Asserts that this.consumingContract is populated and is an address.
+     * Runs before TFHE init, key fetching and proving, so a bad address costs
+     * nothing: the contract is bound into the proof, and a proof built for a
+     * non-address could only fail at the verifier, after the expensive step.
+     * @throws {CofheError} If consumingContract is not set or is not an address
      */
     private assertConsumingContract;
     /**

package/dist/core.cjs

@@ -60,6 +60,7 @@ var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
   CofheErrorCode2["AccountUninitialized"] = "ACCOUNT_UNINITIALIZED";
   CofheErrorCode2["ChainIdUninitialized"] = "CHAIN_ID_UNINITIALIZED";
   CofheErrorCode2["ConsumingContractUninitialized"] = "CONSUMING_CONTRACT_UNINITIALIZED";
+  CofheErrorCode2["ConsumingContractInvalid"] = "CONSUMING_CONTRACT_INVALID";
   CofheErrorCode2["SealOutputFailed"] = "SEAL_OUTPUT_FAILED";
   CofheErrorCode2["SealOutputReturnedNull"] = "SEAL_OUTPUT_RETURNED_NULL";
   CofheErrorCode2["InvalidUtype"] = "INVALID_UTYPE";
@@ -2129,19 +2130,22 @@ var zkProve = async (builder, crs, metadata) => {
     }, 0);
   });
 };
-var constructZkPoKMetadata = (accountAddr, securityZone, chainId) => {
+var constructZkPoKMetadata = (accountAddr, securityZone, chainId, consumingContract) => {
   const accountAddrNoPrefix = accountAddr.startsWith("0x") ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
+  const contractNoPrefix = consumingContract.startsWith("0x") ? consumingContract.slice(2) : consumingContract;
+  const contractBytes = hexToBytes(contractNoPrefix);
   const chainIdBytes = new Uint8Array(32);
   let value = chainId;
   for (let i = 31; i >= 0 && value > 0; i--) {
     chainIdBytes[i] = value & 255;
     value = value >>> 8;
   }
-  const metadata = new Uint8Array(1 + accountBytes.length + 32);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
+  metadata.set(contractBytes, 1 + accountBytes.length + 32);
   return metadata;
 };
 var zkVerifyBatch = async (verifierUrl, serializedBytes, address, securityZone, chainId, consumingContract) => {
@@ -3057,20 +3061,33 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return this.consumingContract;
   }
   /**
-   * Asserts that this.consumingContract is populated
-   * @throws {CofheError} If consumingContract is not set
+   * Asserts that this.consumingContract is populated and is an address.
+   * Runs before TFHE init, key fetching and proving, so a bad address costs
+   * nothing: the contract is bound into the proof, and a proof built for a
+   * non-address could only fail at the verifier, after the expensive step.
+   * @throws {CofheError} If consumingContract is not set or is not an address
    */
   assertConsumingContract() {
-    if (this.consumingContract)
-      return;
-    throw new CofheError({
-      code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
-      message: "Consuming contract is not set",
-      hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
-      context: {
-        consumingContract: this.consumingContract
-      }
-    });
+    if (!this.consumingContract) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
+        message: "Consuming contract is not set",
+        hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
+    if (!viem.isAddress(this.consumingContract, { strict: false })) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_INVALID" /* ConsumingContractInvalid */,
+        message: "Consuming contract is not an address",
+        hint: "setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
   }
   setUseWorker(useWorker) {
     this.useWorker = useWorker;
@@ -3286,7 +3303,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     zkBuilder = zkPack(this.inputItems, zkBuilder);
     this.fireStepEnd("pack" /* Pack */);
     this.fireStepStart("prove" /* Prove */);
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
     let proof = null;
     let usedWorker = false;
     let workerFailedError;

package/dist/core.d.cts

@@ -1,5 +1,5 @@
-import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-D2djRDoH.cjs';
-export { A as AnyExternalHash, i as CofheClientACPs, C as CofheInputConfig, h as CofheInternalConfig, K as DecryptEndpoint, a4 as DecryptForTxBuilder, a5 as DecryptForTxResult, a3 as DecryptForViewBuilder, J as DecryptPollCallbackContext, G as DecryptPollCallbackFunction, a1 as EncryptInputsBuilder, a2 as EncryptInputsBuilderUnset, M as EncryptSetStateFn, W as EncryptStep, N as EncryptStepCallbackContext, S as Encryptable, p as EncryptableAddress, j as EncryptableBool, E as EncryptableItem, B as EncryptableToExternalHashMap, o as EncryptableUint128, l as EncryptableUint16, m as EncryptableUint32, n as EncryptableUint64, k as EncryptableUint8, q as EncryptedNumber, y as ExternalAddressHash, s as ExternalBoolHash, z as ExternalHashProof, D as ExternalItemHashes, x as ExternalUint128Hash, u as ExternalUint16Hash, v as ExternalUint32Hash, w as ExternalUint64Hash, t as ExternalUint8Hash, R as FheAllUTypes, Z as FheKeyDeserializer, r as FheTypeValue, Q as FheUintUTypes, H as HashPlusProofResult, I as IStorage, $ as KeysStorage, a0 as KeysStore, L as LiteralToPrimitive, P as Primitive, T as TfheInitializer, O as TfheThreadsSetting, U as UnsealedItem, a6 as ZkBuilderAndCrsGenerator, a7 as ZkProveWorkerFunction, a8 as ZkProveWorkerRequest, a9 as ZkProveWorkerResponse, f as assertNoRenamedConfigKeys, e as createCofheConfigBase, _ as createKeysStore, Y as fetchKeys, g as getCofheConfigItem, V as isEncryptableItem, X as isLastEncryptionStep, aa as zkProveWithWorker } from './clientTypes-D2djRDoH.cjs';
+import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-BCAMwrqk.cjs';
+export { A as AnyExternalHash, i as CofheClientACPs, C as CofheInputConfig, h as CofheInternalConfig, K as DecryptEndpoint, a4 as DecryptForTxBuilder, a5 as DecryptForTxResult, a3 as DecryptForViewBuilder, J as DecryptPollCallbackContext, G as DecryptPollCallbackFunction, a1 as EncryptInputsBuilder, a2 as EncryptInputsBuilderUnset, M as EncryptSetStateFn, W as EncryptStep, N as EncryptStepCallbackContext, S as Encryptable, p as EncryptableAddress, j as EncryptableBool, E as EncryptableItem, B as EncryptableToExternalHashMap, o as EncryptableUint128, l as EncryptableUint16, m as EncryptableUint32, n as EncryptableUint64, k as EncryptableUint8, q as EncryptedNumber, y as ExternalAddressHash, s as ExternalBoolHash, z as ExternalHashProof, D as ExternalItemHashes, x as ExternalUint128Hash, u as ExternalUint16Hash, v as ExternalUint32Hash, w as ExternalUint64Hash, t as ExternalUint8Hash, R as FheAllUTypes, Z as FheKeyDeserializer, r as FheTypeValue, Q as FheUintUTypes, H as HashPlusProofResult, I as IStorage, $ as KeysStorage, a0 as KeysStore, L as LiteralToPrimitive, P as Primitive, T as TfheInitializer, O as TfheThreadsSetting, U as UnsealedItem, a6 as ZkBuilderAndCrsGenerator, a7 as ZkProveWorkerFunction, a8 as ZkProveWorkerRequest, a9 as ZkProveWorkerResponse, f as assertNoRenamedConfigKeys, e as createCofheConfigBase, _ as createKeysStore, Y as fetchKeys, g as getCofheConfigItem, V as isEncryptableItem, X as isLastEncryptionStep, aa as zkProveWithWorker } from './clientTypes-BCAMwrqk.cjs';
 import { PublicClient, Address, Hex } from 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';
@@ -55,6 +55,7 @@ declare enum CofheErrorCode {
     AccountUninitialized = "ACCOUNT_UNINITIALIZED",
     ChainIdUninitialized = "CHAIN_ID_UNINITIALIZED",
     ConsumingContractUninitialized = "CONSUMING_CONTRACT_UNINITIALIZED",
+    ConsumingContractInvalid = "CONSUMING_CONTRACT_INVALID",
     SealOutputFailed = "SEAL_OUTPUT_FAILED",
     SealOutputReturnedNull = "SEAL_OUTPUT_RETURNED_NULL",
     InvalidUtype = "INVALID_UTYPE",

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-B-qOZCx0.js';
-export { A as AnyExternalHash, i as CofheClientACPs, C as CofheInputConfig, h as CofheInternalConfig, K as DecryptEndpoint, a4 as DecryptForTxBuilder, a5 as DecryptForTxResult, a3 as DecryptForViewBuilder, J as DecryptPollCallbackContext, G as DecryptPollCallbackFunction, a1 as EncryptInputsBuilder, a2 as EncryptInputsBuilderUnset, M as EncryptSetStateFn, W as EncryptStep, N as EncryptStepCallbackContext, S as Encryptable, p as EncryptableAddress, j as EncryptableBool, E as EncryptableItem, B as EncryptableToExternalHashMap, o as EncryptableUint128, l as EncryptableUint16, m as EncryptableUint32, n as EncryptableUint64, k as EncryptableUint8, q as EncryptedNumber, y as ExternalAddressHash, s as ExternalBoolHash, z as ExternalHashProof, D as ExternalItemHashes, x as ExternalUint128Hash, u as ExternalUint16Hash, v as ExternalUint32Hash, w as ExternalUint64Hash, t as ExternalUint8Hash, R as FheAllUTypes, Z as FheKeyDeserializer, r as FheTypeValue, Q as FheUintUTypes, H as HashPlusProofResult, I as IStorage, $ as KeysStorage, a0 as KeysStore, L as LiteralToPrimitive, P as Primitive, T as TfheInitializer, O as TfheThreadsSetting, U as UnsealedItem, a6 as ZkBuilderAndCrsGenerator, a7 as ZkProveWorkerFunction, a8 as ZkProveWorkerRequest, a9 as ZkProveWorkerResponse, f as assertNoRenamedConfigKeys, e as createCofheConfigBase, _ as createKeysStore, Y as fetchKeys, g as getCofheConfigItem, V as isEncryptableItem, X as isLastEncryptionStep, aa as zkProveWithWorker } from './clientTypes-B-qOZCx0.js';
+import { a as CofheConfig, c as CofheClientParams, b as CofheClient, d as CofheClientConnectionState, F as FheTypes } from './clientTypes-LvslG7o0.js';
+export { A as AnyExternalHash, i as CofheClientACPs, C as CofheInputConfig, h as CofheInternalConfig, K as DecryptEndpoint, a4 as DecryptForTxBuilder, a5 as DecryptForTxResult, a3 as DecryptForViewBuilder, J as DecryptPollCallbackContext, G as DecryptPollCallbackFunction, a1 as EncryptInputsBuilder, a2 as EncryptInputsBuilderUnset, M as EncryptSetStateFn, W as EncryptStep, N as EncryptStepCallbackContext, S as Encryptable, p as EncryptableAddress, j as EncryptableBool, E as EncryptableItem, B as EncryptableToExternalHashMap, o as EncryptableUint128, l as EncryptableUint16, m as EncryptableUint32, n as EncryptableUint64, k as EncryptableUint8, q as EncryptedNumber, y as ExternalAddressHash, s as ExternalBoolHash, z as ExternalHashProof, D as ExternalItemHashes, x as ExternalUint128Hash, u as ExternalUint16Hash, v as ExternalUint32Hash, w as ExternalUint64Hash, t as ExternalUint8Hash, R as FheAllUTypes, Z as FheKeyDeserializer, r as FheTypeValue, Q as FheUintUTypes, H as HashPlusProofResult, I as IStorage, $ as KeysStorage, a0 as KeysStore, L as LiteralToPrimitive, P as Primitive, T as TfheInitializer, O as TfheThreadsSetting, U as UnsealedItem, a6 as ZkBuilderAndCrsGenerator, a7 as ZkProveWorkerFunction, a8 as ZkProveWorkerRequest, a9 as ZkProveWorkerResponse, f as assertNoRenamedConfigKeys, e as createCofheConfigBase, _ as createKeysStore, Y as fetchKeys, g as getCofheConfigItem, V as isEncryptableItem, X as isLastEncryptionStep, aa as zkProveWithWorker } from './clientTypes-LvslG7o0.js';
 import { PublicClient, Address, Hex } from 'viem';
 import './types-C07FK-cL.js';
 import 'zod';
@@ -55,6 +55,7 @@ declare enum CofheErrorCode {
     AccountUninitialized = "ACCOUNT_UNINITIALIZED",
     ChainIdUninitialized = "CHAIN_ID_UNINITIALIZED",
     ConsumingContractUninitialized = "CONSUMING_CONTRACT_UNINITIALIZED",
+    ConsumingContractInvalid = "CONSUMING_CONTRACT_INVALID",
     SealOutputFailed = "SEAL_OUTPUT_FAILED",
     SealOutputReturnedNull = "SEAL_OUTPUT_RETURNED_NULL",
     InvalidUtype = "INVALID_UTYPE",

package/dist/core.js

@@ -1,5 +1,5 @@
-export { InitialConnectStore as CONNECT_STORE_DEFAULTS, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, assertNoRenamedConfigKeys, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, getCofheConfigItem, getCofheDebugInterceptors, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker } from './chunk-VE7DKXSF.js';
+export { InitialConnectStore as CONNECT_STORE_DEFAULTS, DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, assertNoRenamedConfigKeys, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, getCofheConfigItem, getCofheDebugInterceptors, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker } from './chunk-KHM6LYLU.js';
 import './chunk-UKQAJK4N.js';
-export { getTaskManagerAddress } from './chunk-3L2IVPMI.js';
-export { EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, fheTypeToString, isEncryptableItem, isLastEncryptionStep } from './chunk-WJGTPW7K.js';
-export { COFHE_ADDRESS_BOOK_ADDRESS, CofheError, CofheErrorCode, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_TASK_MANAGER_ADDRESS, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ID, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, isCofheError } from './chunk-J23FYAI2.js';
+export { getTaskManagerAddress } from './chunk-WAA2U7CT.js';
+export { EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, fheTypeToString, isEncryptableItem, isLastEncryptionStep } from './chunk-3SD2UCRE.js';
+export { COFHE_ADDRESS_BOOK_ADDRESS, CofheError, CofheErrorCode, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_TASK_MANAGER_ADDRESS, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ID, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, isCofheError } from './chunk-OC5TGQGG.js';

package/dist/node.cjs

@@ -1925,19 +1925,22 @@ var zkProve = async (builder, crs, metadata) => {
     }, 0);
   });
 };
-var constructZkPoKMetadata = (accountAddr, securityZone, chainId) => {
+var constructZkPoKMetadata = (accountAddr, securityZone, chainId, consumingContract) => {
   const accountAddrNoPrefix = accountAddr.startsWith("0x") ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
+  const contractNoPrefix = consumingContract.startsWith("0x") ? consumingContract.slice(2) : consumingContract;
+  const contractBytes = hexToBytes(contractNoPrefix);
   const chainIdBytes = new Uint8Array(32);
   let value = chainId;
   for (let i = 31; i >= 0 && value > 0; i--) {
     chainIdBytes[i] = value & 255;
     value = value >>> 8;
   }
-  const metadata = new Uint8Array(1 + accountBytes.length + 32);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
+  metadata.set(contractBytes, 1 + accountBytes.length + 32);
   return metadata;
 };
 var zkVerifyBatch = async (verifierUrl, serializedBytes, address, securityZone, chainId, consumingContract) => {
@@ -2850,20 +2853,33 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return this.consumingContract;
   }
   /**
-   * Asserts that this.consumingContract is populated
-   * @throws {CofheError} If consumingContract is not set
+   * Asserts that this.consumingContract is populated and is an address.
+   * Runs before TFHE init, key fetching and proving, so a bad address costs
+   * nothing: the contract is bound into the proof, and a proof built for a
+   * non-address could only fail at the verifier, after the expensive step.
+   * @throws {CofheError} If consumingContract is not set or is not an address
    */
   assertConsumingContract() {
-    if (this.consumingContract)
-      return;
-    throw new CofheError({
-      code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
-      message: "Consuming contract is not set",
-      hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
-      context: {
-        consumingContract: this.consumingContract
-      }
-    });
+    if (!this.consumingContract) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
+        message: "Consuming contract is not set",
+        hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
+    if (!viem.isAddress(this.consumingContract, { strict: false })) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_INVALID" /* ConsumingContractInvalid */,
+        message: "Consuming contract is not an address",
+        hint: "setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
   }
   setUseWorker(useWorker) {
     this.useWorker = useWorker;
@@ -3079,7 +3095,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     zkBuilder = zkPack(this.inputItems, zkBuilder);
     this.fireStepEnd("pack" /* Pack */);
     this.fireStepStart("prove" /* Prove */);
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
     let proof = null;
     let usedWorker = false;
     let workerFailedError;

package/dist/node.d.cts

@@ -1,4 +1,4 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-D2djRDoH.cjs';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-BCAMwrqk.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-B-qOZCx0.js';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-LvslG7o0.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';

package/dist/node.js

@@ -1,8 +1,8 @@
-import { createCofheConfigBase, createCofheClientBase } from './chunk-VE7DKXSF.js';
+import { createCofheConfigBase, createCofheClientBase } from './chunk-KHM6LYLU.js';
 import './chunk-UKQAJK4N.js';
-import './chunk-3L2IVPMI.js';
-import { fromHexString } from './chunk-WJGTPW7K.js';
-import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-J23FYAI2.js';
+import './chunk-WAA2U7CT.js';
+import { fromHexString } from './chunk-3SD2UCRE.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-OC5TGQGG.js';
 import { promises } from 'fs';
 import { join } from 'path';
 import { init_panic_hook, ProvenCompactCiphertextList, CompactPkeCrs, TfheCompactPublicKey } from 'node-tfhe';

package/dist/web.cjs

@@ -1960,19 +1960,22 @@ var zkProve = async (builder, crs, metadata) => {
     }, 0);
   });
 };
-var constructZkPoKMetadata = (accountAddr, securityZone, chainId) => {
+var constructZkPoKMetadata = (accountAddr, securityZone, chainId, consumingContract) => {
   const accountAddrNoPrefix = accountAddr.startsWith("0x") ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
+  const contractNoPrefix = consumingContract.startsWith("0x") ? consumingContract.slice(2) : consumingContract;
+  const contractBytes = hexToBytes(contractNoPrefix);
   const chainIdBytes = new Uint8Array(32);
   let value = chainId;
   for (let i = 31; i >= 0 && value > 0; i--) {
     chainIdBytes[i] = value & 255;
     value = value >>> 8;
   }
-  const metadata = new Uint8Array(1 + accountBytes.length + 32);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
+  metadata.set(contractBytes, 1 + accountBytes.length + 32);
   return metadata;
 };
 var zkVerifyBatch = async (verifierUrl, serializedBytes, address, securityZone, chainId, consumingContract) => {
@@ -2885,20 +2888,33 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     return this.consumingContract;
   }
   /**
-   * Asserts that this.consumingContract is populated
-   * @throws {CofheError} If consumingContract is not set
+   * Asserts that this.consumingContract is populated and is an address.
+   * Runs before TFHE init, key fetching and proving, so a bad address costs
+   * nothing: the contract is bound into the proof, and a proof built for a
+   * non-address could only fail at the verifier, after the expensive step.
+   * @throws {CofheError} If consumingContract is not set or is not an address
    */
   assertConsumingContract() {
-    if (this.consumingContract)
-      return;
-    throw new CofheError({
-      code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
-      message: "Consuming contract is not set",
-      hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
-      context: {
-        consumingContract: this.consumingContract
-      }
-    });
+    if (!this.consumingContract) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_UNINITIALIZED" /* ConsumingContractUninitialized */,
+        message: "Consuming contract is not set",
+        hint: "Use setConsumingContract(...) to set the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
+    if (!viem.isAddress(this.consumingContract, { strict: false })) {
+      throw new CofheError({
+        code: "CONSUMING_CONTRACT_INVALID" /* ConsumingContractInvalid */,
+        message: "Consuming contract is not an address",
+        hint: "setConsumingContract(...) takes the 20-byte address of the contract that will consume the encrypted inputs.",
+        context: {
+          consumingContract: this.consumingContract
+        }
+      });
+    }
   }
   setUseWorker(useWorker) {
     this.useWorker = useWorker;
@@ -3114,7 +3130,7 @@ var EncryptInputsBuilder = class extends BaseBuilder {
     zkBuilder = zkPack(this.inputItems, zkBuilder);
     this.fireStepEnd("pack" /* Pack */);
     this.fireStepStart("prove" /* Prove */);
-    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId);
+    const metadata = constructZkPoKMetadata(this.account, this.securityZone, this.chainId, this.consumingContract);
     let proof = null;
     let usedWorker = false;
     let workerFailedError;

package/dist/web.d.cts

@@ -1,4 +1,4 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-D2djRDoH.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-BCAMwrqk.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';

package/dist/web.d.ts

@@ -1,4 +1,4 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-B-qOZCx0.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-LvslG7o0.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';

package/dist/web.js

@@ -1,9 +1,9 @@
-import { createCofheConfigBase, createCofheClientBase } from './chunk-VE7DKXSF.js';
+import { createCofheConfigBase, createCofheClientBase } from './chunk-KHM6LYLU.js';
 import './chunk-UKQAJK4N.js';
-import './chunk-3L2IVPMI.js';
+import './chunk-WAA2U7CT.js';
 import { initTfheThreadPool } from './chunk-KSOV5B4B.js';
-import { fheTypeToString, fromHexString } from './chunk-WJGTPW7K.js';
-import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-J23FYAI2.js';
+import { fheTypeToString, fromHexString } from './chunk-3SD2UCRE.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-OC5TGQGG.js';
 import { constructClient } from 'iframe-shared-storage';
 
 // web/const.ts

package/dist/zkProve.worker.js

@@ -1,6 +1,6 @@
 import { initTfheThreadPool } from './chunk-KSOV5B4B.js';
-import { fromHexString } from './chunk-WJGTPW7K.js';
-import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-J23FYAI2.js';
+import { fromHexString } from './chunk-3SD2UCRE.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-OC5TGQGG.js';
 
 // web/zkProve.worker.ts
 var tfheModule = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "1.1.0-alpha.1",
+  "version": "1.1.0-alpha.3",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",