@sentio/sdk 2.59.5-rc.1 → 2.60.0-rc.10

package/src/eth/eth-plugin.ts

@@ -11,12 +11,9 @@ import { PartitionHandlerManager } from '../core/index.js'
 import {
   AccountConfig,
   ContractConfig,
-  Data_EthBlock,
-  Data_EthLog,
-  Data_EthTrace,
-  Data_EthTransaction,
   DataBinding,
   HandlerType,
+  InitResponse,
   LogFilter,
   LogHandlerConfig,
   PreparedData,
@@ -31,67 +28,40 @@ import { ServerError, Status } from 'nice-grpc'
 import { EthProcessorState } from './binds.js'
 import { AccountProcessorState } from './account-processor-state.js'
 import { ProcessorTemplateProcessorState } from './base-processor-template.js'
-import { defaultPreprocessHandler, GlobalProcessorState } from './base-processor.js'
+import { GlobalProcessorState } from './base-processor.js'
 import { validateAndNormalizeAddress } from './eth.js'
 import { EthChainId } from '@sentio/chain'
 import { EthContext } from './context.js'
 import { TemplateInstanceState } from '../core/template.js'
 import { timeOrBlockToBlockNumber } from '@sentio/sdk/utils'
-
-interface Handlers {
-  eventHandlers: ((event: Data_EthLog, preparedData?: PreparedData) => Promise<ProcessResult>)[]
-  traceHandlers: ((trace: Data_EthTrace, preparedData?: PreparedData) => Promise<ProcessResult>)[]
-  blockHandlers: ((block: Data_EthBlock, preparedData?: PreparedData) => Promise<ProcessResult>)[]
-  transactionHandlers: ((trace: Data_EthTransaction, preparedData?: PreparedData) => Promise<ProcessResult>)[]
-}
-
-interface PreprocessHandlers {
-  eventHandlers: ((event: Data_EthLog, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
-  traceHandlers: ((trace: Data_EthTrace, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
-  blockHandlers: ((block: Data_EthBlock, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>)[]
-  transactionHandlers: ((
-    txn: Data_EthTransaction,
-    preprocessStore: { [k: string]: any }
-  ) => Promise<PreprocessResult>)[]
-}
+import { HandlerRegister } from '../core/handler-register.js'
 
 export class EthPlugin extends Plugin {
   name: string = 'EthPlugin'
-  handlers: Handlers = {
-    blockHandlers: [],
-    eventHandlers: [],
-    traceHandlers: [],
-    transactionHandlers: []
-  }
-  preprocessHandlers: PreprocessHandlers = {
-    blockHandlers: [],
-    eventHandlers: [],
-    traceHandlers: [],
-    transactionHandlers: []
-  }
+  handlerRegister = new HandlerRegister()
 
   partitionManager = new PartitionHandlerManager()
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      blockHandlers: [],
-      eventHandlers: [],
-      traceHandlers: [],
-      transactionHandlers: []
-    }
-    const preprocessHandlers: PreprocessHandlers = {
-      blockHandlers: [],
-      eventHandlers: [],
-      traceHandlers: [],
-      transactionHandlers: []
+  async init(config: InitResponse): Promise<void> {
+    for (const state of [EthProcessorState.INSTANCE, GlobalProcessorState.INSTANCE, AccountProcessorState.INSTANCE]) {
+      for (const processor of state.getValues()) {
+        const chainId = processor.getChainId()
+        config.chainIds.push(chainId)
+      }
     }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as EthChainId)
 
     for (const processor of EthProcessorState.INSTANCE.getValues()) {
       // If server favor incremental update this need to change
       // Start basic config for contract
       const chainId = processor.getChainId()
       // this.processorsByChainId.set(chainId, processor)
-
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const provider = getProvider(chainId)
       const startBlock = await timeOrBlockToBlockNumber(provider, processor.config.start)
       const endBlock = processor.config.end ? await timeOrBlockToBlockNumber(provider, processor.config.end) : undefined
@@ -110,8 +80,8 @@ export class EthPlugin extends Plugin {
 
       // Step 1. Prepare all the block handlers
       for (const blockHandler of processor.blockHandlers) {
-        preprocessHandlers.blockHandlers.push(blockHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(blockHandler.handler, chainId)
+
         this.partitionManager.registerPartitionHandler(HandlerType.ETH_BLOCK, handlerId, blockHandler.partitionHandler)
         // TODO wrap the block handler into one
 
@@ -128,8 +98,8 @@ export class EthPlugin extends Plugin {
 
       // Step 2. Prepare all trace handlers
       for (const traceHandler of processor.traceHandlers) {
-        preprocessHandlers.traceHandlers.push(traceHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.traceHandlers.push(traceHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(traceHandler.handler, chainId)
+
         this.partitionManager.registerPartitionHandler(HandlerType.ETH_TRACE, handlerId, traceHandler.partitionHandler)
         for (const signature of traceHandler.signatures) {
           contractConfig.traceConfigs.push({
@@ -144,8 +114,7 @@ export class EthPlugin extends Plugin {
       // Step 3. Prepare all the event handlers
       for (const eventsHandler of processor.eventHandlers) {
         // associate id with filter
-        preprocessHandlers.eventHandlers.push(eventsHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.eventHandlers.push(eventsHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(eventsHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(HandlerType.ETH_LOG, handlerId, eventsHandler.partitionHandler)
         const logConfig: LogHandlerConfig = {
           handlerId: handlerId,
@@ -186,7 +155,9 @@ export class EthPlugin extends Plugin {
 
     for (const processor of GlobalProcessorState.INSTANCE.getValues()) {
       const chainId = processor.getChainId()
-
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const provider = getProvider(chainId)
       const startBlock = await timeOrBlockToBlockNumber(provider, processor.config.start)
       const endBlock = processor.config.end ? await timeOrBlockToBlockNumber(provider, processor.config.end) : undefined
@@ -204,8 +175,7 @@ export class EthPlugin extends Plugin {
       })
 
       for (const blockHandler of processor.blockHandlers) {
-        preprocessHandlers.blockHandlers.push(blockHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(blockHandler.handler, chainId)
         contractConfig.intervalConfigs.push({
           slot: 0,
           slotInterval: blockHandler.blockInterval,
@@ -218,8 +188,7 @@ export class EthPlugin extends Plugin {
       }
 
       for (const transactionHandler of processor.transactionHandler) {
-        preprocessHandlers.transactionHandlers.push(transactionHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.transactionHandlers.push(transactionHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(transactionHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(
           HandlerType.ETH_TRANSACTION,
           handlerId,
@@ -233,8 +202,7 @@ export class EthPlugin extends Plugin {
       }
 
       for (const traceHandler of processor.traceHandlers) {
-        preprocessHandlers.traceHandlers.push(traceHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.traceHandlers.push(traceHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(traceHandler.handler, chainId)
         for (const signature of traceHandler.signatures) {
           contractConfig.traceConfigs.push({
             signature: signature,
@@ -244,11 +212,61 @@ export class EthPlugin extends Plugin {
           })
         }
       }
+
+      for (const eventsHandler of processor.eventHandlers) {
+        // associate id with filter
+        const handlerId = this.handlerRegister.register(eventsHandler.handler, processor.getChainId())
+        const logConfig: LogHandlerConfig = {
+          handlerId: handlerId,
+          handlerName: eventsHandler.handlerName,
+          filters: [],
+          fetchConfig: eventsHandler.fetchConfig
+        }
+
+        if (!eventsHandler.filters || eventsHandler.filters.length === 0) {
+          // if no filter, then we assume all logs
+          logConfig.filters.push({
+            topics: []
+          })
+        } else {
+          for (const filter of eventsHandler.filters) {
+            const topics = await filter.getTopicFilter()
+            // if (!filter.topics) {
+            //   throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+            // }
+            let address = undefined
+            if (filter.address) {
+              address = filter.address.toString()
+            }
+            const logFilter: LogFilter = {
+              addressType: filter.addressType,
+              address: address && validateAndNormalizeAddress(address),
+              topics: []
+            }
+
+            for (const ts of topics) {
+              let hashes: string[] = []
+              if (Array.isArray(ts)) {
+                hashes = hashes.concat(ts)
+              } else if (ts) {
+                hashes.push(ts)
+              }
+              logFilter.topics.push({ hashes: hashes })
+            }
+            logConfig.filters.push(logFilter)
+          }
+        }
+        contractConfig.logConfigs.push(logConfig)
+      }
+
       config.contractConfigs.push(contractConfig)
     }
 
     // part 1.b prepare EVM account processors
     for (const processor of AccountProcessorState.INSTANCE.getValues()) {
+      if (forChainId !== undefined && forChainId !== processor.getChainId().toString()) {
+        continue
+      }
       const accountConfig = AccountConfig.fromPartial({
         address: validateAndNormalizeAddress(processor.config.address),
         chainId: processor.getChainId().toString(),
@@ -257,8 +275,7 @@ export class EthPlugin extends Plugin {
       // TODO add interval
       for (const eventsHandler of processor.eventHandlers) {
         // associate id with filter
-        preprocessHandlers.eventHandlers.push(eventsHandler.preprocessHandler ?? defaultPreprocessHandler)
-        const handlerId = handlers.eventHandlers.push(eventsHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(eventsHandler.handler, processor.getChainId())
         const logConfig: LogHandlerConfig = {
           handlerId: handlerId,
           handlerName: eventsHandler.handlerName,
@@ -268,9 +285,7 @@ export class EthPlugin extends Plugin {
 
         for (const filter of eventsHandler.filters) {
           const topics = await filter.getTopicFilter()
-          // if (!filter.topics) {
-          //   throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
-          // }
+
           let address = undefined
           if (filter.address) {
             address = filter.address.toString()
@@ -292,14 +307,15 @@ export class EthPlugin extends Plugin {
           }
           logConfig.filters.push(logFilter)
         }
+
         accountConfig.logConfigs.push(logConfig)
       }
 
       config.accountConfigs.push(accountConfig)
     }
 
-    this.handlers = handlers
-    this.preprocessHandlers = preprocessHandlers
+    // this.handlers = handlers
+    // this.preprocessHandlers = preprocessHandlers
   }
 
   supportedHandlers = [HandlerType.ETH_LOG, HandlerType.ETH_BLOCK, HandlerType.ETH_TRACE, HandlerType.ETH_TRANSACTION]
@@ -320,21 +336,6 @@ export class EthPlugin extends Plugin {
     }
   }
 
-  preprocessBinding(request: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
-    switch (request.handlerType) {
-      case HandlerType.ETH_LOG:
-        return this.preprocessLog(request, preprocessStore)
-      case HandlerType.ETH_TRACE:
-        return this.preprocessTrace(request, preprocessStore)
-      case HandlerType.ETH_BLOCK:
-        return this.preprocessBlock(request, preprocessStore)
-      case HandlerType.ETH_TRANSACTION:
-        return this.preprocessTransaction(request, preprocessStore)
-      default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
-    }
-  }
-
   async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
     let data: any
     switch (request.handlerType) {
@@ -408,87 +409,6 @@ export class EthPlugin extends Plugin {
     return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length
   }
 
-  async preprocessLog(request: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
-    if (!request.data?.ethLog?.log) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
-    }
-    const ethLog = request.data.ethLog
-
-    const promises: Promise<PreprocessResult>[] = []
-    for (const handlerId of request.handlerIds) {
-      const handler = this.preprocessHandlers.eventHandlers[handlerId]
-      const promise = handler(ethLog, preprocessStore).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing log: ' + JSON.stringify(ethLog.log) + '\n' + errorString(e)
-        )
-      })
-      promises.push(promise)
-    }
-    return mergePreprocessResults(await Promise.all(promises))
-  }
-
-  async preprocessTrace(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
-    if (!binding.data?.ethTrace?.trace) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be null")
-    }
-    const ethTrace = binding.data.ethTrace
-
-    const promises: Promise<PreprocessResult>[] = []
-
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.traceHandlers[handlerId](ethTrace, preprocessStore).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing trace: ' + JSON.stringify(ethTrace.trace) + '\n' + errorString(e)
-        )
-      })
-      promises.push(promise)
-    }
-    return mergePreprocessResults(await Promise.all(promises))
-  }
-
-  async preprocessBlock(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
-    if (!binding.data?.ethBlock?.block) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
-    }
-    const ethBlock = binding.data.ethBlock
-
-    const promises: Promise<PreprocessResult>[] = []
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.blockHandlers[handlerId](ethBlock, preprocessStore).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing block: ' + ethBlock.block?.number + '\n' + errorString(e)
-        )
-      })
-      promises.push(promise)
-    }
-    return mergePreprocessResults(await Promise.all(promises))
-  }
-
-  async preprocessTransaction(binding: DataBinding, preprocessStore: { [k: string]: any }): Promise<PreprocessResult> {
-    if (!binding.data?.ethTransaction?.transaction) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
-    }
-    const ethTransaction = binding.data.ethTransaction
-
-    const promises: Promise<PreprocessResult>[] = []
-
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.preprocessHandlers.transactionHandlers[handlerId](ethTransaction, preprocessStore).catch(
-        (e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)
-          )
-        }
-      )
-      promises.push(promise)
-    }
-    return mergePreprocessResults(await Promise.all(promises))
-  }
-
   async processLog(request: DataBinding, preparedData: PreparedData | undefined): Promise<ProcessResult> {
     if (!request.data?.ethLog?.log) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
@@ -497,8 +417,8 @@ export class EthPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of request.handlerIds) {
-      const handler = this.handlers.eventHandlers[handlerId]
-      const promise = handler(ethLog, preparedData).catch((e) => {
+      const handler = this.handlerRegister.getHandlerById(handlerId)
+      const promise = handler(ethLog, preparedData).catch((e: any) => {
         console.error('error processing log: ', e)
         throw new ServerError(
           Status.INTERNAL,
@@ -522,13 +442,15 @@ export class EthPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.traceHandlers[handlerId](ethTrace, preparedData).catch((e) => {
-        console.error('error processing trace: ', e)
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing trace: ' + JSON.stringify(ethTrace.trace) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(ethTrace, preparedData)
+        .catch((e: any) => {
+          console.error('error processing trace: ', e)
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing trace: ' + JSON.stringify(ethTrace.trace) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -545,13 +467,15 @@ export class EthPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.blockHandlers[handlerId](ethBlock, preparedData).catch((e) => {
-        console.error('error processing block: ', e)
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing block: ' + ethBlock.block?.number + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(ethBlock, preparedData)
+        .catch((e: any) => {
+          console.error('error processing block: ', e)
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing block: ' + ethBlock.block?.number + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -569,12 +493,14 @@ export class EthPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.transactionHandlers[handlerId](ethTransaction, preparedData).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(ethTransaction, preparedData)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(ethTransaction.transaction) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }

package/src/eth/eth.ts

@@ -150,34 +150,39 @@ export function formatEthData(data: {
     return data.__formattedEthData
   }
 
-  const log = data.log ? formatLog(data.log) : undefined
-  if (data.block && !data.block.transactions) {
-    data.block.transactions = []
-  }
-  const block = data.block ? formatRichBlock(data.block) : undefined
-  const trace = data.trace ? (data.trace as Trace) : undefined
-  let transaction = undefined
-  if (data.transaction) {
-    if (!data.transaction.v) {
-      data.transaction.v = '0x1c'
-      data.transaction.r = '0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0'
-      data.transaction.s = '0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a'
+  try {
+    const log = data.log ? formatLog(data.log) : undefined
+    if (data.block && !data.block.transactions) {
+      data.block.transactions = []
+    }
+    const block = data.block ? formatRichBlock(data.block) : undefined
+    const trace = data.trace ? (data.trace as Trace) : undefined
+    let transaction = undefined
+    if (data.transaction) {
+      if (!data.transaction.v) {
+        data.transaction.v = '0x1c'
+        data.transaction.r = '0x88ff6cf0fefd94db46111149ae4bfc179e9b94721fffd821d38d16464b3f71d0'
+        data.transaction.s = '0x45e0aff800961cfce805daef7016b9b675c137a6a41a548f7b60a3484c06a33a'
+      }
+      transaction = formatTransactionResponse(data.transaction)
+    }
+    const transactionReceipt = data.transactionReceipt ? formatTransactionReceipt(data.transactionReceipt) : undefined
+
+    const result = {
+      log,
+      block,
+      trace,
+      transaction,
+      transactionReceipt
     }
-    transaction = formatTransactionResponse(data.transaction)
-  }
-  const transactionReceipt = data.transactionReceipt ? formatTransactionReceipt(data.transactionReceipt) : undefined
-
-  const result = {
-    log,
-    block,
-    trace,
-    transaction,
-    transactionReceipt
-  }
 
-  // Cache the result on the input data object
-  data.__formattedEthData = result
-  return result
+    // Cache the result on the input data object
+    data.__formattedEthData = result
+    return result
+  } catch (e) {
+    console.error('Error formatting eth data', e)
+    return data
+  }
 }
 
 export function formatRichBlock(block: RichBlock): RichBlock {

package/src/fuel/fuel-plugin.ts

@@ -1,12 +1,11 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import { PartitionHandlerManager } from '../core/index.js'
+import { HandlerRegister } from '../core/handler-register.js'
 import {
   ContractConfig,
-  Data_FuelBlock,
-  Data_FuelReceipt,
-  Data_FuelTransaction,
   DataBinding,
   HandlerType,
+  InitResponse,
   ProcessConfigResponse,
   ProcessResult,
   ProcessStreamResponse_Partitions,
@@ -20,30 +19,26 @@ import { FuelProcessorState } from './types.js'
 import { FuelProcessor } from './fuel-processor.js'
 import { FuelGlobalProcessor } from './global-processor.js'
 
-interface Handlers {
-  transactionHandlers: ((trace: Data_FuelTransaction) => Promise<ProcessResult>)[]
-  blockHandlers: ((block: Data_FuelBlock) => Promise<ProcessResult>)[]
-  receiptHandlers: ((log: Data_FuelReceipt) => Promise<ProcessResult>)[]
-}
-
 export class FuelPlugin extends Plugin {
   name: string = 'FuelPlugin'
-  handlers: Handlers = {
-    transactionHandlers: [],
-    blockHandlers: [],
-    receiptHandlers: []
-  }
-
+  handlerRegister = new HandlerRegister()
   partitionManager = new PartitionHandlerManager()
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      transactionHandlers: [],
-      blockHandlers: [],
-      receiptHandlers: []
+  async init(config: InitResponse) {
+    for (const fuelProcessor of FuelProcessorState.INSTANCE.getValues()) {
+      const chainId = fuelProcessor.config.chainId
+      config.chainIds.push(chainId)
     }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as any)
 
     for (const processor of FuelProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.config.chainId
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const processorConfig = processor.config
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
@@ -57,7 +52,7 @@ export class FuelPlugin extends Plugin {
         endBlock: processorConfig.endBlock
       })
       for (const txHandler of processor.txHandlers) {
-        const handlerId = handlers.transactionHandlers.push(txHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(txHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(
           HandlerType.FUEL_TRANSACTION,
           handlerId,
@@ -90,7 +85,7 @@ export class FuelPlugin extends Plugin {
       }
 
       for (const receiptHandler of processor.receiptHandlers ?? []) {
-        const handlerId = handlers.receiptHandlers.push(receiptHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(receiptHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(
           HandlerType.FUEL_RECEIPT,
           handlerId,
@@ -107,7 +102,7 @@ export class FuelPlugin extends Plugin {
       }
 
       for (const blockHandler of processor.blockHandlers) {
-        const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(blockHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(HandlerType.FUEL_BLOCK, handlerId, blockHandler.partitionHandler)
         contractConfig.intervalConfigs.push({
           slot: 0,
@@ -123,8 +118,6 @@ export class FuelPlugin extends Plugin {
 
       config.contractConfigs.push(contractConfig)
     }
-
-    this.handlers = handlers
   }
 
   supportedHandlers = [
@@ -212,12 +205,14 @@ export class FuelPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.receiptHandlers[handlerId](receipt).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(receipt) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(receipt)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(receipt) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -235,12 +230,14 @@ export class FuelPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.transactionHandlers[handlerId](fuelTransaction).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(fuelTransaction.transaction) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(fuelTransaction)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(fuelTransaction.transaction) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -257,13 +254,15 @@ export class FuelPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.blockHandlers[handlerId](ethBlock).catch((e) => {
-        console.error('error processing block: ', e)
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing block: ' + ethBlock.block?.height + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(ethBlock)
+        .catch((e: any) => {
+          console.error('error processing block: ', e)
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing block: ' + ethBlock.block?.height + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }