@xyo-network/xl1-cli-lib 1.15.21 → 1.15.23

package/dist/node/index.mjs

@@ -8,13 +8,16 @@ import { Mutex } from "async-mutex";
 
 // src/orchestration/actor/model/Actor.ts
 import { Base } from "@xylabs/base";
+import { delay } from "@xylabs/delay";
 import { IdLogger } from "@xylabs/logger";
 import { span, spanRootAsync } from "@xylabs/telemetry";
+import { Semaphore } from "async-mutex";
 var Actor = class extends Base {
   static {
     __name(this, "Actor");
   }
   _intervals = /* @__PURE__ */ new Map();
+  _semaphores = /* @__PURE__ */ new Map();
   _timeouts = /* @__PURE__ */ new Map();
   _active = false;
   _displayName;
@@ -49,14 +52,33 @@ var Actor = class extends Base {
       return;
     }
     let running = false;
+    this._semaphores.set(timerName, new Semaphore(1));
     const timeoutId = setTimeout(() => {
       const intervalId = setInterval(() => {
-        if (!this._active || !this._intervals.has(timerName) || running) return;
-        running = true;
-        callback().catch((error) => {
-          this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
-        }).finally(() => {
-          running = false;
+        const semaphore = this._semaphores.get(timerName);
+        if (!this._active || !this._intervals.has(timerName) || !semaphore || running) return;
+        if (semaphore.isLocked()) {
+          this.logger?.warn(`Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`);
+          return;
+        }
+        semaphore.acquire().then(([, release]) => {
+          const startTime = Date.now();
+          running = true;
+          callback().then(() => {
+            const duration = Date.now() - startTime;
+            if (duration > periodMs) {
+              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`);
+            } else if (duration > 5e3) {
+              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`);
+            }
+          }).catch((error) => {
+            this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
+          }).finally(() => {
+            release();
+            running = false;
+          });
+        }).catch((error) => {
+          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`);
         });
       }, periodMs);
       this._intervals.set(timerName, intervalId);
@@ -86,6 +108,16 @@ var Actor = class extends Base {
     await Promise.resolve();
     this._active = false;
     this.logger?.log("Stopping all timers...");
+    await Promise.all([
+      ...this._semaphores.values()
+    ].map(async (semaphore) => {
+      while (semaphore.isLocked()) {
+        this.logger?.log("Waiting for running timer task to complete...");
+        await delay(500);
+      }
+      await semaphore.acquire();
+    }));
+    this._semaphores.clear();
     for (const [, timeoutRef] of this._timeouts.entries()) {
       clearTimeout(timeoutRef);
     }
@@ -179,9 +211,15 @@ var BalanceActor = class _BalanceActor extends Actor {
     this.chainIterator.on("headUpdate", async () => {
       await this.updateBalance();
     });
-    this.registerTimer("BalanceTimer", async () => {
-      await this.updateBalance();
-    }, 1e3, 1e3);
+    this.registerTimer(
+      "BalanceTimer",
+      async () => {
+        await this.updateBalance();
+      },
+      1e3,
+      1e4
+      /* 1000 */
+    );
   }
   async updateBalance() {
     if (this._updateMutex.isLocked()) return;
@@ -219,7 +257,13 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
     this.chainFinalizedArchivist.on("inserted", async (data) => {
       await this.checkInsertedForNewHead(data);
     });
-    this.registerTimer("ChainHeadUpdateTimer", async () => await this.pollForNewHead(), 0, 250);
+    this.registerTimer(
+      "ChainHeadUpdateTimer",
+      async () => await this.pollForNewHead(),
+      0,
+      2500
+      /* 250 */
+    );
   }
   async checkInsertedForNewHead(data) {
     const candidateBlock = sortBlocks(filterAs(data.payloads, asBlockBoundWitness)).at(-1);
@@ -291,54 +335,19 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   async start() {
     await super.start();
-    this.registerTimer("BlockProductionTimer", async () => {
-      await this.spanAsync("produceBlock", async () => {
-        const head = await this.chainIterator.head();
-        const headHash = await PayloadBuilder2.hash(head);
-        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
-          this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`);
-        } else {
-          const nextBlock = await this.producer.next(head);
-          if (nextBlock) {
-            const displayBlockNumber = `0x${toHex2(nextBlock[0].block)}`;
-            this.logger?.log("Produced block:", displayBlockNumber);
-            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
-            this.logger?.log("Published block:", displayBlockNumber);
-            this._lastProducedBlock = nextBlock;
-          }
-        }
-      });
-    }, 100, 500);
+    this.registerTimer(
+      "BlockProductionTimer",
+      async () => {
+        await this.produceBlock();
+      },
+      100,
+      1500
+      /* 500 */
+    );
     if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
       this.registerTimer("ProducerRedeclarationTimer", async () => {
-        await this.spanAsync("producerRedeclarationTimer", async () => {
-          if (this.params.config.producer.disableIntentRedeclaration) return;
-          const head = await this.chainIterator.head();
-          if (isUndefined(head)) return;
-          const currentBlock = head.block;
-          const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock);
-          if (blocksUntilExpiration > BaseBlockProducerService.RedeclarationWindow * 0.1) {
-            this._lastRedeclarationIntent = void 0;
-            return;
-          }
-          if (this._lastRedeclarationIntent) {
-            if (this._lastRedeclarationIntent.exp > currentBlock) return;
-            this._lastRedeclarationIntent = void 0;
-          }
-          if (!await this.validateCurrentBalance()) {
-            this.logger?.error(`Add balance to address ${this.account.address} for the producer to declare it's intent.`);
-            return;
-          }
-          if (!await this.validateCurrentStake()) {
-            this.logger?.error(`Add stake to contract address ${this.params.config.chain.id} for the producer to declare it's intent.`);
-            return;
-          }
-          this.logger?.log("Creating redeclaration intent for producer:", this.account.address);
-          const redeclarationIntent = createDeclarationIntent(this.account.address, "producer", currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration);
-          await this.submitRedeclarationIntent(currentBlock, redeclarationIntent);
-          this._lastRedeclarationIntent = redeclarationIntent;
-        });
-      }, 1e4, TEN_MINUTES);
+        await this.redeclareIntent();
+      }, TEN_MINUTES, TEN_MINUTES);
     }
   }
   async calculateBlocksUntilProducerDeclarationExpiration(currentBlock) {
@@ -351,6 +360,63 @@ var ProducerActor = class _ProducerActor extends Actor {
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock;
     return timeToProducerExpiration;
   }
+  async produceBlock() {
+    await this.spanAsync("produceBlock", async () => {
+      const headStart = Date.now();
+      const head = await this.chainIterator.head();
+      const headDuration = Date.now() - headStart;
+      if (headDuration > 500) {
+        this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex2(head._hash)}`);
+      }
+      const headHash = head._hash;
+      if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
+        this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`);
+      } else {
+        const nextStart = Date.now();
+        const nextBlock = await this.producer.next(head);
+        const nextDuration = Date.now() - nextStart;
+        if (nextDuration > 1e3) {
+          this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`);
+        }
+        if (nextBlock) {
+          const displayBlockNumber = `0x${toHex2(nextBlock[0].block)}`;
+          this.logger?.log("Produced block:", displayBlockNumber);
+          await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
+          this.logger?.log("Published block:", displayBlockNumber);
+          this._lastProducedBlock = nextBlock;
+        }
+      }
+    });
+  }
+  async redeclareIntent() {
+    await this.spanAsync("redeclareIntent", async () => {
+      if (this.params.config.producer.disableIntentRedeclaration) return;
+      const head = await this.chainIterator.head();
+      if (isUndefined(head)) return;
+      const currentBlock = head.block;
+      const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock);
+      if (blocksUntilExpiration > BaseBlockProducerService.RedeclarationWindow * 0.1) {
+        this._lastRedeclarationIntent = void 0;
+        return;
+      }
+      if (this._lastRedeclarationIntent) {
+        if (this._lastRedeclarationIntent.exp > currentBlock) return;
+        this._lastRedeclarationIntent = void 0;
+      }
+      if (!await this.validateCurrentBalance()) {
+        this.logger?.error(`Add balance to address ${this.account.address} for the producer to declare it's intent.`);
+        return;
+      }
+      if (!await this.validateCurrentStake()) {
+        this.logger?.error(`Add stake to contract address ${this.params.config.chain.id} for the producer to declare it's intent.`);
+        return;
+      }
+      this.logger?.log("Creating redeclaration intent for producer:", this.account.address);
+      const redeclarationIntent = createDeclarationIntent(this.account.address, "producer", currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration);
+      await this.submitRedeclarationIntent(currentBlock, redeclarationIntent);
+      this._lastRedeclarationIntent = redeclarationIntent;
+    });
+  }
   async submitRedeclarationIntent(currentBlock, redeclarationIntent) {
     this.logger?.log("Submitting redeclaration intent for producer:", this.account.address);
     const tx = await buildTransaction(this.chainIterator.chainId, [
@@ -438,25 +504,31 @@ var ValidatorActor = class _ValidatorActor extends Actor {
   }
   async start() {
     await super.start();
-    this.registerTimer("BlockProductionTimer", async () => {
-      await this.spanAsync("produceBlock", async () => {
-        const block = await this.chainIterator.head();
-        if (isUndefined2(block)) return;
-        const hash = await PayloadBuilder3.hash(block);
-        if (isDefined2(this._lastValidatedBlock) && this._lastValidatedBlockHash === hash) {
-          this.logger?.log("Block already validated:", `0x${toHex3(block.block)}`);
-        } else {
-          this.logger?.log("Validating block:", `0x${toHex3(block.block)}`);
-          const valid = await this.validateBlock(block);
-          if (valid) {
-            this.logger?.log("Validated block:", `0x${toHex3(block.block)}`);
+    this.registerTimer(
+      "BlockProductionTimer",
+      async () => {
+        await this.spanAsync("produceBlock", async () => {
+          const block = await this.chainIterator.head();
+          if (isUndefined2(block)) return;
+          const hash = await PayloadBuilder3.hash(block);
+          if (isDefined2(this._lastValidatedBlock) && this._lastValidatedBlockHash === hash) {
+            this.logger?.log("Block already validated:", `0x${toHex3(block.block)}`);
           } else {
-            this.logger?.log("Invalid block:", `0x${toHex3(block.block)}`);
-            await this.slashInvalidBlock(block);
+            this.logger?.log("Validating block:", `0x${toHex3(block.block)}`);
+            const valid = await this.validateBlock(block);
+            if (valid) {
+              this.logger?.log("Validated block:", `0x${toHex3(block.block)}`);
+            } else {
+              this.logger?.log("Invalid block:", `0x${toHex3(block.block)}`);
+              await this.slashInvalidBlock(block);
+            }
           }
-        }
-      });
-    }, 100, 500);
+        });
+      },
+      100,
+      1500
+      /* 500 */
+    );
   }
   async slashInvalidBlock(_block) {
     const slashed = await Promise.resolve(true);
@@ -534,7 +606,7 @@ import { initTelemetry, startupSpanAsync as startupSpanAsync8, StepSizes, valida
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { CompletedStepRewardAddressValidatorFactory, DerivedReceiveAddressValidatorFactory, SelfSignerValidator, TransactionTransfersValidatorFactory } from "@xyo-network/xl1-validation";
-import { Semaphore } from "async-mutex";
+import { Semaphore as Semaphore2 } from "async-mutex";
 
 // src/orchestration/archivists/ChainFinalized/archivist.ts
 import { initArchivistSync, startupSpanAsync } from "@xyo-network/chain-sdk";
@@ -1230,7 +1302,7 @@ var getForkFromBlock = /* @__PURE__ */ __name(async (head, chainService, chainAr
 }, "getForkFromBlock");
 
 // src/orchestration/services/implementation/head/submitNewChain.ts
-import { delay } from "@xylabs/delay";
+import { delay as delay2 } from "@xylabs/delay";
 import { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
 var submitNewChain = /* @__PURE__ */ __name(async (chain, chainArchivist, chainSubmissionsArchivistWrite) => {
   for (const block of chain) {
@@ -1241,7 +1313,7 @@ var submitNewChain = /* @__PURE__ */ __name(async (chain, chainArchivist, chainS
         bw._hash
       ]);
       if (result.length > 0) break;
-      await delay(1e3);
+      await delay2(1e3);
     }
   }
 }, "submitNewChain");
@@ -1578,7 +1650,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     startupSpanAsync8("BalanceService", () => initBalanceService({
       name: "BalanceService",
       context: {
-        stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+        stepSemaphores: StepSizes.map(() => new Semaphore2(20)),
         store: {
           chainMap
         },
@@ -1591,7 +1663,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     startupSpanAsync8("TransferService", () => initTransferService({
       name: "TransferService",
       context: {
-        stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+        stepSemaphores: StepSizes.map(() => new Semaphore2(20)),
         store: {
           chainMap
         },
@@ -1827,7 +1899,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var config;
-var version = isDefined17("1.15.20") ? "1.15.20" : "unknown";
+var version = isDefined17("1.15.22") ? "1.15.22" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
   const logger = initLogger(config3);
   const orchestrator = new Orchestrator(logger);