@xyo-network/chain-orchestration 1.19.13 → 1.19.15

package/src/config/actors/Bridge.ts

@@ -0,0 +1,133 @@
+import {
+  AddressZod, HexZod, toAddress, toHex,
+} from '@xylabs/sdk-js'
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import type { ChainId } from '@xyo-network/xl1-sdk'
+import {
+  AttoXL1ConvertFactor, BaseConfigContextZod, HostActorConfigZod, XL1,
+} from '@xyo-network/xl1-sdk'
+import { globalRegistry, z } from 'zod'
+
+const DEFAULT_FIXED_FEE = toHex(XL1(1n) * AttoXL1ConvertFactor.xl1)
+const DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress('2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6')
+const DEFAULT_HARDHAT_CHAIN_ID: ChainId = toHex('7A69')
+const DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80')
+const DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress('5FbDB2315678afecb367f032d93F642f64180aa3')
+const DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100_000n) * AttoXL1ConvertFactor.xl1)
+const DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(10n) * AttoXL1ConvertFactor.xl1)
+
+export const BasisPointsZod = z.coerce.number().int().nonnegative().max(10_000)
+export type BasisPoints = z.infer<typeof BasisPointsZod>
+
+export const BridgeConfigZod = HostActorConfigZod.extend({
+  escrowAddress: AddressZod.optional().register(globalRegistry, {
+    description: 'Address to which bridge escrow will be sent',
+    title: 'bridge.escrowAddress',
+    type: 'string',
+  }),
+  feesAddress: AddressZod.optional().register(globalRegistry, {
+    description: 'Address to which bridge fees will be sent',
+    title: 'bridge.feesAddress',
+    type: 'string',
+  }),
+  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry, {
+    default: DEFAULT_FIXED_FEE,
+    description: 'Fixed fee (in AttoXL1) applied to bridge transfers',
+    title: 'bridge.feeFixed',
+    type: 'bigint',
+  }),
+  feeRateBasisPoints: BasisPointsZod.default(500).register(globalRegistry, {
+    default: 500,
+    description: 'Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers',
+    title: 'bridge.feeRateBasisPoints',
+    type: 'number',
+  }),
+  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry, {
+    default: DEFAULT_MAX_BRIDGE_AMOUNT,
+    description: 'Maximum amount allowed for a bridge transfer',
+    title: 'bridge.maxBridgeAmount',
+    type: 'string',
+  }),
+  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry, {
+    default: DEFAULT_MIN_BRIDGE_AMOUNT,
+    description: 'Minimum amount required for a bridge transfer',
+    title: 'bridge.minBridgeAmount',
+    type: 'string',
+  }),
+  redisHost: z.string().default('localhost').register(globalRegistry, {
+    default: 'localhost',
+    description: 'Host for the Bridge Redis instance',
+    title: 'bridge.redisHost',
+    type: 'string',
+  }),
+  redisPort: z.coerce.number().int().positive().default(6379).register(globalRegistry, {
+    default: 6379,
+    description: 'Port for the Bridge Redis instance',
+    title: 'bridge.redisPort',
+    type: 'number',
+  }),
+  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry, {
+    default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
+    description: 'Hex representation of remote token address used for bridging',
+    title: 'bridge.remoteBridgeContractAddress',
+    type: 'string',
+  }),
+  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry, {
+    default: DEFAULT_HARDHAT_CHAIN_ID,
+    description: 'Remote chain ID',
+    title: 'bridge.remoteChainId',
+    type: 'string',
+  }),
+  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry, {
+    default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
+    description: 'Hex representation of remote token address used for bridging',
+    title: 'bridge.remoteTokenAddress',
+    type: 'string',
+  }),
+  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry, {
+    description: 'Private key for the wallet to use for the remote chain wallet',
+    title: 'bridge.remoteChainWalletPrivateKey',
+    type: 'string',
+  }),
+  xl1ChainId: HexZod.optional().register(globalRegistry, {
+    description: 'XL1 chain id used for bridging',
+    title: 'bridge.xl1ChainId',
+    type: 'string',
+  }),
+  xl1TokenAddress: HexZod.optional().register(globalRegistry, {
+    description: 'XL1 token address used for bridging',
+    title: 'bridge.xl1TokenAddress',
+    type: 'string',
+  }),
+})
+
+export type BridgeConfig = z.infer<typeof BridgeConfigZod>
+
+export const BridgeSettingsZod = BridgeConfigZod.pick({
+  feeFixed: true,
+  feeRateBasisPoints: true,
+  feesAddress: true,
+  escrowAddress: true,
+  maxBridgeAmount: true,
+  minBridgeAmount: true,
+  remoteChainId: true,
+  remoteTokenAddress: true,
+  xl1TokenAddress: true,
+  xl1ChainId: true,
+}).required()
+
+export type BridgeSettings = z.infer<typeof BridgeSettingsZod>
+
+export const isBridgeConfig = zodIsFactory(BridgeConfigZod)
+export const asBridgeConfig = zodAsFactory(BridgeConfigZod, 'asBridgeConfig')
+export const toBridgeConfig = zodToFactory(BridgeConfigZod, 'toBridgeConfig')
+
+export const BridgeConfigContext = BaseConfigContextZod.extend({ config: BridgeConfigZod })
+
+export type BridgeConfigContext = z.infer<typeof BridgeConfigContext>
+
+export const isBridgeConfigContext = zodIsFactory(BridgeConfigContext)
+export const asBridgeConfigContext = zodAsFactory(BridgeConfigContext, 'asBridgeConfigContext')
+export const toBridgeConfigContext = zodToFactory(BridgeConfigContext, 'toBridgeConfigContext')

package/src/config/actors/Mempool.ts

@@ -0,0 +1,39 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import { BaseConfigContextZod, HostActorConfigZod } from '@xyo-network/xl1-sdk'
+import { globalRegistry, z } from 'zod'
+
+export const MempoolConfigZod = HostActorConfigZod.extend({
+  enabled: z.union([z.string(), z.boolean()]).default('false').transform((val, ctx) => {
+    if (typeof val === 'boolean') return val
+    const normalized = val.toLowerCase().trim()
+    if (['true', '1', 'yes', 'on'].includes(normalized)) return true
+    if (['false', '0', 'no', 'off'].includes(normalized)) return false
+    ctx.addIssue({
+      code: 'invalid_type',
+      expected: 'boolean',
+      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`,
+    })
+    return z.NEVER
+  }).register(globalRegistry, {
+    default: 'false',
+    description: 'Enable the Mempool',
+    title: 'mempool.enabled',
+    type: 'boolean',
+  }),
+})
+
+export type MempoolConfig = z.infer<typeof MempoolConfigZod>
+
+export const isMempoolConfig = zodIsFactory(MempoolConfigZod)
+export const asMempoolConfig = zodAsFactory(MempoolConfigZod, 'asMempoolConfig')
+export const toMempoolConfig = zodToFactory(MempoolConfigZod, 'toMempoolConfig')
+
+export const MempoolConfigContext = BaseConfigContextZod.extend({ config: MempoolConfigZod })
+
+export type MempoolConfigContext = z.infer<typeof MempoolConfigContext>
+
+export const isMempoolConfigContext = zodIsFactory(MempoolConfigContext)
+export const asMempoolConfigContext = zodAsFactory(MempoolConfigContext, 'asMempoolConfigContext')
+export const toMempoolConfigContext = zodToFactory(MempoolConfigContext, 'toMempoolConfigContext')

package/src/config/actors/Producer.ts

@@ -0,0 +1,56 @@
+import { AddressZod, asAddress } from '@xylabs/sdk-js'
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import { ActorConfigZod, BaseConfigContextZod } from '@xyo-network/xl1-sdk'
+import { globalRegistry, z } from 'zod'
+
+export const ProducerConfigZod = ActorConfigZod.extend(z.object({
+  allowlist: z.preprocess((val) => {
+    if (typeof val === 'string') {
+      return val.split(',').map(s => asAddress(s.trim()))
+    }
+    return val
+  }, z.array(AddressZod).optional().register(globalRegistry, {
+    description: 'List of allowed producer addresses, if undefined anyone can participate',
+    title: 'allowlist',
+    type: 'array',
+  })),
+
+  disableIntentRedeclaration: z.boolean().optional().register(globalRegistry, {
+    description: 'Should the producer skip redeclaring their intent to continue producing blocks',
+    title: 'producer.disableIntentRedeclaration',
+    type: 'boolean',
+  }),
+  heartbeatInterval: z.coerce.number().default(3_600_000).register(globalRegistry, {
+    description: 'The number of milliseconds between heartbeats if no blocks are produced',
+    title: 'producer.heartbeatInterval',
+    type: 'number',
+  }),
+  // TODO: BigInt schema
+  minStake: z.coerce.number().default(1).register(globalRegistry, {
+    description: 'Minimum stake required to be a Producer',
+    title: 'producer.minStake',
+    type: 'number',
+  }),
+  // TODO: Address schema
+  rewardAddress: z.string().optional().register(globalRegistry, {
+    description: 'Address to receive block rewards',
+    title: 'producer.rewardAddress',
+    type: 'string',
+  }),
+}).shape)
+
+export type ProducerConfig = z.infer<typeof ProducerConfigZod>
+
+export const isProducerConfig = zodIsFactory(ProducerConfigZod)
+export const asProducerConfig = zodAsFactory(ProducerConfigZod, 'asProducerConfig')
+export const toProducerConfig = zodToFactory(ProducerConfigZod, 'toProducerConfig')
+
+export const ProducerConfigContext = BaseConfigContextZod.extend({ config: ProducerConfigZod })
+
+export type ProducerConfigContext = z.infer<typeof ProducerConfigContext>
+
+export const isProducerConfigContext = zodIsFactory(ProducerConfigContext)
+export const asProducerConfigContext = zodAsFactory(ProducerConfigContext, 'asProducerConfigContext')
+export const toProducerConfigContext = zodToFactory(ProducerConfigContext, 'toProducerConfigContext')

package/src/config/actors/RewardRedemption.ts

@@ -0,0 +1,21 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/zod'
+import { BaseConfigContextZod, HostActorConfigZod } from '@xyo-network/xl1-sdk'
+import type { z } from 'zod'
+
+export const RewardRedemptionConfigZod = HostActorConfigZod.extend({})
+
+export type RewardRedemptionConfig = z.infer<typeof RewardRedemptionConfigZod>
+
+export const isRewardRedemptionConfig = zodIsFactory(RewardRedemptionConfigZod)
+export const asRewardRedemptionConfig = zodAsFactory(RewardRedemptionConfigZod, 'asRewardRedemptionConfig')
+export const toRewardRedemptionConfig = zodToFactory(RewardRedemptionConfigZod, 'toRewardRedemptionConfig')
+
+export const RewardRedemptionConfigContext = BaseConfigContextZod.extend({ config: RewardRedemptionConfigZod })
+
+export type RewardRedemptionConfigContext = z.infer<typeof RewardRedemptionConfigContext>
+
+export const isRewardRedemptionConfigContext = zodIsFactory(RewardRedemptionConfigContext)
+export const asRewardRedemptionConfigContext = zodAsFactory(RewardRedemptionConfigContext, 'asRewardRedemptionConfigContext')
+export const toRewardRedemptionConfigContext = zodToFactory(RewardRedemptionConfigContext, 'toRewardRedemptionConfigContext')

package/src/config/actors/index.ts

@@ -0,0 +1,6 @@
+export * from './Api.ts'
+export * from './Api.ts'
+export * from './Bridge.ts'
+export * from './Mempool.ts'
+export * from './Producer.ts'
+export * from './RewardRedemption.ts'

package/src/config/index.ts

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

package/src/config/locators/actors/apiLocatorFromConfig.ts

@@ -0,0 +1,25 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGateway,
+  SimpleXyoRunner,
+} from '@xyo-network/xl1-sdk'
+
+import type { ApiConfigContext } from '../../actors/index.ts'
+
+export function apiLocatorFromConfig(
+  context: ApiConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promisable<ProviderFactoryLocatorInstance> {
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+
+  locator.registerMany([
+    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
+    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
+    SimpleXyoGateway.factory<SimpleXyoGateway>(SimpleXyoGateway.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}

package/src/config/locators/actors/bridgeLocatorFromConfig.ts

@@ -0,0 +1,71 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import { isDefined, isString } from '@xylabs/sdk-js'
+import { HDWallet } from '@xyo-network/wallet'
+import type {
+  ProviderFactoryLocatorInstance, RpcSchemaMap, TransportFactory,
+} from '@xyo-network/xl1-sdk'
+import {
+  AccountBalanceViewerRpcSchemas,
+  ADDRESS_INDEX,
+  BlockViewerRpcSchemas,
+  FinalizationViewerRpcSchemas,
+  generateXyoBaseWalletFromPhrase,
+  HttpRpcTransport,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolViewer,
+  MempoolRunnerRpcSchemas,
+  MempoolViewerRpcSchemas,
+  ProviderFactoryLocator,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGatewayRunner,
+  SimpleXyoRunner,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-sdk'
+
+import type { BridgeConfigContext } from '../../actors/index.ts'
+
+export async function bridgeLocatorFromConfig(
+  context: BridgeConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promise<Promise<Promisable<ProviderFactoryLocatorInstance>>> {
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+
+  const { config } = context
+
+  const { mnemonic } = config
+  const walletPhrase = isDefined(mnemonic) ? mnemonic : HDWallet.generateMnemonic()
+  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)
+
+    locator.registerMany([
+      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas) }),
+      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas) }),
+      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) }),
+    ])
+  }
+
+  locator.registerMany([
+    SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account: signerAccount }),
+    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
+    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}

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

@@ -0,0 +1,6 @@
+export * from './apiLocatorFromConfig.ts'
+export * from './bridgeLocatorFromConfig.ts'
+export * from './mempoolLocatorFromConfig.ts'
+export * from './producerLocatorFromConfig.ts'
+export * from './rewardRedemptionLocatorFromConfig.ts'
+export * from './validatorLocatorFromConfig.ts'

package/src/config/locators/actors/mempoolLocatorFromConfig.ts

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

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

@@ -0,0 +1,66 @@
+import { asAddress, isString } from '@xylabs/sdk-js'
+import { SimpleBlockRunner } from '@xyo-network/chain-services'
+import type {
+  ProviderFactoryLocatorInstance, RpcSchemaMap, TransportFactory,
+} from '@xyo-network/xl1-sdk'
+import {
+  AccountBalanceViewerRpcSchemas,
+  BlockViewerRpcSchemas,
+  FinalizationViewerRpcSchemas,
+  HttpRpcTransport,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolViewer,
+  MempoolRunnerRpcSchemas,
+  MempoolViewerRpcSchemas,
+  ProviderFactoryLocator,
+  SimpleBlockRewardViewer,
+} from '@xyo-network/xl1-sdk'
+
+import { initActorAccount } from '../../../init/index.ts'
+import type { ProducerConfigContext } from '../../actors/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}`)
+  }
+
+  const remoteUrl = config.remote.rpc?.url
+
+  if (isString(remoteUrl)) {
+    const transportFactory: TransportFactory = (schemas: RpcSchemaMap) => new HttpRpcTransport(remoteUrl, schemas)
+
+    locator.registerMany([
+      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, { transport: await transportFactory(MempoolViewerRpcSchemas) }),
+      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, { transport: await transportFactory(MempoolRunnerRpcSchemas) }),
+      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) }),
+    ])
+  }
+
+  locator.registerMany([
+    SimpleBlockRewardViewer.factory<SimpleBlockRewardViewer>(SimpleBlockRewardViewer.dependencies, {}),
+    SimpleBlockRunner.factory<SimpleBlockRunner>(
+      SimpleBlockRunner.dependencies,
+      { account, rewardAddress },
+    )])
+  locator.freeze()
+  return locator
+}

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

@@ -0,0 +1,21 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator,
+  SimpleXyoGatewayRunner,
+} from '@xyo-network/xl1-sdk'
+
+import type { RewardRedemptionConfigContext } from '../../actors/index.ts'
+
+export function rewardRedemptionLocatorFromConfig(
+  context: RewardRedemptionConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promisable<ProviderFactoryLocatorInstance> {
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+
+  locator.registerMany([
+    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}

package/src/config/locators/actors/validatorLocatorFromConfig.ts

@@ -0,0 +1,15 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
+
+export function validatorLocatorFromConfig(
+  context: ActorConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promisable<ProviderFactoryLocatorInstance> {
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+
+  locator.registerMany([
+  ])
+  locator.freeze()
+  return locator
+}

package/src/config/locators/contextFromConfigWithoutLocator.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '@xylabs/sdk-js'
+import type { Config, CreatableProviderContext } from '@xyo-network/xl1-sdk'
+
+import { initStatusReporter } from '../../init/index.ts'
+import { telemetryContextFromConfig } from './telemetryContextFromConfig.ts'
+
+export async function contextFromConfigWithoutLocator(
+  config: Config,
+  logger: Logger,
+  serviceName: string,
+  serviceVersion: string,
+): Promise<Omit<CreatableProviderContext, 'locator'>> {
+  const singletons = {}
+  const caches = {}
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion)
+  const statusReporter = initStatusReporter({ logger })
+  return {
+    ...telemetryConfig,
+    config,
+    singletons,
+    caches,
+    logger,
+    statusReporter,
+  }
+}

package/src/config/locators/index.ts

@@ -0,0 +1,7 @@
+export * from './actors/index.ts'
+export * from './contextFromConfigWithoutLocator.ts'
+export * from './localLocatorFromConfig.ts'
+export * from './locatorsFromConfig.ts'
+export * from './remoteLocatorFromConfig.ts'
+export * from './rootLocatorFromConfig.ts'
+export * from './telemetryContextFromConfig.ts'

package/src/config/locators/localLocatorFromConfig.ts

@@ -0,0 +1,56 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator,
+  SimpleAccountBalanceViewer,
+  SimpleBlockViewer,
+  SimpleFinalizationRunner,
+  SimpleFinalizationViewer,
+  SimpleMempoolRunner,
+  SimpleMempoolViewer,
+  SimpleWindowedBlockViewer,
+  SimpleXyoConnectionViewer,
+  SimpleXyoViewer,
+} from '@xyo-network/xl1-sdk'
+
+import {
+  initActorWallet, initBalanceSummaryMap, initFinalizationArchivistIfNeeded,
+  initServerNode, initTransferSummaryMap,
+} from '../../init/index.ts'
+
+export async function localLocatorFromConfig(
+  context: ActorConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promise<ProviderFactoryLocatorInstance> {
+  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(context), () => 'Balance Summary Map not initialized')
+  const transfersSummaryMap = assertEx(await initTransferSummaryMap(context), () => 'Transfer Summary Map not initialized')
+
+  // TODO: this should not be an api wallet, but a server wallet
+  const wallet = await initActorWallet(context)
+
+  const {
+    writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
+  } = await initServerNode(
+    context,
+    wallet,
+  )
+
+  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet)
+
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+  locator.registerMany([
+    SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
+    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
+    SimpleXyoConnectionViewer.factory<SimpleXyoConnectionViewer>(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleFinalizationRunner.factory<SimpleFinalizationRunner>(SimpleFinalizationRunner.dependencies, { finalizedArchivist: writableChainArchivist }),
+
+  ])
+  locator.freeze()
+  return locator
+}

package/src/config/locators/locatorsFromConfig.ts

@@ -0,0 +1,67 @@
+import { deepMerge } from '@xylabs/sdk-js'
+import {
+  ActorConfigZod,
+  type CachingContext,
+  type Config, type ProviderFactoryLocatorInstance,
+} from '@xyo-network/xl1-sdk'
+
+import {
+  ApiConfigZod, BridgeConfigZod,
+  MempoolConfigZod, ProducerConfigZod, RewardRedemptionConfigZod,
+} from '../actors/index.ts'
+import {
+  apiLocatorFromConfig, bridgeLocatorFromConfig, mempoolLocatorFromConfig,
+  producerLocatorFromConfig, rewardRedemptionLocatorFromConfig, validatorLocatorFromConfig,
+} from './actors/index.ts'
+import { rootLocatorFromConfig } from './rootLocatorFromConfig.ts'
+
+export async function locatorsFromConfig(
+  context: CachingContext,
+  { actors, ...config }: Config,
+): Promise<Record<string, ProviderFactoryLocatorInstance>> {
+  const result: Record<string, ProviderFactoryLocatorInstance> = { _root: await rootLocatorFromConfig({ ...context, config: { ...config, name: '_root' } }) }
+  for (const actorConfig of actors) {
+    switch (actorConfig.name) {
+      case 'producer': {
+        result[actorConfig.name] = await producerLocatorFromConfig(
+          { ...context, config: ProducerConfigZod.parse(deepMerge(config, actorConfig)) },
+          result._root,
+        )
+        break
+      }
+      case 'api': {
+        result[actorConfig.name] = await apiLocatorFromConfig({
+          ...context,
+          config: ApiConfigZod.parse(deepMerge(config, actorConfig)),
+        }, result._root)
+
+        break
+      }
+      case 'mempool': {
+        result[actorConfig.name] = await mempoolLocatorFromConfig({ ...context, config: MempoolConfigZod.parse(deepMerge(config, actorConfig)) }, result._root)
+        break
+      }
+      case 'validator': {
+        result[actorConfig.name] = await validatorLocatorFromConfig({ ...context, config: ActorConfigZod.parse(deepMerge(config, actorConfig)) }, result._root)
+        break
+      }
+      case 'bridge': {
+        result[actorConfig.name] = await bridgeLocatorFromConfig({ ...context, config: BridgeConfigZod.parse(deepMerge(config, actorConfig)) }, result._root)
+
+        break
+      }
+      case 'rewardRedemption': {
+        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig(
+          {
+            ...context,
+            config: RewardRedemptionConfigZod.parse(deepMerge(config, actorConfig)),
+          },
+          result._root,
+        )
+        break
+      }
+    // No default
+    }
+  }
+  return result
+}