@xyo-network/chain-services 1.17.7 → 1.18.0

package/src/Time/BaseTimeSyncService.ts

@@ -1,54 +0,0 @@
-import { creatable, EmptyObject } from '@xylabs/sdk-js'
-import { TimeDomain, TimePayload } from '@xyo-network/xl1-protocol'
-import {
-  BlockViewer,
-  SimpleTimeSyncViewer, TimeSyncViewer,
-  TimeSyncViewerMoniker,
-} from '@xyo-network/xl1-protocol-sdk'
-import { Provider } from 'ethers'
-
-import { BaseService } from '../BaseService.ts'
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseTimeServiceParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {
-  blockViewer: BlockViewer
-  ethProvider?: Provider
-}
-
-@creatable()
-export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncViewer {
-  static readonly defaultMoniker = TimeSyncViewerMoniker
-  static readonly monikers = [TimeSyncViewerMoniker]
-  moniker = BaseTimeSyncService.defaultMoniker
-
-  protected timeSyncViewer!: TimeSyncViewer
-
-  protected get blockViewer() {
-    return this.params.blockViewer
-  }
-
-  protected get ethProvider() {
-    return this.params.ethProvider
-  }
-
-  async convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promise<number> {
-    return await this.timeSyncViewer.convertTime(fromDomain, toDomain, from)
-  }
-
-  override async createHandler(): Promise<void> {
-    await super.createHandler()
-    this.timeSyncViewer = await SimpleTimeSyncViewer.create({ blockViewer: this.blockViewer, ethProvider: this.ethProvider })
-  }
-
-  async currentTime(domain: TimeDomain): Promise<[string, number]> {
-    return await this.timeSyncViewer.currentTime(domain)
-  }
-
-  async currentTimeAndHash(domain: TimeDomain): Promise<[number, string | null]> {
-    return await this.timeSyncViewer.currentTimeAndHash(domain)
-  }
-
-  async currentTimePayload(): Promise<TimePayload> {
-    return await this.timeSyncViewer.currentTimePayload()
-  }
-}

package/src/Time/index.ts

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

package/src/implementation/accountBalance.ts

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { AccountBalanceViewer, Config } from '@xyo-network/xl1-protocol-sdk'
-import {
-  AccountBalanceViewerRpcSchemas,
-  HttpRpcTransport,
-  JsonRpcAccountBalanceViewer,
-} from '@xyo-network/xl1-rpc'
-
-let balanceServiceSingleton: Promisable<AccountBalanceViewer> | undefined
-
-export type InitAccountBalanceServiceParams = InitializableParams<{
-  config: Config
-}>
-
-export const initAccountBalanceService: Initializable<InitAccountBalanceServiceParams, AccountBalanceViewer>
-  = (params): Promisable<AccountBalanceViewer> => {
-    const { config, logger } = params
-    if (balanceServiceSingleton) return balanceServiceSingleton
-    const endpoint = config.services?.accountBalanceViewerEndpoint ?? config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...AccountBalanceViewerRpcSchemas })
-      const viewer = new JsonRpcAccountBalanceViewer(transport)
-      logger?.log('Using AccountBalanceViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      throw new Error('No AccountBalanceViewer endpoint configured')
-    }
-  }

package/src/implementation/blockViewer.ts

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { BlockViewer, Config } from '@xyo-network/xl1-protocol-sdk'
-import {
-  BlockViewerRpcSchemas,
-  HttpRpcTransport,
-  JsonRpcBlockViewer,
-} from '@xyo-network/xl1-rpc'
-
-let blockViewerSingleton: Promisable<BlockViewer> | undefined
-
-export type InitBlockViewerParams = InitializableParams<{
-  config: Config
-}>
-
-export const initBlockViewer: Initializable<InitBlockViewerParams, BlockViewer>
-  = (params): Promisable<BlockViewer> => {
-    const { config, logger } = params
-    if (blockViewerSingleton) return blockViewerSingleton
-    const endpoint = config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...BlockViewerRpcSchemas })
-      const viewer = new JsonRpcBlockViewer(transport)
-      logger?.log('Using BlockViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      throw new Error('No BlockViewer endpoint configured')
-    }
-  }

package/src/implementation/head/createForkedHead/config/getBridgeDestinationDetails.ts

@@ -1,27 +0,0 @@
-import { toHex } from '@xylabs/sdk-js'
-import type { BridgeDetailsDestinationFields } from '@xyo-network/xl1-protocol'
-
-import { getForkBlockRewardHex } from './getForkDetails.ts'
-
-// const bridgeableTokenContract = toHex('0x4865Cb10d55cfB0E60DD2B4F9b888f6a49B76733')
-// const bridgeDestAddress = toHex('0xe53218d47913b5f9E58bb74F0a0eD790bbF21972')
-// const destConfirmation = toHex('0x4fa05d7e799f36f1d45c441a4866eb4570a00a753a39377f404a8d113c01a657') // Eth TX for mint
-const ethChainId = toHex('0x1')
-const bridgeableTokenContract = toHex('0xf72aE3E0DA743033AbD7A407557D684c1aE66aed')
-const bridgeDestAddress = toHex('0x0e65b65B10C791942665030402c35023d88B14dA')
-const destConfirmation = toHex('0x950861b10523b52cdbb4a9ee52ed26601db555d2652bfec21c709e5e70d5b7d3') // Eth TX for mint
-
-export const getBridgeDestChainId = () => ethChainId
-export const getBridgeDestToken = () => bridgeableTokenContract
-export const getBridgeDestAddress = () => bridgeDestAddress
-export const getBridgeDestAmount = () => getForkBlockRewardHex()
-export const getBridgeDestConfirmation = () => destConfirmation
-
-export const getBridgeDestinationDetails = (): BridgeDetailsDestinationFields => {
-  return {
-    dest: getBridgeDestChainId(),
-    destToken: getBridgeDestToken(),
-    destAddress: getBridgeDestAddress(),
-    destAmount: getBridgeDestAmount(),
-  }
-}

package/src/implementation/head/createForkedHead/config/getBridgeSourceDetails.ts

@@ -1,19 +0,0 @@
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { BridgeDetailsSourceFields } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import { getForkBlockRewardHex } from './getForkDetails.ts'
-
-export const getBridgeSrcChainId = (chainService: ChainService) => chainService.chainId()
-export const getBridgeSrcAddress = (account: AccountInstance) => account.address
-export const getBridgeSrcToken = (chainService: ChainService) => chainService.chainId()
-export const getBridgeSrcAmount = () => getForkBlockRewardHex()
-
-export const getBridgeSourceDetails = async (account: AccountInstance, chainService: ChainService): Promise<BridgeDetailsSourceFields> => {
-  return {
-    src: await getBridgeSrcChainId(chainService),
-    srcAddress: getBridgeSrcAddress(account),
-    srcToken: await getBridgeSrcToken(chainService),
-    srcAmount: getBridgeSrcAmount(),
-  }
-}

package/src/implementation/head/createForkedHead/config/getForkDetails.ts

@@ -1,10 +0,0 @@
-import { type Hex, toHex } from '@xylabs/sdk-js'
-import { AttoXL1ConvertFactor } from '@xyo-network/xl1-protocol'
-
-export const getForkBlockReward = (): bigint => {
-  return 18_000_000_000n * AttoXL1ConvertFactor.xl1 // 18b XL1 in AttoXL1
-}
-
-export const getForkBlockRewardHex = (): Hex => {
-  return toHex(getForkBlockReward())
-}

package/src/implementation/head/createForkedHead/config/index.ts

@@ -1,3 +0,0 @@
-export * from './getBridgeDestinationDetails.ts'
-export * from './getBridgeSourceDetails.ts'
-export * from './getForkDetails.ts'

package/src/implementation/head/createForkedHead/createForkedHead.ts

@@ -1,29 +0,0 @@
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import { getBridgeDestinationObservation } from './getBridgeDestinationObservation.ts'
-import { getBridgeIntent } from './getBridgeIntent.ts'
-import { getBridgeSourceObservation } from './getBridgeSourceObservation.ts'
-import { getFirstBlockForNewChain } from './getFirstBlockForNewChain.ts'
-
-export const createForkedHead = async (
-  forkFromBlock: SignedBlockBoundWitnessWithHashMeta,
-  account: WalletInstance,
-  chainService: ChainService,
-): Promise<SignedHydratedBlockWithHashMeta[]> => {
-  const chain: SignedHydratedBlockWithHashMeta[] = []
-  // Build the first block for the new chain
-  const firstBlockForNewChain = await getFirstBlockForNewChain(forkFromBlock, account, chainService)
-  chain.push(firstBlockForNewChain)
-  // Build the bridge intent
-  const bridgeIntent = await getBridgeIntent(firstBlockForNewChain, account, chainService)
-  chain.push(bridgeIntent)
-  // Build the bridge source observation
-  const bridgeSourceObservation = await getBridgeSourceObservation(bridgeIntent, account, chainService)
-  chain.push(bridgeSourceObservation)
-  // Build the bridge destination observation
-  const bridgeDestinationObservation = await getBridgeDestinationObservation(bridgeSourceObservation, account, chainService)
-  chain.push(bridgeDestinationObservation)
-  return chain
-}

package/src/implementation/head/createForkedHead/getBridgeDestinationObservation.ts

@@ -1,42 +0,0 @@
-import { buildNextBlock } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BridgeDestinationObservation, BridgeDestinationObservationFields,
-  HydratedBlockWithHashMeta,
-  SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol'
-import { BridgeDestinationObservationSchema } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import {
-  getBridgeDestConfirmation, getBridgeDestinationDetails, getBridgeSourceDetails,
-} from './config/index.ts'
-
-/**
- * Get the bridge destination observation for a given block.
- * @param previousBlock The previous block to base the observation on.
- * @param account The wallet account to use for the observation.
- * @param chainService The chain service to use for the observation.
- */
-export const getBridgeDestinationObservation = async (
-  previousBlock: HydratedBlockWithHashMeta,
-  account: WalletInstance,
-  chainService: ChainService,
-): Promise<SignedHydratedBlockWithHashMeta> => {
-  const bridgeDestinationObservationFields: BridgeDestinationObservationFields = {
-    ...await getBridgeSourceDetails(account, chainService),
-    ...getBridgeDestinationDetails(),
-    destConfirmation: getBridgeDestConfirmation(),
-  }
-  const bridgeDestinationObservation = new PayloadBuilder<BridgeDestinationObservation>({ schema: BridgeDestinationObservationSchema })
-    .fields(bridgeDestinationObservationFields)
-    .build()
-
-  return await buildNextBlock(
-    previousBlock[0],
-    [],
-    [bridgeDestinationObservation],
-    [account],
-  )
-}

package/src/implementation/head/createForkedHead/getBridgeIntent.ts

@@ -1,51 +0,0 @@
-import { buildNextBlock, createTransferPayload } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BridgeIntent, BridgeIntentFields,
-  SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol'
-import { BridgeIntentSchema, XYO_BRIDGE_ADDRESS } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import {
-  getBridgeDestinationDetails, getBridgeSourceDetails, getForkBlockReward,
-} from './config/index.ts'
-
-/**
- * Get the bridge intent for a given block.
- * @param previousBlock The previous block to base the intent on.
- * @param account The wallet account to use for the intent.
- * @param chainService The chain service to use for the intent.
- */
-export const getBridgeIntent = async (
-  previousBlock: SignedHydratedBlockWithHashMeta,
-  account: WalletInstance,
-  chainService: ChainService,
-): Promise<SignedHydratedBlockWithHashMeta> => {
-  // Create transfer to bridge address
-  const transferPayload = createTransferPayload(
-    account.address,
-    { [XYO_BRIDGE_ADDRESS]: getForkBlockReward() },
-  )
-
-  // Use timestamp as nonce
-  const nonce = `${Date.now()}`
-
-  // Create Bridge Intent
-  const bridgeIntentFields: BridgeIntentFields = {
-    ...await getBridgeSourceDetails(account, chainService),
-    ...getBridgeDestinationDetails(),
-    nonce,
-  }
-  const bridgeIntent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema })
-    .fields(bridgeIntentFields)
-    .build()
-
-  return await buildNextBlock(
-    previousBlock[0],
-    [],
-    [bridgeIntent, transferPayload],
-    [account],
-  )
-}

package/src/implementation/head/createForkedHead/getBridgeSourceObservation.ts

@@ -1,46 +0,0 @@
-import { buildNextBlock } from '@xyo-network/chain-protocol'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BridgeSourceObservation, BridgeSourceObservationFields,
-  SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol'
-import { BridgeSourceObservationSchema } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import { getBridgeDestinationDetails, getBridgeSourceDetails } from './config/index.ts'
-
-/**
- * Get the bridge source observation for a given block.
- * @param previousBlock The previous block to base the observation on.
- * @param account The wallet account to use for the observation.
- * @param chainService The chain service to use for the observation.
- */
-export const getBridgeSourceObservation = async (
-  previousBlock: SignedHydratedBlockWithHashMeta,
-  account: WalletInstance,
-  chainService: ChainService,
-): Promise<SignedHydratedBlockWithHashMeta> => {
-  // TODO: Find actual transfer TX from previous block/source intent?
-  // This hash should contain both the source intent and the transfer to the bridge address
-  // As the block is itself both a block and a transaction, we can use its hash for now
-  const srcTxHash = previousBlock[0]._hash
-
-  const bridgeSourceObservationFields: BridgeSourceObservationFields = {
-    ...await getBridgeSourceDetails(account, chainService),
-    ...getBridgeDestinationDetails(),
-    // Observation
-    srcConfirmation: srcTxHash,
-  }
-
-  const bridgeSourceObservation = new PayloadBuilder<BridgeSourceObservation>({ schema: BridgeSourceObservationSchema })
-    .fields(bridgeSourceObservationFields)
-    .build()
-
-  return await buildNextBlock(
-    previousBlock[0],
-    [],
-    [bridgeSourceObservation],
-    [account],
-  )
-}

package/src/implementation/head/createForkedHead/getFirstBlockForNewChain.ts

@@ -1,41 +0,0 @@
-import { buildBlock, type BuildNextBlockOptions } from '@xyo-network/chain-protocol'
-import type { WithHashMeta } from '@xyo-network/payload-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BlockBoundWitness,
-  SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol'
-import { AttoXL1, XYO_STEP_REWARD_ADDRESS } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-/**
- * Get the first block for the new forked chain.
- * @param forkBlock The block to fork from
- * @param account The wallet account to sign the block
- * @param chainService The chain service instance
- * @returns The first block for the new forked chain
- */
-export const getFirstBlockForNewChain = async (
-  forkBlock: WithHashMeta<BlockBoundWitness>,
-  account: WalletInstance,
-  chainService: ChainService,
-): Promise<SignedHydratedBlockWithHashMeta> => {
-  const {
-    _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes = [], protocol,
-  } = forkBlock
-  const chainId = await chainService.chainId()
-  const options: BuildNextBlockOptions = {
-    blockPayloads: [],
-    chainId,
-    previousBlockHash,
-    previousBlockNumber,
-    previousStepHashes,
-    signers: [account],
-    txs: [],
-    protocol,
-    chainStepRewardAddress: XYO_STEP_REWARD_ADDRESS,
-    stepRewardPoolBalance: AttoXL1(0n),
-  }
-  // Can not use buildNextBlock because we need to control the chain id change here
-  return await buildBlock(options)
-}

package/src/implementation/head/createForkedHead/index.ts

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

package/src/implementation/head/getForkFromBlock.ts

@@ -1,43 +0,0 @@
-import type { Address, Hash } from '@xylabs/sdk-js'
-import {
-  asHash, hexFromBigInt, isDefined,
-} from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { SignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
-import { isSignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-/**
- * Determine if the chain should fork based on the current head and chain configuration.
- * @param head The current head block
- * @param chainService The chain service instance
- * @param chainArchivist The chain archivist instance
- * @returns The block to fork from if the chain should fork, undefined otherwise
- */
-export const getForkFromBlock = async (
-  head: SignedBlockBoundWitnessWithHashMeta,
-  chainService: ChainService,
-  chainArchivist: ArchivistInstance,
-): Promise<SignedBlockBoundWitnessWithHashMeta | undefined> => {
-  // If the head's chain doesn't match our chainId, we may need to fork
-  if (head.chain !== await chainService.chainId()) {
-    // Get the forked at hash from the chain service
-    const forkedAtBigInt = await chainService.forkedAtHash()
-    const forkedAtHex = hexFromBigInt(forkedAtBigInt) // Validate it's a proper hex string
-    const forkedAtHash: Hash | undefined = asHash(forkedAtHex)
-    if (isDefined(forkedAtHash)) {
-      // If we have a forkedAtHash, we need to check if the correct block exists
-      const [forkedAtBlock] = await chainArchivist.get([forkedAtHash])
-      const forkedChainId: Address = await chainService.forkedChainId()
-      const forkedAtBlockNumber: number = Number(await chainService.forkedAtBlockNumber())
-      // If we found the block hash we should fork at, check if it's a valid BlockBoundWitness
-      if (isSignedBlockBoundWitnessWithHashMeta(forkedAtBlock)
-      // And it is on the correct forked from chain
-        && forkedAtBlock.chain === forkedChainId
-        // And it is the correct forked at block number
-        && forkedAtBlock.block === forkedAtBlockNumber) {
-        return forkedAtBlock
-      }
-    }
-  }
-}

package/src/implementation/head/head.ts

@@ -1,49 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { Initializable, SignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
-import { type ChainService, findMostRecentBlock } from '@xyo-network/xl1-protocol-sdk'
-
-import { createBootstrapHead } from './createBootstrapHead.ts'
-import { createForkedHead } from './createForkedHead/index.ts'
-import { getForkFromBlock } from './getForkFromBlock.ts'
-import { submitNewChain } from './submitNewChain.ts'
-
-let headSingleton: Promisable<SignedBlockBoundWitnessWithHashMeta> | undefined
-
-export const initHead: Initializable<{
-  account: WalletInstance
-  chainArchivist: ArchivistInstance
-  chainService: ChainService
-  chainSubmissionsArchivistWrite: ArchivistInstance
-}, SignedBlockBoundWitnessWithHashMeta>
-  = async (params): Promise<SignedBlockBoundWitnessWithHashMeta> => {
-    const {
-      account, chainArchivist, chainSubmissionsArchivistWrite, chainService,
-    } = params
-    if (headSingleton) return headSingleton
-    let head = await findMostRecentBlock(chainArchivist)
-
-    // If there is a head
-    if (head) {
-      // If there is a head but check if it matches our chainId or we should fork from it
-      const forkFromBlock = await getForkFromBlock(head, chainService, chainArchivist)
-      // If we should fork form a block in the current chain
-      if (isDefined(forkFromBlock)) {
-        // Create a new chain from the fork from block
-        const chain = await createForkedHead(forkFromBlock, account, chainService)
-        await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite)
-        const newBlock = assertEx(chain.at(-1), () => new Error('Failed to get new head after forking'))
-        head = newBlock[0]
-      }
-    } else {
-      // If there is no head, create one
-      const chain = await createBootstrapHead(account, chainService)
-      await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite)
-      const newBlock = assertEx(chain.at(-1), () => new Error('Failed to get new head after genesis'))
-      head = newBlock[0]
-    }
-    headSingleton = head
-    return headSingleton
-  }

package/src/implementation/head/submitNewChain.ts

@@ -1,27 +0,0 @@
-import { delay } from '@xylabs/sdk-js'
-import type { ArchivistInstance, WriteArchivist } from '@xyo-network/archivist-model'
-import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
-import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
-
-/**
- * Submit a new chain to the archivist.
- * @param chain The new chain to submit
- * @param chainArchivist The chain archivist instance
- * @param chainSubmissionsArchivistWrite The chain submissions archivist instance
- */
-export const submitNewChain = async (
-  chain: SignedHydratedBlockWithHashMeta[],
-  chainArchivist: ArchivistInstance,
-  chainSubmissionsArchivistWrite: WriteArchivist,
-): Promise<void> => {
-  for (const block of chain) {
-    const [bw] = block
-    await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(block))
-    // Wait for block to show up in finalized archivist
-    while (true) {
-      const result = await chainArchivist.get([bw._hash])
-      if (result.length > 0) break
-      await delay(1000) // Wait 1 second before retrying
-    }
-  }
-}

package/src/implementation/mempoolRunner.ts

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { Config, MempoolRunner } from '@xyo-network/xl1-protocol-sdk'
-import {
-  HttpRpcTransport,
-  JsonRpcMempoolRunner,
-  MempoolRunnerRpcSchemas,
-} from '@xyo-network/xl1-rpc'
-
-let mempoolRunnerSingleton: Promisable<MempoolRunner> | undefined
-
-export type InitMempoolRunnerParams = InitializableParams<{
-  config: Config
-}>
-
-export const initMempoolRunner: Initializable<InitMempoolRunnerParams, MempoolRunner>
-  = (params): Promisable<MempoolRunner> => {
-    const { config, logger } = params
-    if (mempoolRunnerSingleton) return mempoolRunnerSingleton
-    const endpoint = config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...MempoolRunnerRpcSchemas })
-      const runner = new JsonRpcMempoolRunner(transport)
-      logger?.log('Using mempoolRunner RPC service at', endpoint)
-      return runner
-    } else {
-      throw new Error('No MempoolRunner endpoint configured')
-    }
-  }

package/src/implementation/mempoolViewer.ts

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { Config, MempoolViewer } from '@xyo-network/xl1-protocol-sdk'
-import {
-  HttpRpcTransport,
-  JsonRpcMempoolViewer,
-  MempoolViewerRpcSchemas,
-} from '@xyo-network/xl1-rpc'
-
-let mempoolViewerSingleton: Promisable<MempoolViewer> | undefined
-
-export type InitMempoolViewerParams = InitializableParams<{
-  config: Config
-}>
-
-export const initMempoolViewer: Initializable<InitMempoolViewerParams, MempoolViewer>
-  = (params): Promisable<MempoolViewer> => {
-    const { config, logger } = params
-    if (mempoolViewerSingleton) return mempoolViewerSingleton
-    const endpoint = config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...MempoolViewerRpcSchemas })
-      const viewer = new JsonRpcMempoolViewer(transport)
-      logger?.log('Using MempoolViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      throw new Error('No MempoolViewer endpoint configured')
-    }
-  }

package/src/implementation/pendingTransactions.ts

@@ -1,36 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { Config, MempoolViewer } from '@xyo-network/xl1-protocol-sdk'
-import { timeBudget } from '@xyo-network/xl1-protocol-sdk'
-import {
-  HttpRpcTransport, JsonRpcMempoolViewer, MempoolViewerRpcSchemas,
-} from '@xyo-network/xl1-rpc'
-
-import { BasePendingTransactionsService, type BasePendingTransactionsServiceParams } from '../PendingTransactions/index.ts'
-
-let serviceSingleton: Promisable<MempoolViewer> | undefined
-
-export type InitPendingTransactionsServiceParams = InitializableParams<{
-  config: Config
-  params?: BasePendingTransactionsServiceParams
-}>
-
-export const initPendingTransactions: Initializable<InitPendingTransactionsServiceParams, MempoolViewer> = async (
-  {
-    config, params, logger,
-  }: InitPendingTransactionsServiceParams,
-): Promise<MempoolViewer> => {
-  if (serviceSingleton) return serviceSingleton
-  return await timeBudget('initPendingTransactions', logger, async () => {
-    const endpoint = config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...MempoolViewerRpcSchemas })
-      const viewer = new JsonRpcMempoolViewer(transport)
-      logger?.log('Using MempoolViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      serviceSingleton = await BasePendingTransactionsService.create(params)
-    }
-    return serviceSingleton
-  }, 2000, true)
-}

package/src/implementation/producer.ts

@@ -1,16 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import { type BlockProducerService, timeBudget } from '@xyo-network/xl1-protocol-sdk'
-
-import { SimpleBlockRunner, type SimpleBlockRunnerParams } from '../simple/index.ts'
-
-let serviceSingleton: Promisable<BlockProducerService> | undefined
-
-export const initBlockProducer: Initializable<SimpleBlockRunnerParams, BlockProducerService>
-  = async (params: SimpleBlockRunnerParams): Promise<BlockProducerService> => {
-    if (serviceSingleton) return serviceSingleton
-    return await timeBudget('initBlockProducer', params.logger, async () => {
-      serviceSingleton = await SimpleBlockRunner.create(params)
-      return serviceSingleton
-    }, 2000, true)
-  }