@xyo-network/xl1-protocol-sdk 1.26.32 → 1.26.33

package/dist/neutral/index.mjs

@@ -3731,6 +3731,7 @@ var prettifyZodError = (error) => {
 };
 
 // src/simple/block/SimpleBlockViewer.ts
+var MIN_HEAD_POLL_INTERVAL_MS = 5e3;
 var SimpleBlockViewer = class extends AbstractCreatableProvider {
   moniker = SimpleBlockViewer.defaultMoniker;
   _store;
@@ -3738,10 +3739,16 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   finalizationViewer;
   payloadCache = new LruCacheMap({ max: 1e4 });
   signedHydratedBlockWithDataLakePayloadsCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  _headPollHash;
+  _headPollInProgress = false;
+  _headPollTimer = null;
   _signedHydratedBlockCache;
   get finalizedArchivist() {
     return this.params.finalizedArchivist;
   }
+  get headPollIntervalMs() {
+    return this.params.headPollIntervalMs;
+  }
   get hydratedBlockCache() {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
     const context = this.getBlockContextRead();
@@ -3755,9 +3762,14 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     return this._store;
   }
   static async paramsHandler(params) {
+    const headPollIntervalMs = params.headPollIntervalMs;
+    if (headPollIntervalMs !== void 0) {
+      assertEx32(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+    }
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx32(params.finalizedArchivist, () => "finalizedArchivist is required")
+      finalizedArchivist: assertEx32(params.finalizedArchivist, () => "finalizedArchivist is required"),
+      headPollIntervalMs
     };
   }
   async blockByHash(hash) {
@@ -3876,11 +3888,57 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       head: (await this.finalizationViewer.head())[0]
     };
   }
+  async startHandler() {
+    await super.startHandler();
+    if (this.headPollIntervalMs === void 0) return;
+    await this.pollHead(false);
+    this.startHeadPolling();
+  }
+  async stopHandler() {
+    this.stopHeadPolling();
+    this._headPollHash = void 0;
+    await super.stopHandler();
+  }
   async blockByNumberWithContext(chainContext, blockNumber) {
     const block = asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null;
     const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []];
     return result;
   }
+  async pollHead(emitOnChange) {
+    if (this._headPollInProgress) return;
+    this._headPollInProgress = true;
+    try {
+      const block = await this.currentBlock();
+      const hash = block[0]._hash;
+      if (this._headPollHash === void 0) {
+        this._headPollHash = hash;
+        return;
+      }
+      if (hash !== this._headPollHash) {
+        this._headPollHash = hash;
+        if (emitOnChange) {
+          await this.emit("headUpdated", { block });
+        }
+      }
+    } catch (ex) {
+      this.logger?.error("Error polling block head", ex);
+    } finally {
+      this._headPollInProgress = false;
+    }
+  }
+  startHeadPolling() {
+    if (this.headPollIntervalMs === void 0) return;
+    this.stopHeadPolling();
+    this._headPollTimer = setInterval(() => {
+      void this.pollHead(true);
+    }, this.headPollIntervalMs);
+  }
+  stopHeadPolling() {
+    if (this._headPollTimer) {
+      clearInterval(this._headPollTimer);
+      this._headPollTimer = null;
+    }
+  }
 };
 __publicField(SimpleBlockViewer, "defaultMoniker", BlockViewerMoniker2);
 __publicField(SimpleBlockViewer, "dependencies", [FinalizationViewerMoniker]);