@xyo-network/chain-services 1.19.15 → 1.19.17

package/dist/neutral/PendingTransactions/hydratedTransactionToPayloadBundle.d.ts

@@ -1,4 +0,0 @@
-import type { PayloadBundle } from '@xyo-network/payload-model';
-import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-sdk';
-export declare const hydratedTransactionToPayloadBundle: (transaction: SignedHydratedTransactionWithHashMeta) => PayloadBundle;
-//# sourceMappingURL=hydratedTransactionToPayloadBundle.d.ts.map

package/dist/neutral/PendingTransactions/hydratedTransactionToPayloadBundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hydratedTransactionToPayloadBundle.d.ts","sourceRoot":"","sources":["../../../src/PendingTransactions/hydratedTransactionToPayloadBundle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAG/D,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,sBAAsB,CAAA;AAGjF,eAAO,MAAM,kCAAkC,GAAI,aAAa,qCAAqC,KAAG,aAGvG,CAAA"}

package/dist/neutral/PendingTransactions/index.d.ts

@@ -1,2 +0,0 @@
-export * from './BasePendingTransactions.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/neutral/PendingTransactions/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/PendingTransactions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA"}

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -1,382 +0,0 @@
-import { ValueType } from '@opentelemetry/api'
-import {
-  assertEx,
-  exists,
-  filterAs, filterAsync, forget, Hash,
-  isDefined, isUndefined,
-} from '@xylabs/sdk-js'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import { ArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  Payload, PayloadBundle, Sequence, WithStorageMeta,
-} from '@xyo-network/payload-model'
-import {
-  AbstractCreatableProvider,
-  asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, ChainId, creatableProvider,
-  findMostRecentBlock, HydratedTransactionValidationFunction, isTransactionBoundWitnessWithStorageMeta,
-  MempoolViewer, MempoolViewerMoniker, PendingBlocksOptions, PendingTransactionsOptions,
-  SignedHydratedBlockWithHashMeta,
-  SignedHydratedTransactionWithHashMeta,
-  SignedHydratedTransactionWithStorageMeta,
-  TransactionJsonSchemaValidator, validateTransaction,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-
-import { BaseServiceParams } from '../model/index.ts'
-import { bundledPayloadToHydratedTransaction } from './bundledPayloadToHydratedTransaction.ts'
-import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPayloadBundle.ts'
-
-export interface BasePendingTransactionsServiceParams extends BaseServiceParams {
-  additionalPendingTransactionValidators?: HydratedTransactionValidationFunction[]
-  chainArchivist: ArchivistInstance
-  chainId: ChainId
-  pendingBundledTransactionsArchivist: ArchivistInstance
-  rejectedTransactionsArchivist: ArchivistInstance
-}
-
-@creatableProvider()
-export class BasePendingTransactionsService extends AbstractCreatableProvider<BasePendingTransactionsServiceParams> implements MempoolViewer {
-  static readonly defaultMoniker = MempoolViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [MempoolViewerMoniker]
-
-  private static readonly MutexPriority = {
-    /**
-     * Priority for inserting new transactions
-     */
-    InsertNewTransactions: 5,
-    /**
-     * Priority for reading pending transactions
-     */
-    ReadTransactions: 3,
-    /**
-     * Priority for removing finalized/expired/rejected transactions
-     */
-    PurgeTransactions: 1,
-  } as const
-
-  override moniker = BasePendingTransactionsService.defaultMoniker
-
-  /**
-   * A mutex to ensure that the counting the number of pending transactions is
-   * not called concurrently
-   */
-  private _countPendingTransactionsMutex = new Mutex()
-
-  /**
-   * A local Archivist optimized for fast retrieval that stores only validated
-   * pending transactions
-   */
-  private _curatedPendingBundledTransactionsArchivist: MemoryArchivist | undefined
-
-  /**
-   * The last count of total pending transactions
-   */
-  private _pendingTransactionsCount: number = 0
-
-  /**
-   * A set of transaction hashes that are pending removal from the
-   * curated pending transactions archivist. This is used to track
-   * which transactions need to be removed from the archivist.
-   */
-  private _removablePendingTransactionHashes: Set<Hash> = new Set()
-
-  /**
-   * A mutex to ensure that the curated pending transactions archivist is
-   * updated in a thread-safe manner
-   */
-  private _updateCuratedPendingTransactionsArchivistMutex = new Mutex()
-
-  private get additionalPendingTransactionValidators() {
-    return this.params.additionalPendingTransactionValidators ?? []
-  }
-
-  private get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'No completed blocks with data archivist')
-  }
-
-  private get pendingBundledTransactionsArchivist() {
-    return assertEx(this.params.pendingBundledTransactionsArchivist, () => 'No pending bundled transactions archivist')
-  }
-
-  private get pendingBundledTransactionsLocalArchivist() {
-    return assertEx(this._curatedPendingBundledTransactionsArchivist, () => 'No pending bundled transactions curated archivist')
-  }
-
-  private get pendingTransactionsCount() {
-    forget(this.countPendingTransactions())
-    return this._pendingTransactionsCount
-  }
-
-  private get rejectedTransactionsArchivist() {
-    return assertEx(this.params.rejectedTransactionsArchivist, () => 'No rejected transactions archivist')
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-
-    // On new pending transactions, insert them into the curated archivist
-    this.pendingBundledTransactionsArchivist.on('inserted', ({ payloads }) => {
-      forget(this.insertNewTransactions(payloads as WithStorageMeta<PayloadBundle>[]))
-    })
-
-    // On new finalized blocks, remove the transactions from the curated archivist
-    this.chainArchivist.on('inserted', ({ payloads }) => {
-      this.markAnyIncludedTransactionsForRemoval(payloads)
-      forget(this.cleanupWorker())
-    })
-
-    // On new rejected transactions, remove the transactions from the curated archivist
-    this.rejectedTransactionsArchivist.on('inserted', ({ payloads }) => {
-      this.markAnyIncludedTransactionsForRemoval(payloads)
-      forget(this.cleanupWorker())
-    })
-
-    const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter(
-      'xyo_pending_transactions_counter',
-      {
-        description: 'The current number of pending transactions', valueType: ValueType.INT, unit: '1',
-      },
-    )
-    pendingTransactionsCounter?.addCallback((observer) => {
-      observer.observe(this.pendingTransactionsCount)
-    })
-  }
-
-  pendingBlocks(_options?: PendingBlocksOptions): Promise<SignedHydratedBlockWithHashMeta[]> {
-    throw new Error('Method [pendingBlocks] not implemented.')
-  }
-
-  async pendingTransactions({ limit = 100 }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithStorageMeta[]> {
-    return await this.spanAsync('getPendingTransactions', async () => {
-    // Acquires an exclusive mutex to ensure no race conditions while accessing pending transactions.
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        // Find the supplied head
-        let lastHead = (filterAs(await this.chainArchivist.next({ limit: 100 }), x => asBlockBoundWitnessWithHashMeta(x))).at(-1)
-        if (isUndefined(lastHead)) return []
-
-        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)
-
-        const foundPendingTransactions: SignedHydratedTransactionWithStorageMeta[] = []
-        let cursor: Sequence | undefined
-
-        // Continue fetching until the desired number of transactions is reached.
-        while (foundPendingTransactions.length < limit) {
-        // Fetch the next batch of payloads
-          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
-            limit: 100,
-            order: 'asc',
-            cursor,
-          }) as WithStorageMeta<PayloadBundle>[]
-
-          // Exit if no more payloads are available.
-          if (pendingBundledTransactions.length === 0) break
-
-          // Update the cursor for the next iteration to fetch subsequent payloads.
-          cursor = pendingBundledTransactions.at(-1)?._sequence
-
-          // Keep only those payloads that are not marked for deletion.
-          const undeletedTransactionBundles = pendingBundledTransactions.filter(tx =>
-            !this._removablePendingTransactionHashes.has(tx.root))
-
-          // Convert each undeleted payload bundle into a hydrated transaction.
-          const transactions = (await Promise.all(
-            undeletedTransactionBundles.map(p => bundledPayloadToHydratedTransaction(p)),
-          )).filter(exists)
-
-          // Filter transactions to only include those that are active for the next
-          // potential block based on the last supplied head.
-          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)))
-
-          const txValidationResults = await Promise.all(activeTransactions.map(async tx => ([tx, await validateTransaction(
-            { ...this.context, chainId: this.params.chainId },
-            tx,
-            this.additionalPendingTransactionValidators,
-          )])))
-
-          const validTransactions = txValidationResults.filter((
-            [, errors],
-          ) => errors.length === 0).map(([tx]) => tx) as SignedHydratedTransactionWithStorageMeta[]
-
-          const invalidTransactions = txValidationResults.filter((
-            [, errors],
-          ) => errors.length > 0).map(([tx]) => tx) as SignedHydratedTransactionWithStorageMeta[]
-
-          if (invalidTransactions.length > 0) {
-            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`)
-            for (const tx of invalidTransactions) {
-              this.logger?.warn(tx[0]._hash)
-            }
-          }
-
-          // Add the valid hydrated transactions to the result set.
-          foundPendingTransactions.push(...validTransactions)
-        }
-
-        if (foundPendingTransactions.length > 0) {
-          this.logger?.log(`getPendingTransactions: Found ${foundPendingTransactions.length} pending transactions`)
-          for (const tx of foundPendingTransactions) {
-            this.logger?.log(tx[0]._hash)
-          }
-        }
-
-        return foundPendingTransactions
-      }, BasePendingTransactionsService.MutexPriority.ReadTransactions)
-    }, this.context)
-  }
-
-  private async cleanupWorker() {
-    return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-      const lastHead = await findMostRecentBlock(this.chainArchivist)
-      if (isDefined(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)
-    }, BasePendingTransactionsService.MutexPriority.PurgeTransactions)
-  }
-
-  private async countPendingTransactions() {
-    if (this._countPendingTransactionsMutex.isLocked()) return
-    await this._countPendingTransactionsMutex.runExclusive(async () => {
-      const payloads = (await this._curatedPendingBundledTransactionsArchivist?.all()) ?? []
-      this._pendingTransactionsCount = payloads.length
-    })
-  }
-
-  private async filterAlreadyFinalizedTransactions(
-    incomingTransactions: WithStorageMeta<PayloadBundle>[],
-  ): Promise<WithStorageMeta<PayloadBundle>[]> {
-    const incomingTransactionHashes = incomingTransactions.map(payload => payload.root)
-    const finalizedTransactions = await this.chainArchivist.get(incomingTransactionHashes)
-    const finalizedTransactionHashes = new Set(finalizedTransactions.map(item => item._hash))
-    const nonFinalizedTransactions = incomingTransactions.filter(item => !finalizedTransactionHashes.has(item._hash))
-    return nonFinalizedTransactions
-  }
-
-  private async insertNewTransactions(payloads: WithStorageMeta<PayloadBundle>[]) {
-    if (payloads.length === 0) return
-    return await this.spanAsync('InsertNewTransactions', async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        // Check incoming transactions against finalized transactions
-        const unprocessedTransactions = await this.filterAlreadyFinalizedTransactions(payloads)
-        // Hydrate all unprocessed transactions
-        const hydratedUnprocessedTransactions = (await Promise.all(unprocessedTransactions.map(async (tx) => {
-          return await bundledPayloadToHydratedTransaction(tx)
-        }))).filter(exists)
-        // Filter to only valid transactions
-        const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction({ ...this.context, chainId: this.params.chainId }, tx, [TransactionJsonSchemaValidator])
-          if (errors.length > 0) {
-            this.logger?.warn('validateTransaction', errors)
-          }
-          return errors.length > 0 ? false : true
-        })
-        if (validTransactions.length > 0) {
-          const bundledTransactions = validTransactions.map(tx => hydratedTransactionToPayloadBundle(tx))
-          await this.pendingBundledTransactionsLocalArchivist.insert(bundledTransactions)
-        }
-      }, BasePendingTransactionsService.MutexPriority.InsertNewTransactions)
-    }, this.context)
-  }
-
-  /**
-   * Marks any included transactions in the provided payloads for removal preventing them
-   * from being included in the curated pending transactions archivist and from being offered
-   * during the next retrieval of pending transactions.
-   * @param payloads An array of payloads that may contain transactions.
-   */
-  private markAnyIncludedTransactionsForRemoval(payloads: WithStorageMeta<Payload>[]) {
-    const hashes = payloads.filter(isTransactionBoundWitnessWithStorageMeta).map(p => p._hash)
-    for (const hash of hashes) {
-      this._removablePendingTransactionHashes.add(hash)
-    }
-  }
-
-  private async pruneCuratedPendingTransactionsArchivist(head: Hash) {
-    return await this.spanAsync('pruneCuratedPendingTransactionsArchivist', async () => {
-      const foundPendingTransactionsToDeleteHashes: Hash[] = []
-
-      let cursor: Sequence | undefined
-      let [lastHead] = filterAs(await this.chainArchivist.get([head]), x => asBlockBoundWitnessWithHashMeta(x))
-
-      // Continue fetching until the desired number of transactions is reached.
-      while (isDefined(lastHead)) {
-        // Fetch the next batch of payloads
-        const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
-          limit: 100,
-          order: 'asc',
-          cursor,
-        }) as WithStorageMeta<PayloadBundle>[]
-
-        // Exit if no more payloads are available.
-        if (pendingBundledTransactions.length === 0) {
-          break
-        }
-
-        // Update the cursor for the next iteration to fetch subsequent payloads.
-        cursor = pendingBundledTransactions.at(-1)?._sequence
-
-        // Filter out bundles that are marked as removable.
-        const deletedTransactionBundles = pendingBundledTransactions.filter(tx =>
-          this._removablePendingTransactionHashes.has(tx.root))
-
-        // Queue the hashes of deletable transactions for deletion and cleanup.
-        foundPendingTransactionsToDeleteHashes.push(
-          ...deletedTransactionBundles.map(tx => tx._hash).filter(exists),
-        )
-
-        // Keep only those payloads that are not marked for deletion.
-        const undeletedTransactionBundles = pendingBundledTransactions.filter(tx =>
-          !this._removablePendingTransactionHashes.has(tx.root))
-
-        // Convert each undeleted payload bundle into a hydrated transaction.
-        const transactions = (await Promise.all(
-          undeletedTransactionBundles.map(p => bundledPayloadToHydratedTransaction(p)),
-        )).filter(exists)
-
-        // Find expired transactions based on the last supplied head
-        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)))
-        // Find the corresponding bundle hashes for the expired transactions
-        const expiredBundleHashes = expiredTransactions
-          .map(expiredHydratedTx =>
-          // Find the corresponding payload bundle hash for the expired transaction
-            pendingBundledTransactions.find(bundledTx => bundledTx.root === expiredHydratedTx[0]._hash)?._hash)
-          .filter(exists)
-          // Mark all expired bundled transactions for deletion.
-        foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes)
-      }
-
-      // Actually delete the marked payload bundles from the archivist
-      const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes)
-
-      // Remove all deleted hashes from the "pending delete" set now that they are deleted
-      for (const payload of deletedHashes) {
-        this._removablePendingTransactionHashes.delete(payload._hash)
-      }
-
-      if (deletedHashes.length > 0) {
-        this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${deletedHashes.length} deletable transactions`)
-        for (const payload of deletedHashes) {
-          this.logger?.log(payload._hash)
-        }
-      }
-    }, this.context)
-  }
-}
-
-/**
- * Checks if a transaction is expired for a given block.
- * @param block The block number to check against the transaction's validity period.
- * @returns True if the transaction is expired for the given block, false otherwise.
- */
-const isTransactionExpired = (block: XL1BlockNumber) =>
-  ([txBw]: SignedHydratedTransactionWithHashMeta): boolean =>
-    txBw.exp < block
-
-/**
- * Checks if a transaction is active for a given block.
- * @param block The block number to check against the transaction's validity period.
- * @returns True if the transaction is active for the given block, false otherwise.
- */
-const isTransactionActive = (block: XL1BlockNumber) =>
-  ([txBw]: SignedHydratedTransactionWithHashMeta): boolean =>
-    txBw.nbf <= block && txBw.exp >= block

package/src/PendingTransactions/bundledPayloadToHydratedTransaction.ts

@@ -1,14 +0,0 @@
-import type { PayloadBundle, WithStorageMeta } from '@xyo-network/payload-model'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-sdk'
-import { asSignedTransactionBoundWitnessWithHashMeta } from '@xyo-network/xl1-sdk'
-
-export const bundledPayloadToHydratedTransaction = async (
-  payload: WithStorageMeta<PayloadBundle>,
-): Promise<SignedHydratedTransactionWithHashMeta | undefined> => {
-  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads)
-  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find(p => p._hash === payload.root))
-  if (tx) {
-    return [tx, withHashMeta.filter(p => p._hash !== payload.root)]
-  }
-}

package/src/PendingTransactions/hydratedTransactionToPayloadBundle.ts

@@ -1,18 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { PayloadBundle } from '@xyo-network/payload-model'
-import { PayloadBundleSchema } from '@xyo-network/payload-model'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-sdk'
-import { flattenHydratedTransaction } from '@xyo-network/xl1-sdk'
-
-export const hydratedTransactionToPayloadBundle = (transaction: SignedHydratedTransactionWithHashMeta): PayloadBundle => {
-  const root = transaction[0]._hash
-  return bundle(root, transaction)
-}
-
-const bundle = (root: Hash, transaction: SignedHydratedTransactionWithHashMeta) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap(p => PayloadBuilder.omitStorageMeta(p))
-  return new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema })
-    .fields({ payloads, root })
-    .build()
-}

package/src/PendingTransactions/index.ts

@@ -1 +0,0 @@
-export * from './BasePendingTransactions.ts'