@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.13

package/src/simple/mempool/SimpleMempoolRunner.ts

@@ -1,390 +0,0 @@
-import {
-  assertEx, exists, type Hash,
-} from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/sdk-js'
-import {
-  isPayloadBundle, Payload, PayloadBuilder,
-  Sequence,
-  WithHashMeta,
-} from '@xyo-network/sdk-js'
-import {
-  BlockValidationViewer,
-  BlockValidationViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  DEFAULT_MAX_EXP_AHEAD,
-  FinalizationViewer,
-  FinalizationViewerMoniker,
-  isSignedHydratedBlockWithHashMeta, isSignedHydratedTransactionWithHashMeta, MempoolPruneOptions, MempoolRunner,
-  MempoolRunnerMoniker, type MempoolViewer, type SignedHydratedBlock, SignedHydratedBlockWithHashMeta, type SignedHydratedTransaction,
-  SignedHydratedTransactionWithHashMeta,
-  TransactionValidationViewer,
-  TransactionValidationViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import { Mutex } from 'async-mutex'
-
-import { validateTransactionsOpcodes } from '../../block/index.ts'
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import {
-  bundledPayloadToHydratedBlock,
-  bundledPayloadToHydratedTransaction,
-  hydratedBlockToPayloadBundle, hydratedTransactionToPayloadBundle,
-} from '../../model/index.ts'
-
-const DEFAULT_SYNC_INTERVAL = 30_000
-const DEFAULT_SYNC_LIMIT = 100
-
-/** Parameters for SimpleMempoolRunner. */
-export interface SimpleMempoolRunnerParams extends CreatableProviderParams {
-  externalMempools?: MempoolViewer[]
-  maxExpAhead?: number
-  pendingBlocksArchivist: ArchivistInstance
-  pendingTransactionsArchivist: ArchivistInstance
-  syncInterval?: number
-  syncLimit?: number
-}
-
-/** SimpleMempoolRunner implementation. */
-@creatableProvider()
-export class SimpleMempoolRunner extends AbstractCreatableProvider<SimpleMempoolRunnerParams> implements MempoolRunner {
-  static readonly defaultMoniker = MempoolRunnerMoniker
-  static readonly dependencies = [FinalizationViewerMoniker, BlockValidationViewerMoniker, TransactionValidationViewerMoniker, ChainContractViewerMoniker]
-  static readonly monikers = [MempoolRunnerMoniker]
-  moniker = SimpleMempoolRunner.defaultMoniker
-
-  protected _blockValidationViewer!: BlockValidationViewer
-  protected _chainContractViewer!: ChainContractViewer
-  protected _finalizationViewer!: FinalizationViewer
-  protected _transactionValidationViewer!: TransactionValidationViewer
-
-  private _syncMutex = new Mutex()
-  private _syncTimerId: ReturnType<typeof setInterval> | null = null
-
-  protected get blockValidationViewer() {
-    return this._blockValidationViewer!
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer!
-  }
-
-  protected get externalMempools(): MempoolViewer[] {
-    return this.params.externalMempools ?? []
-  }
-
-  protected get finalizationViewer() {
-    return this._finalizationViewer!
-  }
-
-  protected get maxExpAhead() {
-    return this.params.maxExpAhead ?? DEFAULT_MAX_EXP_AHEAD
-  }
-
-  protected get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist
-  }
-
-  protected get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist
-  }
-
-  protected get syncInterval(): number {
-    return this.params.syncInterval ?? DEFAULT_SYNC_INTERVAL
-  }
-
-  protected get syncLimit(): number {
-    return this.params.syncLimit ?? DEFAULT_SYNC_LIMIT
-  }
-
-  protected get transactionValidationViewer() {
-    return this._transactionValidationViewer!
-  }
-
-  static override async paramsHandler(params?: Partial<SimpleMempoolRunnerParams>): Promise<SimpleMempoolRunnerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      pendingBlocksArchivist: assertEx(params?.pendingBlocksArchivist, () => 'pendingBlocksArchivist is required'),
-      pendingTransactionsArchivist: assertEx(params?.pendingTransactionsArchivist, () => 'pendingTransactionsArchivist is required'),
-    }
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._blockValidationViewer = await this.locator.getInstance<BlockValidationViewer>(BlockValidationViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-    this._finalizationViewer = await this.locator.getInstance<FinalizationViewer>(FinalizationViewerMoniker)
-    this._transactionValidationViewer = await this.locator.getInstance<TransactionValidationViewer>(TransactionValidationViewerMoniker)
-  }
-
-  async prunePendingBlocks({
-    batchSize = 10, maxPrune = 1000, maxCheck = 1000,
-  }: MempoolPruneOptions = {}): Promise<[number, number]> {
-    let total = 0
-    let pruned = 0
-    let cursor: Sequence | undefined
-    let batch = await this.pendingBlocksArchivist.next({
-      limit: batchSize, cursor, order: 'desc',
-    })
-    this.logger?.info(`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)
-      const bundles = blocksAndBundles.map(([_, p]) => p)
-      let valid = blocks.map(b => !!b)
-      let remainingBlockMap: number[] = []
-      let remainingBlocks = blocks.map((b, i) => {
-        if (b) {
-          remainingBlockMap.push(i)
-          return b
-        }
-      }).filter(exists)
-
-      assertEx(
-        remainingBlockMap.length === remainingBlocks.length,
-        () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`,
-      )
-      const validationResults = await Promise.all(remainingBlocks.map(remainingBlock => this.blockValidationViewer.validateBlock(
-        remainingBlock,
-        { value: true, state: true },
-      )))
-      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: ${JSON.stringify(r, null, 2)}`)
-        }
-        valid[remainingBlockMap[i]] = validated
-      }
-      const pruneHashes = bundles.map((p, i) => {
-        if (!valid[i]) {
-          return p._hash
-        }
-      }).filter(exists)
-
-      pruned += pruneHashes.length
-      total += batch.length
-      await this.pendingBlocksArchivist.delete(pruneHashes)
-
-      cursor = batch.at(-1)?._sequence
-
-      batch = cursor
-        ? await this.pendingBlocksArchivist.next({
-            limit: batchSize, cursor, order: 'desc',
-          })
-        : []
-    }
-    this.logger?.info(`prunePendingBlocks completed: pruned=${pruned}, totalChecked=${total}`)
-    return [pruned, total]
-  }
-
-  async prunePendingTransactions({
-    batchSize = 10, maxPrune = 1000, maxCheck = 1000,
-  }: MempoolPruneOptions = {}): Promise<[number, number]> {
-    let total = 0
-    let pruned = 0
-    let cursor: Sequence | undefined
-    let batch = await this.pendingTransactionsArchivist.next({
-      limit: batchSize, cursor, order: 'desc',
-    })
-    this.logger?.info(`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)
-      const bundles = transactionsAndBundles.map(([_, p]) => p)
-      let valid = transactions.map(t => !!t)
-      let remainingTransactionMap: number[] = []
-      let remainingTransactions = transactions.map((t, i) => {
-        if (t) {
-          remainingTransactionMap.push(i)
-          return t
-        }
-      }).filter(exists)
-
-      assertEx(
-        remainingTransactionMap.length === remainingTransactions.length,
-        () => `remainingTransactionMap length should match remainingTransactions length [${remainingTransactionMap.length}/${remainingTransactions.length}]`,
-      )
-
-      const validationResults = await Promise.all(remainingTransactions.map(remainingTransaction => this.transactionValidationViewer.validateTransaction(
-        remainingTransaction,
-        { value: true, state: true },
-      )))
-      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: ${JSON.stringify(r, null, 2)}`)
-        }
-        valid[remainingTransactionMap[i]] = validated
-      }
-      const pruneHashes = bundles.map((p, i) => {
-        if (!valid[i]) {
-          return p._hash
-        }
-      }).filter(exists)
-
-      pruned += pruneHashes.length
-      total += batch.length
-      await this.pendingTransactionsArchivist.delete(pruneHashes)
-
-      cursor = batch.at(-1)?._sequence
-
-      batch = cursor
-        ? await this.pendingTransactionsArchivist.next({
-            limit: batchSize, cursor, order: 'desc',
-          })
-        : []
-    }
-    this.logger?.info(`prunePendingTransactions completed: pruned=${pruned}, totalChecked=${total}`)
-    return [pruned, total]
-  }
-
-  async submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]> {
-    const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
-      return hydratedBlockToPayloadBundle([
-        await PayloadBuilder.addHashMeta(bw),
-        await PayloadBuilder.addHashMeta(payloads),
-      ])
-    }))
-    const inserted = await this.pendingBlocksArchivist.insert(bundles)
-    return inserted.map(p => p._hash)
-  }
-
-  async submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]> {
-    const headNumber = await this.finalizationViewer.headNumber()
-    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}`)
-        return false
-      }
-      return true
-    })
-
-    const bundles = await Promise.all(validTransactions.map(async ([tx, payloads]) => {
-      return hydratedTransactionToPayloadBundle([
-        await PayloadBuilder.addHashMeta(tx),
-        await PayloadBuilder.addHashMeta(payloads),
-      ])
-    }))
-    const inserted = await this.pendingTransactionsArchivist.insert(bundles)
-    return inserted.map(p => p._hash)
-  }
-
-  protected override async startHandler(): Promise<void> {
-    await super.startHandler()
-    if (this.externalMempools.length > 0) {
-      await this.syncFromExternal()
-      this._syncTimerId = setInterval(() => {
-        void this.syncFromExternal()
-      }, this.syncInterval)
-    }
-  }
-
-  protected override async stopHandler(): Promise<void> {
-    await super.stopHandler()
-    if (this._syncTimerId) {
-      clearInterval(this._syncTimerId)
-      this._syncTimerId = null
-    }
-  }
-
-  private async simpleBlockValidationCheck(payloads: WithHashMeta<Payload>[]): Promise<[(SignedHydratedBlockWithHashMeta | undefined), WithHashMeta<Payload>][]> {
-    const headNumber = await this.finalizationViewer.headNumber()
-    const chainId = await this.chainContractViewer.chainId()
-
-    const blockBundles: [SignedHydratedBlockWithHashMeta | undefined, WithHashMeta<Payload>][] = await Promise.all(payloads.map(async (p) => {
-      return [isPayloadBundle(p) ? await bundledPayloadToHydratedBlock(p) : undefined, p]
-    }))
-
-    return blockBundles.map(([block, bundle]) => {
-      const blockCheckPassed = !!block
-      const chainIdPassed = blockCheckPassed ? block[0].chain === chainId : false
-      const blockNumberPassed = blockCheckPassed ? block[0].block > headNumber : false
-      const typeCheckPassed = blockCheckPassed ? isSignedHydratedBlockWithHashMeta(block) : false
-      const validationPassed = blockCheckPassed && chainIdPassed && blockNumberPassed && typeCheckPassed
-      const validatedBlock = validationPassed ? block : undefined
-      if (!validationPassed) {
-        this.logger?.info(`Pruning block bundle ${bundle._hash} during simpleValidationCheck`)
-        this.logger?.info(`  - chainId match: ${chainIdPassed}`)
-        this.logger?.info(`  - blockNumber check: ${blockNumberPassed}`)
-        this.logger?.info(`  - typeCheck: ${typeCheckPassed}`)
-        this.logger?.info(`  - bundle hash: ${bundle._hash}`)
-      }
-      return [validatedBlock, bundle]
-    })
-  }
-
-  private async simpleTransactionValidationCheck(payloads: WithHashMeta<Payload>[]): Promise<[(SignedHydratedTransactionWithHashMeta | undefined), WithHashMeta<Payload>][]> {
-    const headNumber = await this.finalizationViewer.headNumber()
-    const chainId = await this.chainContractViewer.chainId()
-
-    const transactionBundles: [SignedHydratedTransactionWithHashMeta | undefined, WithHashMeta<Payload>][] = await Promise.all(payloads.map(async (p) => {
-      return [isPayloadBundle(p) ? await bundledPayloadToHydratedTransaction(p) : undefined, p]
-    }))
-
-    // eslint-disable-next-line complexity
-    return await Promise.all(transactionBundles.map(async ([transaction, bundle]) => {
-      const transactionCheckPassed = !!transaction
-      const chainIdPassed = transactionCheckPassed ? transaction[0].chain === chainId : false
-      const expPassed = transactionCheckPassed
-        ? transaction[0].exp > headNumber && transaction[0].exp <= headNumber + this.maxExpAhead
-        : false
-      const typeCheckPassed = transactionCheckPassed ? isSignedHydratedTransactionWithHashMeta(transaction) : false
-      let opcodeCheckPassed = false
-      try {
-        await validateTransactionsOpcodes(transaction ? [transaction] : [])
-        opcodeCheckPassed = true
-      } catch (e) {
-        this.logger?.info(`Opcode validation failed for transaction ${bundle._hash} during simpleValidationCheck`)
-        this.logger?.info(`  - error: ${(e as Error).message}`)
-      }
-      const validationPassed = transactionCheckPassed && chainIdPassed && expPassed && typeCheckPassed && opcodeCheckPassed
-      const validatedTransaction = validationPassed ? transaction : undefined
-      if (!validationPassed) {
-        this.logger?.info(`Pruning block bundle ${bundle._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: ${bundle._hash}`)
-      }
-      return [validatedTransaction, bundle]
-    }))
-  }
-
-  private async syncBlocksFrom(external: MempoolViewer): Promise<void> {
-    const externalBlocks = await external.pendingBlocks({ limit: this.syncLimit })
-    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`)
-  }
-
-  private async syncFromExternal(): Promise<void> {
-    if (this._syncMutex.isLocked()) return
-    await this._syncMutex.runExclusive(async () => {
-      for (const external of this.externalMempools) {
-        try {
-          await this.syncTransactionsFrom(external)
-          await this.syncBlocksFrom(external)
-        } catch (ex) {
-          this.logger?.error(`Error syncing from external mempool: ${ex}`)
-        }
-      }
-    })
-  }
-
-  private async syncTransactionsFrom(external: MempoolViewer): Promise<void> {
-    const externalTxs = await external.pendingTransactions({ limit: this.syncLimit })
-    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`)
-  }
-}

package/src/simple/mempool/SimpleMempoolViewer.ts

@@ -1,215 +0,0 @@
-import {
-  exists, isDefined, isHash,
-} from '@xylabs/sdk-js'
-import type {
-  ArchivistInstance,
-  HashMeta,
-  PayloadBundle, Sequence,
-} from '@xyo-network/sdk-js'
-import { isHashMeta, isPayloadBundle } from '@xyo-network/sdk-js'
-import {
-  type HydratedTransactionWithHashMeta, type MempoolViewer, MempoolViewerMoniker,
-  PendingTransactionsOptions,
-  type SignedHydratedBlockWithHashMeta, type SignedHydratedTransactionWithHashMeta,
-  WindowedBlockViewer,
-  WindowedBlockViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { bundledPayloadToHydratedBlock, bundledPayloadToHydratedTransaction } from '../../model/index.ts'
-
-type PayloadBundleWithHashMeta = PayloadBundle & HashMeta
-
-type HydratedTxWithBundle = {
-  bundle: PayloadBundleWithHashMeta
-  tx: SignedHydratedTransactionWithHashMeta
-}
-
-/** Default maximum fraction of mempool transactions to return. */
-const DEFAULT_MEMPOOL_SELECTION_RATIO = 0.66
-
-/** Parameters for SimpleMempoolViewer. */
-export interface SimpleMempoolViewerParams extends CreatableProviderParams {
-  /** External mempool viewers (reserved for future use). */
-  externalMempools?: MempoolViewer[]
-  /** Maximum fraction (0–1) of mempool inclusion candidates to return. Defaults to 0.66. */
-  mempoolSelectionRatio?: number
-  pendingBlocksArchivist: ArchivistInstance
-  pendingTransactionsArchivist: ArchivistInstance
-}
-
-/** SimpleMempoolViewer implementation. */
-@creatableProvider()
-export class SimpleMempoolViewer extends AbstractCreatableProvider<SimpleMempoolViewerParams> implements MempoolViewer {
-  static readonly defaultMoniker = MempoolViewerMoniker
-  static readonly dependencies = [WindowedBlockViewerMoniker]
-  static readonly monikers = [MempoolViewerMoniker]
-  moniker = SimpleMempoolViewer.defaultMoniker
-
-  private _windowedBlockViewer?: WindowedBlockViewer
-
-  protected get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist
-  }
-
-  protected get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist
-  }
-
-  protected get windowedBlockViewer() {
-    return this._windowedBlockViewer!
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._windowedBlockViewer = await this.locator.getInstance<WindowedBlockViewer>(WindowedBlockViewerMoniker)
-  }
-
-  async pendingBlocks({ cursor: providedCursor }: PendingTransactionsOptions = {}): Promise<SignedHydratedBlockWithHashMeta[]> {
-    let cursor: Sequence | undefined = undefined
-    if (isHash(providedCursor)) {
-      const [p] = await this.pendingBlocksArchivist.get([providedCursor])
-      if (isDefined(p)) {
-        cursor = p._sequence
-      }
-    }
-    const bundles = await this.pendingBlocksArchivist.next({
-      order: 'desc', limit: 100, cursor,
-    })
-    const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta)
-    return (await Promise.all(filteredBundles.map(async bundle => await bundledPayloadToHydratedBlock(bundle)))).filter(exists)
-  }
-
-  async pendingTransactions({
-    cursor: providedCursor,
-    limit = 100,
-  }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithHashMeta[]> {
-    let cursor: Sequence | undefined = undefined
-    if (isHash(providedCursor)) {
-      const [p] = await this.pendingTransactionsArchivist.get([providedCursor])
-      if (isDefined(p)) {
-        cursor = p._sequence
-      }
-    }
-    this.logger?.info(`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`)
-
-    const filteredBundles: PayloadBundleWithHashMeta[] = bundles.filter(isPayloadBundle).filter(isHashMeta)
-    // this.logger?.info(`Filtered pending transactions: ${JSON.stringify(filteredBundles, null, 2)} filteredBundles`)
-
-    const hydratedWithBundle: HydratedTxWithBundle[] = (await Promise.all(
-      filteredBundles.map(async (bundle) => {
-        const tx = await bundledPayloadToHydratedTransaction(bundle)
-        return isDefined(tx) ? { bundle, tx } : undefined
-      }),
-    )).filter(exists)
-    // this.logger?.info(`Converted pending transactions: ${JSON.stringify(hydratedWithBundle.map(x => x.tx), null, 2)} results`)
-
-    const currentBlock = await this.windowedBlockViewer.currentBlock()
-    const evaluated = await Promise.all(
-      hydratedWithBundle.map(async ({ bundle, tx }) => ({
-        bundle, tx, deletable: await this.isDeletable(tx, currentBlock),
-      })),
-    )
-
-    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`)
-
-    // Delete the invalid transactions that should not remain in the mempool.
-    await Promise.all(
-      deletionCandidates.map(async ({ bundle, tx }) => {
-        await this.deleteBundledTransaction(bundle)
-        this.logger?.info(`Purged completed/expired bundled transaction: ${bundle._hash}/${tx[0]._hash}`)
-      }),
-    )
-
-    const inclusionCandidates = (await Promise.all(validTransactions.map(x => x.tx).map(async (tx) => {
-      // Check if it's a candidate for inclusion (skip deletable check as we've already done that)
-      if (await this.isInclusionCandidate(tx, currentBlock, false)) return tx
-    }))).filter(exists)
-
-    const selectionRatio = this.params.mempoolSelectionRatio ?? DEFAULT_MEMPOOL_SELECTION_RATIO
-    const maxByRatio = Math.ceil(inclusionCandidates.length * selectionRatio)
-    const effectiveLimit = Math.min(limit, maxByRatio)
-
-    const randomInclusionCandidates = deduplicateBySigner(
-      inclusionCandidates.filter(() => Math.random() < selectionRatio),
-    ).slice(0, effectiveLimit)
-
-    // if the random filter resulted in 0 bundles, we fallback to just taking the first bundle to ensure we return something
-    const result = randomInclusionCandidates.length > 0 ? randomInclusionCandidates : deduplicateBySigner(inclusionCandidates).slice(0, 1)
-
-    this.logger?.info(`Inclusion candidates: ${inclusionCandidates.length}`)
-    return result
-  }
-
-  private async deleteBundledTransaction(bundle: PayloadBundleWithHashMeta): Promise<void> {
-    await this.pendingTransactionsArchivist.delete([bundle._hash])
-  }
-
-  /**
-   * Evaluates a transaction to determine if it should be purged from the mempool.
-   * @param tx The transaction to evaluate
-   * @param currentBlock The current block to use for evaluation
-   * @returns True if the transaction should be purged, false otherwise
-   */
-  private async isDeletable(tx: HydratedTransactionWithHashMeta, currentBlock: SignedHydratedBlockWithHashMeta): Promise<boolean> {
-    const currentBlockNumber = currentBlock[0].block
-    const nextBlockNumber = currentBlockNumber + 1
-    const { exp } = tx[0]
-
-    // If it's expired
-    if (nextBlockNumber > exp) return true
-
-    // If it's already included in a block
-    const existingBlock = await this.windowedBlockViewer.blockByTransactionHash(tx[0]._hash)
-    if (existingBlock) return true
-
-    return false
-  }
-
-  /**
-   * Evaluates a transaction to determine if is valid for inclusion in the next block. A transaction is invalid if:
-   * - The transaction is too early/expired
-   * - The transaction has already been included in a block
-   * @param tx The transaction to evaluate
-   * @param currentBlock The current block to use for evaluation
-   * @param checkForDeletable Whether to check if the transaction is deletable (default: true)
-   * @returns True if the transaction is valid for inclusion in the next block, false otherwise
-   */
-  private async isInclusionCandidate(
-    tx: HydratedTransactionWithHashMeta,
-    currentBlock: SignedHydratedBlockWithHashMeta,
-    checkForDeletable: boolean = true,
-  ): Promise<boolean> {
-    const currentBlockNumber = currentBlock[0].block
-    const nextBlockNumber = currentBlockNumber + 1
-    const { nbf } = tx[0]
-
-    // If it's not time yet
-    if (nextBlockNumber < nbf) return false
-
-    // If it's deletable
-    if (checkForDeletable && await this.isDeletable(tx, currentBlock)) return false
-
-    return true
-  }
-}
-
-/** Remove transactions that share the same signer set, keeping the first occurrence. */
-function deduplicateBySigner(txs: SignedHydratedTransactionWithHashMeta[]): SignedHydratedTransactionWithHashMeta[] {
-  const seen = new Set<string>()
-  return txs.filter((tx) => {
-    const key = tx[0].addresses.toSorted().join(',')
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-}

package/src/simple/mempool/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleMempoolRunner.ts'
-export * from './SimpleMempoolViewer.ts'

package/src/simple/network/SimpleXyoNetwork.ts

@@ -1,48 +0,0 @@
-import { isUndefined } from '@xylabs/sdk-js'
-import type {
-  GatewayName,
-  NetworkStatus, XyoNetwork,
-} from '@xyo-network/xl1-protocol-lib'
-import { isNetworkStatus } from '@xyo-network/xl1-protocol-lib'
-import axios from 'axios'
-
-import {
-  errorStatus, StatusNetworks, unknownStatus,
-} from './lib/index.ts'
-
-/** SimpleXyoNetwork implementation. */
-export class SimpleXyoNetwork implements XyoNetwork {
-  protected readonly _networkId: GatewayName
-
-  constructor(networkId: GatewayName) {
-    this._networkId = networkId
-  }
-
-  async status(): Promise<NetworkStatus> {
-    const statusNetwork = StatusNetworks[this._networkId]
-    if (isUndefined(statusNetwork)) {
-      throw new Error(`Unknown status network ID: ${this._networkId}`)
-    }
-
-    return await this.makeRequest(statusNetwork.statusUrl)
-  }
-
-  private async makeRequest(url: string): Promise<NetworkStatus> {
-    try {
-      const response = await axios.get(url)
-      if (isNetworkStatus(response.data)) {
-        return response.data
-      } else {
-        if (response.status === 200) {
-          console.error('Unknown network status response:', response.data)
-
-          return unknownStatus
-        }
-        return errorStatus
-      }
-    } catch (error) {
-      console.error('Error fetching network status:', error)
-      return errorStatus
-    }
-  }
-}

package/src/simple/network/index.ts

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

package/src/simple/network/lib/FailedNetworkStatusPayloads.ts

@@ -1,16 +0,0 @@
-import type { NetworkStatus } from '@xyo-network/xl1-protocol-lib'
-import { NetworkStatusSchema } from '@xyo-network/xl1-protocol-lib'
-
-/** unknownStatus constant. */
-export const unknownStatus: NetworkStatus = {
-  description: 'Unknown Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}
-
-/** errorStatus constant. */
-export const errorStatus: NetworkStatus = {
-  description: 'Error Fetching Network Status',
-  schema: NetworkStatusSchema,
-  state: 'unknown',
-}