@xyo-network/chain-services 1.3.17 → 1.3.19

package/dist/neutral/index.mjs

@@ -19,15 +19,9 @@ var BaseService = class extends BaseEmitter {
   static get singletons() {
     return globalThis["xyoServiceSingletons"] ?? (globalThis["xyoServiceSingletons"] = {});
   }
-  get meter() {
-    return this.params.meterProvider?.getMeter(this.name);
-  }
   get name() {
     return this.constructor.name;
   }
-  get tracer() {
-    return this.params.traceProvider?.getTracer(this.name);
-  }
   static async create(params) {
     const result = new this(params);
     if (result.name === "BaseService") throw new Error("Cannot create BaseService");
@@ -46,8 +40,8 @@ var BaseService = class extends BaseEmitter {
   span(name, fn) {
     return span(`${this.name}:${name}`, fn, this.tracer);
   }
-  async spanAsync(name, fn, timeout) {
-    return await spanAsync(`${this.name}:${name}`, fn, this.tracer, timeout);
+  async spanAsync(name, fn) {
+    return await spanAsync(`${this.name}:${name}`, fn, this.tracer);
   }
 };
 var BaseAccountableService = class extends BaseService {
@@ -651,11 +645,12 @@ XyoElectionService = _ts_decorate6([
 ], XyoElectionService);
 
 // src/PendingTransactions/PendingTransactions.ts
+import { ValueType } from "@opentelemetry/api";
 import { filterAs, filterAsync } from "@xylabs/array";
 import { assertEx as assertEx7 } from "@xylabs/assert";
 import { exists } from "@xylabs/exists";
+import { forget } from "@xylabs/forget";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { hydrateBlock } from "@xyo-network/chain-protocol";
 import { validateTransaction } from "@xyo-network/chain-validation";
 import { asOptionalTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { flattenHydratedTransactions, tryHydrateTransaction } from "@xyo-network/xl1-protocol-sdk";
@@ -689,12 +684,25 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     */
     RemoveFinalizedTransactions: 1
   };
-  // used to remember the last block's transactions that was removed due to it being in the chain
-  _cleanedToBlock;
-  // a local archivist that has only the transactions in it (used as queue)
-  _pendingTransactionsLocalArchivist;
-  _pendingTransactionsLocalArchivistCursor;
-  _updatePendingTransactionsLocalArchivistMutex = new Mutex2();
+  /**
+  * A mutex to ensure that the counting the number of pending transactions is
+  * not called concurrently
+  */
+  _countPendingTransactionsMutex = new Mutex2();
+  /**
+  * A local Archivist optimized for fast retrieval that stores only validated
+  * pending transactions
+  */
+  _curatedPendingTransactionsArchivist;
+  /**
+  * The last count of total pending transactions
+  */
+  _pendingTransactionsCount = 0;
+  /**
+  * A mutex to ensure that the curated pending transactions archivist is
+  * updated in a thread-safe manner
+  */
+  _updateCuratedPendingTransactionsArchivistMutex = new Mutex2();
   get chainArchivist() {
     return assertEx7(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
@@ -704,46 +712,41 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
   get pendingTransactionsArchivist() {
     return assertEx7(this.params.pendingTransactionsArchivist, () => "No pending transactions archivist");
   }
+  get pendingTransactionsCount() {
+    forget(this.countPendingTransactions());
+    return this._pendingTransactionsCount;
+  }
   get pendingTransactionsLocalArchivist() {
-    return assertEx7(this._pendingTransactionsLocalArchivist, () => "No pending transactions curate archivist");
+    return assertEx7(this._curatedPendingTransactionsArchivist, () => "No pending transactions curated archivist");
   }
   get rejectedTransactionsArchivist() {
     return assertEx7(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
-    this._pendingTransactionsLocalArchivist = await MemoryArchivist.create({
+    this._curatedPendingTransactionsArchivist = await MemoryArchivist.create({
       account: "random"
     });
     this.pendingTransactionsArchivist.on("inserted", async ({ payloads }) => {
-      await this._updatePendingTransactionsLocalArchivistMutex.runExclusive(async () => {
-        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
-        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map((tx) => {
-          return tryHydrateTransaction(this.pendingTransactionsArchivist, tx._hash);
-        }))).filter(exists);
-        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction(tx, this.chainIdentification.id);
-          return errors.length > 0 ? false : true;
-        });
-        await this.pendingTransactionsLocalArchivist.insert(flattenHydratedTransactions(validTransactions));
-      }, _XyoPendingTransactionsService.MutexPriority.InsertNewTransactions);
+      await this.insertNewTransactions(payloads);
     });
     this.chainArchivist.on("inserted", async ({ payloads }) => {
-      await this._updatePendingTransactionsLocalArchivistMutex.runExclusive(async () => {
-        const transactions = filterAs(payloads, asOptionalTransactionBoundWitnessWithStorageMeta);
-        await this.pendingTransactionsLocalArchivist.delete(transactions.map((tx) => tx._hash));
-      }, _XyoPendingTransactionsService.MutexPriority.RemoveFinalizedTransactions);
+      await this.removeFinalizedTransactions(payloads);
     });
     this.rejectedTransactionsArchivist.on("inserted", async ({ payloads }) => {
-      await this._updatePendingTransactionsLocalArchivistMutex.runExclusive(async () => {
-        const transactions = filterAs(payloads, asOptionalTransactionBoundWitnessWithStorageMeta);
-        await this.pendingTransactionsLocalArchivist.delete(transactions.map((tx) => tx._hash));
-      }, _XyoPendingTransactionsService.MutexPriority.RemoveRejectedTransactions);
+      await this.removeRejectedTransactions(payloads);
+    });
+    const pendingTransactionsGauge = this.meter?.createObservableGauge("xyo_pending_transactions_count", {
+      description: "The current number of pending transactions",
+      valueType: ValueType.INT
+    });
+    pendingTransactionsGauge?.addCallback((observer) => {
+      observer.observe(this.pendingTransactionsCount);
     });
   }
-  async getPendingTransactions(head, limit, timeout = 1e6) {
+  async getPendingTransactions(head, limit) {
     return await this.spanAsync("getPendingTransactions", async () => {
-      return await this._updatePendingTransactionsLocalArchivistMutex.runExclusive(async () => {
+      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         const foundPendingTransactions = [];
         let cursor;
         while (foundPendingTransactions.length < limit) {
@@ -760,7 +763,15 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
         const hydratedTransactions = await Promise.all(foundPendingTransactions.map((tx) => tryHydrateTransaction(this.pendingTransactionsLocalArchivist, tx._hash)));
         return hydratedTransactions.filter(exists);
       }, _XyoPendingTransactionsService.MutexPriority.ReadTransactions);
-    }, timeout);
+    });
+  }
+  async countPendingTransactions() {
+    if (this._countPendingTransactionsMutex.isLocked()) return;
+    await this._countPendingTransactionsMutex.runExclusive(async () => {
+      const payloads = await this._curatedPendingTransactionsArchivist?.all() ?? [];
+      const pendingTransactions = filterAs(payloads, asOptionalTransactionBoundWitnessWithStorageMeta);
+      this._pendingTransactionsCount = pendingTransactions.length;
+    });
   }
   async filterAlreadyFinalizedTransactions(payloads) {
     const incomingTransactions = filterAs(payloads, asOptionalTransactionBoundWitnessWithStorageMeta);
@@ -770,28 +781,34 @@ var XyoPendingTransactionsService = class _XyoPendingTransactionsService extends
     const nonFinalizedTransactions = incomingTransactions.filter((item) => !finalizedTransactionHashes.has(item._hash));
     return nonFinalizedTransactions;
   }
-  async removeAlreadyIncludedTransactions(head, timeout = 1e6) {
-    return await this.spanAsync("removeAlreadyIncludedTransactions", async () => {
-      let headPtr = head ?? null;
-      while (headPtr !== null) {
-        const [block, payloads] = assertEx7(await hydrateBlock(this.chainArchivist, headPtr), () => `Failed to find head [${head}]`);
-        if (block._hash === this._cleanedToBlock) break;
-        await this.pendingTransactionsLocalArchivist.delete(payloads.map((payload) => asOptionalTransactionBoundWitnessWithStorageMeta(payload)?._hash).filter(exists));
-        this._cleanedToBlock = block._hash;
-        headPtr = block?.previous;
-      }
-    }, timeout);
+  async insertNewTransactions(payloads) {
+    return await this.spanAsync("InsertNewTransactions", async () => {
+      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads);
+        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map((tx) => {
+          return tryHydrateTransaction(this.pendingTransactionsArchivist, tx._hash);
+        }))).filter(exists);
+        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
+          const errors = await validateTransaction(tx, this.chainIdentification.id);
+          return errors.length > 0 ? false : true;
+        });
+        await this.pendingTransactionsLocalArchivist.insert(flattenHydratedTransactions(validTransactions));
+      }, _XyoPendingTransactionsService.MutexPriority.InsertNewTransactions);
+    });
   }
-  async updatePendingTransactionsLocalArchivist(timeout = 1e6) {
-    return await this.spanAsync("updatePendingTransactionsLocalArchivist", async () => {
-      if (this._updatePendingTransactionsLocalArchivistMutex.isLocked()) {
-        console.warn("updatePendingTransactionsLocalArchivist busy - skipping");
-        return;
-      }
-      return await this._updatePendingTransactionsLocalArchivistMutex.runExclusive(async () => {
-        await Promise.resolve();
-      });
-    }, timeout);
+  async removeFinalizedTransactions(payloads) {
+    return await this.removeTransactions(payloads, "RemoveFinalizedTransactions");
+  }
+  async removeRejectedTransactions(payloads) {
+    return await this.removeTransactions(payloads, "RemoveRejectedTransactions");
+  }
+  async removeTransactions(payloads, priority) {
+    return await this.spanAsync(priority, async () => {
+      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+        const transactions = filterAs(payloads, asOptionalTransactionBoundWitnessWithStorageMeta);
+        await this.pendingTransactionsLocalArchivist.delete(transactions.map((tx) => tx._hash));
+      }, _XyoPendingTransactionsService.MutexPriority[priority]);
+    });
   }
 };
 XyoPendingTransactionsService = _ts_decorate7([