@sentio/runtime 2.57.12 → 2.57.13-rc.2

package/lib/service-worker.d.ts

@@ -0,0 +1,11 @@
+import * as _sentio_protos from '@sentio/protos';
+import { DataBinding } from '@sentio/protos';
+import { MessagePort } from 'worker_threads';
+
+declare function export_default({ request, processId, workerPort }: {
+    request: DataBinding;
+    processId: number;
+    workerPort?: MessagePort;
+}): Promise<_sentio_protos.ProcessResult>;
+
+export { export_default as default };

package/lib/service-worker.js

@@ -0,0 +1,130 @@
+import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);
+import {
+  setupLogger
+} from "./chunk-BPGFX5S5.js";
+import {
+  AbstractStoreContext,
+  configureEndpoints,
+  errorString,
+  freezeGlobalConfig,
+  recordRuntimeInfo,
+  require_lib3 as require_lib,
+  require_lib4 as require_lib2
+} from "./chunk-NLEBXJPP.js";
+import {
+  PluginManager,
+  ProcessConfigResponse,
+  __toESM
+} from "./chunk-ZUTD563J.js";
+
+// src/service-worker.ts
+var import_nice_grpc = __toESM(require_lib(), 1);
+var import_nice_grpc_error_details = __toESM(require_lib2(), 1);
+import { BroadcastChannel, threadId } from "worker_threads";
+import { Piscina } from "piscina";
+var started = false;
+var unhandled;
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught Exception, please checking if await is properly used", err);
+  unhandled = err;
+}).on("unhandledRejection", (reason, p) => {
+  if (reason?.message.startsWith('invalid ENS name (disallowed character: "*"')) {
+    return;
+  }
+  console.error("Unhandled Rejection, please checking if await is properly", reason);
+  unhandled = reason;
+});
+async function getConfig(request, context) {
+  if (!started) {
+    throw new import_nice_grpc.ServerError(import_nice_grpc.Status.UNAVAILABLE, "Service Not started.");
+  }
+  const newConfig = ProcessConfigResponse.fromPartial({});
+  await PluginManager.INSTANCE.configure(newConfig);
+  return newConfig;
+}
+var loader = async (options) => {
+  if (options.target) {
+    const m = await import(options.target);
+    console.debug("Module loaded, path:", options.target, "module:", m);
+    return m;
+  }
+};
+var configureChannel = new BroadcastChannel("configure_channel");
+configureChannel.onmessage = (request) => {
+  getConfig(request);
+};
+async function start(request, options) {
+  if (started) {
+    return {};
+  }
+  freezeGlobalConfig();
+  try {
+    await loader(options);
+  } catch (e) {
+    throw new import_nice_grpc.ServerError(import_nice_grpc.Status.INVALID_ARGUMENT, "Failed to load processor: " + errorString(e));
+  }
+  await PluginManager.INSTANCE.start(request);
+  started = true;
+  return {};
+}
+async function service_worker_default({
+  request,
+  processId,
+  workerPort
+}) {
+  const { startRequest, configRequest, options } = Piscina.workerData;
+  if (!started) {
+    const logLevel = process.env["LOG_LEVEL"]?.toUpperCase();
+    setupLogger(options["log-format"] === "json", logLevel === "debug" ? true : options.debug, threadId);
+    configureEndpoints(options);
+    if (startRequest) {
+      await start(startRequest, options);
+      console.debug("worker started, template instance:", startRequest.templateInstances?.length);
+    }
+    if (configRequest) {
+      await getConfig(configRequest);
+      console.debug("worker configured");
+    }
+  }
+  if (unhandled) {
+    const err = unhandled;
+    unhandled = void 0;
+    throw new import_nice_grpc_error_details.RichServerError(
+      import_nice_grpc.Status.UNAVAILABLE,
+      "Unhandled exception/rejection in previous request: " + errorString(err),
+      [
+        import_nice_grpc_error_details.DebugInfo.fromPartial({
+          detail: err.message,
+          stackEntries: err.stack?.split("\n")
+        })
+      ]
+    );
+  }
+  const result = await PluginManager.INSTANCE.processBinding(
+    request,
+    void 0,
+    workerPort ? new WorkerStoreContext(workerPort, processId) : void 0
+  );
+  recordRuntimeInfo(result, request.handlerType);
+  return result;
+}
+var WorkerStoreContext = class extends AbstractStoreContext {
+  constructor(port, processId) {
+    super(processId);
+    this.port = port;
+    this.port.on("message", (resp) => {
+      this.result(resp);
+    });
+    this.port.on("close", () => {
+      this.close();
+    });
+  }
+  doSend(req) {
+    this.port.postMessage(req);
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+export {
+  service_worker_default as default
+};
+//# sourceMappingURL=service-worker.js.map

package/lib/service-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/service-worker.ts"],"sourcesContent":["import {\n  DataBinding,\n  DBResponse,\n  DeepPartial,\n  Empty,\n  ProcessConfigRequest,\n  ProcessConfigResponse,\n  ProcessStreamResponse,\n  StartRequest\n} from '@sentio/protos'\nimport { CallContext, ServerError, Status } from 'nice-grpc'\nimport { PluginManager } from './plugin.js'\nimport { errorString } from './utils.js'\nimport { freezeGlobalConfig } from './global-config.js'\nimport { DebugInfo, RichServerError } from 'nice-grpc-error-details'\nimport { recordRuntimeInfo } from './service.js'\nimport { BroadcastChannel, MessagePort, threadId } from 'worker_threads'\nimport { Piscina } from 'piscina'\nimport { configureEndpoints } from './endpoints.js'\nimport { setupLogger } from './logger.js'\nimport { AbstractStoreContext } from './db-context.js'\n\nlet started = false\n\nlet unhandled: Error | undefined\n\nprocess\n  .on('uncaughtException', (err) => {\n    console.error('Uncaught Exception, please checking if await is properly used', err)\n    unhandled = err\n  })\n  .on('unhandledRejection', (reason, p) => {\n    // @ts-ignore ignore invalid ens error\n    if (reason?.message.startsWith('invalid ENS name (disallowed character: \"*\"')) {\n      return\n    }\n    console.error('Unhandled Rejection, please checking if await is properly', reason)\n    unhandled = reason as Error\n    // shutdownServers(1)\n  })\n\nasync function getConfig(request: ProcessConfigRequest, context?: CallContext): Promise<ProcessConfigResponse> {\n  if (!started) {\n    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')\n  }\n\n  const newConfig = ProcessConfigResponse.fromPartial({})\n  await PluginManager.INSTANCE.configure(newConfig)\n  return newConfig\n}\n\nconst loader = async (options: any) => {\n  if (options.target) {\n    const m = await import(options.target)\n    console.debug('Module loaded, path:', options.target, 'module:', m)\n    return m\n  }\n}\n\nconst configureChannel = new BroadcastChannel('configure_channel')\nconfigureChannel.onmessage = (request: ProcessConfigRequest) => {\n  getConfig(request)\n}\n\nasync function start(request: StartRequest, options: any): Promise<Empty> {\n  if (started) {\n    return {}\n  }\n  freezeGlobalConfig()\n\n  try {\n    await loader(options)\n  } catch (e) {\n    throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))\n  }\n\n  await PluginManager.INSTANCE.start(request)\n  started = true\n  return {}\n}\n\nexport default async function ({\n  request,\n  processId,\n  workerPort\n}: {\n  request: DataBinding\n  processId: number\n  workerPort?: MessagePort\n}) {\n  const { startRequest, configRequest, options } = Piscina.workerData\n  if (!started) {\n    const logLevel = process.env['LOG_LEVEL']?.toUpperCase()\n    setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug, threadId)\n\n    configureEndpoints(options)\n\n    if (startRequest) {\n      await start(startRequest, options)\n      console.debug('worker started, template instance:', startRequest.templateInstances?.length)\n    }\n\n    if (configRequest) {\n      await getConfig(configRequest)\n      console.debug('worker configured')\n    }\n  }\n\n  if (unhandled) {\n    const err = unhandled\n    unhandled = undefined\n    throw new RichServerError(\n      Status.UNAVAILABLE,\n      'Unhandled exception/rejection in previous request: ' + errorString(err),\n      [\n        DebugInfo.fromPartial({\n          detail: err.message,\n          stackEntries: err.stack?.split('\\n')\n        })\n      ]\n    )\n  }\n\n  const result = await PluginManager.INSTANCE.processBinding(\n    request,\n    undefined,\n    workerPort ? new WorkerStoreContext(workerPort, processId) : undefined\n  )\n  recordRuntimeInfo(result, request.handlerType)\n  return result\n}\n\nclass WorkerStoreContext extends AbstractStoreContext {\n  constructor(\n    readonly port: MessagePort,\n    processId: number\n  ) {\n    super(processId)\n    this.port.on('message', (resp: DBResponse) => {\n      this.result(resp)\n    })\n    this.port.on('close', () => {\n      this.close()\n    })\n  }\n\n  doSend(req: DeepPartial<ProcessStreamResponse>): void {\n    this.port.postMessage(req)\n  }\n}\n;import(\"node:process\").then((p) => p.stdout.write(\"\"));"],"mappings":";;;;;;;;;;;;;;;;;;;;AAUA,uBAAiD;AAIjD,qCAA2C;AAE3C,SAAS,kBAA+B,gBAAgB;AACxD,SAAS,eAAe;AAKxB,IAAI,UAAU;AAEd,IAAI;AAEJ,QACG,GAAG,qBAAqB,CAAC,QAAQ;AAChC,UAAQ,MAAM,iEAAiE,GAAG;AAClF,cAAY;AACd,CAAC,EACA,GAAG,sBAAsB,CAAC,QAAQ,MAAM;AAEvC,MAAI,QAAQ,QAAQ,WAAW,6CAA6C,GAAG;AAC7E;AAAA,EACF;AACA,UAAQ,MAAM,6DAA6D,MAAM;AACjF,cAAY;AAEd,CAAC;AAEH,eAAe,UAAU,SAA+B,SAAuD;AAC7G,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,6BAAY,wBAAO,aAAa,sBAAsB;AAAA,EAClE;AAEA,QAAM,YAAY,sBAAsB,YAAY,CAAC,CAAC;AACtD,QAAM,cAAc,SAAS,UAAU,SAAS;AAChD,SAAO;AACT;AAEA,IAAM,SAAS,OAAO,YAAiB;AACrC,MAAI,QAAQ,QAAQ;AAClB,UAAM,IAAI,MAAM,OAAO,QAAQ;AAC/B,YAAQ,MAAM,wBAAwB,QAAQ,QAAQ,WAAW,CAAC;AAClE,WAAO;AAAA,EACT;AACF;AAEA,IAAM,mBAAmB,IAAI,iBAAiB,mBAAmB;AACjE,iBAAiB,YAAY,CAAC,YAAkC;AAC9D,YAAU,OAAO;AACnB;AAEA,eAAe,MAAM,SAAuB,SAA8B;AACxE,MAAI,SAAS;AACX,WAAO,CAAC;AAAA,EACV;AACA,qBAAmB;AAEnB,MAAI;AACF,UAAM,OAAO,OAAO;AAAA,EACtB,SAAS,GAAG;AACV,UAAM,IAAI,6BAAY,wBAAO,kBAAkB,+BAA+B,YAAY,CAAC,CAAC;AAAA,EAC9F;AAEA,QAAM,cAAc,SAAS,MAAM,OAAO;AAC1C,YAAU;AACV,SAAO,CAAC;AACV;AAEA,eAAO,uBAAwB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AACF,GAIG;AACD,QAAM,EAAE,cAAc,eAAe,QAAQ,IAAI,QAAQ;AACzD,MAAI,CAAC,SAAS;AACZ,UAAM,WAAW,QAAQ,IAAI,WAAW,GAAG,YAAY;AACvD,gBAAY,QAAQ,YAAY,MAAM,QAAQ,aAAa,UAAU,OAAO,QAAQ,OAAO,QAAQ;AAEnG,uBAAmB,OAAO;AAE1B,QAAI,cAAc;AAChB,YAAM,MAAM,cAAc,OAAO;AACjC,cAAQ,MAAM,sCAAsC,aAAa,mBAAmB,MAAM;AAAA,IAC5F;AAEA,QAAI,eAAe;AACjB,YAAM,UAAU,aAAa;AAC7B,cAAQ,MAAM,mBAAmB;AAAA,IACnC;AAAA,EACF;AAEA,MAAI,WAAW;AACb,UAAM,MAAM;AACZ,gBAAY;AACZ,UAAM,IAAI;AAAA,MACR,wBAAO;AAAA,MACP,wDAAwD,YAAY,GAAG;AAAA,MACvE;AAAA,QACE,yCAAU,YAAY;AAAA,UACpB,QAAQ,IAAI;AAAA,UACZ,cAAc,IAAI,OAAO,MAAM,IAAI;AAAA,QACrC,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAS,MAAM,cAAc,SAAS;AAAA,IAC1C;AAAA,IACA;AAAA,IACA,aAAa,IAAI,mBAAmB,YAAY,SAAS,IAAI;AAAA,EAC/D;AACA,oBAAkB,QAAQ,QAAQ,WAAW;AAC7C,SAAO;AACT;AAEA,IAAM,qBAAN,cAAiC,qBAAqB;AAAA,EACpD,YACW,MACT,WACA;AACA,UAAM,SAAS;AAHN;AAIT,SAAK,KAAK,GAAG,WAAW,CAAC,SAAqB;AAC5C,WAAK,OAAO,IAAI;AAAA,IAClB,CAAC;AACD,SAAK,KAAK,GAAG,SAAS,MAAM;AAC1B,WAAK,MAAM;AAAA,IACb,CAAC;AAAA,EACH;AAAA,EAEA,OAAO,KAA+C;AACpD,SAAK,KAAK,YAAY,GAAG;AAAA,EAC3B;AACF;AACC,OAAO,cAAc,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC;","names":[]}

package/lib/test-processor.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/test-processor.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/test-processor.test.ts"],"sourcesContent":["import { Plugin, PluginManager } from './plugin.js'\nimport { DataBinding, HandlerType, ProcessResult } from './gen/processor/protos/processor.js'\n\nclass TestPlugin extends Plugin {\n  async processBinding(request: DataBinding): Promise<ProcessResult> {\n    const dbContext = PluginManager.INSTANCE.dbContextLocalStorage.getStore()\n    if (dbContext) {\n      await dbContext.sendRequest({\n        get: {\n          entity: 'Test',\n          id: '1'\n        }\n      })\n    }\n\n    return ProcessResult.fromPartial({\n      states: {\n        configUpdated: true\n      }\n    })\n  }\n  supportedHandlers = [HandlerType.UNKNOWN]\n}\n\nPluginManager.INSTANCE.plugins = []\nPluginManager.INSTANCE.register(new TestPlugin())\n;import(\"node:process\").then((p) => p.stdout.write(\"\"));"],"mappings":";;;;;;;;AAGA,IAAM,aAAN,cAAyB,OAAO;AAAA,EAC9B,MAAM,eAAe,SAA8C;AACjE,UAAM,YAAY,cAAc,SAAS,sBAAsB,SAAS;AACxE,QAAI,WAAW;AACb,YAAM,UAAU,YAAY;AAAA,QAC1B,KAAK;AAAA,UACH,QAAQ;AAAA,UACR,IAAI;AAAA,QACN;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO,cAAc,YAAY;AAAA,MAC/B,QAAQ;AAAA,QACN,eAAe;AAAA,MACjB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EACA,oBAAoB,gBAAoB;AAC1C;AAEA,cAAc,SAAS,UAAU,CAAC;AAClC,cAAc,SAAS,SAAS,IAAI,WAAW,CAAC;AAC/C,OAAO,cAAc,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,CAAC;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/runtime",
-  "version": "2.57.12",
+  "version": "2.57.13-rc.2",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/db-context.ts

@@ -9,6 +9,7 @@ import {
 } from '@sentio/protos'
 import * as process from 'node:process'
 import { dbMetrics } from './metrics.js'
+
 const {
   request_errors,
   unsolved_requests,
@@ -27,19 +28,26 @@ type RequestType = keyof Request
 
 export const timeoutError = new Error('timeout')
 
-export class StoreContext {
+export interface IStoreContext {
+  sendRequest(request: DeepPartial<Request>, timeoutSecs?: number): Promise<DBResponse>
+
+  result(dbResult: DBResponse): void
+
+  error(processId: number, e: any): void
+
+  close(): void
+}
+
+export abstract class AbstractStoreContext implements IStoreContext {
   private static opCounter = 0n
-  private defers = new Map<
+  protected defers = new Map<
     bigint,
     { resolve: (value: any) => void; reject: (reason?: any) => void; requestType?: RequestType }
   >()
   private statsInterval: NodeJS.Timeout | undefined
   private pendings: Promise<unknown>[] = []
 
-  constructor(
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
-    readonly processId: number
-  ) {}
+  constructor(readonly processId: number) {}
 
   newPromise<T>(opId: bigint, requestType?: RequestType) {
     return new Promise<T>((resolve, reject) => {
@@ -48,6 +56,8 @@ export class StoreContext {
     })
   }
 
+  abstract doSend(resp: DeepPartial<ProcessStreamResponse>): void
+
   sendRequest(request: DeepPartial<Request>, timeoutSecs?: number): Promise<DBResponse> {
     if (STORE_BATCH_IDLE > 0 && STORE_BATCH_SIZE > 1 && request.upsert) {
       // batch upsert if possible
@@ -67,12 +77,11 @@ export class StoreContext {
       promises.push(timeoutPromise)
     }
 
-    this.subject.next({
+    this.doSend({
       dbRequest: {
         ...request,
         opId
-      },
-      processId: this.processId
+      }
     })
 
     send_counts[requestType]?.add(1)
@@ -80,7 +89,7 @@ export class StoreContext {
     if (requestType === 'upsert' && STORE_UPSERT_NO_WAIT) {
       this.pendings.push(promise)
       return Promise.resolve({
-        opId,
+        opId
       } as DBResponse)
     }
 
@@ -131,10 +140,7 @@ export class StoreContext {
         error: e?.toString()
       }
     })
-    this.subject.next({
-      result: errorResult,
-      processId
-    })
+    this.doSend({ result: errorResult, processId })
   }
 
   close() {
@@ -188,7 +194,7 @@ export class StoreContext {
         opId,
         request: req,
         promise,
-        timer: timeout,
+        timer: timeout
       }
 
       if (STORE_UPSERT_NO_WAIT) {
@@ -208,12 +214,11 @@ export class StoreContext {
       // console.debug('sending batch upsert', opId, 'batch size', request?.entity.length)
       clearTimeout(timer)
       this.upsertBatch = undefined
-      this.subject.next({
+      this.doSend({
         dbRequest: {
           upsert: request,
           opId
-        },
-        processId: this.processId
+        }
       })
       send_counts['upsert']?.add(1)
       batched_request_count.add(1)
@@ -225,3 +230,19 @@ export class StoreContext {
     await Promise.all(this.pendings)
   }
 }
+
+export class StoreContext extends AbstractStoreContext {
+  constructor(
+    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
+    processId: number
+  ) {
+    super(processId)
+  }
+
+  doSend(resp: DeepPartial<ProcessStreamResponse>) {
+    this.subject.next({
+      ...resp,
+      processId: this.processId
+    })
+  }
+}

package/src/endpoints.ts

@@ -1,3 +1,7 @@
+import path from 'path'
+import fs from 'fs-extra'
+import { ChainConfig } from './chain-config.js'
+
 export class Endpoints {
   static INSTANCE: Endpoints = new Endpoints()
 
@@ -9,3 +13,34 @@ export class Endpoints {
 
   batchCount = 1
 }
+
+export function configureEndpoints(options: any) {
+  const fullPath = path.resolve(options['chains-config'])
+  const chainsConfig = fs.readJsonSync(fullPath)
+
+  const concurrencyOverride = process.env['OVERRIDE_CONCURRENCY']
+    ? parseInt(process.env['OVERRIDE_CONCURRENCY'])
+    : undefined
+  const batchCountOverride = process.env['OVERRIDE_BATCH_COUNT']
+    ? parseInt(process.env['OVERRIDE_BATCH_COUNT'])
+    : undefined
+
+  Endpoints.INSTANCE.concurrency = concurrencyOverride ?? options.concurrency
+  Endpoints.INSTANCE.batchCount = batchCountOverride ?? options['batch-count']
+  Endpoints.INSTANCE.chainQueryAPI = options['chainquery-server']
+  Endpoints.INSTANCE.priceFeedAPI = options['pricefeed-server']
+
+  for (const [id, config] of Object.entries(chainsConfig)) {
+    const chainConfig = config as ChainConfig
+    if (chainConfig.ChainServer) {
+      Endpoints.INSTANCE.chainServer.set(id, chainConfig.ChainServer)
+    } else {
+      const http = chainConfig.Https?.[0]
+      if (http) {
+        Endpoints.INSTANCE.chainServer.set(id, http)
+      } else {
+        console.error('not valid config for chain', id)
+      }
+    }
+  }
+}

package/src/logger.ts

@@ -13,7 +13,7 @@ function stringify(obj: any): string {
   })
 }
 
-export function setupLogger(json: boolean, enableDebug: boolean) {
+export function setupLogger(json: boolean, enableDebug: boolean, workerId?: number) {
   const utilFormatter = {
     transform: (info: any) => {
       const stringRes = []
@@ -45,7 +45,8 @@ export function setupLogger(json: boolean, enableDebug: boolean) {
       format.timestamp({ format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' }),
       utilFormatter,
       format.errors({ stack: true }),
-      json ? format.json() : format.simple()
+      json ? format.json() : format.simple(),
+      format.label({ label: workerId ? `worker #{workerId}` : '' })
     ),
     level: enableDebug ? 'debug' : 'info',
     transports: [new transports.Console()]

package/src/plugin.ts

@@ -7,7 +7,7 @@ import {
   ProcessResult,
   StartRequest
 } from '@sentio/protos'
-import { StoreContext } from './db-context.js'
+import { IStoreContext, StoreContext } from './db-context.js'
 import { AsyncLocalStorage } from 'node:async_hooks'
 
 export abstract class Plugin {
@@ -48,7 +48,7 @@ export abstract class Plugin {
 export class PluginManager {
   static INSTANCE = new PluginManager()
 
-  dbContextLocalStorage = new AsyncLocalStorage<StoreContext | undefined>()
+  dbContextLocalStorage = new AsyncLocalStorage<IStoreContext | undefined>()
   plugins: Plugin[] = []
   typesToPlugin = new Map<HandlerType, Plugin>()
 
@@ -93,7 +93,7 @@ export class PluginManager {
   processBinding(
     request: DataBinding,
     preparedData: PreparedData | undefined,
-    dbContext?: StoreContext
+    dbContext?: IStoreContext
   ): Promise<ProcessResult> {
     const plugin = this.typesToPlugin.get(request.handlerType)
     if (!plugin) {

package/src/processor-runner.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-import path from 'path'
 import fs from 'fs-extra'
 
 import { compressionAlgorithms } from '@grpc/grpc-js'
@@ -15,17 +14,23 @@ import { Session } from 'node:inspector/promises'
 
 import { ProcessorDefinition } from './gen/processor/protos/processor.js'
 import { ProcessorServiceImpl } from './service.js'
-import { Endpoints } from './endpoints.js'
+import { configureEndpoints } from './endpoints.js'
 import { FullProcessorServiceImpl } from './full-service.js'
-import { ChainConfig } from './chain-config.js'
 import { setupLogger } from './logger.js'
 
 import { setupOTLP } from './otlp.js'
 import { ActionServer } from './action-server.js'
+import { ServiceManager } from './service-manager.js'
 
 // const mergedRegistry = Registry.merge([globalRegistry, niceGrpcRegistry])
 
-const optionDefinitions = [
+let workerNum = 1
+try {
+  workerNum = parseInt(process.env['PROCESSOR_WORKER']?.trim() ?? '1')
+} catch (e) {
+  console.error('Failed to parse worker number', e)
+}
+export const optionDefinitions = [
   { name: 'target', type: String, defaultOption: true },
   { name: 'port', alias: 'p', type: String, defaultValue: '4000' },
   { name: 'concurrency', type: Number, defaultValue: 4 },
@@ -42,12 +47,13 @@ const optionDefinitions = [
   { name: 'log-format', type: String, defaultValue: 'console' },
   { name: 'debug', type: Boolean, defaultValue: false },
   { name: 'otlp-debug', type: Boolean, defaultValue: false },
-  { name: 'start-action-server', type: Boolean, defaultValue: false }
+  { name: 'start-action-server', type: Boolean, defaultValue: false },
+  { name: 'worker', type: Number, defaultValue: workerNum }
 ]
 
 const options = commandLineArgs(optionDefinitions, { partial: true })
 
-const logLevel = process.env['LOG_LEVEL']?.toUpperCase()
+const logLevel = process.env['LOG_LEVEL']?.toLowerCase()
 
 setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug)
 console.debug('Starting with', options.target)
@@ -56,39 +62,12 @@ await setupOTLP(options['otlp-debug'])
 
 Error.stackTraceLimit = 20
 
-const fullPath = path.resolve(options['chains-config'])
-const chainsConfig = fs.readJsonSync(fullPath)
-
-const concurrencyOverride = process.env['OVERRIDE_CONCURRENCY']
-  ? parseInt(process.env['OVERRIDE_CONCURRENCY'])
-  : undefined
-const batchCountOverride = process.env['OVERRIDE_BATCH_COUNT']
-  ? parseInt(process.env['OVERRIDE_BATCH_COUNT'])
-  : undefined
-
-Endpoints.INSTANCE.concurrency = concurrencyOverride ?? options.concurrency
-Endpoints.INSTANCE.batchCount = batchCountOverride ?? options['batch-count']
-Endpoints.INSTANCE.chainQueryAPI = options['chainquery-server']
-Endpoints.INSTANCE.priceFeedAPI = options['pricefeed-server']
-
-for (const [id, config] of Object.entries(chainsConfig)) {
-  const chainConfig = config as ChainConfig
-  if (chainConfig.ChainServer) {
-    Endpoints.INSTANCE.chainServer.set(id, chainConfig.ChainServer)
-  } else {
-    const http = chainConfig.Https?.[0]
-    if (http) {
-      Endpoints.INSTANCE.chainServer.set(id, http)
-    } else {
-      console.error('not valid config for chain', id)
-    }
-  }
-}
+configureEndpoints(options)
 
 console.debug('Starting Server', options)
 
 let server: any
-let baseService: ProcessorServiceImpl
+let baseService: ProcessorServiceImpl | ServiceManager
 const loader = async () => {
   const m = await import(options.target)
   console.debug('Module loaded', m)
@@ -106,7 +85,13 @@ if (options['start-action-server']) {
     // .use(prometheusServerMiddleware())
     .use(openTelemetryServerMiddleware())
     .use(errorDetailsServerMiddleware)
-  baseService = new ProcessorServiceImpl(loader, server.shutdown)
+
+  if (options.worker > 1) {
+    baseService = new ServiceManager(options, loader, server.shutdown)
+  } else {
+    baseService = new ProcessorServiceImpl(loader, server.shutdown)
+  }
+
   const service = new FullProcessorServiceImpl(baseService)
 
   server.add(ProcessorDefinition, service)