@interfold/sdk 0.13.0 → 0.15.0

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CommitteePublicKeyAssembler: () => CommitteePublicKeyAssembler,
   CommitteeSize: () => CommitteeSize,
   ContractClient: () => ContractClient,
   DEFAULT_COMPUTE_PROVIDER_PARAMS: () => DEFAULT_COMPUTE_PROVIDER_PARAMS,
@@ -40,6 +41,8 @@ __export(index_exports, {
   FailureReason: () => FailureReason,
   InterfoldEventType: () => InterfoldEventType,
   InterfoldSDK: () => InterfoldSDK,
+  MAX_COMMITTEE_PUBLIC_KEY_BYTES: () => MAX_COMMITTEE_PUBLIC_KEY_BYTES,
+  MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES: () => MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES,
   RandomnessProviderEventType: () => RandomnessProviderEventType,
   RegistryEventType: () => RegistryEventType,
   SDKError: () => SDKError,
@@ -132,6 +135,15 @@ var DEFAULT_E3_CONFIG = {
   payment_amount: "0"
   // 0 ETH in wei
 };
+function cryptoConfigIdForParamSet(paramSet) {
+  if (paramSet === 0) {
+    return "0x04f3677e73b0f5066d6caf5cbd92e3fb2e38338edaf5cfc971ab28f7b684da78";
+  }
+  if (paramSet === 1) {
+    return "0xd9c86e581f8291ffb5b63595600e8d096ed30b16e2e0a6634a76c22b1f58fb4e";
+  }
+  throw new SDKError(`Unsupported BFV parameter set: ${paramSet}`, "UNSUPPORTED_CRYPTO_CONFIG");
+}
 function encodeBfvParams(params) {
   const { degree, plaintextModulus, moduli, error1Variance } = params;
   if (error1Variance === void 0) {
@@ -342,11 +354,7 @@ var ContractClient = class _ContractClient {
       }
       const committeeSize = validateCommitteeSize(params.committeeSize);
       const maxFee = params.maxFee ?? await this.getE3Quote(params);
-      const expectedCryptoConfigId = await this.publicClient.readContract({
-        address: this.contracts.interfold,
-        abi: import_types.Interfold__factory.abi,
-        functionName: "activeCryptoConfigId"
-      });
+      const expectedCryptoConfigId = cryptoConfigIdForParamSet(params.paramSet);
       const { request } = await this.publicClient.simulateContract({
         address: this.contracts.interfold,
         abi: import_types.Interfold__factory.abi,
@@ -393,7 +401,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");
     }
@@ -402,11 +410,25 @@ var ContractClient = class _ContractClient {
       if (!account) {
         throw new SDKError("No account connected", "NO_ACCOUNT");
       }
+      const encodedOutputReference = (0, import_viem2.encodeAbiParameters)(
+        [
+          {
+            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: import_types.Interfold__factory.abi,
         functionName: "publishCiphertextOutput",
-        args: [e3Id, ciphertextOutput, ciphertextCommitment, proof],
+        args: [e3Id, encodedOutputReference],
         account,
         gas: gasLimit
       });
@@ -431,11 +453,7 @@ var ContractClient = class _ContractClient {
   async getE3Quote(requestParams) {
     try {
       const committeeSize = validateCommitteeSize(requestParams.committeeSize);
-      const expectedCryptoConfigId = await this.publicClient.readContract({
-        address: this.contracts.interfold,
-        abi: import_types.Interfold__factory.abi,
-        functionName: "activeCryptoConfigId"
-      });
+      const expectedCryptoConfigId = cryptoConfigIdForParamSet(requestParams.paramSet);
       return this.publicClient.readContract({
         address: this.contracts.interfold,
         abi: import_types.Interfold__factory.abi,
@@ -536,6 +554,7 @@ var import_types3 = require("@interfold/contracts/types");
 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";
@@ -551,6 +570,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";
@@ -590,6 +610,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 */
   ]);
@@ -1189,9 +1210,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) {
@@ -1231,8 +1252,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);
@@ -1312,8 +1333,150 @@ var InterfoldSDK = class _InterfoldSDK {
     });
   }
 };
+
+// src/committee-public-key.ts
+var import_viem4 = require("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 || (0, import_viem4.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 (!(0, import_viem4.isHex)(event.chunk)) {
+    throw new Error("Committee public-key chunk is not valid hex");
+  }
+  const chunk = (0, import_viem4.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]);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CommitteePublicKeyAssembler,
   CommitteeSize,
   ContractClient,
   DEFAULT_COMPUTE_PROVIDER_PARAMS,
@@ -1324,6 +1487,8 @@ var InterfoldSDK = class _InterfoldSDK {
   FailureReason,
   InterfoldEventType,
   InterfoldSDK,
+  MAX_COMMITTEE_PUBLIC_KEY_BYTES,
+  MAX_COMMITTEE_PUBLIC_KEY_CHUNK_BYTES,
   RandomnessProviderEventType,
   RegistryEventType,
   SDKError,