@xyo-network/xl1-protocol-sdk 1.16.23 → 1.16.24

package/dist/neutral/config/Config.d.ts

@@ -17,9 +17,6 @@ export declare const ConfigZod: z.ZodObject<{
         mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
         port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     }, z.core.$strip>>;
-    app: z.ZodDefault<z.ZodObject<{
-        port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    }, z.core.$strip>>;
     bridge: z.ZodDefault<z.ZodObject<{
         host: z.ZodDefault<z.ZodString>;
         mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
@@ -47,7 +44,6 @@ export declare const ConfigZod: z.ZodObject<{
     }, z.core.$strip>>;
     producer: z.ZodDefault<z.ZodObject<{
         allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>>;
-        apiEndpoint: z.ZodOptional<z.ZodString>;
         disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
         healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
         heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -62,6 +58,9 @@ export declare const ConfigZod: z.ZodObject<{
         mnemonic: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
         port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     }, z.core.$strip>>;
+    services: z.ZodDefault<z.ZodObject<{
+        accountBalanceViewerEndpoint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     storage: z.ZodDefault<z.ZodObject<{
         mongo: z.ZodOptional<z.ZodObject<{
             connectionString: z.ZodOptional<z.ZodString>;
@@ -73,6 +72,12 @@ export declare const ConfigZod: z.ZodObject<{
         root: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     telemetry: z.ZodDefault<z.ZodObject<{
+        metrics: z.ZodOptional<z.ZodObject<{
+            scrape: z.ZodObject<{
+                path: z.ZodDefault<z.ZodString>;
+                port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
         otel: z.ZodOptional<z.ZodObject<{
             otlpEndpoint: z.ZodOptional<z.ZodURL>;
         }, z.core.$strip>>;

package/dist/neutral/config/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAexB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAexB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAAmF,CAAA;AAErH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAapB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,eAAO,MAAM,gBAAgB,QAAO,MAA6B,CAAA"}

package/dist/neutral/config/Producer.d.ts

@@ -1,7 +1,6 @@
 import * as z from 'zod';
 export declare const ProducerConfigZod: z.ZodObject<{
     allowlist: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>>;
-    apiEndpoint: z.ZodOptional<z.ZodString>;
     disableIntentRedeclaration: z.ZodOptional<z.ZodBoolean>;
     healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     heartbeatInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;

package/dist/neutral/config/Producer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../src/config/Producer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;;iBA0D5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"Producer.d.ts","sourceRoot":"","sources":["../../../src/config/Producer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;iBAoD5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/config/Services.d.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod';
+export declare const ServicesConfigZod: z.ZodObject<{
+    accountBalanceViewerEndpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ServicesConfig = z.infer<typeof ServicesConfigZod>;
+//# sourceMappingURL=Services.d.ts.map

package/dist/neutral/config/Services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Services.d.ts","sourceRoot":"","sources":["../../../src/config/Services.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,iBAAiB;;iBAM5B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/config/Telemetry.d.ts

@@ -1,8 +1,24 @@
 import * as z from 'zod';
+export declare const MetricsScrapeConfigZod: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const MetricsConfigZod: z.ZodObject<{
+    scrape: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const OpenTelemetryConfigZod: z.ZodObject<{
     otlpEndpoint: z.ZodOptional<z.ZodURL>;
 }, z.core.$strip>;
 export declare const TelemetryConfigZod: z.ZodObject<{
+    metrics: z.ZodOptional<z.ZodObject<{
+        scrape: z.ZodObject<{
+            path: z.ZodDefault<z.ZodString>;
+            port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
     otel: z.ZodOptional<z.ZodObject<{
         otlpEndpoint: z.ZodOptional<z.ZodURL>;
     }, z.core.$strip>>;

package/dist/neutral/config/Telemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Telemetry.d.ts","sourceRoot":"","sources":["../../../src/config/Telemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,sBAAsB;;iBAOjC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;iBAGe,CAAA;AAE9C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"Telemetry.d.ts","sourceRoot":"","sources":["../../../src/config/Telemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,sBAAsB;;;iBAaQ,CAAA;AAE3C,eAAO,MAAM,gBAAgB;;;;;iBAAyF,CAAA;AAEtH,eAAO,MAAM,sBAAsB;;iBAOjC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;iBAKe,CAAA;AAE9C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/neutral/index.mjs

@@ -1040,34 +1040,22 @@ var ApiConfigZod = z2.object({
   })
 });
 
-// src/config/App.ts
+// src/config/Bridge.ts
 import { globalRegistry as globalRegistry2 } from "zod";
 import * as z3 from "zod";
-var AppConfigZod = z3.object({
-  port: z3.coerce.number().default(3e3).register(globalRegistry2, {
-    default: 3e3,
-    description: "Port for the application",
-    title: "app.port",
-    type: "number"
-  })
-});
-
-// src/config/Bridge.ts
-import { globalRegistry as globalRegistry3 } from "zod";
-import * as z4 from "zod";
-var BridgeConfigZod = z4.object({
-  host: z4.string().default("localhost").register(globalRegistry3, {
+var BridgeConfigZod = z3.object({
+  host: z3.string().default("localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge",
     title: "api.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry3, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry2, {
     description: "Mnemonic for the Bridge wallet",
     title: "api.mnemonic",
     type: "string"
   }),
-  port: z4.coerce.number().default(8081).register(globalRegistry3, {
+  port: z3.coerce.number().default(8081).register(globalRegistry2, {
     default: 8081,
     description: "Port for the Bridge",
     title: "api.port",
@@ -1077,15 +1065,15 @@ var BridgeConfigZod = z4.object({
 
 // src/config/Chain.ts
 import { AddressZod } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry4 } from "zod";
-import * as z5 from "zod";
-var ChainConfigZod = z5.object({
-  id: z5.string().optional().register(globalRegistry4, {
+import { globalRegistry as globalRegistry3 } from "zod";
+import * as z4 from "zod";
+var ChainConfigZod = z4.object({
+  id: z4.string().optional().register(globalRegistry3, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
     type: "string"
   }),
-  genesisRewardAddress: AddressZod.optional().register(globalRegistry4, {
+  genesisRewardAddress: AddressZod.optional().register(globalRegistry3, {
     description: "Address to send the initial genesis rewards to, if a new chain is being created.",
     title: "chain.genesisRewardAddress",
     type: "Address"
@@ -1093,29 +1081,29 @@ var ChainConfigZod = z5.object({
 });
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5 } from "zod";
-import * as z6 from "zod";
-var EvmInfuraConfigZod = z6.object({
-  projectId: z6.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry4 } from "zod";
+import * as z5 from "zod";
+var EvmInfuraConfigZod = z5.object({
+  projectId: z5.string().optional().register(globalRegistry4, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z6.string().optional().register(globalRegistry5, {
+  projectSecret: z5.string().optional().register(globalRegistry4, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z6.object({
-  url: z6.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z5.object({
+  url: z5.url().optional().register(globalRegistry4, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z6.object({
-  chainId: z6.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z5.object({
+  chainId: z5.string().optional().register(globalRegistry4, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -1126,18 +1114,18 @@ var EvmConfigZod = z6.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6 } from "zod";
-import * as z7 from "zod";
+import { globalRegistry as globalRegistry5 } from "zod";
+import * as z6 from "zod";
 var LogLevels = Object.keys(LogLevel);
-var LogConfigZod = z7.object({
-  logLevel: z7.enum(LogLevels).default("info").register(globalRegistry6, {
+var LogConfigZod = z6.object({
+  logLevel: z6.enum(LogLevels).default("info").register(globalRegistry5, {
     choices: LogLevels,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z7.boolean().default(false).register(globalRegistry6, {
+  silent: z6.boolean().default(false).register(globalRegistry5, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1146,10 +1134,10 @@ var LogConfigZod = z7.object({
 });
 
 // src/config/Mempool.ts
-import { globalRegistry as globalRegistry7 } from "zod";
-import * as z8 from "zod";
-var MempoolConfigZod = z8.object({
-  enabled: z8.string().default("false").transform((val, ctx) => {
+import { globalRegistry as globalRegistry6 } from "zod";
+import * as z7 from "zod";
+var MempoolConfigZod = z7.object({
+  enabled: z7.string().default("false").transform((val, ctx) => {
     const normalized = val.toLowerCase().trim();
     if ([
       "true",
@@ -1168,25 +1156,25 @@ var MempoolConfigZod = z8.object({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z8.NEVER;
-  }).register(globalRegistry7, {
+    return z7.NEVER;
+  }).register(globalRegistry6, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  host: z8.string().default("localhost").register(globalRegistry7, {
+  host: z7.string().default("localhost").register(globalRegistry6, {
     default: "localhost",
     description: "Host for the Mempool",
     title: "mempool.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry6, {
     description: "Mnemonic for the Mempool wallet",
     title: "mempool.mnemonic",
     type: "string"
   }),
-  port: z8.coerce.number().default(8083).register(globalRegistry7, {
+  port: z7.coerce.number().default(8083).register(globalRegistry6, {
     default: 8083,
     description: "Port for the Mempool",
     title: "mempool.port",
@@ -1196,60 +1184,55 @@ var MempoolConfigZod = z8.object({
 
 // src/config/Producer.ts
 import { AddressZod as AddressZod2, asAddress as asAddress3 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry8 } from "zod";
-import * as z9 from "zod";
-var ProducerConfigZod = z9.object({
-  allowlist: z9.preprocess((val) => {
+import { globalRegistry as globalRegistry7 } from "zod";
+import * as z8 from "zod";
+var ProducerConfigZod = z8.object({
+  allowlist: z8.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress3(s.trim()));
     }
     return val;
-  }, z9.array(AddressZod2).optional().register(globalRegistry8, {
+  }, z8.array(AddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  apiEndpoint: z9.string().optional().register(globalRegistry8, {
-    description: "Endpoint of the API to use for chain data",
-    title: "producer.apiEndpoint",
-    type: "string"
-  }),
-  disableIntentRedeclaration: z9.boolean().optional().register(globalRegistry8, {
+  disableIntentRedeclaration: z8.boolean().optional().register(globalRegistry7, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
   // TODO: Port schema
-  healthCheckPort: z9.coerce.number().optional().register(globalRegistry8, {
+  healthCheckPort: z8.coerce.number().optional().register(globalRegistry7, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
   }),
-  heartbeatInterval: z9.coerce.number().default(36e5).register(globalRegistry8, {
+  heartbeatInterval: z8.coerce.number().default(36e5).register(globalRegistry7, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z9.coerce.number().default(1).register(globalRegistry8, {
+  minStake: z8.coerce.number().default(1).register(globalRegistry7, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry7, {
     description: "Mnemonic for the Producer wallet",
     title: "producer.mnemonic",
     type: "string"
   }),
   // TODO: Port schema
-  port: z9.coerce.number().default(8081).register(globalRegistry8, {
+  port: z8.coerce.number().default(8081).register(globalRegistry7, {
     default: 8081,
     description: "Port for the Producer",
     title: "producer.port",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z9.string().optional().register(globalRegistry8, {
+  rewardAddress: z8.string().optional().register(globalRegistry7, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -1257,27 +1240,27 @@ var ProducerConfigZod = z9.object({
 });
 
 // src/config/RewardRedemptionApi.ts
-import { globalRegistry as globalRegistry9 } from "zod";
-import * as z10 from "zod";
-var RewardRedemptionApiConfigZod = z10.object({
-  chainRpcApiUrl: z10.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+import { globalRegistry as globalRegistry8 } from "zod";
+import * as z9 from "zod";
+var RewardRedemptionApiConfigZod = z9.object({
+  chainRpcApiUrl: z9.string().default("http://localhost:8080/rpc").register(globalRegistry8, {
     default: "http://localhost:8080/rpc",
     description: "URL for the Chain RPC API",
     title: "rewardRedemptionApi.chainRpcApiUrl",
     type: "string"
   }),
-  host: z10.string().default("localhost").register(globalRegistry9, {
+  host: z9.string().default("localhost").register(globalRegistry8, {
     default: "localhost",
     description: "Host for the Redemption API",
     title: "rewardRedemptionApi.host",
     type: "string"
   }),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry9, {
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry8, {
     description: "Mnemonic for the Redemption API wallet",
     title: "rewardRedemptionApi.mnemonic",
     type: "string"
   }),
-  port: z10.coerce.number().default(8082).register(globalRegistry9, {
+  port: z9.coerce.number().default(8082).register(globalRegistry8, {
     default: 8082,
     description: "Port for the Redemption API",
     title: "rewardRedemptionApi.port",
@@ -1285,6 +1268,17 @@ var RewardRedemptionApiConfigZod = z10.object({
   })
 });
 
+// src/config/Services.ts
+import { globalRegistry as globalRegistry9 } from "zod";
+import * as z10 from "zod";
+var ServicesConfigZod = z10.object({
+  accountBalanceViewerEndpoint: z10.string().optional().register(globalRegistry9, {
+    description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
+    title: "services.accountBalanceViewerEndpoint",
+    type: "string"
+  })
+});
+
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined8, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry10 } from "zod";
@@ -1337,6 +1331,23 @@ var StorageConfigZod = z12.object({
 // src/config/Telemetry.ts
 import { globalRegistry as globalRegistry12 } from "zod";
 import * as z13 from "zod";
+var MetricsScrapeConfigZod = z13.object({
+  path: z13.string().default("/metrics").register(globalRegistry12, {
+    default: "/metrics",
+    description: "Path for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.path",
+    type: "string"
+  }),
+  port: z13.coerce.number().default(9464).register(globalRegistry12, {
+    default: 9464,
+    description: "Port for the metrics scrape endpoint",
+    title: "telemetry.metrics.scrape.port",
+    type: "number"
+  })
+}).describe("Metrics scrape configuration");
+var MetricsConfigZod = z13.object({
+  scrape: MetricsScrapeConfigZod
+}).describe("Metrics configuration options");
 var OpenTelemetryConfigZod = z13.object({
   // OpenTelemetry options
   otlpEndpoint: z13.url().optional().register(globalRegistry12, {
@@ -1346,6 +1357,8 @@ var OpenTelemetryConfigZod = z13.object({
   })
 });
 var TelemetryConfigZod = z13.object({
+  // Metrics configuration
+  metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
@@ -1384,13 +1397,13 @@ var Xl1CommonConfigSchema = z15.object({
 var ConfigZod = z15.object({
   ...Xl1CommonConfigSchema.shape,
   api: ApiConfigZod.default(ApiConfigZod.parse({})).describe("Configuration for the API node"),
-  app: AppConfigZod.default(AppConfigZod.parse({})).describe("Configuration for the application"),
   bridge: BridgeConfigZod.default(BridgeConfigZod.parse({})).describe("Configuration for the Bridge node"),
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
   mempool: MempoolConfigZod.default(MempoolConfigZod.parse({})).describe("Configuration for the mempool"),
   producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe("Configuration for the producer"),
   rewardRedemptionApi: RewardRedemptionApiConfigZod.default(RewardRedemptionApiConfigZod.parse({})).describe("Configuration for the rewards redemption API"),
+  services: ServicesConfigZod.default(ServicesConfigZod.parse({})).describe("Configuration for the global services"),
   storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
   telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
   validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")