@xyo-network/chain-orchestration 1.20.14 → 1.20.16

package/src/node/evm/initJsonRpcProvider.ts

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

package/src/node/health/index.ts

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

package/src/node/health/initHealthEndpoints.ts

@@ -1,67 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import http from 'node:http'
-
-import type { CreatableStatus } from '@xylabs/sdk-js'
-import { isDefined } from '@xylabs/sdk-js'
-import type { ActorConfigContext, RuntimeStatusMonitor } from '@xyo-network/xl1-sdk'
-
-const sendStatus = (res: ServerResponse, status: CreatableStatus, errorCode: number) => {
-  const statusCode = status === 'started' ? 200 : errorCode
-  res.writeHead(statusCode, { 'Content-Type': 'application/json' })
-  res.end(JSON.stringify({ status }))
-}
-
-const notFound = (res: ServerResponse) => {
-  res.writeHead(404, { 'Content-Type': 'application/json' })
-  res.end(JSON.stringify({ status: 'not found' }))
-}
-
-/**
- * Starts an HTTP server with Kubernetes health endpoints:
- * - /healthz
- * - /livez
- * - /readyz
- * @param context The actor configuration context
- * @param port The port to listen on (default: 8080)
- * @param statusMonitor The runtime status monitor to determine the health status
- */
-const createHealthServer = (context: ActorConfigContext, port: number, statusMonitor: RuntimeStatusMonitor) => {
-  const { logger } = context
-  const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
-    const url = req.url ?? ''
-
-    const status = statusMonitor.getGlobalStatus()
-
-    switch (url) {
-      case '/healthz': {
-        sendStatus(res, status, 500)
-        break
-      }
-      case '/livez': {
-        sendStatus(res, status, 503)
-        break
-      }
-      case '/readyz': {
-        sendStatus(res, status, 503)
-        break
-      }
-      default: {
-        notFound(res)
-      }
-    }
-  })
-
-  server.listen(port, () => {
-    logger?.log(`Health server running on http://localhost:${port}`)
-    logger?.log(' - /healthz')
-    logger?.log(' - /livez')
-    logger?.log(' - /readyz')
-  })
-  return server
-}
-
-export function initHealthEndpoints(context: ActorConfigContext, statusMonitor: RuntimeStatusMonitor) {
-  const { config } = context
-  const { healthCheckPort } = config
-  return isDefined(healthCheckPort) ? createHealthServer(context, healthCheckPort, statusMonitor) : undefined
-}

package/src/node/index.ts

@@ -1,8 +0,0 @@
-export * from '../shared/index.ts'
-export * from './archivists/index.ts'
-export * from './config/index.ts'
-export * from './evm/index.ts'
-export * from './health/index.ts'
-export * from './init/index.ts'
-export * from './manifest/index.ts'
-export * from './sharedMiddleware.ts'

package/src/node/init/index.ts

@@ -1,6 +0,0 @@
-export * from './initBalanceSummaryMap.ts'
-export * from './initEvmProvidersIfAvailable.ts'
-export * from './initFinalizationArchivistIfNeeded.ts'
-export * from './initFinalizedArchivist.ts'
-export * from './initServerNode.ts'
-export * from './initTransferSummaryMap.ts'

package/src/node/init/initBalanceSummaryMap.ts

@@ -1,33 +0,0 @@
-import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { MongoMap } from '@xyo-network/chain-protocol'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import type {
-  BalancesStepSummary, BaseConfigContext, MapType,
-} from '@xyo-network/xl1-sdk'
-import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-sdk'
-
-export async function initBalanceSummaryMap({ logger, config }: BaseConfigContext): Promise<MapType<string, WithStorageMeta<BalancesStepSummary>>> {
-  const mongoConfig = config.storage?.mongo
-  if (hasMongoConfig(mongoConfig)) {
-    // Create the MongoDB SDK from the configuration
-    const {
-      connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName,
-    } = mongoConfig
-    const payloadSdkConfig: BaseMongoSdkPrivateConfig = {
-      dbConnectionString, dbDomain, dbName, dbPassword, dbUserName,
-    }
-
-    const sdkBalanceSummaryMap = new BaseMongoSdk<WithStorageMeta<BalancesStepSummary>>({ ...payloadSdkConfig, collection: 'balance_summary_map' })
-    const result = await MongoMap.create<MongoMap<Hash, WithStorageMeta<BalancesStepSummary>>>({
-      sdk: sdkBalanceSummaryMap,
-      getCache: { enabled: true, maxEntries: 5000 },
-    })
-    assertEx(await result.start(), () => 'Failed to start transfer summary map')
-    return result
-  } else {
-    logger?.warn('[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.')
-    return new MemoryMap<string, WithStorageMeta<BalancesStepSummary>>()
-  }
-}

package/src/node/init/initEvmProvidersIfAvailable.ts

@@ -1,93 +0,0 @@
-import { asEthAddress, assertEx } from '@xylabs/sdk-js'
-import {
-  EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer,
-} from '@xyo-network/chain-ethereum'
-import type {
-  ChainId,
-  Position,
-  ProviderFactoryLocatorInstance,
-} from '@xyo-network/xl1-sdk'
-import {
-  SimpleChainContractViewer,
-  SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer,
-  XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-sdk'
-
-import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
-
-/* TODO: Rename function since it initializes both EVM and non-EVM providers */
-export async function initEvmProvidersIfAvailable(
-  locator: ProviderFactoryLocatorInstance,
-): Promise<ProviderFactoryLocatorInstance> {
-  const context = locator.context
-  const { logger } = context
-  if (canUseEvmProvider(context)) {
-    const chainId = assertEx(context.config.chain.id as ChainId, () => 'Missing config.chain.id (required for EVM providers)')
-    const provider = await initEvmProvider(context)
-    const address = asEthAddress(chainId, true)
-
-    // Register the contract events viewer
-    locator.register(EvmStakeEventsViewer.factory<EvmStakeEventsViewer>(
-      EvmStakeEventsViewer.dependencies,
-      { address, provider },
-    ))
-
-    // Register the stake viewer
-    locator.register(EvmStakeViewer.factory<EvmStakeViewer>(
-      EvmStakeViewer.dependencies,
-      { address, provider },
-    ))
-
-    // Register the stake totals viewer
-    locator.register(EvmStakeTotalsViewer.factory<EvmStakeTotalsViewer>(
-      EvmStakeTotalsViewer.dependencies,
-      { address, provider },
-    ))
-
-    // Register the contract viewer
-    locator.register(EvmChainContractViewer.factory<EvmChainContractViewer>(
-      EvmChainContractViewer.dependencies,
-      { address, provider },
-    ))
-
-    locator.register(SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(
-      SimpleTimeSyncViewer.dependencies,
-      { ethProvider: provider },
-    ))
-  } else {
-    logger?.warn('EVM provider not available - running with memory based contract/stake viewers')
-    const positions: Position[] = []
-
-    // Register the contract events viewer
-    locator.register(SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(
-      SimpleStakeEventsViewer.dependencies,
-      { positions },
-    ))
-
-    // Register the stake viewer
-    locator.register(SimpleStakeViewer.factory<SimpleStakeViewer>(
-      SimpleStakeViewer.dependencies,
-      { positions },
-    ))
-
-    // Register the stake totals viewer
-    locator.register(SimpleStakeTotalsViewer.factory<SimpleStakeTotalsViewer>(
-      SimpleStakeTotalsViewer.dependencies,
-      {},
-    ))
-
-    // Register the contract viewer
-    locator.register(SimpleChainContractViewer.factory<SimpleChainContractViewer>(
-      SimpleChainContractViewer.dependencies,
-      {
-        minWithdrawalBlocks: 10, stakingTokenAddress: XYO_ZERO_ADDRESS, rewardsContract: XYO_ZERO_ADDRESS,
-      },
-    ))
-
-    locator.register(SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(
-      SimpleTimeSyncViewer.dependencies,
-      {},
-    ))
-  }
-  return locator
-}

package/src/node/init/initFinalizationArchivistIfNeeded.ts

@@ -1,44 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { createBootstrapHead } from '@xyo-network/chain-sdk'
-import type { AccountInstance, ArchivistInstance } from '@xyo-network/sdk-js'
-import { Account } from '@xyo-network/sdk-js'
-import type {
-  ActorConfig,
-  ChainId,
-  SignedBlockBoundWitnessWithHashMeta,
-} from '@xyo-network/xl1-sdk'
-import {
-  asAttoXL1, findMostRecentBlock,
-  flattenHydratedBlock,
-} from '@xyo-network/xl1-sdk'
-
-export async function initFinalizationArchivistIfNeeded(
-  archivist: ArchivistInstance,
-  config: ActorConfig,
-  account: AccountInstance,
-): Promise<[SignedBlockBoundWitnessWithHashMeta, ChainId]> {
-  const configuredChainId = config.chain.id
-  const possibleHead = await findMostRecentBlock(archivist)
-  if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
-    throw new Error(`Configured chain ID (${configuredChainId}) does not match the existing chain ID (${possibleHead.chain})`)
-  }
-
-  let possibleChainId: ChainId | undefined = configuredChainId
-
-  // if there is no configured chain ID and no head, create a new chain
-  if (!possibleHead) {
-    possibleChainId = possibleChainId ?? (await Account.random()).address
-    // If there is no head, create one
-    const chain = await createBootstrapHead(
-      account,
-      possibleChainId,
-      asAttoXL1(20_000_000_000_000_000_000_000n),
-      config.chain.genesisRewardAddress ?? account.address,
-    )
-    const payloads = chain.flatMap(block => flattenHydratedBlock(block))
-    await archivist.insert(payloads)
-  }
-  const head = possibleHead ?? assertEx(await findMostRecentBlock(archivist), () => 'No blocks found in chain archivist')
-  const chainId = assertEx(possibleChainId, () => 'Chain ID could not be determined')
-  return [head, chainId]
-}

package/src/node/init/initFinalizedArchivist.ts

@@ -1,16 +0,0 @@
-import { MongoDBArchivistV2 } from '@xyo-network/archivist-mongodb'
-import type { MongoDBModuleParamsV2 } from '@xyo-network/module-model-mongodb'
-import type { Config } from '@xyo-network/xl1-sdk'
-
-async function initMongoFinalizedArchivist(config: Config) {
-  const payloadSdkConfig = {
-    ...config.storage.mongo,
-    collection: 'chain_validated',
-  } satisfies MongoDBModuleParamsV2['payloadSdkConfig']
-  return await MongoDBArchivistV2.create({ payloadSdkConfig })
-}
-
-export async function initFinalizedArchivist(config: Config) {
-  const finalizedArchivist = await initMongoFinalizedArchivist(config)
-  return finalizedArchivist
-}

package/src/node/init/initServerNode.ts

@@ -1,51 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { NodeInstance } from '@xyo-network/sdk-js'
-import { asArchivistInstance } from '@xyo-network/sdk-js'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
-
-import { loadNode } from '../manifest/index.ts'
-
-async function writableChainArchivistFromNode(node: NodeInstance) {
-  return asArchivistInstance(
-    await node.resolve('Chain:Validated'),
-    { required: true },
-  )
-}
-
-async function readonlyChainArchivistFromNode(node: NodeInstance) {
-  return assertEx(asArchivistInstance(
-    await node.resolve('Chain:Validated'),
-    { required: true },
-  ))
-}
-
-async function pendingTransactionsArchivistFromNode(node: NodeInstance) {
-  return asArchivistInstance(
-    await node.resolve('XYOChain:Pending:Transactions'),
-    { required: true },
-  )
-}
-
-async function pendingBlocksArchivistFromNode(node: NodeInstance) {
-  return asArchivistInstance(
-    await node.resolve('XYOChain:Pending:Blocks'),
-    { required: true },
-  )
-}
-
-export async function initServerNode(
-  context: BaseConfigContext,
-  wallet: WalletInstance,
-  providedNode?: NodeInstance,
-) {
-  const node: NodeInstance = providedNode ?? await loadNode(context, wallet)
-  assertEx(await node.start(), () => 'Failed to start node')
-  const writableChainArchivist = await writableChainArchivistFromNode(node)
-  const readonlyChainArchivist = await readonlyChainArchivistFromNode(node)
-  const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node)
-  const pendingBlocksArchivist = await pendingBlocksArchivistFromNode(node)
-  return {
-    node, writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
-  }
-}

package/src/node/init/initTransferSummaryMap.ts

@@ -1,33 +0,0 @@
-import { BaseMongoSdk, type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { MongoMap } from '@xyo-network/chain-protocol'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import type {
-  BaseConfigContext, MapType, TransfersStepSummary,
-} from '@xyo-network/xl1-sdk'
-import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-sdk'
-
-export async function initTransferSummaryMap({ logger, config }: BaseConfigContext): Promise<MapType<string, WithStorageMeta<TransfersStepSummary>>> {
-  const mongoConfig = config.storage?.mongo
-  if (hasMongoConfig(mongoConfig)) {
-    // Create the MongoDB SDK from the configuration
-    const {
-      connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName,
-    } = mongoConfig
-    const payloadSdkConfig: BaseMongoSdkPrivateConfig = {
-      dbConnectionString, dbDomain, dbName, dbPassword, dbUserName,
-    }
-
-    const sdkTransferSummaryMap = new BaseMongoSdk<WithStorageMeta<TransfersStepSummary>>({ ...payloadSdkConfig, collection: 'transfer_summary_map' })
-    const result = await MongoMap.create<MongoMap<Hash, WithStorageMeta<TransfersStepSummary>>>({
-      sdk: sdkTransferSummaryMap,
-      getCache: { enabled: true, maxEntries: 5000 },
-    })
-    assertEx(await result.start(), () => 'Failed to start transfer summary map')
-    return result
-  } else {
-    logger?.warn('[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.')
-    return new MemoryMap<string, WithStorageMeta<TransfersStepSummary>>()
-  }
-}

package/src/node/manifest/getLocator.ts

@@ -1,65 +0,0 @@
-import { type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
-import { isDefined } from '@xylabs/sdk-js'
-import { MongoDBArchivistV2, MongoDBArchivistV2Deletable } from '@xyo-network/archivist-mongodb'
-import { ViewArchivist } from '@xyo-network/archivist-view'
-import { initTelemetry } from '@xyo-network/chain-telemetry'
-import type { MongoDBModuleParamsV2 } from '@xyo-network/module-model-mongodb'
-import {
-  AbstractModule, LoggerModuleStatusReporter,
-  MemoryArchivist, MemorySentinel, ModuleFactoryLocator,
-} from '@xyo-network/sdk-js'
-import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
-import { hasMongoConfig } from '@xyo-network/xl1-sdk'
-
-/**
- * Used for retrieving a locator with the necessary modules registered for testing
- * operation of the node (entirely in memory)
- * @returns A locator with the necessary modules registered
- */
-export const getLocator = async (
-  { logger, config }: BaseConfigContext,
-) => {
-  const { otlpEndpoint } = config.telemetry?.otel ?? {}
-  const { path: endpoint = '/metrics', port: port = 9465 } = config.telemetry?.metrics?.scrape ?? {}
-  const { traceProvider, meterProvider } = await initTelemetry({
-    attributes: {
-      serviceName: 'xl1-api',
-      serviceVersion: '1.0.0',
-    },
-    otlpEndpoint,
-    metricsConfig: { endpoint, port },
-  })
-
-  if (isDefined(logger)) AbstractModule.defaultLogger = logger
-  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : undefined
-
-  const locator = new ModuleFactoryLocator()
-  // If there's a MongoDB configuration
-  const mongoConfig = config.storage?.mongo
-  if (hasMongoConfig(mongoConfig)) {
-    // Create the MongoDB SDK from the configuration
-    const {
-      connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName,
-    } = mongoConfig
-    const payloadSdkConfig: BaseMongoSdkPrivateConfig = {
-      dbConnectionString, dbDomain, dbName, dbPassword, dbUserName,
-    }
-    const params: Partial<MongoDBModuleParamsV2> = {
-      meterProvider, payloadSdkConfig, statusReporter, traceProvider,
-    }
-    // Register the MongoDB Archivist as the default
-    locator.register(MongoDBArchivistV2.factory(params), undefined, true)
-    locator.register(MongoDBArchivistV2Deletable.factory(params), { 'network.xyo.storage.capabilities.delete': 'enabled' }, false)
-  }
-
-  locator.register(MemoryArchivist.factory({
-    traceProvider, meterProvider, statusReporter,
-  }))
-  locator.register(MemorySentinel.factory({
-    traceProvider, meterProvider, statusReporter,
-  }))
-  locator.register(ViewArchivist.factory({
-    traceProvider, meterProvider, statusReporter,
-  }))
-  return locator
-}

package/src/node/manifest/index.ts

@@ -1,5 +0,0 @@
-export * from './getLocator.ts'
-export * from './loadNode.ts'
-export * from './nodeManifest.ts'
-export * from './private/index.ts'
-export * from './public/index.ts'

package/src/node/manifest/loadNode.ts

@@ -1,26 +0,0 @@
-import { ManifestWrapper } from '@xyo-network/sdk-js'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
-
-import { getLocator } from './getLocator.ts'
-import { NodeManifest } from './nodeManifest.ts'
-import { PrivateChildManifests } from './private/index.ts'
-import { PublicChildManifests } from './public/index.ts'
-
-/**
- * Creates a node with the xyo-chain modules registered
- * @returns A node with the xyo-chain modules registered
- */
-export const loadNode = async (
-  context: BaseConfigContext,
-  wallet: WalletInstance,
-) => {
-  const locator = await getLocator(context)
-  const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests)
-  const [node, ...childNodes] = await wrapper.loadNodes()
-  if (childNodes?.length > 0) {
-    await Promise.all(childNodes.map(childNode => node.register(childNode)))
-    await Promise.all(childNodes.map(childNode => node.attach(childNode.address, true)))
-  }
-  return node
-}

package/src/node/manifest/node.json

@@ -1,17 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "44'/60'/1",
-        "name": "XYOChain",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [],
-        "public": []
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

package/src/node/manifest/nodeManifest.ts

@@ -1,8 +0,0 @@
-import type { PackageManifestPayload } from '@xyo-network/sdk-js'
-
-import node from './node.json' with { type: 'json' }
-
-/**
- * Root Node Manifest
- */
-export const NodeManifest = node as unknown as PackageManifestPayload

package/src/node/manifest/private/index.ts

@@ -1,4 +0,0 @@
-/**
- * Private Child Manifests
- */
-export const PrivateChildManifests = []

package/src/node/manifest/public/Chain.json

@@ -1,49 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "1",
-        "name": "Chain",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [
-          {
-            "config": {
-              "accountPath": "1/1'/1'",
-              "name": "Validated",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "payloadSdkConfig": {
-                "collection": "chain_validated"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          }
-        ],
-        "public": [
-          {
-            "config": {
-              "accountPath": "1/1/1",
-              "name": "Finalized",
-              "allowedQueries": [
-                "network.xyo.query.archivist.get",
-                "network.xyo.query.archivist.next"
-              ],
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 50000
-              },
-              "originArchivist": "Validated",
-              "schema": "network.xyo.archivist.view.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

package/src/node/manifest/public/Pending.json

@@ -1,54 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "2",
-        "name": "Pending",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [],
-        "public": [
-          {
-            "config": {
-              "accountPath": "2/1/1",
-              "name": "Transactions",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "labels": {
-                "network.xyo.storage.capabilities.delete": "enabled",
-                "network.xyo.storage.class": "mongodb"
-              },
-              "payloadSdkConfig": {
-                "collection": "pending_transaction_bundles"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "2/1/2",
-              "name": "Blocks",
-              "getCache": {
-                "enabled": true,
-                "maxEntries": 5000
-              },
-              "labels": {
-                "network.xyo.storage.capabilities.delete": "enabled",
-                "network.xyo.storage.class": "mongodb"
-              },
-              "payloadSdkConfig": {
-                "collection": "pending_block_bundles"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

package/src/node/manifest/public/index.ts

@@ -1,20 +0,0 @@
-import type { ModuleManifest, PackageManifestPayload } from '@xyo-network/sdk-js'
-
-import Chain from './Chain.json' with { type: 'json' }
-import Pending from './Pending.json' with { type: 'json' }
-
-/**
- * Chain Node Manifest
- */
-const ChainNodeManifest = Chain as unknown as PackageManifestPayload
-/**
- * Pending Node Manifest
- */
-const PendingNodeManifest = Pending as unknown as PackageManifestPayload
-/**
- * Public Child Manifests
- */
-export const PublicChildManifests: ModuleManifest[] = [
-  ...ChainNodeManifest.nodes,
-  ...PendingNodeManifest.nodes,
-]

package/src/node/sharedMiddleware.ts

@@ -1,24 +0,0 @@
-import {
-  customPoweredByHeader,
-  disableCaseSensitiveRouting,
-  disableExpressDefaultPoweredByHeader,
-  getJsonBodyParser,
-  getJsonBodyParserOptions,
-  responseProfiler,
-  standardResponses,
-} from '@xylabs/express'
-import compression from 'compression'
-import cors from 'cors'
-import type { Express } from 'express'
-
-export function sharedMiddleware(app: Express): void {
-  app.set('etag', false)
-  app.use(cors())
-  app.use(compression())
-  app.use(responseProfiler)
-  app.use(getJsonBodyParser(getJsonBodyParserOptions({ limit: '1mb' })))
-  app.use(standardResponses)
-  disableExpressDefaultPoweredByHeader(app)
-  app.use(customPoweredByHeader)
-  disableCaseSensitiveRouting(app)
-}