@xyo-network/chain-orchestration 1.19.18 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/chain-orchestration",
-  "version": "1.19.18",
+  "version": "1.20.0",
   "description": "XYO Layer One SDK Orchestration",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -21,15 +21,24 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
-      "default": "./dist/neutral/index.mjs"
+      "browser": {
+        "types": "./dist/browser/neutral/index.d.ts",
+        "source": "./src/neutral/index.ts",
+        "default": "./dist/browser/index.mjs"
+      },
+      "node": {
+        "types": "./dist/node/node/index.d.ts",
+        "source": "./src/node/index.ts",
+        "default": "./dist/node/index.mjs"
+      },
+      "neutral": {
+        "types": "./dist/neutral/neutral/index.d.ts",
+        "source": "./src/neutral/index.ts",
+        "default": "./dist/neutral/index.mjs"
+      }
     },
     "./package.json": "./package.json"
   },
-  "module": "./dist/neutral/index.mjs",
-  "source": "./src/index.ts",
-  "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
     "src",
@@ -38,45 +47,46 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xyo-network/archivist-lmdb": "~5.3.10",
-    "@xyo-network/archivist-mongodb": "~5.3.10",
-    "@xyo-network/archivist-view": "~5.3.10",
+    "@xyo-network/archivist-lmdb": "~5.3.15",
+    "@xyo-network/archivist-mongodb": "~5.3.15",
+    "@xyo-network/archivist-view": "~5.3.15",
     "@xyo-network/bios": "~7.2.1",
-    "@xyo-network/bridge-model": "~5.3.10",
-    "@xyo-network/chain-ethereum": "~1.19.18",
-    "@xyo-network/chain-protocol": "~1.19.18",
-    "@xyo-network/chain-sdk": "~1.19.18",
-    "@xyo-network/chain-services": "~1.19.18",
-    "@xyo-network/chain-telemetry": "~1.19.18",
-    "@xyo-network/chain-utils": "~1.19.18",
-    "@xyo-network/chain-validation": "~1.19.18",
-    "@xyo-network/module-abstract": "~5.3.10",
-    "@xyo-network/sdk-js": "~5.3.10",
-    "@xyo-network/sentinel-memory": "~5.3.10",
+    "@xyo-network/bridge-model": "~5.3.15",
+    "@xyo-network/chain-ethereum": "~1.20.0",
+    "@xyo-network/chain-protocol": "~1.20.0",
+    "@xyo-network/chain-sdk": "~1.20.0",
+    "@xyo-network/chain-services": "~1.20.0",
+    "@xyo-network/chain-telemetry": "~1.20.0",
+    "@xyo-network/chain-utils": "~1.20.0",
+    "@xyo-network/chain-validation": "~1.20.0",
+    "@xyo-network/module-abstract": "~5.3.15",
+    "@xyo-network/sdk-js": "~5.3.15",
+    "@xyo-network/sentinel-memory": "~5.3.15",
     "async-mutex": "~0.5.0"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@types/node": "~25.3.0",
+    "@types/node": "~25.3.3",
     "@xylabs/mongo": "~5.0.80",
     "@xylabs/sdk-js": "~5.0.80",
     "@xylabs/ts-scripts-yarn3": "~7.3.2",
     "@xylabs/tsconfig": "~7.3.2",
     "@xylabs/zod": "~5.0.80",
-    "@xyo-network/account-model": "~5.3.10",
+    "@xyo-network/account-model": "~5.3.15",
     "@xyo-network/bios-model": "~7.2.1",
-    "@xyo-network/module-model-mongodb": "~5.3.10",
-    "@xyo-network/sdk-js": "~5.3.10",
+    "@xyo-network/module-model-mongodb": "~5.3.15",
+    "@xyo-network/sdk-js": "~5.3.15",
     "@xyo-network/storage-model": "~7.2.1",
-    "@xyo-network/wallet-model": "~5.3.10",
-    "@xyo-network/xl1-sdk": "~1.24.29",
-    "axios": "^1.13.5",
-    "cosmiconfig": "^9.0.0",
+    "@xyo-network/wallet-model": "~5.3.15",
+    "@xyo-network/xl1-sdk": "~1.25.14",
+    "axios": "^1.13.6",
+    "cosmiconfig": "^9.0.1",
     "eslint": "^9.39.3",
     "ethers": "^6.16.0",
     "lmdb": "^3.5.1",
     "mongodb": "^7.1.0",
     "typescript": "~5.9.3",
+    "vitest": "^4.0.18",
     "zod": "^4.3.6"
   },
   "peerDependencies": {

package/src/neutral/config/index.ts

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

package/src/neutral/config/locators/basicRemoteRunnerLocator.ts

@@ -0,0 +1,39 @@
+import { isDefined } from '@xylabs/sdk-js'
+import type {
+  ChainId,
+  RemoteConfig, RpcTransport, XyoSignerRpcSchemas,
+} from '@xyo-network/xl1-sdk'
+import {
+  JsonRpcXyoRunner, JsonRpcXyoSigner,
+  ProviderFactoryLocator, RestDataLakeViewer,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGatewayRunner,
+} from '@xyo-network/xl1-sdk'
+
+import { basicRemoteViewerLocator } from './basicRemoteViewerLocator.ts'
+
+export async function basicRemoteRunnerLocator(
+  name: string,
+  remoteConfig: RemoteConfig,
+  signerTransport: RpcTransport<XyoSignerRpcSchemas>,
+  chainId?: ChainId,
+  dataLakeEndpoint?: string,
+) {
+  const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint)
+  const locator = new ProviderFactoryLocator(remoteViewerLocator.context, {})
+  locator.registerMany([
+    JsonRpcXyoSigner.factory<JsonRpcXyoSigner>(JsonRpcXyoSigner.dependencies, { transport: signerTransport }),
+    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
+    JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
+  ])
+
+  if (isDefined(dataLakeEndpoint)) {
+    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
+    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
+  }
+
+  locator.freeze()
+
+  return locator
+}

package/src/neutral/config/locators/basicRemoteViewerLocator.ts

@@ -0,0 +1,59 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type {
+  BlockViewer,
+  ChainId,
+  RemoteConfig,
+} from '@xyo-network/xl1-sdk'
+import {
+  ActorConfigZod,
+  BaseConfigZod,
+  BlockViewerMoniker,
+  JsonRpcBlockViewer,
+  ProviderFactoryLocator, RestDataLakeViewer,
+  SimpleTransactionViewer,
+  SimpleXyoConnectionViewer, SimpleXyoGateway,
+} from '@xyo-network/xl1-sdk'
+
+import { commonLocatorFromConfig, remoteLocatorFromConfig } from '../../../shared/index.ts'
+
+async function getChainIdFromRemote(remoteConfig: RemoteConfig) {
+  const locator = new ProviderFactoryLocator({
+    config: BaseConfigZod.parse({ remote: remoteConfig }), singletons: {}, caches: {},
+  })
+  locator.registerMany([
+    JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
+  ])
+  locator.freeze()
+  const blockViewer = await locator.getInstance<BlockViewer>(BlockViewerMoniker)
+  return assertEx(await blockViewer.chainId(), () => 'Chain ID could not be determined from remote config')
+}
+
+export async function basicRemoteViewerLocator(
+  name: string,
+  remoteConfig: RemoteConfig,
+  chainId?: ChainId,
+  dataLakeEndpoint?: string,
+) {
+  const config = ActorConfigZod.parse({
+    name, remote: remoteConfig, chain: { id: chainId ?? await getChainIdFromRemote(remoteConfig) },
+  })
+  const rootLocator = await commonLocatorFromConfig({
+    config, singletons: {}, caches: {},
+  })
+  const remoteLocator = await remoteLocatorFromConfig(rootLocator.context)
+  const locator = new ProviderFactoryLocator(remoteLocator.context, {})
+  locator.registerMany([
+    SimpleXyoGateway.factory<SimpleXyoGateway>(SimpleXyoGateway.dependencies, {}),
+    SimpleXyoConnectionViewer.factory<SimpleXyoConnectionViewer>(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleTransactionViewer.factory<SimpleTransactionViewer>(SimpleTransactionViewer.dependencies, {}),
+  ])
+
+  if (isDefined(dataLakeEndpoint)) {
+    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
+    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
+  }
+
+  locator.freeze()
+
+  return locator
+}

package/src/neutral/config/locators/index.ts

@@ -0,0 +1,3 @@
+export * from './basicRemoteRunnerLocator.ts'
+export * from './basicRemoteViewerLocator.ts'
+export * from './rootLocatorFromConfig.ts'

package/src/neutral/config/locators/rootLocatorFromConfig.ts

@@ -0,0 +1,21 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+
+import {
+  commonLocatorFromConfig, initEvmProvidersIfAvailable, remoteLocatorFromConfig,
+} from '../../../shared/index.ts'
+
+export async function rootLocatorFromConfig(
+  context: ActorConfigContext,
+  validateDepsOnRegister = false,
+): Promise<ProviderFactoryLocatorInstance> {
+  const { config } = context
+  let locator = await commonLocatorFromConfig(context, validateDepsOnRegister)
+  const newLocator = await (config.remote.rpc
+    ? remoteLocatorFromConfig(context, validateDepsOnRegister)
+    : undefined)
+  locator = assertEx(newLocator, () => 'Root locator could not be created from config. No supported configuration found.')
+  locator = await initEvmProvidersIfAvailable(locator)
+  locator.freeze()
+  return locator
+}

package/src/neutral/index.ts

@@ -0,0 +1,2 @@
+export * from '../shared/index.ts'
+export * from './config/index.ts'

package/src/{archivists → node/archivists}/ChainFinalized/archivist.ts

@@ -1,15 +1,15 @@
 import { timeBudget } from '@xylabs/sdk-js'
 import { startupSpanAsync } from '@xyo-network/chain-utils'
 import type { ArchivistInstance } from '@xyo-network/sdk-js'
+import type { CreatableProviderContext } from '@xyo-network/xl1-sdk'
 import { Mutex } from 'async-mutex'
 
-import type { ChainInitializableParams } from '../../ChainInitializableParams.ts'
 import { initLocalChainFinalizedArchivist } from './local.ts'
 
 const mutex = new Mutex()
 let singleton: ArchivistInstance | undefined
 
-export async function initChainFinalizedArchivist(context: ChainInitializableParams) {
+export async function initChainFinalizedArchivist(context: CreatableProviderContext) {
   return await mutex.runExclusive(async () => {
     if (singleton) return singleton
     return await timeBudget('initChainFinalizedArchivist', context.logger, async () => {

package/src/node/config/index.ts

@@ -0,0 +1,2 @@
+export * from './locators/index.ts'
+export * from './tryParseConfig.ts'

package/src/{config → node/config}/locators/actors/apiLocatorFromConfig.ts

@@ -7,7 +7,7 @@ import {
   SimpleXyoRunner,
 } from '@xyo-network/xl1-sdk'
 
-import type { ApiConfigContext } from '../../actors/index.ts'
+import type { ApiConfigContext } from '../../../../neutral/index.ts'
 
 export function apiLocatorFromConfig(
   context: ApiConfigContext,

package/src/{config → node/config}/locators/actors/bridgeLocatorFromConfig.ts

@@ -1,16 +1,10 @@
 import type { Promisable } from '@xylabs/sdk-js'
-import { isDefined, isString } from '@xylabs/sdk-js'
+import { isDefined } from '@xylabs/sdk-js'
 import { HDWallet } from '@xyo-network/sdk-js'
-import type {
-  ProviderFactoryLocatorInstance, RpcSchemaMap, TransportFactory,
-} from '@xyo-network/xl1-sdk'
+import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
 import {
-  AccountBalanceViewerRpcSchemas,
   ADDRESS_INDEX,
-  BlockViewerRpcSchemas,
-  FinalizationViewerRpcSchemas,
   generateXyoBaseWalletFromPhrase,
-  HttpRpcTransport,
   JsonRpcAccountBalanceViewer,
   JsonRpcBlockViewer,
   JsonRpcFinalizationViewer,
@@ -18,18 +12,14 @@ import {
   JsonRpcMempoolViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
-  MempoolRunnerRpcSchemas,
-  MempoolViewerRpcSchemas,
   ProviderFactoryLocator,
   SimpleXyoConnectionRunner,
   SimpleXyoGatewayRunner,
   SimpleXyoRunner,
   SimpleXyoSigner,
-  XyoRunnerRpcSchemas,
-  XyoViewerRpcSchemas,
 } from '@xyo-network/xl1-sdk'
 
-import type { BridgeConfigContext } from '../../actors/index.ts'
+import type { BridgeConfigContext } from '../../../../neutral/index.ts'
 
 export async function bridgeLocatorFromConfig(
   context: BridgeConfigContext,
@@ -44,25 +34,21 @@ export async function bridgeLocatorFromConfig(
   const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase)
   const signerAccount = await wallet.derivePath(ADDRESS_INDEX.XYO)
 
-  const remoteUrl = config.remote.rpc?.url
-
-  if (isString(remoteUrl)) {
-    const transportFactory: TransportFactory = (schemas: RpcSchemaMap) => new HttpRpcTransport(remoteUrl, schemas)
-
+  if (config.remote.rpc) {
     locator.registerMany([
-      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas) }),
-      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas) }),
+      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, {}),
+      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, {}),
       JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
         JsonRpcAccountBalanceViewer.dependencies,
-        { transport: await transportFactory(AccountBalanceViewerRpcSchemas) },
+        {},
       ),
       JsonRpcFinalizationViewer.factory<JsonRpcFinalizationViewer>(
         JsonRpcFinalizationViewer.dependencies,
-        { transport: await transportFactory(FinalizationViewerRpcSchemas) },
+        {},
       ),
-      JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, { transport: await transportFactory(BlockViewerRpcSchemas) }),
-      JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, { transport: await transportFactory(XyoRunnerRpcSchemas) }),
-      JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, { transport: await transportFactory(XyoViewerRpcSchemas) }),
+      JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
+      JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
+      JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, {}),
     ])
   }
 

package/src/{config → node/config}/locators/actors/mempoolLocatorFromConfig.ts

@@ -1,11 +1,8 @@
 import type { Promisable } from '@xylabs/sdk-js'
 import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import {
-  ProviderFactoryLocator,
-  SimpleBlockValidationViewer,
-} from '@xyo-network/xl1-sdk'
+import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
 
-import type { MempoolConfigContext } from '../../actors/index.ts'
+import type { MempoolConfigContext } from '../../../../neutral/index.ts'
 
 export function mempoolLocatorFromConfig(
   context: MempoolConfigContext,
@@ -14,7 +11,6 @@ export function mempoolLocatorFromConfig(
   const locator = new ProviderFactoryLocator({ ...context, locator: parent })
 
   locator.registerMany([
-    SimpleBlockValidationViewer.factory<SimpleBlockValidationViewer>(SimpleBlockValidationViewer.dependencies, {}),
   ])
   locator.freeze()
   return locator

package/src/node/config/locators/actors/producerLocatorFromConfig.ts

@@ -0,0 +1,29 @@
+import { asAddress } from '@xylabs/sdk-js'
+import { SimpleBlockRunner } from '@xyo-network/chain-services'
+import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
+
+import type { ProducerConfigContext } from '../../../../neutral/index.ts'
+import { initActorAccount } from '../../../../neutral/index.ts'
+
+export async function producerLocatorFromConfig(
+  context: ProducerConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promise<ProviderFactoryLocatorInstance> {
+  const { logger, config } = context
+  const account = await initActorAccount(context)
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+  const rewardAddress = asAddress(config.rewardAddress ?? account.address, true)
+  logger?.info(`Using reward address ${rewardAddress}`)
+  if (rewardAddress === account.address) {
+    logger?.warn(`Using producer account address as reward address: ${account.address}`)
+  }
+
+  locator.registerMany([
+    SimpleBlockRunner.factory<SimpleBlockRunner>(
+      SimpleBlockRunner.dependencies,
+      { account, rewardAddress },
+    )])
+  locator.freeze()
+  return locator
+}

package/src/node/config/locators/actors/rewardRedemptionLocatorFromConfig.ts

@@ -0,0 +1,56 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  JsonRpcAccountBalanceViewer,
+  JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolViewer,
+  JsonRpcXyoRunner,
+  JsonRpcXyoViewer,
+  ProviderFactoryLocator,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGatewayRunner,
+  SimpleXyoRunner,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-sdk'
+
+import { initActorAccount, type RewardRedemptionConfigContext } from '../../../../neutral/index.ts'
+
+export async function rewardRedemptionLocatorFromConfig(
+  context: RewardRedemptionConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promise<Promisable<ProviderFactoryLocatorInstance>> {
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+
+  const { config } = context
+
+  const account = await initActorAccount(context)
+
+  if (config.remote.rpc) {
+    locator.registerMany([
+      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, {}),
+      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, {}),
+      JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
+        JsonRpcAccountBalanceViewer.dependencies,
+        {},
+      ),
+      JsonRpcFinalizationViewer.factory<JsonRpcFinalizationViewer>(
+        JsonRpcFinalizationViewer.dependencies,
+        {},
+      ),
+      JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
+      JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
+      JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, {}),
+    ])
+  }
+
+  locator.registerMany([
+    SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account }),
+    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
+    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}

package/src/node/config/locators/basicRemoteRunnerLocator.ts

@@ -0,0 +1,49 @@
+import { isDefined } from '@xylabs/sdk-js'
+import type { AccountInstance } from '@xyo-network/sdk-js'
+import { isAccountInstance } from '@xyo-network/sdk-js'
+import type {
+  ChainId,
+  RemoteConfig, RpcTransport, XyoSignerRpcSchemas,
+} from '@xyo-network/xl1-sdk'
+import {
+  JsonRpcXyoRunner, JsonRpcXyoSigner,
+  ProviderFactoryLocator, RestDataLakeViewer,
+  SimpleXyoConnectionRunner,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-sdk'
+
+import { basicRemoteViewerLocator } from './basicRemoteViewerLocator.ts'
+
+export async function basicRemoteRunnerLocator(
+  name: string,
+  remoteConfig: RemoteConfig,
+  signer: RpcTransport<XyoSignerRpcSchemas> | AccountInstance,
+  chainId?: ChainId,
+  dataLakeEndpoint?: string,
+) {
+  const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint)
+  const locator = new ProviderFactoryLocator(remoteViewerLocator.context, {})
+  locator.registerMany([
+    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
+    JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
+  ])
+
+  if (isAccountInstance(signer)) {
+    locator.register(
+      SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account: signer }),
+    )
+  } else {
+    locator.register(
+      JsonRpcXyoSigner.factory<JsonRpcXyoSigner>(JsonRpcXyoSigner.dependencies, { transport: signer }),
+    )
+  }
+
+  if (isDefined(dataLakeEndpoint)) {
+    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
+    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
+  }
+
+  locator.freeze()
+
+  return locator
+}

package/src/node/config/locators/basicRemoteViewerLocator.ts

@@ -0,0 +1,64 @@
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type {
+  BlockViewer,
+  ChainId,
+  RemoteConfig,
+} from '@xyo-network/xl1-sdk'
+import {
+  ActorConfigZod,
+  BaseConfigZod,
+  BlockViewerMoniker,
+  JsonRpcAccountBalanceViewer, JsonRpcBlockViewer,
+  ProviderFactoryLocator, RestDataLakeViewer,
+  SimpleTransactionViewer,
+  SimpleXyoConnectionViewer, SimpleXyoGateway,
+} from '@xyo-network/xl1-sdk'
+
+import { remoteLocatorFromConfig } from '../../../shared/index.ts'
+import { rootLocatorFromConfig } from './rootLocatorFromConfig.ts'
+
+async function getChainIdFromRemote(remoteConfig: RemoteConfig) {
+  const locator = new ProviderFactoryLocator({
+    config: BaseConfigZod.parse({ remote: remoteConfig }), singletons: {}, caches: {},
+  }, {}, true)
+  locator.registerMany([
+    JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
+  ])
+  locator.freeze()
+  const blockViewer = await locator.getInstance<BlockViewer>(BlockViewerMoniker)
+  return assertEx(await blockViewer.chainId(), () => 'Chain ID could not be determined from remote config')
+}
+
+export async function basicRemoteViewerLocator(
+  name: string,
+  remoteConfig: RemoteConfig,
+  chainId?: ChainId,
+  dataLakeEndpoint?: string,
+) {
+  const config = ActorConfigZod.parse({
+    name, remote: remoteConfig, chain: { id: chainId ?? await getChainIdFromRemote(remoteConfig) },
+  })
+  const rootLocator = await rootLocatorFromConfig({
+    config, singletons: {}, caches: {},
+  })
+  const remoteLocator = await remoteLocatorFromConfig(rootLocator.context)
+  const locator = new ProviderFactoryLocator(remoteLocator.context, {})
+  locator.registerMany([
+    SimpleTransactionViewer.factory<SimpleTransactionViewer>(SimpleTransactionViewer.dependencies, {}),
+    JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
+      JsonRpcAccountBalanceViewer.dependencies,
+      {},
+    ),
+    SimpleXyoConnectionViewer.factory<SimpleXyoConnectionViewer>(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleXyoGateway.factory<SimpleXyoGateway>(SimpleXyoGateway.dependencies, {}),
+  ])
+
+  if (isDefined(dataLakeEndpoint)) {
+    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
+    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
+  }
+
+  locator.freeze()
+
+  return locator
+}

package/src/node/config/locators/index.ts

@@ -0,0 +1,5 @@
+export * from './basicRemoteRunnerLocator.ts'
+export * from './basicRemoteViewerLocator.ts'
+export * from './localLocatorFromConfig.ts'
+export * from './locatorsFromConfig.ts'
+export * from './rootLocatorFromConfig.ts'

package/src/{config → node/config}/locators/localLocatorFromConfig.ts

@@ -1,7 +1,5 @@
 import { assertEx } from '@xylabs/sdk-js'
-import type {
-  ActorConfigContext, ChainId, ProviderFactoryLocatorInstance,
-} from '@xyo-network/xl1-sdk'
+import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
 import {
   ProviderFactoryLocator,
   SimpleAccountBalanceViewer,
@@ -16,15 +14,16 @@ import {
   SimpleXyoViewer,
 } from '@xyo-network/xl1-sdk'
 
+import { initActorWallet } from '../../../neutral/index.ts'
 import {
-  initActorWallet, initBalanceSummaryMap, initFinalizationArchivistIfNeeded,
+  initBalanceSummaryMap, initFinalizationArchivistIfNeeded,
   initServerNode, initTransferSummaryMap,
 } from '../../init/index.ts'
 
 export async function localLocatorFromConfig(
   context: ActorConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promise<[ProviderFactoryLocatorInstance, ChainId | null]> {
+  validateDepsOnRegister = false,
+) {
   const balancesSummaryMap = assertEx(await initBalanceSummaryMap(context), () => 'Balance Summary Map not initialized')
   const transfersSummaryMap = assertEx(await initTransferSummaryMap(context), () => 'Transfer Summary Map not initialized')
 
@@ -38,9 +37,9 @@ export async function localLocatorFromConfig(
     wallet,
   )
 
-  const [_head, chainId] = await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet)
+  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet)
 
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+  const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister)
   locator.registerMany([
     SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
     SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
@@ -50,10 +49,10 @@ export async function localLocatorFromConfig(
     SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
     SimpleXyoConnectionViewer.factory<SimpleXyoConnectionViewer>(SimpleXyoConnectionViewer.dependencies, {}),
     SimpleTransactionViewer.factory<SimpleTransactionViewer>(SimpleTransactionViewer.dependencies, {}),
-    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, {}),
     SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
     SimpleFinalizationRunner.factory<SimpleFinalizationRunner>(SimpleFinalizationRunner.dependencies, { finalizedArchivist: writableChainArchivist }),
 
   ])
-  return [locator, chainId]
+  return locator
 }

package/src/node/config/locators/localViewerFromConfig.ts

@@ -0,0 +1,14 @@
+import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
+import { XyoViewerMoniker } from '@xyo-network/xl1-sdk'
+
+import { commonLocatorFromConfig } from '../../../shared/index.ts'
+import { localLocatorFromConfig } from './localLocatorFromConfig.ts'
+
+export async function localViewerFromConfig(
+  context: ActorConfigContext,
+) {
+  const commonLocator = await commonLocatorFromConfig(context)
+  const locator = await localLocatorFromConfig({ ...commonLocator.context, config: { ...commonLocator.context.config, ...context.config } }, true)
+  locator.freeze()
+  return locator.getInstance(XyoViewerMoniker)
+}