@interfold/sdk 0.14.0 → 0.15.0

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { PublicClient, WalletClient, Chain, Hash, Abi, Log, Address } from 'viem';
-import { C as ContractAddresses, E as E3RequestParams, a as E3, F as FailureReason, b as E3Stage } from './types-Cwx_flfX.js';
-export { c as CommitteeSize, v as validateCommitteeSize } from './types-Cwx_flfX.js';
+import { PublicClient, WalletClient, Chain, Hash, Abi, Log, Hex, Address } from 'viem';
+import { C as ContractAddresses, E as E3RequestParams, a as CiphertextOutputReference, b as E3, F as FailureReason, c as E3Stage } from './types-BJe3EYvv.js';
+export { d as CommitteeSize, v as validateCommitteeSize } from './types-BJe3EYvv.js';
 import { ThresholdBfvParamsPresetName, BfvParams, EncryptedValueAndPublicInputs, VerifiableEncryptionResult } from './crypto/index.js';
 export { ThresholdBfvParamsPresetNames, computeCiphertextCommitment, computePublicKeyCommitment, encryptNumber, encryptNumberAndGenInputs, encryptNumberAndGenProof, encryptVector, encryptVectorAndGenInputs, encryptVectorAndGenProof, generateProof, generatePublicKey, getThresholdBfvParamsSet } from './crypto/index.js';
-import { AllEventTypes, EventCallback, RandomnessProviderEventType, RandomnessProviderEventCallback } from './events/index.js';
+import { AllEventTypes, EventCallback, RandomnessProviderEventType, RandomnessProviderEventCallback, CommitteePublicKeyChunkPublishedData } from './events/index.js';
 export { CiphernodeAddedData, CiphernodeRemovedData, CiphertextOutputPublishedData, CommitteeFinalizedData, CommitteePublishedData, CommitteeRandomnessRequestedData, CommitteeRequestedData, E3ActivatedData, E3RequestedData, EventFilter, EventListener, EventListenerConfig, EventListenerOptions, InterfoldEvent, InterfoldEventData, InterfoldEventType, PlaintextOutputPublishedData, RandomnessCircuitBreakerTrippedData, RandomnessFulfilledData, RandomnessProviderEvent, RegistryEventData, RegistryEventType, SDKEventEmitter } from './events/index.js';
 export { ContractClient, ContractClientConfig } from './contracts/index.js';
 import '@aztec/bb.js';
@@ -31,9 +31,9 @@ declare class InterfoldSDK {
     /**
      * Validate serialized BFV public-key bytes before using them for encryption.
      *
-     * `CommitteePublished.publicKey` is an untrusted transport value. Consumers
-     * must compare its semantic BFV commitment with the event's on-chain
-     * `pkCommitment` before accepting it.
+     * A reassembled public key is an untrusted transport value. Consumers must
+     * compare its semantic BFV commitment with the on-chain `pkCommitment`
+     * before accepting it.
      */
     validatePublicKeyCommitment(publicKey: Uint8Array, expectedCommitment: Uint8Array): Promise<boolean>;
     encryptNumber(data: bigint, publicKey: Uint8Array): Promise<Uint8Array>;
@@ -46,7 +46,7 @@ declare class InterfoldSDK {
     requestE3(params: E3RequestParams): Promise<Hash>;
     cancelE3(e3Id: bigint): Promise<Hash>;
     getE3PublicKey(e3Id: bigint): Promise<`0x${string}`>;
-    publishCiphertextOutput(e3Id: bigint, ciphertextOutput: `0x${string}`, ciphertextCommitment: `0x${string}`, proof: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    publishCiphertextOutput(e3Id: bigint, outputReference: CiphertextOutputReference, gasLimit?: bigint): Promise<Hash>;
     getE3(e3Id: bigint): Promise<E3>;
     getE3Quote(params: E3RequestParams): Promise<bigint>;
     getFailureReason(e3Id: bigint): Promise<FailureReason>;
@@ -76,6 +76,34 @@ declare class InterfoldSDK {
     }): InterfoldSDK;
 }
 
+declare const MAX_COMMITTEE_PUBLIC_KEY_BYTES: number;
+declare const MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES: number;
+interface AssembledCommitteePublicKey {
+    e3Id: bigint;
+    nodes: string[];
+    pkCommitment: Hex;
+    publicKey: Uint8Array;
+}
+/**
+ * Reassembles the deterministic public-key chunks emitted by the registry.
+ *
+ * The first candidate emitted by each publisher is the only candidate accepted
+ * from that publisher. This matches ciphernode and indexer recovery behavior.
+ */
+declare class CommitteePublicKeyAssembler {
+    private readonly maxTrackedE3s;
+    private readonly selectedCandidates;
+    private readonly assemblies;
+    private readonly invalidAssemblies;
+    private readonly completedAssemblies;
+    private readonly trackedE3s;
+    constructor(maxTrackedE3s?: number);
+    add(event: CommitteePublicKeyChunkPublishedData): AssembledCommitteePublicKey | undefined;
+    clear(e3Id: bigint): void;
+    private track;
+    private dropE3;
+}
+
 declare const DEFAULT_THRESHOLD_BFV_PARAMS_PRESET_NAME: ThresholdBfvParamsPresetName;
 
 declare class SDKError extends Error {
@@ -137,4 +165,4 @@ declare function calculateInputWindow(publicClient: PublicClient, duration?: num
  */
 declare function decodePlaintextOutput(plaintextOutput: string): number | null;
 
-export { AllEventTypes, BfvParams, type ComputeProviderParams, ContractAddresses, DEFAULT_COMPUTE_PROVIDER_PARAMS, DEFAULT_E3_CONFIG, DEFAULT_THRESHOLD_BFV_PARAMS_PRESET_NAME, E3, E3RequestParams, E3Stage, EncryptedValueAndPublicInputs, EventCallback, FailureReason, InterfoldSDK, RandomnessProviderEventCallback, RandomnessProviderEventType, type SDKConfig, SDKError, ThresholdBfvParamsPresetName, VerifiableEncryptionResult, calculateInputWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };
+export { AllEventTypes, type AssembledCommitteePublicKey, BfvParams, CiphertextOutputReference, CommitteePublicKeyAssembler, CommitteePublicKeyChunkPublishedData, type ComputeProviderParams, ContractAddresses, DEFAULT_COMPUTE_PROVIDER_PARAMS, DEFAULT_E3_CONFIG, DEFAULT_THRESHOLD_BFV_PARAMS_PRESET_NAME, E3, E3RequestParams, E3Stage, EncryptedValueAndPublicInputs, EventCallback, FailureReason, InterfoldSDK, MAX_COMMITTEE_PUBLIC_KEY_BYTES, MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES, RandomnessProviderEventCallback, RandomnessProviderEventType, type SDKConfig, SDKError, ThresholdBfvParamsPresetName, VerifiableEncryptionResult, calculateInputWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };

package/dist/index.js

@@ -9,6 +9,7 @@ import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/contracts/contract-client.ts
 import {
+  encodeAbiParameters as encodeAbiParameters2,
   createPublicClient,
   createWalletClient,
   http,
@@ -333,7 +334,7 @@ var ContractClient = class _ContractClient {
       throw new SDKError(`Failed to cancel E3: ${error}`, "CANCEL_E3_FAILED");
     }
   }
-  async publishCiphertextOutput(e3Id, ciphertextOutput, ciphertextCommitment, proof, gasLimit) {
+  async publishCiphertextOutput(e3Id, outputReference, gasLimit) {
     if (!this.walletClient) {
       throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
@@ -342,11 +343,25 @@ var ContractClient = class _ContractClient {
       if (!account) {
         throw new SDKError("No account connected", "NO_ACCOUNT");
       }
+      const encodedOutputReference = encodeAbiParameters2(
+        [
+          {
+            type: "tuple",
+            components: [
+              { name: "contentHash", type: "bytes32" },
+              { name: "ciphertextCommitment", type: "bytes32" },
+              { name: "computeProof", type: "bytes" },
+              { name: "availabilityProof", type: "bytes" }
+            ]
+          }
+        ],
+        [outputReference]
+      );
       const { request } = await this.publicClient.simulateContract({
         address: this.contracts.interfold,
         abi: Interfold__factory.abi,
         functionName: "publishCiphertextOutput",
-        args: [e3Id, ciphertextOutput, ciphertextCommitment, proof],
+        args: [e3Id, encodedOutputReference],
         account,
         gas: gasLimit
       });
@@ -472,6 +487,7 @@ import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnable__factor
 var InterfoldEventType = /* @__PURE__ */ ((InterfoldEventType2) => {
   InterfoldEventType2["E3_REQUESTED"] = "E3Requested";
   InterfoldEventType2["CIPHERTEXT_OUTPUT_PUBLISHED"] = "CiphertextOutputPublished";
+  InterfoldEventType2["CIPHERTEXT_OUTPUT_REFERENCE_PUBLISHED"] = "CiphertextOutputReferencePublished";
   InterfoldEventType2["PLAINTEXT_OUTPUT_PUBLISHED"] = "PlaintextOutputPublished";
   InterfoldEventType2["E3_PROGRAM_REGISTERED"] = "E3ProgramRegistered";
   InterfoldEventType2["ENCRYPTION_SCHEME_ENABLED"] = "EncryptionSchemeEnabled";
@@ -487,6 +503,7 @@ var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
   RegistryEventType2["COMMITTEE_RANDOMNESS_REQUESTED"] = "CommitteeRandomnessRequested";
   RegistryEventType2["RANDOMNESS_CIRCUIT_BREAKER_TRIPPED"] = "RandomnessCircuitBreakerTripped";
   RegistryEventType2["COMMITTEE_PUBLISHED"] = "CommitteePublished";
+  RegistryEventType2["COMMITTEE_PUBLIC_KEY_CHUNK_PUBLISHED"] = "CommitteePublicKeyChunkPublished";
   RegistryEventType2["COMMITTEE_FINALIZED"] = "SortitionCommitteeFinalized";
   RegistryEventType2["INTERFOLD_SET"] = "InterfoldSet";
   RegistryEventType2["OWNERSHIP_TRANSFERRED"] = "OwnershipTransferred";
@@ -526,6 +543,7 @@ var EventListener = class _EventListener {
     "CommitteeRandomnessRequested" /* COMMITTEE_RANDOMNESS_REQUESTED */,
     "RandomnessCircuitBreakerTripped" /* RANDOMNESS_CIRCUIT_BREAKER_TRIPPED */,
     "CommitteePublished" /* COMMITTEE_PUBLISHED */,
+    "CommitteePublicKeyChunkPublished" /* COMMITTEE_PUBLIC_KEY_CHUNK_PUBLISHED */,
     "SortitionCommitteeFinalized" /* COMMITTEE_FINALIZED */,
     "InterfoldSet" /* INTERFOLD_SET */
   ]);
@@ -1133,9 +1151,9 @@ var InterfoldSDK = class _InterfoldSDK {
   /**
    * Validate serialized BFV public-key bytes before using them for encryption.
    *
-   * `CommitteePublished.publicKey` is an untrusted transport value. Consumers
-   * must compare its semantic BFV commitment with the event's on-chain
-   * `pkCommitment` before accepting it.
+   * A reassembled public key is an untrusted transport value. Consumers must
+   * compare its semantic BFV commitment with the on-chain `pkCommitment`
+   * before accepting it.
    */
   async validatePublicKeyCommitment(publicKey, expectedCommitment) {
     if (expectedCommitment.length !== 32) {
@@ -1175,8 +1193,8 @@ var InterfoldSDK = class _InterfoldSDK {
   async getE3PublicKey(e3Id) {
     return this.contractClient.getE3PublicKey(e3Id);
   }
-  async publishCiphertextOutput(e3Id, ciphertextOutput, ciphertextCommitment, proof, gasLimit) {
-    return this.contractClient.publishCiphertextOutput(e3Id, ciphertextOutput, ciphertextCommitment, proof, gasLimit);
+  async publishCiphertextOutput(e3Id, outputReference, gasLimit) {
+    return this.contractClient.publishCiphertextOutput(e3Id, outputReference, gasLimit);
   }
   async getE3(e3Id) {
     return this.contractClient.getE3(e3Id);
@@ -1256,7 +1274,149 @@ var InterfoldSDK = class _InterfoldSDK {
     });
   }
 };
+
+// src/committee-public-key.ts
+import { hexToBytes, isHex, keccak256 } from "viem";
+var MAX_COMMITTEE_PUBLIC_KEY_BYTES = 512 * 1024;
+var MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES = 90 * 1024;
+var DEFAULT_MAX_TRACKED_COMMITTEE_KEYS = 128;
+var CommitteePublicKeyAssembler = class {
+  constructor(maxTrackedE3s = DEFAULT_MAX_TRACKED_COMMITTEE_KEYS) {
+    this.maxTrackedE3s = maxTrackedE3s;
+    if (!Number.isInteger(maxTrackedE3s) || maxTrackedE3s < 1) {
+      throw new Error("Maximum tracked committee-key count must be a positive integer");
+    }
+  }
+  selectedCandidates = /* @__PURE__ */ new Map();
+  assemblies = /* @__PURE__ */ new Map();
+  invalidAssemblies = /* @__PURE__ */ new Set();
+  completedAssemblies = /* @__PURE__ */ new Set();
+  trackedE3s = /* @__PURE__ */ new Map();
+  add(event) {
+    const e3Key = event.e3Id.toString();
+    this.track(e3Key);
+    const metadata = validateEvent(event);
+    const publisherKey = `${e3Key}:${event.publisher.toLowerCase()}`;
+    const selectedCandidate = this.selectedCandidates.get(publisherKey);
+    if (selectedCandidate && selectedCandidate.toLowerCase() !== metadata.candidateHash.toLowerCase()) {
+      return void 0;
+    }
+    this.selectedCandidates.set(publisherKey, metadata.candidateHash);
+    const assemblyKey = `${publisherKey}:${metadata.candidateHash.toLowerCase()}`;
+    if (this.completedAssemblies.has(assemblyKey)) return void 0;
+    if (this.invalidAssemblies.has(assemblyKey)) return void 0;
+    const assembly = this.assemblies.get(assemblyKey) ?? {
+      nodes: [...event.nodes],
+      pkCommitment: metadata.pkCommitment,
+      candidateHash: metadata.candidateHash,
+      totalLength: event.totalLength,
+      chunks: Array.from({ length: event.chunkCount }).fill(void 0)
+    };
+    if (!metadataMatches(assembly, event, metadata.pkCommitment)) {
+      this.assemblies.delete(assemblyKey);
+      this.invalidAssemblies.add(assemblyKey);
+      return void 0;
+    }
+    const existing = assembly.chunks[event.chunkIndex];
+    if (existing && !bytesEqual(existing, metadata.chunk)) {
+      this.assemblies.delete(assemblyKey);
+      this.invalidAssemblies.add(assemblyKey);
+      return void 0;
+    }
+    assembly.chunks[event.chunkIndex] = metadata.chunk;
+    this.assemblies.set(assemblyKey, assembly);
+    if (assembly.chunks.some((chunk) => chunk === void 0)) return void 0;
+    const publicKey = new Uint8Array(assembly.totalLength);
+    let offset = 0;
+    for (const chunk of assembly.chunks) {
+      publicKey.set(chunk, offset);
+      offset += chunk.length;
+    }
+    if (offset !== assembly.totalLength || keccak256(publicKey).toLowerCase() !== assembly.candidateHash.toLowerCase()) {
+      this.assemblies.delete(assemblyKey);
+      this.invalidAssemblies.add(assemblyKey);
+      return void 0;
+    }
+    this.completedAssemblies.add(assemblyKey);
+    this.assemblies.delete(assemblyKey);
+    return {
+      e3Id: event.e3Id,
+      nodes: assembly.nodes,
+      pkCommitment: assembly.pkCommitment,
+      publicKey
+    };
+  }
+  clear(e3Id) {
+    const e3Key = e3Id.toString();
+    this.trackedE3s.delete(e3Key);
+    this.dropE3(e3Key);
+  }
+  track(e3Key) {
+    this.trackedE3s.delete(e3Key);
+    this.trackedE3s.set(e3Key, true);
+    while (this.trackedE3s.size > this.maxTrackedE3s) {
+      const oldest = this.trackedE3s.keys().next().value;
+      if (oldest === void 0) return;
+      this.trackedE3s.delete(oldest);
+      this.dropE3(oldest);
+    }
+  }
+  dropE3(e3Key) {
+    const prefix = `${e3Key}:`;
+    for (const key of this.selectedCandidates.keys()) {
+      if (key.startsWith(prefix)) this.selectedCandidates.delete(key);
+    }
+    for (const key of this.assemblies.keys()) {
+      if (key.startsWith(prefix)) this.assemblies.delete(key);
+    }
+    for (const key of this.invalidAssemblies) {
+      if (key.startsWith(prefix)) this.invalidAssemblies.delete(key);
+    }
+    for (const key of this.completedAssemblies) {
+      if (key.startsWith(prefix)) this.completedAssemblies.delete(key);
+    }
+  }
+};
+function validateEvent(event) {
+  if (!isBytes32(event.candidateHash) || !isBytes32(event.pkCommitment)) {
+    throw new Error("Committee public-key chunk contains an invalid bytes32 value");
+  }
+  if (!Number.isInteger(event.totalLength) || event.totalLength <= 0 || event.totalLength > MAX_COMMITTEE_PUBLIC_KEY_BYTES) {
+    throw new Error("Committee public-key total length is outside the supported range");
+  }
+  const expectedChunkCount = Math.ceil(event.totalLength / MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES);
+  if (!Number.isInteger(event.chunkCount) || event.chunkCount !== expectedChunkCount) {
+    throw new Error("Committee public-key chunk count does not match the total length");
+  }
+  if (!Number.isInteger(event.chunkIndex) || event.chunkIndex < 0 || event.chunkIndex >= event.chunkCount) {
+    throw new Error("Committee public-key chunk index is outside the candidate range");
+  }
+  if (!isHex(event.chunk)) {
+    throw new Error("Committee public-key chunk is not valid hex");
+  }
+  const chunk = hexToBytes(event.chunk);
+  const remaining = event.totalLength - event.chunkIndex * MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES;
+  const expectedLength = Math.min(remaining, MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES);
+  if (chunk.length !== expectedLength) {
+    throw new Error("Committee public-key chunk length does not match its index");
+  }
+  return {
+    candidateHash: event.candidateHash,
+    pkCommitment: event.pkCommitment,
+    chunk
+  };
+}
+function metadataMatches(assembly, event, pkCommitment) {
+  return assembly.totalLength === event.totalLength && assembly.chunks.length === event.chunkCount && assembly.pkCommitment.toLowerCase() === pkCommitment.toLowerCase() && assembly.nodes.length === event.nodes.length && assembly.nodes.every((node, index) => node.toLowerCase() === event.nodes[index]?.toLowerCase());
+}
+function isBytes32(value) {
+  return /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+function bytesEqual(left, right) {
+  return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
 export {
+  CommitteePublicKeyAssembler,
   CommitteeSize,
   ContractClient,
   DEFAULT_COMPUTE_PROVIDER_PARAMS,
@@ -1267,6 +1427,8 @@ export {
   FailureReason,
   InterfoldEventType,
   InterfoldSDK,
+  MAX_COMMITTEE_PUBLIC_KEY_BYTES,
+  MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES,
   RandomnessProviderEventType,
   RegistryEventType,
   SDKError,