@xyo-network/chain-orchestration 1.20.14 → 1.20.16

package/src/shared/ChainInitializableParams.ts

@@ -1,4 +0,0 @@
-import type { CreatableProviderContext } from '@xyo-network/xl1-sdk'
-
-/** @deprecated */
-export type ChainInitializableParams = CreatableProviderContext

package/src/shared/actor/ValidatorActor.ts

@@ -1,75 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { creatable } from '@xylabs/sdk-js'
-import { processPendingBlocks } from '@xyo-network/chain-sdk'
-import type {
-  ActorParamsV3, BlockBoundWitness, BlockValidationViewer, BlockViewer,
-  FinalizationRunner,
-  MempoolViewer,
-} from '@xyo-network/xl1-sdk'
-import {
-  ActorV3, BlockValidationViewerMoniker, BlockViewerMoniker, FinalizationRunnerMoniker,
-  MempoolViewerMoniker,
-} from '@xyo-network/xl1-sdk'
-
-import { ValidatorConfig } from '../config/index.ts'
-
-export type ValidatorActorParams = ActorParamsV3<
-  {
-    config: ValidatorConfig
-  }>
-
-@creatable()
-export class ValidatorActor extends ActorV3<ValidatorActorParams> {
-  protected _blockValidationViewer!: BlockValidationViewer
-  protected _blockViewer!: BlockViewer
-  protected _finalizationRunner!: FinalizationRunner
-  protected _lastValidatedBlock: BlockBoundWitness | undefined
-  protected _lastValidatedBlockHash: Hash | undefined
-  protected _mempoolViewer!: MempoolViewer
-
-  protected get allowedProducers() {
-    return this.params.config.allowedProducers ?? []
-  }
-
-  protected get blockValidationViewer() {
-    return this._blockValidationViewer
-  }
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get finalizationRunner() {
-    return this._finalizationRunner
-  }
-
-  protected get mempoolViewer() {
-    return this._mempoolViewer
-  }
-
-  override async createHandler() {
-    await super.startHandler()
-    this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker)
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
-    this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker)
-    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker)
-  }
-
-  override async startHandler(): Promise<void> {
-    await super.startHandler()
-    this.registerTimer('ValidatorActor', async () => {
-      await this.spanAsync('processPendingBlocks', async () => {
-        console.log('ValidatorActor: Processing pending blocks...')
-        await processPendingBlocks({
-          blockValidationViewer: this.blockValidationViewer,
-          context: this.context,
-          logger: this.logger,
-          mempoolViewer: this.mempoolViewer,
-          blockViewer: this.blockViewer,
-          finalizationRunner: this.finalizationRunner,
-          allowedProducers: this.allowedProducers,
-        })
-      }, { ...this.context, timeBudgetLimit: 1500 })
-    }, 2000, 500)
-  }
-}

package/src/shared/actor/index.ts

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

package/src/shared/buildTelemetryConfig.ts

@@ -1,10 +0,0 @@
-import type { Config } from '@xyo-network/xl1-sdk'
-
-export function buildTelemetryConfig(config: Config, serviceName: string, serviceVersion: string, defaultMetricsScrapePort = 9464) {
-  const { otlpEndpoint } = config.telemetry?.otel ?? {}
-  const { path: endpoint = '/metrics', port = defaultMetricsScrapePort } = config.telemetry?.metrics?.scrape ?? {}
-  const telemetryConfig = {
-    attributes: { serviceName, serviceVersion }, otlpEndpoint, metricsConfig: { endpoint, port },
-  }
-  return telemetryConfig
-}

package/src/shared/config/actors/Api.ts

@@ -1,29 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { BaseConfigContextZod, HostActorConfigZod } from '@xyo-network/xl1-sdk'
-import { globalRegistry, z } from 'zod'
-
-export const ApiConfigZod = HostActorConfigZod.extend(z.object({
-  initRewardsCache: z.union([z.number(), z.string(), z.boolean()]).transform(
-    v => v !== '0' && v !== 'false' && v !== false && v != 0,
-  ).default(true).register(globalRegistry, {
-    description: 'Whether to initialize the rewards cache on startup',
-    title: 'api.initRewardsCache',
-    type: 'boolean',
-  }),
-}).shape)
-
-export type ApiConfig = z.infer<typeof ApiConfigZod>
-
-export const isApiConfig = zodIsFactory(ApiConfigZod)
-export const asApiConfig = zodAsFactory(ApiConfigZod, 'asApiConfig')
-export const toApiConfig = zodToFactory(ApiConfigZod, 'toApiConfig')
-
-export const ApiConfigContext = BaseConfigContextZod.extend({ config: ApiConfigZod })
-
-export type ApiConfigContext = z.infer<typeof ApiConfigContext>
-
-export const isApiConfigContext = zodIsFactory(ApiConfigContext)
-export const asApiConfigContext = zodAsFactory(ApiConfigContext, 'asApiConfigContext')
-export const toApiConfigContext = zodToFactory(ApiConfigContext, 'toApiConfigContext')

package/src/shared/config/actors/Bridge.ts

@@ -1,131 +0,0 @@
-import {
-  AddressZod, HexZod, toAddress, toHex, zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-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(1000n) * AttoXL1ConvertFactor.xl1)
-const DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300 // 3%
-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(1_000_000n) * AttoXL1ConvertFactor.xl1)
-const DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * 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(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry, {
-    default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
-    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/shared/config/actors/Mempool.ts

@@ -1,39 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-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/shared/config/actors/Producer.ts

@@ -1,56 +0,0 @@
-import {
-  AddressZod, asAddress,
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-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/shared/config/actors/RewardRedemption.ts

@@ -1,21 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-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/shared/config/actors/Validator.ts

@@ -1,22 +0,0 @@
-import {
-  AddressZod,
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { BaseConfigContextZod, HostActorConfigZod } from '@xyo-network/xl1-sdk'
-import { z } from 'zod'
-
-export const ValidatorConfigZod = HostActorConfigZod.extend({ allowedProducers: z.array(AddressZod).optional() })
-
-export type ValidatorConfig = z.infer<typeof ValidatorConfigZod>
-
-export const isValidatorConfig = zodIsFactory(ValidatorConfigZod)
-export const asValidatorConfig = zodAsFactory(ValidatorConfigZod, 'asValidatorConfig')
-export const toValidatorConfig = zodToFactory(ValidatorConfigZod, 'toValidatorConfig')
-
-export const ValidatorConfigContext = BaseConfigContextZod.extend({ config: ValidatorConfigZod })
-
-export type ValidatorConfigContext = z.infer<typeof ValidatorConfigContext>
-
-export const isValidatorConfigContext = zodIsFactory(ValidatorConfigContext)
-export const asValidatorConfigContext = zodAsFactory(ValidatorConfigContext, 'asValidatorConfigContext')
-export const toValidatorConfigContext = zodToFactory(ValidatorConfigContext, 'toValidatorConfigContext')

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

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

package/src/shared/config/index.ts

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

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

@@ -1,63 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import type {
-  CreatableProviderFactory, ProviderFactoryLocatorInstance, RemoteConfig, RpcTransport, XyoSignerRpcSchemas,
-} from '@xyo-network/xl1-sdk'
-import {
-  JsonRpcXyoRunner, JsonRpcXyoSigner,
-  ProviderFactoryLocator, RestDataLakeViewer,
-  SimpleXyoConnectionRunner,
-  SimpleXyoGatewayRunner,
-} from '@xyo-network/xl1-sdk'
-
-import type { BasicRemoteViewerLocatorOptions } from './basicRemoteViewerLocator.ts'
-import { baseBasicRemoteViewerLocator } from './basicRemoteViewerLocator.ts'
-
-export interface BasicRemoteRunnerLocatorOptions extends BasicRemoteViewerLocatorOptions {
-  additionalRunnerProviders?: CreatableProviderFactory[]
-  signerFactory?: CreatableProviderFactory
-  skipGatewayRunner?: boolean
-}
-
-export async function baseBasicRemoteRunnerLocator(
-  name: string,
-  remoteConfig: RemoteConfig,
-  signerTransport: RpcTransport<XyoSignerRpcSchemas>,
-  dataLakeEndpoint?: string,
-  options?: BasicRemoteRunnerLocatorOptions,
-): Promise<ProviderFactoryLocatorInstance> {
-  const remoteViewerLocator = await baseBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, options)
-  const locator = new ProviderFactoryLocator(remoteViewerLocator.context, {})
-
-  const providers: CreatableProviderFactory[] = [
-    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
-    JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
-  ]
-
-  if (!options?.skipGatewayRunner) {
-    providers.push(
-      SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
-    )
-  }
-
-  locator.registerMany([
-    ...providers,
-    ...options?.additionalRunnerProviders ?? [],
-  ])
-
-  if (options?.signerFactory) {
-    locator.register(options.signerFactory)
-  } else {
-    locator.register(
-      JsonRpcXyoSigner.factory<JsonRpcXyoSigner>(JsonRpcXyoSigner.dependencies, { transport: signerTransport }),
-    )
-  }
-
-  if (isDefined(dataLakeEndpoint)) {
-    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
-    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
-  }
-
-  locator.freeze()
-
-  return locator
-}

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

@@ -1,44 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import type { CreatableProviderFactory, RemoteConfig } from '@xyo-network/xl1-sdk'
-import {
-  ActorConfigZod,
-  ProviderFactoryLocator, RestDataLakeViewer,
-  SimpleTransactionViewer,
-  SimpleXyoConnectionViewer, SimpleXyoGateway,
-} from '@xyo-network/xl1-sdk'
-
-import { commonLocatorFromConfig } from './commonLocatorFromConfig.ts'
-import { remoteLocatorFromConfig } from './remoteLocatorFromConfig.ts'
-
-export interface BasicRemoteViewerLocatorOptions {
-  additionalProviders?: CreatableProviderFactory[]
-}
-
-export async function baseBasicRemoteViewerLocator(
-  name: string,
-  remoteConfig: RemoteConfig,
-  dataLakeEndpoint?: string,
-  options?: BasicRemoteViewerLocatorOptions,
-) {
-  const config = ActorConfigZod.parse({ name, remote: 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, {}),
-    ...options?.additionalProviders ?? [],
-  ])
-
-  if (isDefined(dataLakeEndpoint)) {
-    const dataLakeViewerParams = { endpoint: dataLakeEndpoint }
-    locator.register(RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, dataLakeViewerParams))
-  }
-
-  locator.freeze()
-
-  return locator
-}

package/src/shared/config/locators/commonLocatorFromConfig.ts

@@ -1,40 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { BaseConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import {
-  ProviderFactoryLocator,
-  SimpleBlockRewardViewer,
-  SimpleNetworkStakeViewer,
-  SimpleStepRewardsByPositionViewer,
-  SimpleStepRewardsByStakerViewer,
-  SimpleStepRewardsByStepViewer,
-  SimpleStepRewardsTotalViewer,
-  SimpleStepRewardsViewer,
-  SimpleStepViewer,
-  SimpleTimeSyncViewer,
-  SimpleTransactionValidationViewer,
-  SimpleTransactionViewer,
-  SimpleWindowedBlockViewer,
-} from '@xyo-network/xl1-sdk'
-
-export function commonLocatorFromConfig(
-  context: BaseConfigContext,
-  validateDepsOnRegister = false,
-): Promisable<ProviderFactoryLocatorInstance> {
-  const locator: ProviderFactoryLocatorInstance = new ProviderFactoryLocator(context, {}, validateDepsOnRegister)
-
-  locator.registerMany([
-    SimpleNetworkStakeViewer.factory<SimpleNetworkStakeViewer>(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(SimpleTimeSyncViewer.dependencies, {}),
-    SimpleStepViewer.factory<SimpleStepViewer>(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory<SimpleStepRewardsViewer>(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory<SimpleStepRewardsByPositionViewer>(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory<SimpleStepRewardsByStakerViewer>(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory<SimpleStepRewardsByStepViewer>(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory<SimpleStepRewardsTotalViewer>(SimpleStepRewardsTotalViewer.dependencies, {}),
-    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 1000, syncInterval: 10_000 }),
-    SimpleBlockRewardViewer.factory<SimpleBlockRewardViewer>(SimpleBlockRewardViewer.dependencies, {}),
-    SimpleTransactionViewer.factory<SimpleTransactionViewer>(SimpleTransactionViewer.dependencies, {}),
-    SimpleTransactionValidationViewer.factory<SimpleTransactionValidationViewer>(SimpleTransactionValidationViewer.dependencies, {}),
-  ])
-  return locator
-}

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

@@ -1,4 +0,0 @@
-export * from './basicRemoteRunnerLocator.ts'
-export * from './basicRemoteViewerLocator.ts'
-export * from './commonLocatorFromConfig.ts'
-export * from './remoteLocatorFromConfig.ts'

package/src/shared/config/locators/remoteLocatorFromConfig.ts

@@ -1,56 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { validateHydratedBlock, validateHydratedBlockState } from '@xyo-network/chain-validation'
-import type {
-  BaseConfigContext, HydratedBlockStateValidationFunction, ProviderFactoryLocatorInstance,
-} from '@xyo-network/xl1-sdk'
-import {
-  BlockCumulativeBalanceValidatorFactory,
-  JsonRpcAccountBalanceViewer,
-  JsonRpcBlockViewer,
-  JsonRpcFinalizationViewer,
-  JsonRpcMempoolRunner,
-  JsonRpcMempoolViewer,
-  JsonRpcNetworkStakeViewer,
-  JsonRpcStakeViewer,
-  JsonRpcTransactionViewer,
-  JsonRpcXyoViewer,
-  ProviderFactoryLocator,
-  SimpleBlockValidationViewer,
-  SimpleStakeEventsViewer,
-} from '@xyo-network/xl1-sdk'
-
-const cumulativeBalanceValidator = BlockCumulativeBalanceValidatorFactory()
-
-const validateHydratedBlockStateWithCumulativeBalance: HydratedBlockStateValidationFunction = async (context, block) => {
-  const [stateErrors, cumulativeErrors] = await Promise.all([
-    validateHydratedBlockState(context, block),
-    cumulativeBalanceValidator(context, block),
-  ])
-  return [...stateErrors, ...cumulativeErrors]
-}
-
-export function remoteLocatorFromConfig(
-  context: BaseConfigContext,
-  validateDepsOnRegister = false,
-): Promisable<ProviderFactoryLocatorInstance> {
-  const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister)
-
-  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, {}),
-    JsonRpcTransactionViewer.factory<JsonRpcTransactionViewer>(JsonRpcTransactionViewer.dependencies, {}),
-    JsonRpcNetworkStakeViewer.factory<JsonRpcNetworkStakeViewer>(JsonRpcNetworkStakeViewer.dependencies, {}),
-    JsonRpcStakeViewer.factory<JsonRpcStakeViewer>(JsonRpcStakeViewer.dependencies, {}),
-    SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(SimpleStakeEventsViewer.dependencies, { positions: [] }),
-    JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, {}),
-    SimpleBlockValidationViewer.factory<SimpleBlockValidationViewer>(
-      SimpleBlockValidationViewer.dependencies,
-      { state: validateHydratedBlockStateWithCumulativeBalance, protocol: validateHydratedBlock },
-    ),
-  ])
-
-  return locator
-}

package/src/shared/config/mergeConfig.ts

@@ -1,11 +0,0 @@
-import { deepMerge } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-sdk'
-
-export function mergeConfig({ actors, ...baseConfig }: Config) {
-  return {
-    ...baseConfig,
-    actors: actors.map((actor) => {
-      return deepMerge(baseConfig, actor)
-    }),
-  }
-}

package/src/shared/createDeclarationIntentBlock.ts

@@ -1,19 +0,0 @@
-import { buildNextBlock } from '@xyo-network/chain-sdk'
-import type { AccountInstance, WithHashMeta } from '@xyo-network/sdk-js'
-import type { BlockBoundWitness, XL1BlockRange } from '@xyo-network/xl1-sdk'
-import { createDeclarationIntent } from '@xyo-network/xl1-sdk'
-
-export async function createProducerChainStakeIntentBlock(prevBlock: WithHashMeta<BlockBoundWitness>, producerAccount: AccountInstance, range: XL1BlockRange) {
-  const producerDeclarationPayload = createDeclarationIntent(
-    producerAccount.address,
-    'producer',
-    range[0],
-    range[1],
-  )
-  return await buildNextBlock(
-    prevBlock,
-    [],
-    [producerDeclarationPayload],
-    [producerAccount],
-  )
-}