@xyo-network/xl1-cli-lib 1.17.0 → 1.17.2

package/src/orchestration/services/implementation/evm/index.ts

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

package/src/orchestration/services/implementation/evm/initChainId.ts

@@ -1,20 +0,0 @@
-import {
-  assertEx, hexFrom, isDefined, isHex,
-} from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-
-export const canUseChainId = (config: Pick<Config, 'evm'>): boolean => {
-  return isDefined(config.evm.chainId)
-}
-
-export const getChainId = (config: Pick<Config, 'evm'>) => {
-  const chainId = assertEx(config.evm.chainId, () => 'Missing config.evm.chainId')
-  if (isHex(chainId, { prefix: true })) {
-    const hex = hexFrom(chainId)
-    const parsed = Number.parseInt(hex, 16)
-    return parsed
-  } else {
-    const parsed = Number.parseInt(chainId, 10)
-    return parsed
-  }
-}

package/src/orchestration/services/implementation/evm/initEvmProvider.ts

@@ -1,24 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-import type { Provider } from 'ethers'
-import type { JsonRpcProvider } from 'ethers/providers'
-
-import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
-import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvider.ts'
-
-let provider: Promise<JsonRpcProvider> | undefined
-
-export const initEvmProvider = async ({ config }: { config: Pick<Config, 'evm'>; logger?: Logger }): Promise<Provider> => {
-  if (provider) return provider
-  if (canUseInfuraProvider(config)) {
-    provider = initInfuraProvider(config)
-  } else if (canUseJsonRpcProvider(config)) {
-    provider = initJsonRpcProvider(config)
-  }
-  return assertEx(await provider, () => 'No provider available')
-}
-
-export const canUseEvmProvider = ({ config }: { config: Pick<Config, 'evm'> }) => {
-  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
-}

package/src/orchestration/services/implementation/evm/initInfuraProvider.ts

@@ -1,26 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-import { InfuraProvider } from 'ethers/providers'
-
-import { canUseChainId, getChainId } from './initChainId.ts'
-
-let instance: Promise<InfuraProvider> | undefined
-
-export const initInfuraProvider = (config: Pick<Config, 'evm'>) => {
-  if (instance) return instance
-  const providerConfig = getInfuraProviderConfig(config)
-  instance = Promise.resolve(new InfuraProvider(...providerConfig))
-  return instance
-}
-
-export const canUseInfuraProvider = (config: Pick<Config, 'evm'>): boolean => {
-  return canUseChainId(config)
-    && isDefined(config.evm?.infura?.projectId)
-    && isDefined(config.evm?.infura?.projectSecret)
-}
-
-export const getInfuraProviderConfig = (config: Pick<Config, 'evm'>) => {
-  const projectId = assertEx(config.evm?.infura?.projectId, () => 'Missing config.evm.infura.projectId')
-  const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => 'Missing config.evm.infura.projectSecret')
-  return [getChainId(config), projectId, projectSecret] as const
-}

package/src/orchestration/services/implementation/evm/initJsonRpcProvider.ts

@@ -1,20 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-import { JsonRpcProvider } from 'ethers/providers'
-
-import { canUseChainId, getChainId } from './initChainId.ts'
-
-export const initJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
-  const providerConfig = getJsonRpcProviderConfig(config)
-  return Promise.resolve(new JsonRpcProvider(...providerConfig))
-}
-
-export const canUseJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
-  return canUseChainId(config)
-    && isDefined(config.evm.jsonRpc?.url)
-}
-
-export const getJsonRpcProviderConfig = (config: Pick<Config, 'evm'>) => {
-  const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => 'Missing config.evm.jsonRpc.url')
-  return [jsonRpcUrl, getChainId(config)] as const
-}

package/src/orchestration/services/implementation/head/createBootstrapHead.ts

@@ -1,31 +0,0 @@
-import {
-  buildNextBlock, createDeclarationIntent, createGenesisBlock,
-} from '@xyo-network/chain-protocol'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-export const createBootstrapHead = async (account: WalletInstance, chainService: ChainService): Promise<SignedHydratedBlockWithHashMeta[]> => {
-  const chainId = await chainService.chainId()
-  const chain: SignedHydratedBlockWithHashMeta[] = []
-
-  // Create genesis block
-  const genesisBlock = await createGenesisBlock(account, chainId, 10_000_000n, account.address)
-  chain.push(genesisBlock)
-
-  // Create producer declaration block
-  const producerDeclarationPayload = createDeclarationIntent(
-    account.address,
-    'producer',
-    genesisBlock[0].block,
-    genesisBlock[0].block + 10_000,
-  )
-  const producerDeclarationBlock = await buildNextBlock(
-    genesisBlock[0],
-    [],
-    [producerDeclarationPayload],
-    [account],
-  )
-  chain.push(producerDeclarationBlock)
-  return chain
-}

package/src/orchestration/services/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/orchestration/services/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/orchestration/services/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/orchestration/services/implementation/head/createForkedHead/config/index.ts

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

package/src/orchestration/services/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/orchestration/services/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/orchestration/services/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/orchestration/services/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/orchestration/services/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/orchestration/services/implementation/head/createForkedHead/index.ts

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

package/src/orchestration/services/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/orchestration/services/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/orchestration/services/implementation/head/index.ts

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

package/src/orchestration/services/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/orchestration/services/implementation/index.ts

@@ -1,11 +0,0 @@
-export * from './accountBalance.ts'
-export * from './blockViewer.ts'
-export * from './chain/index.ts'
-export * from './evm/index.ts'
-export * from './head/index.ts'
-export * from './pendingTransactions.ts'
-export * from './producer.ts'
-export * from './reward.ts'
-export * from './time.ts'
-export * from './transfer.ts'
-export * from './validator.ts'

package/src/orchestration/services/implementation/pendingTransactions.ts

@@ -1,35 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import { BasePendingTransactionsService, type BasePendingTransactionsServiceParams } from '@xyo-network/chain-services'
-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'
-
-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/orchestration/services/implementation/producer.ts

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

package/src/orchestration/services/implementation/reward.ts

@@ -1,50 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import {
-  type BaseBlockRewardServiceParams, EvmBlockRewardService, type EvmBlockRewardServiceParams, MemoryBlockRewardService,
-} from '@xyo-network/chain-services'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import {
-  type BlockRewardService, type Config, timeBudget,
-} from '@xyo-network/xl1-protocol-sdk'
-
-import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
-
-let rewardServiceSingleton: Promise<BlockRewardService> | undefined
-
-export const initBlockRewardService: Initializable<
-  BaseBlockRewardServiceParams<Pick<Config, 'evm'>> | EvmBlockRewardServiceParams,
-  BlockRewardService
-> = (params): Promise<BlockRewardService> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return timeBudget('initBlockRewardService', params.logger, () => {
-    const { config } = params
-    rewardServiceSingleton = canUseEvmBlockRewardService({ config })
-      ? initEvmBlockRewardService(params as EvmBlockRewardServiceParams)
-      : initXyoBlockRewardService(params)
-    return rewardServiceSingleton
-  }, 2000, true)
-}
-
-const initXyoBlockRewardService = (params: BaseBlockRewardServiceParams): Promise<BlockRewardService> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return timeBudget('initXyoBlockRewardService', params.logger, () => {
-    rewardServiceSingleton = MemoryBlockRewardService.create(params)
-    return rewardServiceSingleton
-  }, 2000, true)
-}
-
-const canUseEvmBlockRewardService = (params: { config: Pick<Config, 'evm'> }) => canUseEvmProvider({ config: params.config })
-
-const initEvmBlockRewardService = async (params: EvmBlockRewardServiceParams): Promise<BlockRewardService> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return await timeBudget('initEvmBlockRewardService', params.logger, async () => {
-    const { account: paramsAccount } = params
-    const account = assertEx(paramsAccount, () => 'Account is required')
-    const provider = assertEx(await initEvmProvider(params))
-    const evmBlockRewardServiceParams: EvmBlockRewardServiceParams = {
-      ...params, provider, account,
-    }
-    rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams)
-    return rewardServiceSingleton
-  }, 2000, true)
-}