@sentio/runtime 4.0.0-rc.1 → 4.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/runtime",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.3",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/src/action-server.ts

@@ -1,5 +1,6 @@
 import { PluginManager } from './plugin.js'
-import { ProcessConfigResponse } from '@sentio/protos'
+import { ProcessConfigResponseSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 
 export class ActionServer {
   constructor(readonly loader: () => Promise<void>) {}
@@ -7,7 +8,7 @@ export class ActionServer {
   async listen(port: number) {
     const pluginManager = PluginManager.INSTANCE
     await this.loader()
-    await pluginManager.configure(ProcessConfigResponse.create())
+    await pluginManager.configure(create(ProcessConfigResponseSchema))
     console.log('Starting Action Server at:', port)
     await pluginManager.startServer(port)
   }

package/src/db-context.ts

@@ -1,15 +1,16 @@
 import { Subject } from 'rxjs'
 import {
-  DBRequest,
-  DBRequest_DBUpsert,
-  DBResponse,
-  DeepPartial,
-  ProcessResult,
-  ProcessStreamResponse,
-  ProcessStreamResponseV3,
-  TemplateInstance,
-  TimeseriesResult
+  DBRequestSchema,
+  type DBRequest_DBUpsert,
+  type DBResponse,
+  DBResponseSchema,
+  ProcessResultSchema,
+  ProcessStreamResponseSchema,
+  ProcessStreamResponseV3Schema,
+  type TemplateInstance,
+  type TimeseriesResult
 } from '@sentio/protos'
+import { create, type MessageInitShape } from '@bufbuild/protobuf'
 import * as process from 'node:process'
 import { dbMetrics } from './metrics.js'
 
@@ -26,13 +27,19 @@ const STORE_BATCH_IDLE = process.env['STORE_BATCH_MAX_IDLE'] ? parseInt(process.
 const STORE_BATCH_SIZE = process.env['STORE_BATCH_SIZE'] ? parseInt(process.env['STORE_BATCH_SIZE']) : 10
 const STORE_UPSERT_NO_WAIT = process.env['STORE_UPSERT_NO_WAIT'] === 'true'
 
-type Request = Omit<DBRequest, 'opId'>
-type RequestType = keyof Request
+// Init-shapes carried over the rxjs Subject before being yielded by connect.
+type ProcessStreamResponseInit = MessageInitShape<typeof ProcessStreamResponseSchema>
+type ProcessStreamResponseV3Init = MessageInitShape<typeof ProcessStreamResponseV3Schema>
+
+// The DBRequest oneof selection (without the op_id), e.g. { case: 'upsert', value: {...} }.
+// protobuf-es moved the per-op flat fields under the `op` oneof.
+type Request = NonNullable<MessageInitShape<typeof DBRequestSchema>['op']>
+type RequestType = NonNullable<Request['case']>
 
 export const timeoutError = new Error('timeout')
 
 export interface IStoreContext {
-  sendRequest(request: DeepPartial<Request>, timeoutSecs?: number): Promise<DBResponse>
+  sendRequest(request: Request, timeoutSecs?: number): Promise<DBResponse>
 
   result(dbResult: DBResponse): void
 
@@ -64,15 +71,15 @@ export abstract class AbstractStoreContext implements IStoreContext {
     })
   }
 
-  abstract doSend(resp: DeepPartial<ProcessStreamResponse>): void
+  abstract doSend(resp: ProcessStreamResponseInit | ProcessStreamResponseV3Init): void
 
-  sendRequest(request: DeepPartial<Request>, timeoutSecs?: number): Promise<DBResponse> {
-    if (STORE_BATCH_IDLE > 0 && STORE_BATCH_SIZE > 1 && request.upsert) {
+  sendRequest(request: Request, timeoutSecs?: number): Promise<DBResponse> {
+    if (STORE_BATCH_IDLE > 0 && STORE_BATCH_SIZE > 1 && request.case === 'upsert') {
       // batch upsert if possible
-      return this.sendUpsertInBatch(request.upsert as DBRequest_DBUpsert)
+      return this.sendUpsertInBatch(request.value as DBRequest_DBUpsert)
     }
 
-    const requestType = Object.keys(request)[0] as RequestType
+    const requestType = request.case as RequestType
     const opId = StoreContext.opCounter++
     const promise = this.newPromise<DBResponse>(opId, requestType)
 
@@ -88,9 +95,12 @@ export abstract class AbstractStoreContext implements IStoreContext {
     }
 
     this.doSend({
-      dbRequest: {
-        ...request,
-        opId
+      value: {
+        case: 'dbRequest',
+        value: {
+          op: request,
+          opId
+        }
       }
     })
 
@@ -98,9 +108,7 @@ export abstract class AbstractStoreContext implements IStoreContext {
 
     if (requestType === 'upsert' && STORE_UPSERT_NO_WAIT) {
       this.pendings.push(promise)
-      return Promise.resolve({
-        opId
-      } as DBResponse)
+      return Promise.resolve(create(DBResponseSchema, { opId }))
     }
 
     return Promise.race(promises)
@@ -130,8 +138,8 @@ export abstract class AbstractStoreContext implements IStoreContext {
       if (defer.requestType) {
         recv_counts[defer.requestType]?.add(1)
       }
-      if (dbResult.error) {
-        defer.reject(new Error(dbResult.error))
+      if (dbResult.value.case === 'error') {
+        defer.reject(new Error(dbResult.value.value))
       } else {
         defer.resolve(dbResult)
       }
@@ -143,12 +151,12 @@ export abstract class AbstractStoreContext implements IStoreContext {
   error(processId: number, e: any) {
     const stack = e.stack
     console.error('process error', processId, e, stack)
-    const errorResult = ProcessResult.create({
+    const errorResult = create(ProcessResultSchema, {
       states: {
         error: e?.toString() + (stack ? `\n${stack}` : '')
       }
     })
-    this.doSend({ result: errorResult, processId })
+    this.doSend({ value: { case: 'result', value: errorResult }, processId })
   }
 
   close() {
@@ -182,9 +190,7 @@ export abstract class AbstractStoreContext implements IStoreContext {
         this.sendBatch()
       }
       if (STORE_UPSERT_NO_WAIT) {
-        return {
-          opId
-        }
+        return create(DBResponseSchema, { opId })
       }
 
       return promise
@@ -207,9 +213,7 @@ export abstract class AbstractStoreContext implements IStoreContext {
 
       if (STORE_UPSERT_NO_WAIT) {
         this.pendings.push(promise)
-        return {
-          opId: this.upsertBatch.opId
-        }
+        return create(DBResponseSchema, { opId: this.upsertBatch.opId })
       } else {
         return promise
       }
@@ -223,9 +227,12 @@ export abstract class AbstractStoreContext implements IStoreContext {
       clearTimeout(timer)
       this.upsertBatch = undefined
       this.doSend({
-        dbRequest: {
-          upsert: request,
-          opId
+        value: {
+          case: 'dbRequest',
+          value: {
+            op: { case: 'upsert', value: request },
+            opId
+          }
         }
       })
       send_counts['upsert']?.add(1)
@@ -241,13 +248,13 @@ export abstract class AbstractStoreContext implements IStoreContext {
 
 export class StoreContext extends AbstractStoreContext {
   constructor(
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
+    readonly subject: Subject<ProcessStreamResponseInit>,
     processId: number
   ) {
     super(processId)
   }
 
-  doSend(resp: DeepPartial<ProcessStreamResponse>) {
+  doSend(resp: ProcessStreamResponseInit) {
     this.subject.next({
       ...resp,
       processId: this.processId
@@ -259,7 +266,7 @@ export class StoreContext extends AbstractStoreContext {
 export class DataBindingContext extends AbstractStoreContext implements IDataBindingContext {
   constructor(
     readonly processId: number,
-    readonly subject: Subject<DeepPartial<ProcessStreamResponseV3>>
+    readonly subject: Subject<ProcessStreamResponseV3Init>
   ) {
     super(processId)
   }
@@ -267,22 +274,28 @@ export class DataBindingContext extends AbstractStoreContext implements IDataBin
   sendTemplateRequest(templates: Array<TemplateInstance>, unbind: boolean) {
     this.subject.next({
       processId: this.processId,
-      tplRequest: {
-        templates,
-        remove: unbind
+      value: {
+        case: 'tplRequest',
+        value: {
+          templates,
+          remove: unbind
+        }
       }
     })
   }
   sendTimeseriesRequest(timeseries: Array<TimeseriesResult>) {
     this.subject.next({
       processId: this.processId,
-      tsRequest: {
-        data: timeseries
+      value: {
+        case: 'tsRequest',
+        value: {
+          data: timeseries
+        }
       }
     })
   }
 
-  doSend(resp: DeepPartial<ProcessStreamResponseV3>) {
+  doSend(resp: ProcessStreamResponseV3Init) {
     this.subject.next({
       ...resp,
       processId: this.processId

package/src/full-service.ts

@@ -1,416 +1,34 @@
-import { CallContext } from 'nice-grpc'
-// Different than the simple one which
+import { create } from '@bufbuild/protobuf'
+import { type HandlerContext, type ServiceImpl } from '@connectrpc/connect'
 import {
-  DataBinding,
-  ExecutionConfig,
-  HandlerType,
-  PreprocessStreamRequest,
-  ProcessBindingsRequest,
-  ProcessConfigRequest,
-  ProcessConfigResponse,
-  ProcessorServiceImplementation,
-  ProcessResult,
-  ProcessStreamRequest,
-  StartRequest
-} from './gen/processor/protos/processor.js'
-
-import { DeepPartial, Empty, ProcessorV3ServiceImplementation, UpdateTemplatesRequest } from '@sentio/protos'
-import os from 'os'
+  ExecutionConfigSchema,
+  type ProcessConfigRequest,
+  ProcessorV3,
+  type ProcessStreamRequest,
+  type StartRequest,
+  type UpdateTemplatesRequest
+} from '@sentio/protos'
+import { ProcessorServiceImplV3 } from './service-v3.js'
 import { GLOBAL_CONFIG } from './global-config.js'
-import { compareSemver, locatePackageJson, parseSemver, Semver } from './utils.js'
-import { LRUCache } from 'lru-cache'
-import { createHash } from 'crypto'
-
-const FUEL_PROTO_UPDATE_VERSION = parseSemver('2.54.0-rc.7')
-const FUEL_PROTO_NO_FUEL_TRANSACTION_AS_CALL_VERSION = parseSemver('2.55.0-rc.1')
-
-const MOVE_USE_RAW_VERSION = parseSemver('2.55.0-rc.1')
-const ETH_USE_RAW_VERSION = parseSemver('2.57.9-rc.12')
-// new driver (after MOVE_USE_RAW_VERSION) will sent the same event multiple times when fetch all true
-// so we need to cache it, key will be tx-handler_id
-const PROCESSED_MOVE_EVENT_TX_HANDLER = new LRUCache<string, boolean>({
-  max: 10000
-})
-
-const enableTxCache = process.env.ENABLE_PARSE_CACHE === 'true'
-
-// Cache for parsed JSON data
-const PARSED_DATA_CACHE = new LRUCache<string, any>({
-  max: enableTxCache ? 5000 : 1
-})
-
-/**
- * Gets parsed JSON data from a string, using a cache to avoid repeated parsing
- * @param rawData The raw string data to parse
- * @returns The parsed JSON object
- */
-function getParsedData(rawData: string): any {
-  if (!enableTxCache) {
-    return JSON.parse(rawData)
-  }
-
-  // Create a digest of the raw data for cache key
-  const digest = createHash('md5').update(rawData).digest('hex')
-
-  // Check if we already have this data parsed
-  let parsedData = PARSED_DATA_CACHE.get(digest)
-  if (!parsedData) {
-    // Parse and cache the data
-    parsedData = JSON.parse(rawData)
-    PARSED_DATA_CACHE.set(digest, parsedData)
-  }
-
-  return parsedData
-}
-
-/**
- * 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')
-    this.sdkVersion = parseSemver(sdkPackageJson.version)
-  }
-
-  adjustDataBinding(dataBinding?: DataBinding): void {
-    const isBeforeMoveUseRawVersion = compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0
-    // const isBeforeEthUseRawVersion = compareSemver(this.sdkVersion,ETH_USE_RAW_VERSION) < 0
-
-    if (!dataBinding) {
-      return
-    }
-    switch (dataBinding.handlerType) {
-      case HandlerType.ETH_LOG:
-        const ethLog = dataBinding.data?.ethLog
-        if (ethLog?.log == null && ethLog?.rawLog) {
-          ethLog.log = JSON.parse(ethLog.rawLog)
-
-          if (ethLog.rawTransaction) {
-            ethLog.transaction = getParsedData(ethLog.rawTransaction)
-          }
-          if (ethLog.rawBlock) {
-            ethLog.block = getParsedData(ethLog.rawBlock)
-          }
-          if (ethLog.rawTransactionReceipt) {
-            ethLog.transactionReceipt = getParsedData(ethLog.rawTransactionReceipt)
-          }
-        }
-        break
-      case HandlerType.ETH_TRANSACTION:
-        const ethTx = dataBinding.data?.ethTransaction
-        if (ethTx?.transaction == null && ethTx?.rawTransaction) {
-          ethTx.transaction = getParsedData(ethTx.rawTransaction)
-          if (ethTx.rawBlock) {
-            ethTx.block = getParsedData(ethTx.rawBlock)
-          } else {
-            ethTx.block = undefined
-          }
-          if (ethTx.rawTransactionReceipt) {
-            ethTx.transactionReceipt = getParsedData(ethTx.rawTransactionReceipt)
-          } else {
-            ethTx.transactionReceipt = undefined
-          }
-        }
-        break
-      case HandlerType.FUEL_TRANSACTION:
-        if (compareSemver(this.sdkVersion, FUEL_PROTO_UPDATE_VERSION) < 0) {
-          dataBinding.handlerType = HandlerType.FUEL_CALL
-          if (dataBinding.data) {
-            dataBinding.data.fuelCall = dataBinding.data?.fuelTransaction
-          }
-        }
-        break
-      case HandlerType.FUEL_RECEIPT:
-        if (compareSemver(this.sdkVersion, FUEL_PROTO_UPDATE_VERSION) < 0) {
-          dataBinding.handlerType = HandlerType.FUEL_CALL
-          if (dataBinding.data) {
-            dataBinding.data.fuelCall = dataBinding.data?.fuelLog
-          }
-        }
-
-        break
-      case HandlerType.APT_EVENT:
-        const aptEvent = dataBinding.data?.aptEvent
-        if (aptEvent) {
-          if (isBeforeMoveUseRawVersion && aptEvent.rawTransaction) {
-            const transaction = getParsedData(aptEvent.rawTransaction)
-
-            const key = `${transaction.hash}-${dataBinding.handlerIds[0]}`
-            if (PROCESSED_MOVE_EVENT_TX_HANDLER.has(key)) {
-              console.debug('skip binding', key)
-              dataBinding.handlerType = HandlerType.UNKNOWN
-              return
-            }
-            PROCESSED_MOVE_EVENT_TX_HANDLER.set(key, true)
-
-            aptEvent.transaction = transaction
-            if (!transaction.events?.length) {
-              // when fetch all is not true, then events is empty, we need to fill it to old format
-              transaction.events = [JSON.parse(aptEvent.rawEvent)]
-            }
-          }
-        }
-        break
-      case HandlerType.APT_CALL:
-        const aptCall = dataBinding.data?.aptCall
-        if (aptCall) {
-          if (isBeforeMoveUseRawVersion && aptCall.rawTransaction) {
-            aptCall.transaction = getParsedData(aptCall.rawTransaction)
-          }
-        }
-        break
-      case HandlerType.APT_RESOURCE:
-        const aptResource = dataBinding.data?.aptResource
-        if (aptResource) {
-          if (isBeforeMoveUseRawVersion && aptResource.rawResources) {
-            aptResource.resources = aptResource.rawResources.map((e) => JSON.parse(e))
-          }
-        }
-        break
-      case HandlerType.SUI_EVENT:
-        const suiEvent = dataBinding.data?.suiEvent
-        if (suiEvent) {
-          if (isBeforeMoveUseRawVersion && suiEvent.rawTransaction) {
-            const transaction = getParsedData(suiEvent.rawTransaction)
-
-            const key = `${transaction.digest}-${dataBinding.handlerIds[0]}`
-            if (PROCESSED_MOVE_EVENT_TX_HANDLER.has(key)) {
-              console.debug('skip binding', key)
-              dataBinding.handlerType = HandlerType.UNKNOWN
-              return
-            }
-            PROCESSED_MOVE_EVENT_TX_HANDLER.set(key, true)
-
-            suiEvent.transaction = transaction
-            if (!transaction.events?.length) {
-              // when fetch all is not true, then events is empty, we need to fill it to old format
-              transaction.events = [JSON.parse(suiEvent.rawEvent)]
-            }
-          }
-        }
-        break
-      case HandlerType.SUI_CALL:
-        const suiCall = dataBinding.data?.suiCall
-        if (suiCall) {
-          if (isBeforeMoveUseRawVersion && suiCall.rawTransaction) {
-            suiCall.transaction = getParsedData(suiCall.rawTransaction)
-          }
-        }
-        break
-      case HandlerType.SUI_OBJECT:
-        const suiObject = dataBinding.data?.suiObject
-        if (suiObject) {
-          if (isBeforeMoveUseRawVersion && (suiObject.rawSelf || suiObject.rawObjects)) {
-            if (suiObject.rawSelf) {
-              suiObject.self = JSON.parse(suiObject.rawSelf)
-            }
-            suiObject.objects = suiObject.rawObjects.map((e) => JSON.parse(e))
-          }
-        }
-        break
-      case HandlerType.SUI_OBJECT_CHANGE:
-        const suiObjectChange = dataBinding.data?.suiObjectChange
-        if (suiObjectChange) {
-          if (isBeforeMoveUseRawVersion && suiObjectChange.rawChanges) {
-            suiObjectChange.changes = suiObjectChange.rawChanges.map((e) => JSON.parse(e))
-          }
-        }
-        break
-      case HandlerType.UNKNOWN:
-        // if (dataBinding.data?.ethBlock) {
-        //   if (dataBinding.data.raw.length === 0) {
-        //     // This is actually not needed in current system, just as initla test propose, move to test only
-        //     // when this is stable
-        //     dataBinding.data.raw = new TextEncoder().encode(JSON.stringify(dataBinding.data.ethBlock.block))
-        //   }
-        // }
-        break
-      default:
-        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')
-    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()
-    }
+export class FullProcessorServiceV3Impl implements ServiceImpl<typeof ProcessorV3> {
+  constructor(readonly instance: ProcessorServiceImplV3) {}
 
-    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: any) {
-      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 {
-//   const timeA = getTimestamp(a) || new Date(0)
-//   const timeB = getTimestamp(b) || new Date(0)
-//   const timeCmp = timeA.getTime() - timeB.getTime()
-//   if (timeCmp !== 0) {
-//     return timeCmp
-//   }
-//   return getSecondary(a) - getSecondary(b)
-// }
-//
-// function getTimestamp(d: DataBinding): Date | undefined {
-//   return (
-//     d.data?.ethLog?.timestamp ||
-//     d.data?.ethTransaction?.timestamp ||
-//     (d.data?.ethBlock?.block?.timestamp ? new Date(Number(d.data.ethBlock.block.timestamp) * 1000) : undefined) ||
-//     d.data?.ethTrace?.timestamp ||
-//     (d.data?.aptCall?.transaction ? new Date(Number(d.data.aptCall.transaction.timestamp) / 1000) : undefined) ||
-//     (d.data?.aptEvent?.transaction ? new Date(Number(d.data.aptEvent.transaction.timestamp) / 1000) : undefined) ||
-//     (d.data?.aptResource?.timestampMicros ? new Date(Number(d.data.aptResource.timestampMicros) / 1000) : undefined) ||
-//     d.data?.fuelCall?.timestamp
-//   )
-// }
-//
-// function getSecondary(d: DataBinding) {
-//   return (
-//     d.data?.ethLog?.log?.logIndex ||
-//     d.data?.ethTransaction?.transaction?.transactionIndex ||
-//     d.data?.ethBlock?.block?.number ||
-//     d.data?.ethTrace?.trace?.transactionPosition
-//   )
-// }
-
-export class FullProcessorServiceV3Impl implements ProcessorV3ServiceImplementation {
-  patcher: RuntimeServicePatcher = new RuntimeServicePatcher()
-
-  constructor(readonly instance: ProcessorV3ServiceImplementation) {}
-
-  async start(request: StartRequest, context: CallContext): Promise<DeepPartial<Empty>> {
+  async start(request: StartRequest, context: HandlerContext) {
     return this.instance.start(request, context)
   }
 
-  async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<DeepPartial<ProcessConfigResponse>> {
+  async getConfig(request: ProcessConfigRequest, context: HandlerContext) {
     const config = await this.instance.getConfig(request, context)
-    this.patcher.patchConfig(config)
+    config.executionConfig = create(ExecutionConfigSchema, GLOBAL_CONFIG.execution)
     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
-    }
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
+    yield* this.instance.processBindingsStream(requests, context)
   }
 
-  async updateTemplates(request: UpdateTemplatesRequest, context: CallContext): Promise<DeepPartial<Empty>> {
+  async updateTemplates(request: UpdateTemplatesRequest, context: HandlerContext) {
     return this.instance.updateTemplates(request, context)
   }
 }