@interfold/sdk 0.12.1 → 0.14.0

package/dist/index.d.ts

@@ -3,8 +3,8 @@ import { C as ContractAddresses, E as E3RequestParams, a as E3, F as FailureReas
 export { c as CommitteeSize, v as validateCommitteeSize } from './types-Cwx_flfX.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 } from './events/index.js';
-export { CiphernodeAddedData, CiphernodeRemovedData, CiphertextOutputPublishedData, CommitteeFinalizedData, CommitteePublishedData, CommitteeRequestedData, E3ActivatedData, E3RequestedData, EventFilter, EventListener, EventListenerConfig, EventListenerOptions, InterfoldEvent, InterfoldEventData, InterfoldEventType, PlaintextOutputPublishedData, RegistryEventData, RegistryEventType, SDKEventEmitter } from './events/index.js';
+import { AllEventTypes, EventCallback, RandomnessProviderEventType, RandomnessProviderEventCallback } 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';
 
@@ -54,6 +54,9 @@ declare class InterfoldSDK {
     estimateGas(functionName: string, args: readonly unknown[], contractAddress: `0x${string}`, abi: Abi, value?: bigint): Promise<bigint>;
     waitForTransaction(hash: Hash): Promise<unknown>;
     onInterfoldEvent<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): Promise<void>;
+    onRandomnessProviderEvent<T extends RandomnessProviderEventType>(provider: `0x${string}`, eventType: T, callback: RandomnessProviderEventCallback<T>, fromBlock?: bigint): Promise<void>;
+    offRandomnessProviderEvent<T extends RandomnessProviderEventType>(provider: `0x${string}`, eventType: T, callback: RandomnessProviderEventCallback<T>): void;
+    getHistoricalRandomnessProviderEvents(provider: `0x${string}`, eventType: RandomnessProviderEventType, fromBlock?: bigint, toBlock?: bigint): Promise<Log[]>;
     off<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
     once<T extends AllEventTypes>(type: T, callback: EventCallback<T>): Promise<void>;
     getHistoricalEvents(eventType: AllEventTypes, fromBlock?: bigint, toBlock?: bigint): Promise<Log[]>;
@@ -134,4 +137,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, type SDKConfig, SDKError, ThresholdBfvParamsPresetName, VerifiableEncryptionResult, calculateInputWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };
+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 };

package/dist/index.js

@@ -67,6 +67,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) {
@@ -277,11 +286,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: Interfold__factory.abi,
-        functionName: "activeCryptoConfigId"
-      });
+      const expectedCryptoConfigId = cryptoConfigIdForParamSet(params.paramSet);
       const { request } = await this.publicClient.simulateContract({
         address: this.contracts.interfold,
         abi: Interfold__factory.abi,
@@ -366,11 +371,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: Interfold__factory.abi,
-        functionName: "activeCryptoConfigId"
-      });
+      const expectedCryptoConfigId = cryptoConfigIdForParamSet(requestParams.paramSet);
       return this.publicClient.readContract({
         address: this.contracts.interfold,
         abi: Interfold__factory.abi,
@@ -465,7 +466,7 @@ var ContractClient = class _ContractClient {
 };
 
 // src/events/event-listener.ts
-import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnable__factory2, Interfold__factory as Interfold__factory2 } from "@interfold/contracts/types";
+import { CiphernodeRegistryOwnable__factory as CiphernodeRegistryOwnable__factory2, Interfold__factory as Interfold__factory2, IRandomnessProvider__factory } from "@interfold/contracts/types";
 
 // src/events/types.ts
 var InterfoldEventType = /* @__PURE__ */ ((InterfoldEventType2) => {
@@ -483,6 +484,8 @@ var InterfoldEventType = /* @__PURE__ */ ((InterfoldEventType2) => {
 })(InterfoldEventType || {});
 var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
   RegistryEventType2["COMMITTEE_REQUESTED"] = "CommitteeRequested";
+  RegistryEventType2["COMMITTEE_RANDOMNESS_REQUESTED"] = "CommitteeRandomnessRequested";
+  RegistryEventType2["RANDOMNESS_CIRCUIT_BREAKER_TRIPPED"] = "RandomnessCircuitBreakerTripped";
   RegistryEventType2["COMMITTEE_PUBLISHED"] = "CommitteePublished";
   RegistryEventType2["COMMITTEE_FINALIZED"] = "SortitionCommitteeFinalized";
   RegistryEventType2["INTERFOLD_SET"] = "InterfoldSet";
@@ -490,11 +493,20 @@ var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
   RegistryEventType2["INITIALIZED"] = "Initialized";
   return RegistryEventType2;
 })(RegistryEventType || {});
+var RandomnessProviderEventType = /* @__PURE__ */ ((RandomnessProviderEventType2) => {
+  RandomnessProviderEventType2["RANDOMNESS_FULFILLED"] = "RandomnessFulfilled";
+  return RandomnessProviderEventType2;
+})(RandomnessProviderEventType || {});
 
 // src/events/event-listener.ts
 var EventListener = class _EventListener {
+  static DEFAULT_HISTORICAL_BLOCK_RANGE = 10000n;
+  static MAX_REMEMBERED_LOGS = 1e4;
   listeners = /* @__PURE__ */ new Map();
   activeWatchers = /* @__PURE__ */ new Map();
+  watcherStartBlocks = /* @__PURE__ */ new Map();
+  randomnessProviderListeners = /* @__PURE__ */ new Map();
+  seenLiveLogs = /* @__PURE__ */ new Map();
   isPolling = false;
   lastBlockNumber = BigInt(0);
   publicClient;
@@ -511,6 +523,8 @@ var EventListener = class _EventListener {
   // runtime; those default to the Interfold contract.
   static REGISTRY_ONLY_EVENTS = /* @__PURE__ */ new Set([
     "CommitteeRequested" /* COMMITTEE_REQUESTED */,
+    "CommitteeRandomnessRequested" /* COMMITTEE_RANDOMNESS_REQUESTED */,
+    "RandomnessCircuitBreakerTripped" /* RANDOMNESS_CIRCUIT_BREAKER_TRIPPED */,
     "CommitteePublished" /* COMMITTEE_PUBLISHED */,
     "SortitionCommitteeFinalized" /* COMMITTEE_FINALIZED */,
     "InterfoldSet" /* INTERFOLD_SET */
@@ -526,6 +540,93 @@ var EventListener = class _EventListener {
     const { address, abi } = this.resolveContract(eventType);
     return this.watchContractEvent(address, eventType, abi, callback);
   }
+  async onRandomnessProviderEvent(provider, eventType, callback, fromBlock) {
+    const listenerKey = `${provider.toLowerCase()}:${eventType}`;
+    const watcherKey = `randomness-provider:${listenerKey}`;
+    const requestedStartBlock = fromBlock ?? this.config.fromBlock;
+    let callbacks = this.randomnessProviderListeners.get(listenerKey);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.randomnessProviderListeners.set(listenerKey, callbacks);
+    }
+    if (this.activeWatchers.has(watcherKey)) {
+      const activeStartBlock = this.watcherStartBlocks.get(watcherKey);
+      if (fromBlock !== void 0 && requestedStartBlock !== activeStartBlock) {
+        throw new SDKError(
+          `Randomness provider watcher for ${eventType} on ${provider} already starts at ${activeStartBlock ?? "latest"}; requested ${requestedStartBlock ?? "latest"}`,
+          "INVALID_EVENT_CONFIG"
+        );
+      }
+      callbacks.add(callback);
+      return;
+    }
+    callbacks.add(callback);
+    try {
+      const unwatch = this.publicClient.watchContractEvent({
+        address: provider,
+        abi: IRandomnessProvider__factory.abi,
+        eventName: eventType,
+        fromBlock: requestedStartBlock,
+        onLogs: (logs) => {
+          for (const log of logs) {
+            if (!this.rememberLiveLog(log)) continue;
+            const event = {
+              type: eventType,
+              data: log.args,
+              provider,
+              log,
+              timestamp: /* @__PURE__ */ new Date(),
+              blockNumber: log.blockNumber ?? 0n,
+              transactionHash: log.transactionHash ?? "0x"
+            };
+            const currentCallbacks = this.randomnessProviderListeners.get(listenerKey);
+            currentCallbacks?.forEach((currentCallback) => {
+              try {
+                const result = currentCallback(event);
+                if (result) {
+                  void result.catch((error) => {
+                    console.error(`Error in randomness provider callback for ${eventType}:`, error);
+                  });
+                }
+              } catch (error) {
+                console.error(`Error in randomness provider callback for ${eventType}:`, error);
+              }
+            });
+          }
+        }
+      });
+      this.activeWatchers.set(watcherKey, unwatch);
+      this.watcherStartBlocks.set(watcherKey, requestedStartBlock);
+    } catch (error) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) this.randomnessProviderListeners.delete(listenerKey);
+      throw new SDKError(`Failed to watch randomness provider event ${eventType} on ${provider}: ${error}`, "WATCH_EVENT_FAILED");
+    }
+  }
+  offRandomnessProviderEvent(provider, eventType, callback) {
+    const listenerKey = `${provider.toLowerCase()}:${eventType}`;
+    const callbacks = this.randomnessProviderListeners.get(listenerKey);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) {
+      this.randomnessProviderListeners.delete(listenerKey);
+      const watcherKey = `randomness-provider:${listenerKey}`;
+      const unwatch = this.activeWatchers.get(watcherKey);
+      if (unwatch) unwatch();
+      this.activeWatchers.delete(watcherKey);
+      this.watcherStartBlocks.delete(watcherKey);
+    }
+  }
+  async getHistoricalRandomnessProviderEvents(provider, eventType, fromBlock, toBlock) {
+    const start = fromBlock ?? this.config.fromBlock;
+    if (start === void 0) {
+      throw new SDKError("Randomness provider history requires fromBlock or EventListenerConfig.fromBlock", "INVALID_EVENT_CONFIG");
+    }
+    try {
+      return await this.getHistoricalContractEvents(provider, IRandomnessProvider__factory.abi, eventType, start, toBlock);
+    } catch (error) {
+      throw new SDKError(`Failed to get randomness provider events from ${provider}: ${error}`, "HISTORICAL_EVENTS_FAILED");
+    }
+  }
   async once(type, callback) {
     const handler = (event) => {
       this.off(type, handler);
@@ -554,6 +655,7 @@ var EventListener = class _EventListener {
             for (let i = 0; i < logs.length; i++) {
               const log = logs[i];
               if (!log) break;
+              if (!emitter.rememberLiveLog(log)) continue;
               const event = {
                 type: eventType,
                 data: log.args,
@@ -607,13 +709,7 @@ var EventListener = class _EventListener {
   async getHistoricalEvents(eventType, fromBlock, toBlock) {
     const { address, abi } = this.resolveContract(eventType);
     try {
-      return await this.publicClient.getContractEvents({
-        address,
-        abi,
-        eventName: eventType,
-        fromBlock: fromBlock ?? this.config.fromBlock,
-        toBlock: toBlock ?? this.config.toBlock
-      });
+      return await this.getHistoricalContractEvents(address, abi, eventType, fromBlock, toBlock);
     } catch (error) {
       throw new SDKError(`Failed to get historical events: ${error}`, "HISTORICAL_EVENTS_FAILED");
     }
@@ -672,7 +768,65 @@ var EventListener = class _EventListener {
       }
     });
     this.activeWatchers.clear();
+    this.watcherStartBlocks.clear();
     this.listeners.clear();
+    this.randomnessProviderListeners.clear();
+    this.seenLiveLogs.clear();
+  }
+  logIdentity(log) {
+    if (log.blockHash && log.transactionHash && log.logIndex !== null && log.logIndex !== void 0) {
+      return `${log.blockHash}:${log.transactionHash}:${log.logIndex}:${Boolean(log.removed)}`;
+    }
+    return void 0;
+  }
+  rememberLiveLog(log) {
+    const identity = this.logIdentity(log);
+    if (!identity) return true;
+    if (this.seenLiveLogs.has(identity)) return false;
+    this.seenLiveLogs.set(identity, true);
+    if (this.seenLiveLogs.size > _EventListener.MAX_REMEMBERED_LOGS) {
+      const oldest = this.seenLiveLogs.keys().next().value;
+      if (oldest !== void 0) this.seenLiveLogs.delete(oldest);
+    }
+    return true;
+  }
+  async getHistoricalContractEvents(address, abi, eventName, fromBlock, toBlock) {
+    const start = fromBlock ?? this.config.fromBlock;
+    const configuredEnd = toBlock ?? this.config.toBlock;
+    if (start === void 0) {
+      return await this.publicClient.getContractEvents({
+        address,
+        abi,
+        eventName,
+        toBlock: configuredEnd
+      });
+    }
+    const end = configuredEnd ?? await this.publicClient.getBlockNumber({ cacheTime: 0 });
+    if (end < start) return [];
+    const range = this.config.historicalBlockRange ?? _EventListener.DEFAULT_HISTORICAL_BLOCK_RANGE;
+    if (range <= 0n) throw new SDKError("Historical block range must be greater than zero", "INVALID_EVENT_CONFIG");
+    const logs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let cursor = start; cursor <= end; cursor += range) {
+      const chunkEnd = cursor + range - 1n < end ? cursor + range - 1n : end;
+      const chunk = await this.publicClient.getContractEvents({
+        address,
+        abi,
+        eventName,
+        fromBlock: cursor,
+        toBlock: chunkEnd
+      });
+      for (const log of chunk) {
+        const identity = this.logIdentity(log);
+        if (identity && seen.has(identity)) continue;
+        if (identity) {
+          seen.add(identity);
+          this.rememberLiveLog(log);
+        }
+        logs.push(log);
+      }
+    }
+    return logs;
   }
   async pollForEvents() {
     while (this.isPolling) {
@@ -1046,6 +1200,15 @@ var InterfoldSDK = class _InterfoldSDK {
   async onInterfoldEvent(eventType, callback) {
     return this.eventListener.onInterfoldEvent(eventType, callback);
   }
+  async onRandomnessProviderEvent(provider, eventType, callback, fromBlock) {
+    return this.eventListener.onRandomnessProviderEvent(provider, eventType, callback, fromBlock);
+  }
+  offRandomnessProviderEvent(provider, eventType, callback) {
+    this.eventListener.offRandomnessProviderEvent(provider, eventType, callback);
+  }
+  async getHistoricalRandomnessProviderEvents(provider, eventType, fromBlock, toBlock) {
+    return this.eventListener.getHistoricalRandomnessProviderEvents(provider, eventType, fromBlock, toBlock);
+  }
   off(eventType, callback) {
     this.eventListener.off(eventType, callback);
   }
@@ -1104,6 +1267,7 @@ export {
   FailureReason,
   InterfoldEventType,
   InterfoldSDK,
+  RandomnessProviderEventType,
   RegistryEventType,
   SDKError,
   ThresholdBfvParamsPresetNames,