@sentio/runtime 2.60.0-rc.1 → 2.60.0-rc.10

package/lib/service-worker.js

@@ -1,7 +1,7 @@
 import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);
 import {
   setupLogger
-} from "./chunk-RJMWLF3Q.js";
+} from "./chunk-CYS2DAE4.js";
 import {
   ProcessorServiceImpl,
   configureEndpoints,
@@ -10,10 +10,10 @@ import {
   require_cjs,
   require_lib3 as require_lib,
   require_lib4 as require_lib2
-} from "./chunk-7JPTCCHQ.js";
+} from "./chunk-BOHR42T4.js";
 import {
   __toESM
-} from "./chunk-AQYRWO7H.js";
+} from "./chunk-TC6OWLVA.js";
 
 // src/service-worker.ts
 var import_nice_grpc = __toESM(require_lib(), 1);

package/package.json

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

package/src/full-service.ts

@@ -2,19 +2,22 @@ import { CallContext } from 'nice-grpc'
 import { createRequire } from 'module'
 // Different than the simple one which
 import {
+  ConfigureHandlersRequest,
   DataBinding,
   ExecutionConfig,
   HandlerType,
+  InitResponse,
   PreprocessStreamRequest,
   ProcessBindingsRequest,
   ProcessConfigRequest,
+  ProcessConfigResponse,
   ProcessorServiceImplementation,
   ProcessResult,
   ProcessStreamRequest,
   StartRequest
 } from './gen/processor/protos/processor.js'
 
-import { Empty } from '@sentio/protos'
+import { ConfigureHandlersResponse, DeepPartial, Empty, ProcessorV3ServiceImplementation } from '@sentio/protos'
 import fs from 'fs-extra'
 import path from 'path'
 import os from 'os'
@@ -78,9 +81,15 @@ function locatePackageJson(pkgId: string) {
   return JSON.parse(content)
 }
 
-export class FullProcessorServiceImpl implements ProcessorServiceImplementation {
-  constructor(instance: ProcessorServiceImplementation) {
-    this.instance = instance
+/**
+ * The RuntimeServicePatcher class is responsible for providing backward compatibility
+ * patches for different SDK versions. It ensures that the runtime can adapt to changes
+ * in the SDK by applying necessary adjustments to data bindings and other configurations.
+ */
+export class RuntimeServicePatcher {
+  sdkVersion: Semver
+
+  constructor() {
     const sdkPackageJson = locatePackageJson('@sentio/sdk')
     const runtimePackageJson = locatePackageJson('@sentio/runtime')
 
@@ -89,111 +98,7 @@ export class FullProcessorServiceImpl implements ProcessorServiceImplementation
     this.sdkVersion = parseSemver(sdkPackageJson.version)
   }
 
-  instance: ProcessorServiceImplementation
-  sdkVersion: Semver
-
-  async getConfig(request: ProcessConfigRequest, context: CallContext) {
-    const config = await this.instance.getConfig(request, context)
-    config.executionConfig = ExecutionConfig.fromPartial(GLOBAL_CONFIG.execution)
-
-    if (config.contractConfigs) {
-      for (const contract of config.contractConfigs) {
-        // for old fuel processor
-        if (
-          compareSemver(this.sdkVersion, FUEL_PROTO_NO_FUEL_TRANSACTION_AS_CALL_VERSION) < 0 &&
-          contract.fuelCallConfigs
-        ) {
-          contract.fuelTransactionConfigs = contract.fuelCallConfigs
-          contract.fuelCallConfigs = undefined
-        }
-
-        // @ts-ignore convert old fuelLogConfigs to fuelReceiptConfigs
-        if (contract.fuelLogConfigs) {
-          contract.fuelReceiptConfigs = contract.fuelLogConfigs.map((e) => ({
-            handlerId: e.handlerId,
-            handlerName: e.handlerName,
-            log: {
-              logIds: e.logIds
-            }
-          }))
-        }
-
-        // @ts-ignore old fields
-        if (contract.aptosCallConfigs) {
-          // @ts-ignore old fields
-          contract.moveCallConfigs = contract.aptosCallConfigs
-        }
-        // @ts-ignore old fields
-        if (contract.aptosEventConfigs) {
-          // @ts-ignore old fields
-          contract.moveEventConfigs = contract.aptosEventConfigs
-        }
-      }
-    }
-
-    if (compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0) {
-      PROCESSED_MOVE_EVENT_TX_HANDLER.clear()
-    }
-
-    return config
-  }
-
-  async start(request: StartRequest, context: CallContext) {
-    return await this.instance.start(request, context)
-  }
-
-  async stop(request: Empty, context: CallContext) {
-    return await this.instance.stop(request, context)
-  }
-
-  async processBindings(request: ProcessBindingsRequest, options: CallContext) {
-    // if (GLOBAL_CONFIG.execution.sequential) {
-    //   request.bindings = request.bindings.sort(dataCompare)
-    // }
-
-    for (const binding of request.bindings) {
-      this.adjustDataBinding(binding)
-    }
-    try {
-      const result = await this.instance.processBindings(request, options)
-      this.adjustResult(result.result as ProcessResult)
-      if (!result.configUpdated && result.result?.states?.configUpdated) {
-        result.configUpdated = result.result?.states?.configUpdated
-      }
-      return result
-    } catch (e) {
-      if (this.sdkVersion.minor <= 16) {
-        // Old sdk doesn't handle this well
-        if (
-          e.code === os.constants.errno.ECONNRESET ||
-          e.code === os.constants.errno.ECONNREFUSED ||
-          e.code === os.constants.errno.ECONNABORTED
-        ) {
-          process.exit(1)
-        }
-      }
-      throw e
-    }
-  }
-
-  async *adjustBindingsStream(requests: AsyncIterable<ProcessStreamRequest>): AsyncIterable<ProcessStreamRequest> {
-    for await (const request of requests) {
-      this.adjustDataBinding(request.binding)
-      yield request
-    }
-  }
-
-  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
-    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
-  }
-
-  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
-    yield* this.instance.preprocessBindingsStream(this.adjustBindingsStream(requests), context)
-  }
-
-  private adjustResult(res: ProcessResult): void {}
-
-  private adjustDataBinding(dataBinding?: DataBinding): void {
+  adjustDataBinding(dataBinding?: DataBinding): void {
     const isBeforeMoveUseRawVersion = compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0
     // const isBeforeEthUseRawVersion = compareSemver(this.sdkVersion,ETH_USE_RAW_VERSION) < 0
 
@@ -350,6 +255,127 @@ export class FullProcessorServiceImpl implements ProcessorServiceImplementation
         break
     }
   }
+
+  patchConfig(config: DeepPartial<ProcessConfigResponse>): void {
+    config.executionConfig = ExecutionConfig.fromPartial(GLOBAL_CONFIG.execution)
+
+    if (config.contractConfigs) {
+      for (const contract of config.contractConfigs) {
+        // for old fuel processor
+        if (
+          compareSemver(this.sdkVersion, FUEL_PROTO_NO_FUEL_TRANSACTION_AS_CALL_VERSION) < 0 &&
+          contract.fuelCallConfigs
+        ) {
+          contract.fuelTransactionConfigs = contract.fuelCallConfigs
+          contract.fuelCallConfigs = undefined
+        }
+
+        // @ts-ignore convert old fuelLogConfigs to fuelReceiptConfigs
+        if (contract.fuelLogConfigs) {
+          contract.fuelReceiptConfigs = contract.fuelLogConfigs.map((e) => ({
+            handlerId: e.handlerId,
+            handlerName: e.handlerName,
+            log: {
+              logIds: e.logIds
+            }
+          }))
+        }
+
+        // @ts-ignore old fields
+        if (contract.aptosCallConfigs) {
+          // @ts-ignore old fields
+          contract.moveCallConfigs = contract.aptosCallConfigs
+        }
+        // @ts-ignore old fields
+        if (contract.aptosEventConfigs) {
+          // @ts-ignore old fields
+          contract.moveEventConfigs = contract.aptosEventConfigs
+        }
+      }
+    }
+  }
+}
+
+export class FullProcessorServiceImpl implements ProcessorServiceImplementation {
+  constructor(instance: ProcessorServiceImplementation) {
+    this.instance = instance
+    const sdkPackageJson = locatePackageJson('@sentio/sdk')
+    const runtimePackageJson = locatePackageJson('@sentio/runtime')
+
+    console.log('Runtime version:', runtimePackageJson.version, 'SDK version:', sdkPackageJson.version)
+
+    this.sdkVersion = parseSemver(sdkPackageJson.version)
+  }
+
+  instance: ProcessorServiceImplementation
+  sdkVersion: Semver
+  patcher: RuntimeServicePatcher = new RuntimeServicePatcher()
+
+  async getConfig(request: ProcessConfigRequest, context: CallContext) {
+    const config = await this.instance.getConfig(request, context)
+    this.patcher.patchConfig(config)
+
+    if (compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0) {
+      PROCESSED_MOVE_EVENT_TX_HANDLER.clear()
+    }
+
+    return config
+  }
+
+  async start(request: StartRequest, context: CallContext) {
+    return await this.instance.start(request, context)
+  }
+
+  async stop(request: Empty, context: CallContext) {
+    return await this.instance.stop(request, context)
+  }
+
+  async processBindings(request: ProcessBindingsRequest, options: CallContext) {
+    // if (GLOBAL_CONFIG.execution.sequential) {
+    //   request.bindings = request.bindings.sort(dataCompare)
+    // }
+
+    for (const binding of request.bindings) {
+      this.patcher.adjustDataBinding(binding)
+    }
+    try {
+      const result = await this.instance.processBindings(request, options)
+      this.adjustResult(result.result as ProcessResult)
+      if (!result.configUpdated && result.result?.states?.configUpdated) {
+        result.configUpdated = result.result?.states?.configUpdated
+      }
+      return result
+    } catch (e) {
+      if (this.sdkVersion.minor <= 16) {
+        // Old sdk doesn't handle this well
+        if (
+          e.code === os.constants.errno.ECONNRESET ||
+          e.code === os.constants.errno.ECONNREFUSED ||
+          e.code === os.constants.errno.ECONNABORTED
+        ) {
+          process.exit(1)
+        }
+      }
+      throw e
+    }
+  }
+
+  async *adjustBindingsStream(requests: AsyncIterable<ProcessStreamRequest>): AsyncIterable<ProcessStreamRequest> {
+    for await (const request of requests) {
+      this.patcher.adjustDataBinding(request.binding)
+      yield request
+    }
+  }
+
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
+  }
+
+  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
+    yield* this.instance.preprocessBindingsStream(this.adjustBindingsStream(requests), context)
+  }
+
+  private adjustResult(res: ProcessResult): void {}
 }
 
 // function dataCompare(a: DataBinding, b: DataBinding): number {
@@ -383,3 +409,35 @@ export class FullProcessorServiceImpl implements ProcessorServiceImplementation
 //     d.data?.ethTrace?.trace?.transactionPosition
 //   )
 // }
+
+export class FullProcessorServiceV3Impl implements ProcessorV3ServiceImplementation {
+  patcher: RuntimeServicePatcher = new RuntimeServicePatcher()
+
+  constructor(readonly instance: ProcessorV3ServiceImplementation) {}
+
+  async init(request: Empty, context: CallContext): Promise<DeepPartial<InitResponse>> {
+    const resp = await this.instance.init(request, context)
+    resp.executionConfig = ExecutionConfig.fromPartial(GLOBAL_CONFIG.execution)
+    return resp
+  }
+
+  async configureHandlers(
+    request: ConfigureHandlersRequest,
+    context: CallContext
+  ): Promise<DeepPartial<ConfigureHandlersResponse>> {
+    const config = await this.instance.configureHandlers(request, context)
+    this.patcher.patchConfig(config)
+    return config
+  }
+
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
+  }
+
+  async *adjustBindingsStream(requests: AsyncIterable<ProcessStreamRequest>): AsyncIterable<ProcessStreamRequest> {
+    for await (const request of requests) {
+      this.patcher.adjustDataBinding(request.binding)
+      yield request
+    }
+  }
+}

package/src/gen/processor/protos/processor.ts

@@ -434,6 +434,11 @@ export interface ProcessConfigResponse {
   dbSchema: DataBaseSchema | undefined;
 }
 
+export interface ConfigureHandlersResponse {
+  contractConfigs: ContractConfig[];
+  accountConfigs: AccountConfig[];
+}
+
 export interface ContractConfig {
   contract: ContractInfo | undefined;
   intervalConfigs: OnIntervalConfig[];
@@ -668,6 +673,11 @@ export interface TemplateInstance {
 export interface InitResponse {
   chainIds: string[];
   dbSchema: DataBaseSchema | undefined;
+  config: ProjectConfig | undefined;
+  executionConfig: ExecutionConfig | undefined;
+  metricConfigs: MetricConfig[];
+  exportConfigs: ExportConfig[];
+  eventLogConfigs: EventLogConfig[];
 }
 
 export interface ConfigureHandlersRequest {
@@ -2148,6 +2158,84 @@ export const ProcessConfigResponse = {
   },
 };
 
+function createBaseConfigureHandlersResponse(): ConfigureHandlersResponse {
+  return { contractConfigs: [], accountConfigs: [] };
+}
+
+export const ConfigureHandlersResponse = {
+  encode(message: ConfigureHandlersResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.contractConfigs) {
+      ContractConfig.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.accountConfigs) {
+      AccountConfig.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ConfigureHandlersResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfigureHandlersResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.contractConfigs.push(ContractConfig.decode(reader, reader.uint32()));
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.accountConfigs.push(AccountConfig.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConfigureHandlersResponse {
+    return {
+      contractConfigs: globalThis.Array.isArray(object?.contractConfigs)
+        ? object.contractConfigs.map((e: any) => ContractConfig.fromJSON(e))
+        : [],
+      accountConfigs: globalThis.Array.isArray(object?.accountConfigs)
+        ? object.accountConfigs.map((e: any) => AccountConfig.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ConfigureHandlersResponse): unknown {
+    const obj: any = {};
+    if (message.contractConfigs?.length) {
+      obj.contractConfigs = message.contractConfigs.map((e) => ContractConfig.toJSON(e));
+    }
+    if (message.accountConfigs?.length) {
+      obj.accountConfigs = message.accountConfigs.map((e) => AccountConfig.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ConfigureHandlersResponse>): ConfigureHandlersResponse {
+    return ConfigureHandlersResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ConfigureHandlersResponse>): ConfigureHandlersResponse {
+    const message = createBaseConfigureHandlersResponse();
+    message.contractConfigs = object.contractConfigs?.map((e) => ContractConfig.fromPartial(e)) || [];
+    message.accountConfigs = object.accountConfigs?.map((e) => AccountConfig.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseContractConfig(): ContractConfig {
   return {
     contract: undefined,
@@ -4405,7 +4493,15 @@ export const TemplateInstance = {
 };
 
 function createBaseInitResponse(): InitResponse {
-  return { chainIds: [], dbSchema: undefined };
+  return {
+    chainIds: [],
+    dbSchema: undefined,
+    config: undefined,
+    executionConfig: undefined,
+    metricConfigs: [],
+    exportConfigs: [],
+    eventLogConfigs: [],
+  };
 }
 
 export const InitResponse = {
@@ -4416,6 +4512,21 @@ export const InitResponse = {
     if (message.dbSchema !== undefined) {
       DataBaseSchema.encode(message.dbSchema, writer.uint32(18).fork()).ldelim();
     }
+    if (message.config !== undefined) {
+      ProjectConfig.encode(message.config, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.executionConfig !== undefined) {
+      ExecutionConfig.encode(message.executionConfig, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.metricConfigs) {
+      MetricConfig.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+    for (const v of message.exportConfigs) {
+      ExportConfig.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+    for (const v of message.eventLogConfigs) {
+      EventLogConfig.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -4440,6 +4551,41 @@ export const InitResponse = {
 
           message.dbSchema = DataBaseSchema.decode(reader, reader.uint32());
           continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.config = ProjectConfig.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.executionConfig = ExecutionConfig.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.metricConfigs.push(MetricConfig.decode(reader, reader.uint32()));
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.exportConfigs.push(ExportConfig.decode(reader, reader.uint32()));
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.eventLogConfigs.push(EventLogConfig.decode(reader, reader.uint32()));
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -4453,6 +4599,17 @@ export const InitResponse = {
     return {
       chainIds: globalThis.Array.isArray(object?.chainIds) ? object.chainIds.map((e: any) => globalThis.String(e)) : [],
       dbSchema: isSet(object.dbSchema) ? DataBaseSchema.fromJSON(object.dbSchema) : undefined,
+      config: isSet(object.config) ? ProjectConfig.fromJSON(object.config) : undefined,
+      executionConfig: isSet(object.executionConfig) ? ExecutionConfig.fromJSON(object.executionConfig) : undefined,
+      metricConfigs: globalThis.Array.isArray(object?.metricConfigs)
+        ? object.metricConfigs.map((e: any) => MetricConfig.fromJSON(e))
+        : [],
+      exportConfigs: globalThis.Array.isArray(object?.exportConfigs)
+        ? object.exportConfigs.map((e: any) => ExportConfig.fromJSON(e))
+        : [],
+      eventLogConfigs: globalThis.Array.isArray(object?.eventLogConfigs)
+        ? object.eventLogConfigs.map((e: any) => EventLogConfig.fromJSON(e))
+        : [],
     };
   },
 
@@ -4464,6 +4621,21 @@ export const InitResponse = {
     if (message.dbSchema !== undefined) {
       obj.dbSchema = DataBaseSchema.toJSON(message.dbSchema);
     }
+    if (message.config !== undefined) {
+      obj.config = ProjectConfig.toJSON(message.config);
+    }
+    if (message.executionConfig !== undefined) {
+      obj.executionConfig = ExecutionConfig.toJSON(message.executionConfig);
+    }
+    if (message.metricConfigs?.length) {
+      obj.metricConfigs = message.metricConfigs.map((e) => MetricConfig.toJSON(e));
+    }
+    if (message.exportConfigs?.length) {
+      obj.exportConfigs = message.exportConfigs.map((e) => ExportConfig.toJSON(e));
+    }
+    if (message.eventLogConfigs?.length) {
+      obj.eventLogConfigs = message.eventLogConfigs.map((e) => EventLogConfig.toJSON(e));
+    }
     return obj;
   },
 
@@ -4476,6 +4648,15 @@ export const InitResponse = {
     message.dbSchema = (object.dbSchema !== undefined && object.dbSchema !== null)
       ? DataBaseSchema.fromPartial(object.dbSchema)
       : undefined;
+    message.config = (object.config !== undefined && object.config !== null)
+      ? ProjectConfig.fromPartial(object.config)
+      : undefined;
+    message.executionConfig = (object.executionConfig !== undefined && object.executionConfig !== null)
+      ? ExecutionConfig.fromPartial(object.executionConfig)
+      : undefined;
+    message.metricConfigs = object.metricConfigs?.map((e) => MetricConfig.fromPartial(e)) || [];
+    message.exportConfigs = object.exportConfigs?.map((e) => ExportConfig.fromPartial(e)) || [];
+    message.eventLogConfigs = object.eventLogConfigs?.map((e) => EventLogConfig.fromPartial(e)) || [];
     return message;
   },
 };
@@ -14994,10 +15175,10 @@ export interface ProcessorClient<CallOptionsExt = {}> {
   ): AsyncIterable<PreprocessStreamResponse>;
 }
 
-export type ProcessorV2Definition = typeof ProcessorV2Definition;
-export const ProcessorV2Definition = {
-  name: "ProcessorV2",
-  fullName: "processor.ProcessorV2",
+export type ProcessorV3Definition = typeof ProcessorV3Definition;
+export const ProcessorV3Definition = {
+  name: "ProcessorV3",
+  fullName: "processor.ProcessorV3",
   methods: {
     init: {
       name: "Init",
@@ -15011,7 +15192,7 @@ export const ProcessorV2Definition = {
       name: "ConfigureHandlers",
       requestType: ConfigureHandlersRequest,
       requestStream: false,
-      responseType: ProcessConfigResponse,
+      responseType: ConfigureHandlersResponse,
       responseStream: false,
       options: {},
     },
@@ -15026,24 +15207,24 @@ export const ProcessorV2Definition = {
   },
 } as const;
 
-export interface ProcessorV2ServiceImplementation<CallContextExt = {}> {
+export interface ProcessorV3ServiceImplementation<CallContextExt = {}> {
   init(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<InitResponse>>;
   configureHandlers(
     request: ConfigureHandlersRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<ProcessConfigResponse>>;
+  ): Promise<DeepPartial<ConfigureHandlersResponse>>;
   processBindingsStream(
     request: AsyncIterable<ProcessStreamRequest>,
     context: CallContext & CallContextExt,
   ): ServerStreamingMethodResult<DeepPartial<ProcessStreamResponseV2>>;
 }
 
-export interface ProcessorV2Client<CallOptionsExt = {}> {
+export interface ProcessorV3Client<CallOptionsExt = {}> {
   init(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<InitResponse>;
   configureHandlers(
     request: DeepPartial<ConfigureHandlersRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<ProcessConfigResponse>;
+  ): Promise<ConfigureHandlersResponse>;
   processBindingsStream(
     request: AsyncIterable<DeepPartial<ProcessStreamRequest>>,
     options?: CallOptions & CallOptionsExt,

package/src/plugin.ts

@@ -62,7 +62,7 @@ export abstract class Plugin {
   shutdownServer() {}
 
   /**
-   * Initialize the plugin, for service v2.
+   * Initialize the plugin, for service v3.
    * @param config
    */
   async init(config: InitResponse): Promise<void> {}

package/src/processor-runner.ts

@@ -15,13 +15,15 @@ import { Session } from 'node:inspector/promises'
 import { ProcessorDefinition } from './gen/processor/protos/processor.js'
 import { ProcessorServiceImpl } from './service.js'
 import { configureEndpoints } from './endpoints.js'
-import { FullProcessorServiceImpl } from './full-service.js'
+import { FullProcessorServiceImpl, FullProcessorServiceV3Impl } from './full-service.js'
 import { setupLogger } from './logger.js'
 
 import { setupOTLP } from './otlp.js'
 import { ActionServer } from './action-server.js'
 import { ServiceManager } from './service-manager.js'
 import path from 'path'
+import { ProcessorV3Definition } from '@sentio/protos'
+import { ProcessorServiceImplV3 } from './service-v3.js'
 
 // const mergedRegistry = Registry.merge([globalRegistry, niceGrpcRegistry])
 
@@ -103,7 +105,10 @@ if (options['start-action-server']) {
   const service = new FullProcessorServiceImpl(baseService)
 
   server.add(ProcessorDefinition, service)
-
+  server.add(
+    ProcessorV3Definition,
+    new FullProcessorServiceV3Impl(new ProcessorServiceImplV3(loader, options, server.shutdown))
+  )
   server.listen('0.0.0.0:' + options.port)
 
   console.log('Processor Server Started at:', options.port)