@xyo-network/chain-orchestration 1.16.22 → 1.16.24

package/src/{initChainStakeViewer.ts → init/initChainStakeViewer.ts}

@@ -1,5 +1,6 @@
 import {
-  assertEx, type Logger, toEthAddress,
+  asAddress,
+  assertEx, type Logger, toAddress, toEthAddress,
 } from '@xylabs/sdk-js'
 import { EthereumChainStakeEvents, EthereumChainStakeViewer } from '@xyo-network/chain-sdk'
 import { StakedXyoChainV2__factory } from '@xyo-network/typechain'
@@ -8,7 +9,7 @@ import {
   type Config, SimpleChainStakeViewer, type StakeViewer,
 } from '@xyo-network/xl1-protocol-sdk'
 
-import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
+import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
 
 export async function initEvmChainStakeViewer(config: Config, logger?: Logger): Promise<StakeViewer> {
   const provider = await initEvmProvider({ config, logger })
@@ -24,7 +25,9 @@ export async function initEvmChainStakeViewer(config: Config, logger?: Logger):
 }
 
 export async function initSimpleStakeViewer(config: Config, logger?: Logger): Promise<StakeViewer> {
-  const stakeChainViewer = await SimpleChainStakeViewer.create({ logger, positions: [] })
+  const stakeChainViewer = await SimpleChainStakeViewer.create({
+    chainId: asAddress(toAddress(1n), true), logger, positions: [],
+  })
   assertEx(await stakeChainViewer.start(), () => 'Failed to start SimpleChainStake viewer')
   return stakeChainViewer
 }

package/src/init/initSeedPhrase.ts

@@ -0,0 +1,29 @@
+import { assertEx, isString } from '@xylabs/sdk-js'
+import type { BiosExternalInterface } from '@xyo-network/bios-model'
+import { HDWallet } from '@xyo-network/wallet'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+
+// TODO: Make nodejs version of bios support round tripping mnemonic between boots
+export async function initSeedPhrase({
+  config, logger, bios,
+}: ConfigContext<{ bios: BiosExternalInterface }>): Promise<string> {
+  const storedSeedPhrase = await bios.seedPhraseStore.get('os')
+  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`)
+  const { mnemonic } = config.api
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn('[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
+    await bios.seedPhraseStore.set('os', mnemonic)
+  } else {
+    let seedPhrase: string
+    if (isString(mnemonic)) {
+      seedPhrase = mnemonic
+    } else {
+      seedPhrase = HDWallet.generateMnemonic()
+      logger?.log('[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.')
+      logger?.log(`[API] Mnemonic: ${seedPhrase}`)
+    }
+    await bios.seedPhraseStore.set('os', seedPhrase)
+  }
+  return assertEx(await bios.seedPhraseStore.get('os'), () => 'Unable to acquire mnemonic from bios')
+}

package/src/init/initServerNode.ts

@@ -0,0 +1,45 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BalancesStepSummary, MapType, TransfersStepSummary,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+import { loadNode } from '../manifest/index.ts'
+
+async function chainArchivistFromNode(node: NodeInstance) {
+  const chainArchivist = assertEx(asArchivistInstance(
+    await node.resolve('Chain:Validated'),
+    { required: true },
+  ), () => 'FinalizedArchivist not found in node')
+  return chainArchivist
+}
+
+async function pendingArchivistFromNode(node: NodeInstance) {
+  const pendingArchivist = assertEx(asArchivistInstance(
+    await node.resolve('XYOChain:Pending:PendingTransactions'),
+    { required: true },
+  ), () => 'PendingArchivist not found in node')
+  return pendingArchivist
+}
+
+export async function initServerNode({
+  wallet, logger, config, node: providedNode, transferSummaryMap, balanceSummaryMap,
+}: ConfigContext<{
+  balanceSummaryMap: MapType<string, WithStorageMeta<BalancesStepSummary>>
+  node?: NodeInstance
+  transferSummaryMap: MapType<string, WithStorageMeta<TransfersStepSummary>>
+  wallet: WalletInstance
+}>) {
+  const node: NodeInstance = providedNode ?? await loadNode({
+    wallet, logger, config, transferSummaryMap, balanceSummaryMap,
+  })
+  const chainArchivist = await chainArchivistFromNode(node)
+  const pendingArchivist = await pendingArchivistFromNode(node)
+  return {
+    node, chainArchivist, pendingArchivist,
+  }
+}

package/src/init/initServerWallet.ts

@@ -0,0 +1,17 @@
+import { isDefined } from '@xylabs/sdk-js'
+import { boot } from '@xyo-network/bios'
+import { HDWallet } from '@xyo-network/wallet'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+import { initSeedPhrase } from './initSeedPhrase.ts'
+
+export async function initServerWallet({ config, logger }: ConfigContext) {
+  const { mnemonic } = config.api
+  const bios = await boot()
+  const seedPhrase = isDefined(mnemonic)
+    ? mnemonic
+    : await initSeedPhrase({
+        bios, config, logger,
+      })
+  return await HDWallet.fromPhrase(seedPhrase)
+}

package/src/init/initTransferSummaryMap.ts

@@ -0,0 +1,33 @@
+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/payload-model'
+import type { MapType, TransfersStepSummary } from '@xyo-network/xl1-protocol-sdk'
+import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-protocol-sdk'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+
+export async function initTransferSummaryMap({ config, logger }: ConfigContext): 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/manifest/getLocator.ts

@@ -0,0 +1,101 @@
+import { type BaseMongoSdkPrivateConfig } from '@xylabs/mongo'
+import {
+  asAddress, assertEx, isDefined,
+  ZERO_ADDRESS,
+} from '@xylabs/sdk-js'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import { MongoDBArchivistV2 } from '@xyo-network/archivist-mongodb'
+import { ViewArchivist } from '@xyo-network/archivist-view'
+import {
+  AddressBalanceDivinerV2, AddressTransferDiviner, ArchivistSyncDiviner, HeadValidationDiviner,
+} from '@xyo-network/chain-modules'
+import { initTelemetry } from '@xyo-network/chain-telemetry'
+import { AbstractModule, LoggerModuleStatusReporter } from '@xyo-network/module-abstract'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { MongoDBModuleParamsV2 } from '@xyo-network/module-model-mongodb'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import { MemorySentinel } from '@xyo-network/sentinel-memory'
+import { StepSizes } from '@xyo-network/xl1-protocol'
+import type {
+  BalancesStepSummary, MapType, TransfersStepSummary,
+} from '@xyo-network/xl1-protocol-sdk'
+import { hasMongoConfig } from '@xyo-network/xl1-protocol-sdk'
+import { Semaphore } from 'async-mutex'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+
+/**
+ * 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 ({
+  config, logger, balanceSummaryMap, transferSummaryMap,
+}: ConfigContext<{
+  balanceSummaryMap: MapType<string, WithStorageMeta<BalancesStepSummary>>
+  transferSummaryMap: MapType<string, WithStorageMeta<TransfersStepSummary>>
+}>) => {
+  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(AddressBalanceDivinerV2.factory<AddressBalanceDivinerV2>({
+    traceProvider, meterProvider, statusReporter, summaryMap: balanceSummaryMap, stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+  }))
+
+  locator.register(AddressTransferDiviner.factory<AddressTransferDiviner>({
+    traceProvider, meterProvider, statusReporter, summaryMap: transferSummaryMap, stepSemaphores: StepSizes.map(() => new Semaphore(20)),
+  }))
+
+  const chainId = isDefined(config.chain.id)
+    ? assertEx(asAddress(config.chain.id), () => 'chain.id must be an Address')
+    : ZERO_ADDRESS
+  locator.register(HeadValidationDiviner.factory<HeadValidationDiviner>({
+    traceProvider,
+    meterProvider,
+    statusReporter,
+    chainId,
+    allowedProducers: config.producer.allowlist,
+  }))
+  locator.register(MemoryArchivist.factory({
+    traceProvider, meterProvider, statusReporter,
+  }))
+  locator.register(MemorySentinel.factory({
+    traceProvider, meterProvider, statusReporter,
+  }))
+  locator.register(ViewArchivist.factory({
+    traceProvider, meterProvider, statusReporter,
+  }))
+  locator.register(ArchivistSyncDiviner.factory({
+    traceProvider, meterProvider, statusReporter,
+  }))
+  return locator
+}

package/src/manifest/index.ts

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

package/src/manifest/loadNode.ts

@@ -0,0 +1,37 @@
+import { ManifestWrapper } from '@xyo-network/manifest-wrapper'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BalancesStepSummary, MapType, TransfersStepSummary,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import type { ConfigContext } from '../ConfigContext.ts'
+import { getLocator } from './getLocator.ts'
+import { NodeManifest } from './nodeManifest.ts'
+import { PrivateChildManifests } from './private/index.ts'
+import { PublicChildManifestsWithMempool, PublicChildManifestsWithoutMempool } 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 ({
+  wallet, config, balanceSummaryMap, transferSummaryMap,
+}: ConfigContext<{
+  balanceSummaryMap: MapType<string, WithStorageMeta<BalancesStepSummary>>
+  transferSummaryMap: MapType<string, WithStorageMeta<TransfersStepSummary>>
+  wallet: WalletInstance
+}>) => {
+  const { enabled: mempoolEnabled } = config.mempool
+  const PublicChildManifests = mempoolEnabled ? PublicChildManifestsWithoutMempool : PublicChildManifestsWithMempool
+  const locator = await getLocator({
+    config, balanceSummaryMap, transferSummaryMap,
+  })
+  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/manifest/node.json

@@ -0,0 +1,17 @@
+{
+  "$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/manifest/nodeManifest.ts

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

package/src/manifest/private/index.ts

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

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

@@ -0,0 +1,175 @@
+{
+  "$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"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/2'",
+              "schema": "network.xyo.diviner.chain.head.validation.config",
+              "eventSubscriptions": [
+                {
+                  "sourceEvent": "inserted",
+                  "sourceModule": "Submissions",
+                  "targetModuleFunction": "divine"
+                }
+              ],
+              "inArchivist": "Submissions",
+              "outArchivist": "Validated",
+              "name": "HeadValidationDiviner"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/3'",
+              "automations": [
+                {
+                  "frequency": 1000,
+                  "frequencyUnits": "millis",
+                  "schema": "network.xyo.automation.interval",
+                  "type": "interval"
+                }
+              ],
+              "name": "ChainValidationSentinel",
+              "schema": "network.xyo.sentinel.config",
+              "synchronous": true,
+              "tasks": [
+                {
+                  "mod": "HeadValidationDiviner",
+                  "endPoint": "divine"
+                }
+              ]
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/4'",
+              "automations": [
+                {
+                  "frequency": 10000,
+                  "frequencyUnits": "millis",
+                  "schema": "network.xyo.automation.interval",
+                  "type": "interval"
+                }
+              ],
+              "name": "AddressBalancePollingSentinel",
+              "schema": "network.xyo.sentinel.config",
+              "synchronous": true,
+              "tasks": [
+                {
+                  "mod": "AddressBalanceDiviner",
+                  "endPoint": "divine"
+                }
+              ]
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1'/5'",
+              "automations": [
+                {
+                  "frequency": 10000,
+                  "frequencyUnits": "millis",
+                  "schema": "network.xyo.automation.interval",
+                  "type": "interval"
+                }
+              ],
+              "name": "AddressTransferPollingSentinel",
+              "schema": "network.xyo.sentinel.config",
+              "synchronous": true,
+              "tasks": [
+                {
+                  "mod": "AddressTransferDiviner",
+                  "endPoint": "divine"
+                }
+              ]
+            }
+          }
+        ],
+        "public": [
+          {
+            "config": {
+              "accountPath": "1/1/1",
+              "name": "Submissions",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_submissions"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/2",
+              "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"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/3'",
+              "name": "AddressBalanceDiviner",
+              "schema": "network.xyo.diviner.chain.address.balance.config",
+              "map": {
+                "lmdb": {
+                  "dbName": "summaries",
+                  "storeName": "address_balance",
+                  "location": ".store"
+                }
+              },
+              "archivist": "Validated"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/4'",
+              "name": "AddressTransferDiviner",
+              "schema": "network.xyo.diviner.chain.address.transfer.config",
+              "map": {
+                "lmdb": {
+                  "dbName": "summaries",
+                  "storeName": "address_transfer",
+                  "location": ".store"
+                }
+              },
+              "archivist": "Validated"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

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

@@ -0,0 +1,35 @@
+{
+  "$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": "PendingTransactions",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "labels": {
+                "network.xyo.storage.class": "mongodb"
+              },
+              "payloadSdkConfig": {
+                "collection": "pending_bundles"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}

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

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

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

@@ -0,0 +1,97 @@
+{
+  "$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",
+              "allowedQueries": [
+                "network.xyo.query.archivist.get",
+                "network.xyo.query.archivist.next"
+              ],
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_validated"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          }
+        ],
+        "public": [
+          {
+            "config": {
+              "accountPath": "1/1/1",
+              "name": "Submissions",
+              "getCache": {
+                "enabled": true,
+                "maxEntries": 5000
+              },
+              "payloadSdkConfig": {
+                "collection": "chain_submissions"
+              },
+              "schema": "network.xyo.archivist.config"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/2",
+              "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"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/3'",
+              "name": "AddressBalanceDiviner",
+              "schema": "network.xyo.diviner.chain.address.balance.config",
+              "map": {
+                "lmdb": {
+                  "dbName": "summaries",
+                  "storeName": "address_balance",
+                  "location": ".store"
+                }
+              },
+              "archivist": "Validated"
+            }
+          },
+          {
+            "config": {
+              "accountPath": "1/1/4'",
+              "name": "AddressTransferDiviner",
+              "schema": "network.xyo.diviner.chain.address.transfer.config",
+              "map": {
+                "lmdb": {
+                  "dbName": "summaries",
+                  "storeName": "address_transfer",
+                  "location": ".store"
+                }
+              },
+              "archivist": "Validated"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "schema": "network.xyo.manifest"
+}