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

package/src/simple/gateway/SimpleXyoGatewayRunner.ts

@@ -1,137 +0,0 @@
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import {
-  assertEx, BigIntToJsonZod, isDefined,
-} from '@xylabs/sdk-js'
-import { type Payload, type WithHashMeta } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, AttoXL1, ConfirmSubmittedTransactionOptions,
-  DataLakeRunner, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionOptions, Transfer, UnsignedHydratedTransaction,
-  XyoConnection, XyoGatewayRunner, XyoSigner,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber, DataLakeRunnerMoniker, isSignedHydratedTransaction, TransferSchema, XyoConnectionMoniker, XyoGatewayMoniker, XyoGatewayRunnerMoniker, XyoSignerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-import {
-  buildUnsignedTransaction, confirmSubmittedTransaction, flattenHydratedTransaction,
-} from '../../transaction/index.ts'
-
-/** Parameters for SimpleXyoGatewayRunner. */
-export interface SimpleXyoGatewayRunnerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleXyoGatewayRunner implementation. */
-export class SimpleXyoGatewayRunner extends AbstractCreatableProvider<SimpleXyoGatewayRunnerParams> implements XyoGatewayRunner {
-  static readonly defaultMoniker = XyoGatewayRunnerMoniker
-  static readonly dependencies = [XyoConnectionMoniker, XyoSignerMoniker]
-  static readonly monikers = [XyoGatewayRunnerMoniker, XyoGatewayMoniker]
-  moniker = SimpleXyoGatewayRunner.defaultMoniker
-
-  private _connection!: XyoConnection
-  private _dataLakeRunner?: DataLakeRunner
-  private _signer!: XyoSigner
-
-  get connection(): XyoConnection {
-    return this._connection
-  }
-
-  get dataLakeRunner(): DataLakeRunner | undefined {
-    return this._dataLakeRunner
-  }
-
-  get signer(): XyoSigner {
-    return this._signer
-  }
-
-  async addPayloadsToChain(
-    onChain: AllowedBlockPayload[],
-    offChain: Payload[],
-    options?: TransactionOptions,
-  ): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
-    // Get chain providers
-    const viewer = assertEx(this.connection.viewer, () => 'No viewer available on connection')
-
-    // Resolve transaction options
-    const {
-      nbf, exp, chain, fees,
-    } = options ?? {}
-    const resolvedChainId = isDefined(chain) ? chain : await viewer.chainId()
-    const resolvedNbf = asXL1BlockNumber(isDefined(nbf) ? nbf : await viewer.currentBlockNumber(), true)
-    const resolvedExp = asXL1BlockNumber(isDefined(exp) ? exp : resolvedNbf + 10, true)
-
-    // Build, sign, and broadcast the transaction
-    const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees)
-    return await this.addTransactionToChain(tx, await PayloadBuilder.addHashMeta(offChain))
-  }
-
-  async addTransactionToChain(
-    tx: UnsignedHydratedTransaction | SignedHydratedTransaction,
-    offChain: WithHashMeta<Payload>[] = [],
-  ): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
-    const connection = this.connection
-
-    const signer = this.signer
-    const runner = assertEx(connection.runner, () => 'No runner available on connection')
-
-    // Prepare for returning the SignedHydratedTransactionWithHashMeta
-    let signedTx: SignedHydratedTransactionWithHashMeta
-
-    // If the supplied transaction is already signed
-    if (isSignedHydratedTransaction(tx)) {
-      // Ensure it has hash meta
-      const [bw, payloads] = tx
-      const hashedBw = await PayloadBuilder.addHashMeta(bw)
-      const hashedPayloads = await PayloadBuilder.addHashMeta(payloads)
-      signedTx = [hashedBw, hashedPayloads]
-    } else {
-      // Otherwise, sign it using our signer
-      signedTx = await signer.signTransaction(tx)
-    }
-
-    await this._dataLakeRunner?.insert([...flattenHydratedTransaction(signedTx), ...offChain])
-
-    // Broadcast the transaction
-    return [await runner.broadcastTransaction([signedTx[0], signedTx[1]]), signedTx]
-  }
-
-  async confirmSubmittedTransaction(txHash: Hash, options?: ConfirmSubmittedTransactionOptions): Promise<SignedHydratedTransaction> {
-    return await confirmSubmittedTransaction(
-      assertEx(this.connection.viewer, () => 'Connection viewer is undefined'),
-      txHash,
-      options,
-    )
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._connection = await this.locator.getInstance<XyoConnection>(XyoConnectionMoniker)
-    this._signer = await this.locator.getInstance<XyoSigner>(XyoSignerMoniker)
-    this._dataLakeRunner = await this.locator.tryGetInstance<DataLakeRunner>(DataLakeRunnerMoniker)
-  }
-
-  async send(to: Address, amount: AttoXL1, options?: TransactionOptions): Promise<Hash> {
-    return await this.sendMany({ [to]: amount }, options)
-  }
-
-  async sendMany(transfers: Record<Address, AttoXL1>, options?: TransactionOptions): Promise<Hash> {
-    const from = await this.signer.address()
-    const hexTransfers: Record<Address, Hex> = Object.fromEntries(
-      Object.entries(transfers).map(([address, amount]) => ([
-        address, BigIntToJsonZod.parse(amount),
-      ])),
-    )
-    const transfer = new PayloadBuilder<Transfer>({ schema: TransferSchema }).fields({
-      from,
-      transfers: hexTransfers,
-      epoch: Date.now(),
-    }).build()
-    const [hash] = await this.addPayloadsToChain([transfer], [], options)
-    return hash
-  }
-}

package/src/simple/gateway/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleXyoGateway.ts'
-export * from './SimpleXyoGatewayRunner.ts'

package/src/simple/index.ts

@@ -1,22 +0,0 @@
-export * from './accountBalance/index.ts'
-export * from './block/index.ts'
-export * from './blockReward/index.ts'
-export * from './blockValidation/index.ts'
-export * from './chainContractViewer/index.ts'
-export * from './client/index.ts'
-export * from './datalake/index.ts'
-export * from './finalization/index.ts'
-export * from './gateway/index.ts'
-export * from './mempool/index.ts'
-export * from './network/index.ts'
-export * from './permissions/index.ts'
-export * from './runner/index.ts'
-export * from './signer/index.ts'
-export * from './StakeEventsViewer/index.ts'
-export * from './StakeTotalsViewer/index.ts'
-export * from './StakeViewer/index.ts'
-export * from './timeSync2/index.ts'
-export * from './transactionValidation/index.ts'
-export * from './transactionValidation/index.ts'
-export * from './TransactionViewer/index.ts'
-export * from './windowedBlock/index.ts'

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`)
-  }
-}