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

package/dist/neutral/index.mjs

@@ -107,7 +107,7 @@ var ActorV3 = class extends AbstractCreatable {
       this._intervals.set(timerName, intervalId);
     }, dueTimeMs);
     this._timeouts.set(timerName, timeoutId);
-    this.logger?.log(
+    this.logger?.debug(
       `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`
     );
   }
@@ -117,11 +117,11 @@ var ActorV3 = class extends AbstractCreatable {
    */
   async stopHandler() {
     await super.stopHandler();
-    this.logger?.log("Stopping all timers...");
+    this.logger?.debug("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...");
+          this.logger?.debug("Waiting for running timer task to complete...");
           await delay(500);
         }
         await semaphore.acquire();
@@ -136,7 +136,7 @@ var ActorV3 = class extends AbstractCreatable {
       clearInterval(intervalRef);
     }
     this._intervals.clear();
-    this.logger?.log("Stopped.");
+    this.logger?.debug("Stopped.");
   }
 };
 var Actor = class extends ActorV3 {
@@ -1074,9 +1074,7 @@ var blockRate = (startBlock, endBlock, timeUnit) => {
 };
 var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
   if (endBlockHeight <= startBlockHeight) {
-    console.error("startBlockHeight", startBlockHeight);
-    console.error("endBlockHeight", endBlockHeight);
-    throw new Error("End block height must be greater than start block height");
+    throw new Error(`End block height must be greater than start block height [start=${startBlockHeight}, end=${endBlockHeight}]`);
   }
   const startingBlock = await viewer.blockByNumber(startBlockHeight);
   const endingBlock = await viewer.blockByNumber(endBlockHeight);
@@ -1145,7 +1143,6 @@ var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, t
   );
 };
 var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
-  console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`);
   assertEx9(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
   const startBlockEpoch = startBlock.$epoch;
   const estimatedEndBlockNumber = asXL1BlockNumber3(startBlock.block - estimatedBlocksBack, true);
@@ -2199,12 +2196,12 @@ var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmSubmittedTransaction = async (viewer, txHash, options) => {
   const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {};
-  options?.logger?.log("\u{1F680} confirming transaction:", txHash, "\n");
+  options?.logger?.debug("Confirming transaction", txHash);
   let attempts = 0;
   while (true) {
     const tx = await viewer.transaction.byHash(txHash) ?? void 0;
     if (isDefined14(tx)) {
-      options?.logger?.log("\u2705 Transaction confirmed:", txHash, "\n");
+      options?.logger?.debug("Transaction confirmed", txHash);
       return tx;
     } else {
       attempts++;
@@ -2212,7 +2209,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
         options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
         throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
       } else {
-        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
+        options?.logger?.debug(`Transaction not confirmed yet, attempt ${attempts}. Retrying...`, txHash);
         await delay2(attemptDelay);
       }
     }
@@ -2712,7 +2709,7 @@ var registerCreatableProviderFactory = (registry, factory, labels, primary = fal
   const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
   for (const primaryMoniker of primaryMonikers) {
     if (!factory.monikers.includes(primaryMoniker)) {
-      console.warn(`Primary moniker ${String(primary)} not found in factory monikers`);
+      throw new Error(`Primary moniker ${String(primaryMoniker)} not found in factory monikers`);
     }
   }
   const isPrimaryForMoniker = (moniker) => {
@@ -2853,7 +2850,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
       if (this.context.singletons[factory.uniqueId]) {
         return this.context.singletons[factory.uniqueId];
       }
-      this.logger?.info(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
+      this.logger?.debug(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
       const result = await factory.getInstance(resolvedParams, { start });
       this.context.singletons[factory.uniqueId] = result;
       return result;
@@ -3734,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;
@@ -3741,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();
@@ -3758,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) {
@@ -3879,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]);
@@ -4015,7 +4070,9 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     const windowedUncleChain = await this.updateWindowedChainCache();
     const uncles = findUncles(this.context, windowedUncleChain, blocks);
     if (uncles.length !== 1) {
-      this.logger?.warn(JSON.stringify({ uncles, blocks: blocks.length }, null, 2));
+      this.logger?.warn(`Unexpected uncle count during block validation [uncles=${uncles.length}, blocks=${blocks.length}]`);
+      this.logger?.debug(JSON.stringify({ uncles, blocks: blocks.length }, null, 2));
+      this.logger?.debug(JSON.stringify(windowedUncleChain, null, 2));
       throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`);
     }
     return await Promise.all(uncles[0].map(async (block) => {
@@ -4381,7 +4438,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
-        console.log(`Could not find current block with hash ${currentHead._hash}`);
+        this.logger?.error(`Could not find current block with hash ${currentHead._hash}`);
       }
       return assertEx36(block, () => "Could not find current block");
     }, this.context);
@@ -4623,7 +4680,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       cursor,
       order: "desc"
     });
-    this.logger?.info(`Starting prunePendingBlocks with batchSize=${batchSize}, maxPrune=${maxPrune}, maxCheck=${maxCheck}`);
+    this.logger?.debug(`Starting prunePendingBlocks with batchSize=${batchSize}, maxPrune=${maxPrune}, maxCheck=${maxCheck}`);
     while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
       const blocksAndBundles = await this.simpleBlockValidationCheck(batch);
       const blocks = blocksAndBundles.map(([b]) => b);
@@ -4647,8 +4704,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       for (const [i, r] of validationResults.entries()) {
         const validated = isSignedHydratedBlockWithHashMeta(r);
         if (!validated) {
-          this.logger?.info(`Pruning block ${bundles[remainingBlockMap[i]]._hash} during block validation`);
-          this.logger?.info(`  - validation result: ${r.at(0)?.message}`);
+          this.logger?.debug(`Pruning block ${bundles[remainingBlockMap[i]]._hash} during block validation`);
+          this.logger?.debug(`  - validation result: ${r.at(0)?.message}`);
         }
         valid[remainingBlockMap[i]] = validated;
       }
@@ -4667,7 +4724,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         order: "desc"
       }) : [];
     }
-    this.logger?.info(`prunePendingBlocks completed: pruned=${pruned}, totalChecked=${total}`);
+    this.logger?.debug(`prunePendingBlocks completed: pruned=${pruned}, totalChecked=${total}`);
     return [pruned, total];
   }
   async prunePendingTransactions({
@@ -4683,7 +4740,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       cursor,
       order: "desc"
     });
-    this.logger?.info(`Starting prunePendingTransactions with batchSize=${batchSize}, maxPrune=${maxPrune}, maxCheck=${maxCheck}`);
+    this.logger?.debug(`Starting prunePendingTransactions with batchSize=${batchSize}, maxPrune=${maxPrune}, maxCheck=${maxCheck}`);
     while (batch.length > 0 && pruned < maxPrune && total < maxCheck) {
       const transactionsAndBundles = await this.simpleTransactionValidationCheck(batch);
       const transactions = transactionsAndBundles.map(([t]) => t);
@@ -4707,8 +4764,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       for (const [i, r] of validationResults.entries()) {
         const validated = isSignedHydratedTransactionWithHashMeta(r);
         if (!validated) {
-          this.logger?.info(`Pruning transaction ${bundles[remainingTransactionMap[i]]._hash} during transaction validation`);
-          this.logger?.info(`  - validation result: ${r.at(0)?.message}`);
+          this.logger?.debug(`Pruning transaction ${bundles[remainingTransactionMap[i]]._hash} during transaction validation`);
+          this.logger?.debug(`  - validation result: ${r.at(0)?.message}`);
         }
         valid[remainingTransactionMap[i]] = validated;
       }
@@ -4727,7 +4784,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         order: "desc"
       }) : [];
     }
-    this.logger?.info(`prunePendingTransactions completed: pruned=${pruned}, totalChecked=${total}`);
+    this.logger?.debug(`prunePendingTransactions completed: pruned=${pruned}, totalChecked=${total}`);
     return [pruned, total];
   }
   async submitBlocks(blocks) {
@@ -4745,7 +4802,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     const maxExp = headNumber + this.maxExpAhead;
     const validTransactions = transactions.filter(([tx]) => {
       if (tx.exp > maxExp) {
-        this.logger?.info(`Rejecting transaction with exp ${tx.exp} exceeding max allowed ${maxExp}`);
+        this.logger?.debug(`Rejecting transaction with exp ${tx.exp} exceeding max allowed ${maxExp}`);
         return false;
       }
       return true;
@@ -4789,11 +4846,11 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       const validationPassed = blockCheckPassed && chainIdPassed && blockNumberPassed && typeCheckPassed;
       const validatedBlock = validationPassed ? block : void 0;
       if (!validationPassed) {
-        this.logger?.info(`Pruning block bundle ${bundle3._hash} during simpleValidationCheck`);
-        this.logger?.info(`  - chainId match: ${chainIdPassed}`);
-        this.logger?.info(`  - blockNumber check: ${blockNumberPassed} [${headNumber}|${block?.[0].block}]`);
-        this.logger?.info(`  - typeCheck: ${typeCheckPassed}`);
-        this.logger?.info(`  - bundle hash: ${bundle3._hash}`);
+        this.logger?.debug(`Pruning block bundle ${bundle3._hash} during simpleValidationCheck`);
+        this.logger?.debug(`  - chainId match: ${chainIdPassed}`);
+        this.logger?.debug(`  - blockNumber check: ${blockNumberPassed} [${headNumber}|${block?.[0].block}]`);
+        this.logger?.debug(`  - typeCheck: ${typeCheckPassed}`);
+        this.logger?.debug(`  - bundle hash: ${bundle3._hash}`);
       }
       return [validatedBlock, bundle3];
     });
@@ -4814,18 +4871,18 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         await validateTransactionsOpcodes(transaction ? [transaction] : []);
         opcodeCheckPassed = true;
       } catch (e) {
-        this.logger?.info(`Opcode validation failed for transaction ${bundle3._hash} during simpleValidationCheck`);
-        this.logger?.info(`  - error: ${e.message}`);
+        this.logger?.debug(`Opcode validation failed for transaction ${bundle3._hash} during simpleValidationCheck`);
+        this.logger?.debug(`  - error: ${e.message}`);
       }
       const validationPassed = transactionCheckPassed && chainIdPassed && expPassed && typeCheckPassed && opcodeCheckPassed;
       const validatedTransaction = validationPassed ? transaction : void 0;
       if (!validationPassed) {
-        this.logger?.info(`Pruning block bundle ${bundle3._hash} during simpleValidationCheck`);
-        this.logger?.info(`  - chainId match: ${chainIdPassed}`);
-        this.logger?.info(`  - exp check: ${expPassed}`);
-        this.logger?.info(`  - opcode check: ${opcodeCheckPassed}`);
-        this.logger?.info(`  - typeCheck: ${typeCheckPassed}`);
-        this.logger?.info(`  - bundle hash: ${bundle3._hash}`);
+        this.logger?.debug(`Pruning block bundle ${bundle3._hash} during simpleValidationCheck`);
+        this.logger?.debug(`  - chainId match: ${chainIdPassed}`);
+        this.logger?.debug(`  - exp check: ${expPassed}`);
+        this.logger?.debug(`  - opcode check: ${opcodeCheckPassed}`);
+        this.logger?.debug(`  - typeCheck: ${typeCheckPassed}`);
+        this.logger?.debug(`  - bundle hash: ${bundle3._hash}`);
       }
       return [validatedTransaction, bundle3];
     }));
@@ -4835,7 +4892,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     if (externalBlocks.length === 0) return;
     const bundles = externalBlocks.map((block) => hydratedBlockToPayloadBundle(block));
     await this.pendingBlocksArchivist.insert(bundles);
-    this.logger?.info(`Synced ${externalBlocks.length} blocks from external mempool`);
+    this.logger?.debug(`Synced ${externalBlocks.length} blocks from external mempool`);
   }
   async syncFromExternal() {
     if (this._syncMutex.isLocked()) return;
@@ -4855,7 +4912,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     if (externalTxs.length === 0) return;
     const bundles = externalTxs.map((tx) => hydratedTransactionToPayloadBundle(tx));
     await this.pendingTransactionsArchivist.insert(bundles);
-    this.logger?.info(`Synced ${externalTxs.length} transactions from external mempool`);
+    this.logger?.debug(`Synced ${externalTxs.length} transactions from external mempool`);
   }
 };
 __publicField(SimpleMempoolRunner, "defaultMoniker", MempoolRunnerMoniker);
@@ -4920,13 +4977,13 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
         cursor = p._sequence;
       }
     }
-    this.logger?.info(`Fetching pending transactions from cursor: ${cursor}`);
+    this.logger?.debug(`Fetching pending transactions from cursor: ${cursor}`);
     const bundles = await this.pendingTransactionsArchivist.next({
       order: "asc",
       limit: limit * 5,
       cursor
     });
-    this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`);
+    this.logger?.debug(`Fetched pending transactions: ${bundles.length} bundles`);
     const filteredBundles = bundles.filter(isPayloadBundle2).filter(isHashMeta2);
     const hydratedWithBundle = (await Promise.all(
       filteredBundles.map(async (bundle3) => {
@@ -4944,11 +5001,11 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     );
     const validTransactions = evaluated.filter((x) => !x.deletable);
     const deletionCandidates = evaluated.filter((x) => x.deletable);
-    this.logger?.info(`Pending transactions: ${validTransactions.length} valid, ${deletionCandidates.length} not deletable`);
+    this.logger?.debug(`Pending transactions: ${validTransactions.length} valid, ${deletionCandidates.length} not deletable`);
     await Promise.all(
       deletionCandidates.map(async ({ bundle: bundle3, tx }) => {
         await this.deleteBundledTransaction(bundle3);
-        this.logger?.info(`Purged completed/expired bundled transaction: ${bundle3._hash}/${tx[0]._hash}`);
+        this.logger?.debug(`Purged completed/expired bundled transaction: ${bundle3._hash}/${tx[0]._hash}`);
       })
     );
     const inclusionCandidates = (await Promise.all(validTransactions.map((x) => x.tx).map(async (tx) => {
@@ -4961,7 +5018,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
       inclusionCandidates.filter(() => Math.random() < selectionRatio)
     ).slice(0, effectiveLimit);
     const result = randomInclusionCandidates.length > 0 ? randomInclusionCandidates : deduplicateBySigner(inclusionCandidates).slice(0, 1);
-    this.logger?.info(`Inclusion candidates: ${inclusionCandidates.length}`);
+    this.logger?.debug(`Inclusion candidates: ${inclusionCandidates.length}`);
     return result;
   }
   async deleteBundledTransaction(bundle3) {
@@ -5055,10 +5112,15 @@ var StatusNetworks = {
 
 // src/simple/network/SimpleXyoNetwork.ts
 var SimpleXyoNetwork = class {
+  _logger;
   _networkId;
-  constructor(networkId) {
+  constructor(networkId, logger) {
+    this._logger = logger;
     this._networkId = networkId;
   }
+  get logger() {
+    return this._logger;
+  }
   async status() {
     const statusNetwork = StatusNetworks[this._networkId];
     if (isUndefined7(statusNetwork)) {
@@ -5073,13 +5135,13 @@ var SimpleXyoNetwork = class {
         return response.data;
       } else {
         if (response.status === 200) {
-          console.error("Unknown network status response:", response.data);
+          this.logger?.error("Unknown network status response", response.data);
           return unknownStatus;
         }
         return errorStatus;
       }
     } catch (error) {
-      console.error("Error fetching network status:", error);
+      this.logger?.error("Error fetching network status", error);
       return errorStatus;
     }
   }
@@ -6030,7 +6092,7 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
           this.addBlock(block);
         }
       } catch (ex) {
-        console.error("Error during sync:", ex);
+        this.logger?.error("Error during sync", ex);
       }
     });
   }