@interfold/sdk 0.12.0 → 0.13.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   FailureReason: () => FailureReason,
   InterfoldEventType: () => InterfoldEventType,
   InterfoldSDK: () => InterfoldSDK,
+  RandomnessProviderEventType: () => RandomnessProviderEventType,
   RegistryEventType: () => RegistryEventType,
   SDKError: () => SDKError,
   ThresholdBfvParamsPresetNames: () => ThresholdBfvParamsPresetNames,
@@ -547,6 +548,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";
@@ -554,11 +557,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;
@@ -575,6 +587,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 */
@@ -590,6 +604,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: import_types3.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, import_types3.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);
@@ -618,6 +719,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,
@@ -671,13 +773,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");
     }
@@ -736,7 +832,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) {
@@ -1102,6 +1256,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);
   }
@@ -1161,6 +1324,7 @@ var InterfoldSDK = class _InterfoldSDK {
   FailureReason,
   InterfoldEventType,
   InterfoldSDK,
+  RandomnessProviderEventType,
   RegistryEventType,
   SDKError,
   ThresholdBfvParamsPresetNames,