@xyo-network/xl1-cli-lib 1.19.14 → 1.19.15

package/src/runCLI.ts

@@ -1,30 +1,30 @@
-import type { Logger } from '@xylabs/sdk-js'
+import { deepMerge, isDefined } from '@xylabs/sdk-js'
+import { getApiActor, runApi } from '@xyo-network/chain-api'
+import { getMempoolActor, runMempool } from '@xyo-network/chain-mempool'
 import {
-  deepMerge, isDefined, toAddress,
-} from '@xylabs/sdk-js'
-import { runApi } from '@xyo-network/chain-api'
-import { runMempool } from '@xyo-network/chain-mempool'
-import { Orchestrator } from '@xyo-network/chain-orchestration'
+  ApiConfigZod, BridgeConfigZod, contextFromConfigWithoutLocator, locatorsFromConfig, MempoolConfigZod, Orchestrator,
+  ProducerConfigZod,
+  RewardRedemptionConfigZod,
+  tryParseConfig,
+} from '@xyo-network/chain-orchestration'
 import { runProducer } from '@xyo-network/chain-producer'
-import type { ActorName, Config } from '@xyo-network/xl1-sdk'
-import { ConfigZod, isZodError } from '@xyo-network/xl1-sdk'
+import type { ActorConfig, Config } from '@xyo-network/xl1-sdk'
+import {
+  ActorConfigZod, ConfigZod, isZodError,
+  resolveConfig,
+} from '@xyo-network/xl1-sdk'
 import type { Argv } from 'yargs'
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
 
-import { runBridge, runRewardRedemptionApi } from './commands/index.ts'
+import {
+  getValidatorActor, runBridge, runRewardRedemptionApi,
+} from './commands/index.ts'
 import { XL1LogoColorizedAscii } from './images.ts'
 import { initLogger } from './initLogger.ts'
-import { contextFromConfigWithoutLocator, locatorsFromConfig } from './locatorFromConfig.ts'
 import { optionsFromGlobalZodRegistry } from './optionsFromGlobalZodRegistry.ts'
-import { tryParseConfig } from './tryParseConfig.ts'
 import { waitForHostPort } from './waitForHostPort.ts'
 
-interface RunCliContext {
-  logger: Logger
-  orchestrator: Orchestrator
-}
-
 /** Version string injected by Rollup at build time. */
 declare const __VERSION__: string
 
@@ -37,42 +37,18 @@ let configuration: Config
 
 const version = isDefined(__VERSION__) ? __VERSION__ : 'unknown'
 
-function resolveConfig(config: Config): Config {
-  const logger = console
-  const defaultChainId = toAddress('1')
-  const resolved = structuredClone(config)
-  if (!resolved.chain.id) {
-    logger.warn(`No chain ID specified in configuration; defaulting to ${defaultChainId}`)
-    resolved.chain.id = defaultChainId
-  }
-  return resolved
-}
-
-const getContextFromConfig = async (configuration: Config): Promise<RunCliContext> => {
-  const logger = initLogger(configuration)
-  const orchestrator = await Orchestrator.create({ logger })
-  // Handle cancellation (Ctrl+C)
-  process.on('SIGINT', () => {
-    void (async () => {
-      try {
-        logger.log('\nSIGINT received. Attempting graceful shutdown...')
-        await orchestrator?.stop()
-        logger.log('Orchestrator stopped, exiting now.')
-        process.exit(0)
-      } catch (err) {
-        logger.error('Error stopping orchestrator:', err)
-        process.exit(1)
-      }
-    })()
-  })
-  return { logger, orchestrator }
-}
-
 const getLocatorsFromConfig = async (actors: string[], configuration: Config) => {
+  const actorConfigs: ActorConfig[] = []
+  for (const actorName of actors) {
+    const rawConfig = configuration.actors.find(actor => actor.name === actorName) ?? { name: actorName }
+    const actorConfig = ActorConfigZod.loose().parse(rawConfig)
+    actorConfigs.push(actorConfig)
+  }
+  const config = ConfigZod.parse(deepMerge(configuration, { actors: actorConfigs }))
   const logger = initLogger(configuration)
   const orchestrator = await Orchestrator.create({ logger })
-  const context = await contextFromConfigWithoutLocator(configuration, logger, 'xl1-cli', version)
-  const locators = await locatorsFromConfig(actors, configuration, context)
+  const context = await contextFromConfigWithoutLocator(config, logger, 'xl1-cli', version)
+  const locators = await locatorsFromConfig(context, config)
   // Handle cancellation (Ctrl+C)
   process.on('SIGINT', () => {
     void (async () => {
@@ -109,12 +85,12 @@ $0 <command> [options]`)
     })
     .env('XL1')
     .scriptName('xl1')
-    .middleware((argv) => {
+    .middleware(async (argv) => {
       try {
         // Parse the various config sources
-        const parsedConfigFile = tryParseConfig() // Config file
-        const parsedConfigArgs = argv // Command-line arguments & ENV VARs
-        const parseResult = ConfigZod.safeParse(parsedConfigFile)
+        const parsedConfigFile = await tryParseConfig() // Config file
+        const parsedConfigArgs = ConfigZod.safeParse(argv).data ?? {} // Command-line arguments & ENV VARs
+        const parseResult = ConfigZod.safeParse(deepMerge(parsedConfigFile, parsedConfigArgs))
         if (!parseResult.success) {
           throw parseResult.error
         }
@@ -125,7 +101,7 @@ $0 <command> [options]`)
         // and receive a flattened object. We might need to manually invoke
         // the parser without the defaults to achieve this.
         // const mergedConfig = deepMerge(parsedConfigArgs, parsedConfigFile)
-        const mergedConfig = deepMerge(parsedConfigArgs)
+        const mergedConfig = parseResult.data
         const validatedMergedConfigResult = ConfigZod.safeParse(mergedConfig)
         if (!validatedMergedConfigResult.success) {
           throw validatedMergedConfigResult.error
@@ -138,17 +114,6 @@ $0 <command> [options]`)
         }
         configuration = validatedConfigResult.data
 
-        const { actors, ...rootConfig } = configuration
-        const actorNames = Object.keys(actors) as ActorName[]
-
-        for (const actorName of actorNames) {
-          configuration.actors[actorName] = deepMerge(
-            rootConfig ?? {},
-            configuration.actors[actorName] ?? {},
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ) as any
-        }
-
         // Check if user wants to dump config and exit
         if (argv['dump-config']) {
           console.log(JSON.stringify(configuration, null, 2))
@@ -171,56 +136,75 @@ $0 <command> [options]`)
     .command('api', 'Run a XL1 API Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 API Node', () => {}, async () => {
-          const { locators, orchestrator } = await getLocatorsFromConfig(['api'], configuration)
-          await runApi(configuration, orchestrator, locators['api'])
+          const { locators, orchestrator } = await getLocatorsFromConfig(['api', 'mempool', 'validator'], configuration)
+          const actors = await Promise.all([getApiActor(
+            ApiConfigZod.parse(locators['api'].context.config),
+            locators['api'],
+          ), getMempoolActor(
+            MempoolConfigZod.parse(locators['mempool'].context.config),
+            locators['mempool'],
+          ), getValidatorActor(
+            ActorConfigZod.parse(locators['validator'].context.config),
+            locators['validator'],
+          )])
+
+          for (const actor of actors) {
+            await orchestrator.registerActor(actor)
+          }
+
+          await orchestrator.start()
         })
     })
     .command('bridge', 'Run a XL1 Bridge Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 Bridge Node', () => {}, async () => {
           const { locators, orchestrator } = await getLocatorsFromConfig(['bridge'], configuration)
-          await runBridge(configuration, orchestrator, locators['bridge'])
+          await runBridge(BridgeConfigZod.parse(locators['bridge'].context.config), orchestrator, locators['bridge'])
         })
     })
     .command('mempool', 'Run a XL1 Mempool Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 Mempool Node', () => {}, async () => {
           const { locators, orchestrator } = await getLocatorsFromConfig(['mempool'], configuration)
-          await runMempool(configuration, orchestrator, locators['mempool'])
+          await runMempool(MempoolConfigZod.parse(locators['mempool'].context.config), orchestrator, locators['mempool'])
         })
     })
     .command('producer', 'Run a XL1 Producer Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 Producer Node', () => {}, async () => {
           const { locators, orchestrator } = await getLocatorsFromConfig(['producer'], configuration)
-          await runProducer(configuration, orchestrator, locators['producer'])
+          await runProducer(ProducerConfigZod.parse(locators['producer'].context.config), orchestrator, locators['producer'])
         })
     })
     .command('reward-redemption-api', 'Run a XL1 Rewards Redemption API Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 Rewards Redemption API Node', () => {}, async () => {
           const { locators, orchestrator } = await getLocatorsFromConfig(['rewardRedemption'], configuration)
-          await runRewardRedemptionApi(configuration, orchestrator, locators['rewardRedemption'])
+          await runRewardRedemptionApi(RewardRedemptionConfigZod.parse(locators['rewardRedemption'].context.config), orchestrator, locators['rewardRedemption'])
         })
     })
     .command('$0', 'Run a full XL1 Node', () => {}, async () => {
       const actors = ['producer', 'api']
-      if (configuration.actors.mempool.enabled) {
+      const mempoolEnabled = configuration.actors.find(actor => actor.name === 'mempool')?.enabled
+      if (mempoolEnabled) {
         actors.push('mempool')
       }
       const { locators, orchestrator } = await getLocatorsFromConfig(['api', 'producer'], configuration)
-      if (configuration.actors.mempool.enabled) {
+      if (mempoolEnabled) {
+        const mempoolConfig = MempoolConfigZod.parse(locators['mempool'].context.config)
         // Start Mempool but do not block
-        await runMempool(configuration, orchestrator, locators['mempool'])
+        await runMempool(mempoolConfig, orchestrator, locators['mempool'])
         // Wait for Mempool to be ready
-        await waitForHostPort(configuration.actors.mempool.host, configuration.actors.mempool.port)
+        await waitForHostPort(mempoolConfig.host, mempoolConfig.port)
       }
       // Start API but do not block
-      await runApi(configuration, orchestrator, locators['api'])
+      const apiConfig = ApiConfigZod.parse(locators['api'].context.config)
+      await runApi(apiConfig, orchestrator, locators['api'])
       // Wait for API to be ready
-      await waitForHostPort(configuration.actors.api.host, configuration.actors.api.port)
+      await waitForHostPort(apiConfig.host, apiConfig.port)
       // Start Producer and block on it
-      await runProducer(configuration, orchestrator, locators['producer'])
+      const producerConfig = ProducerConfigZod.parse(locators['producer'].context.config)
+      await runProducer(producerConfig, orchestrator, locators['producer'])
     })
     .options({
       'dump-config': {

package/dist/node/locatorFromConfig.d.ts

@@ -1,14 +0,0 @@
-import type { Logger, Promisable } from '@xylabs/sdk-js';
-import type { Config, CreatableProviderContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk';
-export declare function telemetryContextFromConfig(config: Config, serviceName: string, serviceVersion: string): Promise<import("@xyo-network/chain-telemetry").TelemetryProviders>;
-export declare function contextFromConfigWithoutLocator(config: Config, logger: Logger, serviceName: string, serviceVersion: string): Promise<Omit<CreatableProviderContext, 'locator'>>;
-export declare function rootLocatorFromConfig(config: Config, context: Omit<CreatableProviderContext, 'locator'>): Promise<ProviderFactoryLocatorInstance>;
-export declare function localLocatorFromConfig(config: Config, context: CreatableProviderContext): Promise<ProviderFactoryLocatorInstance>;
-export declare function remoteLocatorFromConfig(config: Config, context: CreatableProviderContext): Promise<ProviderFactoryLocatorInstance>;
-export declare function producerLocatorFromConfig(config: Config, context: CreatableProviderContext): Promise<ProviderFactoryLocatorInstance>;
-export declare function apiLocatorFromConfig(config: Config, context: CreatableProviderContext): Promisable<ProviderFactoryLocatorInstance>;
-export declare function mempoolLocatorFromConfig(config: Config, context: CreatableProviderContext): Promisable<ProviderFactoryLocatorInstance>;
-export declare function bridgeLocatorFromConfig(config: Config, context: CreatableProviderContext): Promise<Promise<Promisable<ProviderFactoryLocatorInstance>>>;
-export declare function rewardRedemptionLocatorFromConfig(config: Config, context: CreatableProviderContext): Promisable<ProviderFactoryLocatorInstance>;
-export declare function locatorsFromConfig(actors: string[], config: Config, context: Omit<CreatableProviderContext, 'locator'>): Promise<Record<string, ProviderFactoryLocatorInstance>>;
-//# sourceMappingURL=locatorFromConfig.d.ts.map

package/dist/node/locatorFromConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"locatorFromConfig.d.ts","sourceRoot":"","sources":["../../src/locatorFromConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAYxD,OAAO,KAAK,EACV,MAAM,EAAE,wBAAwB,EAAE,8BAA8B,EACjE,MAAM,sBAAsB,CAAA;AA0C7B,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,sEAW3G;AAED,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC,CAAC,CAapD;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC,GACjD,OAAO,CAAC,8BAA8B,CAAC,CAuBzC;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,8BAA8B,CAAC,CAkCzC;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,8BAA8B,CAAC,CA4BzC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,8BAA8B,CAAC,CAsCzC;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,UAAU,CAAC,8BAA8B,CAAC,CAU5C;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,UAAU,CAAC,8BAA8B,CAAC,CAO5C;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,8BAA8B,CAAC,CAAC,CAAC,CAoC9D;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,GAChC,UAAU,CAAC,8BAA8B,CAAC,CAQ5C;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC,GACjD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC,CAQzD"}

package/dist/node/tryParseConfig.d.ts

@@ -1,431 +0,0 @@
-/**
- * Attempts to parse the configuration from a file using cosmiconfig.
- * @returns The parsed configuration object if found and valid, otherwise undefined.
- */
-export declare const tryParseConfig: () => {
-    chain: {
-        id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-        genesisRewardAddress?: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }) | undefined;
-    };
-    evm: {
-        chainId?: string | undefined;
-        infura?: {
-            projectId?: string | undefined;
-            projectSecret?: string | undefined;
-        } | undefined;
-        jsonRpc?: {
-            url?: string | undefined;
-        } | undefined;
-    };
-    log: {
-        logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-        silent: boolean;
-    };
-    remote: {
-        rpc?: {
-            url: string;
-        } | undefined;
-    };
-    storage: {
-        mongo?: {
-            connectionString?: string | undefined;
-            database?: string | undefined;
-            domain?: string | undefined;
-            password?: string | undefined;
-            username?: string | undefined;
-        } | undefined;
-        root?: string | undefined;
-    };
-    telemetry: {
-        metrics?: {
-            scrape: {
-                path: string;
-                port?: number | undefined;
-            };
-        } | undefined;
-        otel?: {
-            otlpEndpoint?: string | undefined;
-        } | undefined;
-    };
-    validation: {
-        allowedRewardRedeemers?: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        })[] | undefined;
-        allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        })[] | undefined;
-    };
-    actors: {
-        api: {
-            chain: {
-                id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | undefined;
-            };
-            evm: {
-                chainId?: string | undefined;
-                infura?: {
-                    projectId?: string | undefined;
-                    projectSecret?: string | undefined;
-                } | undefined;
-                jsonRpc?: {
-                    url?: string | undefined;
-                } | undefined;
-            };
-            log: {
-                logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-                silent: boolean;
-            };
-            remote: {
-                rpc?: {
-                    url: string;
-                } | undefined;
-            };
-            storage: {
-                mongo?: {
-                    connectionString?: string | undefined;
-                    database?: string | undefined;
-                    domain?: string | undefined;
-                    password?: string | undefined;
-                    username?: string | undefined;
-                } | undefined;
-                root?: string | undefined;
-            };
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                allowedRewardRedeemers?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-                allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-            };
-            host: string;
-            initRewardsCache: boolean;
-            port: number;
-            mnemonic?: string | undefined;
-        };
-        bridge: {
-            chain: {
-                id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | undefined;
-            };
-            evm: {
-                chainId?: string | undefined;
-                infura?: {
-                    projectId?: string | undefined;
-                    projectSecret?: string | undefined;
-                } | undefined;
-                jsonRpc?: {
-                    url?: string | undefined;
-                } | undefined;
-            };
-            log: {
-                logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-                silent: boolean;
-            };
-            remote: {
-                rpc?: {
-                    url: string;
-                } | undefined;
-            };
-            storage: {
-                mongo?: {
-                    connectionString?: string | undefined;
-                    database?: string | undefined;
-                    domain?: string | undefined;
-                    password?: string | undefined;
-                    username?: string | undefined;
-                } | undefined;
-                root?: string | undefined;
-            };
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                allowedRewardRedeemers?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-                allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-            };
-            feeFixed: import("@xylabs/sdk-js").BrandedHex;
-            feeRateBasisPoints: number;
-            host: string;
-            maxBridgeAmount: import("@xylabs/sdk-js").BrandedHex;
-            minBridgeAmount: import("@xylabs/sdk-js").BrandedHex;
-            port: number;
-            redisHost: string;
-            redisPort: number;
-            remoteBridgeContractAddress: Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            };
-            remoteChainId: import("@xylabs/sdk-js").BrandedHex;
-            remoteTokenAddress: import("@xylabs/sdk-js").BrandedHex;
-            remoteChainWalletPrivateKey: import("@xylabs/sdk-js").BrandedHex;
-            escrowAddress?: (Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }) | undefined;
-            feesAddress?: (Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }) | undefined;
-            mnemonic?: string | undefined;
-            xl1ChainId?: import("@xylabs/sdk-js").BrandedHex | undefined;
-            xl1TokenAddress?: import("@xylabs/sdk-js").BrandedHex | undefined;
-        };
-        mempool: {
-            chain: {
-                id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | undefined;
-            };
-            evm: {
-                chainId?: string | undefined;
-                infura?: {
-                    projectId?: string | undefined;
-                    projectSecret?: string | undefined;
-                } | undefined;
-                jsonRpc?: {
-                    url?: string | undefined;
-                } | undefined;
-            };
-            log: {
-                logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-                silent: boolean;
-            };
-            remote: {
-                rpc?: {
-                    url: string;
-                } | undefined;
-            };
-            storage: {
-                mongo?: {
-                    connectionString?: string | undefined;
-                    database?: string | undefined;
-                    domain?: string | undefined;
-                    password?: string | undefined;
-                    username?: string | undefined;
-                } | undefined;
-                root?: string | undefined;
-            };
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                allowedRewardRedeemers?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-                allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-            };
-            enabled: boolean;
-            host: string;
-            port: number;
-            mnemonic?: string | undefined;
-        };
-        producer: {
-            chain: {
-                id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | undefined;
-            };
-            evm: {
-                chainId?: string | undefined;
-                infura?: {
-                    projectId?: string | undefined;
-                    projectSecret?: string | undefined;
-                } | undefined;
-                jsonRpc?: {
-                    url?: string | undefined;
-                } | undefined;
-            };
-            log: {
-                logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-                silent: boolean;
-            };
-            remote: {
-                rpc?: {
-                    url: string;
-                } | undefined;
-            };
-            storage: {
-                mongo?: {
-                    connectionString?: string | undefined;
-                    database?: string | undefined;
-                    domain?: string | undefined;
-                    password?: string | undefined;
-                    username?: string | undefined;
-                } | undefined;
-                root?: string | undefined;
-            };
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                allowedRewardRedeemers?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-                allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-            };
-            heartbeatInterval: number;
-            minStake: number;
-            port: number;
-            allowlist?: (Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            })[] | undefined;
-            disableIntentRedeclaration?: boolean | undefined;
-            healthCheckPort?: number | undefined;
-            mnemonic?: string | undefined;
-            rewardAddress?: string | undefined;
-        };
-        rewardRedemption: {
-            chain: {
-                id?: import("@xylabs/sdk-js").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | undefined;
-            };
-            evm: {
-                chainId?: string | undefined;
-                infura?: {
-                    projectId?: string | undefined;
-                    projectSecret?: string | undefined;
-                } | undefined;
-                jsonRpc?: {
-                    url?: string | undefined;
-                } | undefined;
-            };
-            log: {
-                logLevel: "log" | "error" | "warn" | "info" | "debug" | "trace";
-                silent: boolean;
-            };
-            remote: {
-                rpc?: {
-                    url: string;
-                } | undefined;
-            };
-            storage: {
-                mongo?: {
-                    connectionString?: string | undefined;
-                    database?: string | undefined;
-                    domain?: string | undefined;
-                    password?: string | undefined;
-                    username?: string | undefined;
-                } | undefined;
-                root?: string | undefined;
-            };
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                allowedRewardRedeemers?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-                allowedRewardEscrowAccountSigners?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                })[] | undefined;
-            };
-            host: string;
-            port: number;
-            mnemonic?: string | undefined;
-        };
-    };
-};
-//# sourceMappingURL=tryParseConfig.d.ts.map

package/dist/node/tryParseConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tryParseConfig.d.ts","sourceRoot":"","sources":["../../src/tryParseConfig.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB1B,CAAA"}