@cofhe/sdk 0.5.1 → 0.6.0

package/core/encrypt/encryptInputsBuilder.ts

@@ -16,6 +16,7 @@ import {
   type EncryptedItemInputs,
   type TfheInitializer,
   type EncryptStepCallbackContext,
+  type HashPlusProofResult,
 } from '../types.js';
 import { cofheMocksCheckEncryptableBits, cofheMocksZkVerifySign } from './cofheMocksZkVerifySign.js';
 import { hardhat } from 'viem/chains';
@@ -47,10 +48,11 @@ 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[]> extends BaseBuilder {
+export class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
   private securityZone: number;
   private stepCallback?: EncryptStepCallbackFunction;
   private inputItems: [...T];
+  private hpp: boolean = false;
 
   private zkvWalletClient: WalletClient | undefined;
 
@@ -154,7 +156,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setAccount(account: string): EncryptInputsBuilder<T> {
+  setAccount(account: string): EncryptInputsBuilder<T, HPP> {
     this.account = account;
     return this;
   }
@@ -177,7 +179,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setChainId(chainId: number): EncryptInputsBuilder<T> {
+  setChainId(chainId: number): EncryptInputsBuilder<T, HPP> {
     this.chainId = chainId;
     return this;
   }
@@ -200,7 +202,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setSecurityZone(securityZone: number): EncryptInputsBuilder<T> {
+  setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP> {
     this.securityZone = securityZone;
     return this;
   }
@@ -209,6 +211,21 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return this.securityZone;
   }
 
+  /**
+   * Example:
+   * ```typescript
+   * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
+   *   .asHashPlusProof()
+   *   .execute();
+   * ```
+   *
+   * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+   */
+  asHashPlusProof(): EncryptInputsBuilder<T, true> {
+    this.hpp = true;
+    return this as unknown as EncryptInputsBuilder<T, true>;
+  }
+
   /**
    * @param useWorker - Whether to use Web Workers for ZK proof generation.
    *
@@ -223,7 +240,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The chainable EncryptInputsBuilder instance.
    */
-  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T> {
+  setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP> {
     this.useWorker = useWorker;
     return this;
   }
@@ -260,7 +277,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The EncryptInputsBuilder instance.
    */
-  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T> {
+  onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP> {
     this.stepCallback = callback;
     return this;
   }
@@ -541,7 +558,7 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     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: string }, index: number) => ({
+      ({ ct_hash, signature }: { ct_hash: string; signature: `0x${string}` }, index: number) => ({
         ctHash: BigInt(ct_hash),
         securityZone: this.securityZone,
         utype: this.inputItems[index].utype,
@@ -554,6 +571,18 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
     return encryptedInputs as [...EncryptedItemInputs<T>];
   }
 
+  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;
+    }
+
+    return [...hashes, proof] as unknown as HashPlusProofResult<T>;
+  }
+
   /**
    * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
    *
@@ -573,11 +602,17 @@ export class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuild
    *
    * @returns The encrypted inputs.
    */
-  async execute(): Promise<[...EncryptedItemInputs<T>]> {
-    // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
-    if (this.chainId === hardhat.id) return this.mocksExecute();
+  async execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]> {
+    type Result = HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>];
+
+    let items: [...EncryptedItemInputs<T>];
 
+    // On hardhat chain, interact with MockZkVerifier contract instead of CoFHE
+    if (this.chainId === hardhat.id) items = await this.mocksExecute();
     // On other chains, interact with CoFHE coprocessor
-    return this.productionExecute();
+    else items = await this.productionExecute();
+
+    if (this.hpp) return this.structsToHashPlusProof(items) as unknown as Result;
+    return items as unknown as Result;
   }
 }

package/core/encrypt/zkPackProveVerify.ts

@@ -49,7 +49,7 @@ export type VerifyResultRaw = {
 
 export type VerifyResult = {
   ct_hash: string;
-  signature: string;
+  signature: `0x${string}`;
 };
 
 export type ZkProvenCiphertextList = {
@@ -321,6 +321,6 @@ export const zkVerify = async (
   }
 };
 
-const concatSigRecid = (signature: string, recid: number): string => {
-  return signature + (recid + 27).toString(16).padStart(2, '0');
+const concatSigRecid = (signature: string, recid: number): `0x${string}` => {
+  return `${signature}${(recid + 27).toString(16).padStart(2, '0')}` as `0x${string}`;
 };

package/core/index.ts

@@ -41,6 +41,19 @@ export type {
   EncryptedItemInputs,
   EncryptableToEncryptedItemInputMap,
   FheTypeValue,
+  // Hash-plus-proof external types
+  ExternalBoolHash,
+  ExternalUint8Hash,
+  ExternalUint16Hash,
+  ExternalUint32Hash,
+  ExternalUint64Hash,
+  ExternalUint128Hash,
+  ExternalAddressHash,
+  ExternalHashProof,
+  AnyExternalHash,
+  EncryptableToExternalHashMap,
+  ExternalItemHashes,
+  HashPlusProofResult,
   // Decryption types
   UnsealedItem,
   DecryptPollCallbackFunction,
@@ -96,7 +109,6 @@ export {
   MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
   MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
   MOCKS_THRESHOLD_NETWORK_ADDRESS,
-  TEST_BED_ADDRESS,
   TFHE_RS_ZK_MAX_BITS,
   TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT,
 } from './consts.js';

package/core/test/decryptBuilders.test.ts

@@ -197,6 +197,20 @@ describe('DecryptForTxBuilder', () => {
       expect(selected.getChainId()).toBe(99);
       expect(selected.getAccount()).toBe('0xabc');
     });
+
+    it('should allow configuring 404 retry timeout', () => {
+      const builder = createTxBuilder();
+      const result = builder.set404RetryTimeout(15_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).retry404TimeoutMs).toBe(15_000);
+    });
+
+    it('should throw for invalid 404 retry timeout', () => {
+      const builder = createTxBuilder();
+
+      expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -326,6 +340,20 @@ describe('DecryptForViewBuilder', () => {
       expect(result.getChainId()).toBe(TEST_CHAIN_ID);
       expect(result.getAccount()).toBe(account.address);
     });
+
+    it('should allow configuring 404 retry timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+      const result = builder.set404RetryTimeout(12_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).retry404TimeoutMs).toBe(12_000);
+    });
+
+    it('should throw for invalid 404 retry timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+
+      expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---

package/core/test/encryptInputsBuilder.test.ts

@@ -744,6 +744,41 @@ describe('EncryptInputsBuilder', () => {
     });
   });
 
+  describe('asHashPlusProof', () => {
+    it('should return the same builder instance for chaining', () => {
+      expect(builder.asHashPlusProof()).toBe(builder);
+    });
+
+    it('execute() returns [hash, proof] for a single input', async () => {
+      const result = await builder.asHashPlusProof().execute();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(2); // 1 hash + 1 proof
+    });
+
+    it('execute() returns [hash1, hash2, proof] for two inputs', async () => {
+      const result = await new EncryptInputsBuilder({
+        ...createDefaultParams(),
+        inputs: [Encryptable.uint128(100n), Encryptable.bool(true)] as [
+          ReturnType<typeof Encryptable.uint128>,
+          ReturnType<typeof Encryptable.bool>,
+        ],
+      })
+        .asHashPlusProof()
+        .execute();
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(3); // 2 hashes + 1 proof
+    });
+
+    it('should be composable with other builder methods', async () => {
+      const overriddenSender = '0x5555555555555555555555555555555555555555';
+      const result = await builder.asHashPlusProof().setAccount(overriddenSender).execute();
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(2);
+    });
+  });
+
   describe('setUseWorker and getUseWorker', () => {
     it('should have setUseWorker method', () => {
       expect(builder).toHaveProperty('setUseWorker');

package/core/test/pollCallbacks.test.ts

@@ -188,6 +188,117 @@ describe('decrypt polling callbacks', () => {
     );
   });
 
+  it('tnDecryptV2 calls onPoll for 404 submit retries', async () => {
+    const onPoll = vi.fn();
+
+    let submitCalls = 0;
+    const fetchMock = vi.fn(async (url: string, options?: any) => {
+      if (url === `${thresholdNetworkUrl}/v2/decrypt` && options?.method === 'POST') {
+        submitCalls += 1;
+
+        if (submitCalls === 1) {
+          return makeMockResponse({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            json: async () => ({ message: 'Not Found' }),
+          });
+        }
+
+        return makeMockResponse({
+          ok: true,
+          json: async () => ({ request_id: 'req-submit-retry-404' }),
+        });
+      }
+
+      if (url === `${thresholdNetworkUrl}/v2/decrypt/req-submit-retry-404` && options?.method === 'GET') {
+        return makeMockResponse({
+          ok: true,
+          json: async () => ({
+            request_id: 'req-submit-retry-404',
+            status: 'COMPLETED',
+            submitted_at: 't',
+            is_succeed: true,
+            decrypted: [0x01],
+            signature: `0x${'01'.repeat(32)}${'02'.repeat(32)}1b`,
+          }),
+        });
+      }
+
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+
+    global.fetch = fetchMock as any;
+
+    const promise = tnDecryptV2({
+      ctHash: 1n,
+      chainId: 1,
+      permission: null,
+      thresholdNetworkUrl,
+      onPoll,
+    });
+
+    for (let i = 0; i < 25 && onPoll.mock.calls.length < 1; i += 1) {
+      await Promise.resolve();
+    }
+
+    expect(onPoll).toHaveBeenCalledTimes(1);
+    expect(onPoll).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        operation: 'decrypt',
+        requestId: '',
+        attemptIndex: 0,
+        intervalMs: 1000,
+        timeoutMs: 5 * 60 * 1000,
+      })
+    );
+
+    await vi.advanceTimersByTimeAsync(1000);
+    await promise;
+
+    expect(onPoll).toHaveBeenCalledTimes(2);
+    expect(onPoll).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        operation: 'decrypt',
+        requestId: 'req-submit-retry-404',
+        attemptIndex: 0,
+      })
+    );
+  });
+
+  it('tnDecryptV2 times out 404 submit retries using default timeout', async () => {
+    const fetchMock = vi.fn(async (url: string, options?: any) => {
+      if (url === `${thresholdNetworkUrl}/v2/decrypt` && options?.method === 'POST') {
+        return makeMockResponse({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          json: async () => ({ message: 'Not Found' }),
+        });
+      }
+
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+
+    global.fetch = fetchMock as any;
+
+    const promise = tnDecryptV2({
+      ctHash: 1n,
+      chainId: 1,
+      permission: null,
+      thresholdNetworkUrl,
+    });
+
+    const rejection = expect(promise).rejects.toMatchObject({
+      message: 'decrypt submit retried 404 responses without receiving request_id for 10000ms',
+    });
+
+    await vi.advanceTimersByTimeAsync(11_000);
+    await rejection;
+  });
+
   it('tnDecryptV2 returns immediately when submit responds with cached completed payload', async () => {
     const onPoll = vi.fn();
 
@@ -458,6 +569,121 @@ describe('decrypt polling callbacks', () => {
     );
   });
 
+  it('tnSealOutputV2 calls onPoll for 404 submit retries', async () => {
+    const onPoll = vi.fn();
+
+    let submitCalls = 0;
+    const fetchMock = vi.fn(async (url: string, options?: any) => {
+      if (url === `${thresholdNetworkUrl}/v2/sealoutput` && options?.method === 'POST') {
+        submitCalls += 1;
+
+        if (submitCalls === 1) {
+          return makeMockResponse({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            json: async () => ({ message: 'Not Found' }),
+          });
+        }
+
+        return makeMockResponse({
+          ok: true,
+          json: async () => ({ request_id: 'req-seal-submit-retry-404' }),
+        });
+      }
+
+      if (url === `${thresholdNetworkUrl}/v2/sealoutput/req-seal-submit-retry-404` && options?.method === 'GET') {
+        return makeMockResponse({
+          ok: true,
+          json: async () => ({
+            request_id: 'req-seal-submit-retry-404',
+            status: 'COMPLETED',
+            submitted_at: 't',
+            is_succeed: true,
+            sealed: {
+              data: [1, 2, 3],
+              public_key: [4, 5],
+              nonce: [6],
+            },
+          }),
+        });
+      }
+
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+
+    global.fetch = fetchMock as any;
+
+    const promise = tnSealOutputV2({
+      ctHash: 1n,
+      chainId: 1,
+      permission: {} as any,
+      thresholdNetworkUrl,
+      onPoll,
+    });
+
+    for (let i = 0; i < 25 && onPoll.mock.calls.length < 1; i += 1) {
+      await Promise.resolve();
+    }
+
+    expect(onPoll).toHaveBeenCalledTimes(1);
+    expect(onPoll).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        operation: 'sealoutput',
+        requestId: '',
+        attemptIndex: 0,
+        intervalMs: 1000,
+        timeoutMs: 5 * 60 * 1000,
+      })
+    );
+
+    await vi.advanceTimersByTimeAsync(1000);
+    await promise;
+
+    expect(onPoll).toHaveBeenCalledTimes(2);
+    expect(onPoll).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        operation: 'sealoutput',
+        requestId: 'req-seal-submit-retry-404',
+        attemptIndex: 0,
+      })
+    );
+  });
+
+  it('tnSealOutputV2 uses custom 404 submit retry timeout', async () => {
+    const fetchMock = vi.fn(async (url: string, options?: any) => {
+      if (url === `${thresholdNetworkUrl}/v2/sealoutput` && options?.method === 'POST') {
+        return makeMockResponse({
+          ok: false,
+          status: 404,
+          statusText: 'Not Found',
+          json: async () => ({ message: 'Not Found' }),
+        });
+      }
+
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+
+    global.fetch = fetchMock as any;
+
+    const promise = tnSealOutputV2({
+      ctHash: 1n,
+      chainId: 1,
+      permission: {} as any,
+      thresholdNetworkUrl,
+      retry404TimeoutMs: 2000,
+    });
+
+    const rejection = expect(promise).rejects.toMatchObject({
+      message: 'sealOutput submit retried 404 responses without receiving request_id for 2000ms',
+    });
+
+    await vi.advanceTimersByTimeAsync(3000);
+    await rejection;
+  });
+
   it('tnSealOutputV2 returns immediately when submit responds with cached completed payload', async () => {
     const onPoll = vi.fn();
 

package/core/types.ts

@@ -111,16 +111,14 @@ export type EncryptedNumber = {
   securityZone: number;
 };
 
-export type EncryptedItemInput<TSignature = string> = {
+export type EncryptedItemInput = {
   ctHash: bigint;
   securityZone: number;
   utype: FheTypes;
-  signature: TSignature;
+  signature: `0x${string}`;
 };
 
-export function assertCorrectEncryptedItemInput(
-  input: EncryptedItemInput
-): asserts input is EncryptedItemInput<`0x${string}`> {
+export function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput {
   if (!input.signature.startsWith('0x')) throw new Error('Signature must be a hex string starting with 0x');
 }
 
@@ -387,6 +385,68 @@ export type EncryptStepCallbackContext = Record<string, any> & {
 };
 export type EncryptStepCallbackFunction = (state: EncryptStep, context?: EncryptStepCallbackContext) => void;
 
+// HASH PLUS PROOF ENCRYPTED INPUTS
+
+/**
+ * Branded bytes32 types for external encrypted inputs (Solidity: externalEbool, externalEuint*, externalEaddress).
+ * The readonly `utype` field brands each hash so it can't be accidentally passed to the wrong asE* function.
+ */
+export type ExternalBoolHash = `0x${string}` & { readonly utype: FheTypes.Bool };
+export type ExternalUint8Hash = `0x${string}` & { readonly utype: FheTypes.Uint8 };
+export type ExternalUint16Hash = `0x${string}` & { readonly utype: FheTypes.Uint16 };
+export type ExternalUint32Hash = `0x${string}` & { readonly utype: FheTypes.Uint32 };
+export type ExternalUint64Hash = `0x${string}` & { readonly utype: FheTypes.Uint64 };
+export type ExternalUint128Hash = `0x${string}` & { readonly utype: FheTypes.Uint128 };
+export type ExternalAddressHash = `0x${string}` & { readonly utype: FheTypes.Uint160 };
+
+/** Branded bytes proof blob (Solidity: bytes memory proof). */
+export type ExternalHashProof = `0x${string}` & { readonly _kind: 'ExternalHashProof' };
+
+/** Union of all External*Hash types — useful for utilities that operate on any hash without caring about the specific FHE type. */
+export type AnyExternalHash =
+  | ExternalBoolHash
+  | ExternalUint8Hash
+  | ExternalUint16Hash
+  | ExternalUint32Hash
+  | ExternalUint64Hash
+  | ExternalUint128Hash
+  | ExternalAddressHash;
+
+/**
+ * Maps a single EncryptableItem to its corresponding External*Hash type.
+ * Mirrors EncryptableToEncryptedItemInputMap.
+ */
+export type EncryptableToExternalHashMap<E extends EncryptableItem> = E extends EncryptableBool
+  ? ExternalBoolHash
+  : E extends EncryptableUint8
+    ? ExternalUint8Hash
+    : E extends EncryptableUint16
+      ? ExternalUint16Hash
+      : E extends EncryptableUint32
+        ? ExternalUint32Hash
+        : E extends EncryptableUint64
+          ? ExternalUint64Hash
+          : E extends EncryptableUint128
+            ? ExternalUint128Hash
+            : E extends EncryptableAddress
+              ? ExternalAddressHash
+              : never;
+
+/**
+ * Maps an EncryptableItem[] tuple to a tuple of corresponding External*Hash types,
+ * preserving index positions. e.g. [EncryptableBool, EncryptableUint32] → [ExternalBoolHash, ExternalUint32Hash]
+ */
+export type ExternalItemHashes<T extends EncryptableItem[]> = {
+  [K in keyof T]: T[K] extends EncryptableItem ? EncryptableToExternalHashMap<T[K]> : never;
+};
+
+/**
+ * Return type of EncryptInputsBuilder.execute() when asHashPlusProof() is set.
+ * Tuple of per-input hashes in input order, followed by a single proof blob.
+ * e.g. [Encryptable.bool(true), Encryptable.uint32(5)] → [ExternalBoolHash, ExternalUint32Hash, ExternalHashProof]
+ */
+export type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];
+
 // DECRYPT
 
 export type DecryptEndpoint = 'decrypt' | 'sealoutput';

package/dist/chains.cjs

@@ -67,9 +67,9 @@ var hardhat = defineChain({
   name: "Hardhat",
   network: "localhost",
   // These are unused in the mock environment
-  coFheUrl: "http://127.0.0.1:8448",
-  verifierUrl: "http://127.0.0.1:3001",
-  thresholdNetworkUrl: "http://127.0.0.1:3000",
+  coFheUrl: "http://ignored-in-mock-environment",
+  verifierUrl: "http://ignored-in-mock-environment",
+  thresholdNetworkUrl: "http://ignored-in-mock-environment",
   environment: "MOCK"
 });
 

package/dist/chains.js

@@ -1 +1 @@
-export { arbSepolia, baseSepolia, chains, getChainById, getChainByName, hardhat, localcofhe, sepolia } from './chunk-TBLR7NNE.js';
+export { arbSepolia, baseSepolia, chains, getChainById, getChainByName, hardhat, localcofhe, sepolia } from './chunk-MTRAXQXC.js';

package/dist/{chunk-4FP4V35O.js → chunk-ESMZCFJY.js}

@@ -2,7 +2,6 @@
 var TASK_MANAGER_ADDRESS = "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
 var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
 var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
-var TEST_BED_ADDRESS = "0x0000000000000000000000000000000000005003";
 var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
 var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
 var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
@@ -10,4 +9,4 @@ var TFHE_RS_ZK_MAX_BITS = 2048;
 var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
 var TFHE_RS_KEY_VERSION = 2;
 
-export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TEST_BED_ADDRESS, TFHE_RS_KEY_VERSION, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS };
+export { MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ADDRESS, TFHE_RS_KEY_VERSION, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS };

package/dist/{chunk-TBLR7NNE.js → chunk-MTRAXQXC.js}

@@ -65,9 +65,9 @@ var hardhat = defineChain({
   name: "Hardhat",
   network: "localhost",
   // These are unused in the mock environment
-  coFheUrl: "http://127.0.0.1:8448",
-  verifierUrl: "http://127.0.0.1:3001",
-  thresholdNetworkUrl: "http://127.0.0.1:3000",
+  coFheUrl: "http://ignored-in-mock-environment",
+  verifierUrl: "http://ignored-in-mock-environment",
+  thresholdNetworkUrl: "http://ignored-in-mock-environment",
   environment: "MOCK"
 });