@sentio/sdk 2.59.4 → 2.60.0-rc.1

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,
@@ -249,6 +217,9 @@ export class EthPlugin extends Plugin {
 
     // 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 +228,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,
@@ -298,8 +268,8 @@ export class EthPlugin extends Plugin {
       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 +290,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 +363,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 +371,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 +396,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 +421,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 +447,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/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
       }

package/src/solana/solana-plugin.ts

@@ -1,5 +1,12 @@
 import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
-import { ContractConfig, DataBinding, HandlerType, ProcessConfigResponse, ProcessResult } from '@sentio/protos'
+import {
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  InitResponse,
+  ProcessConfigResponse,
+  ProcessResult
+} from '@sentio/protos'
 
 import { ServerError, Status } from 'nice-grpc'
 
@@ -9,9 +16,20 @@ import { Instruction as SolInstruction } from '@coral-xyz/anchor'
 export class SolanaPlugin extends Plugin {
   name: string = 'SolanaPlugin'
 
-  async configure(config: ProcessConfigResponse) {
+  async init(config: InitResponse) {
+    for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
+      const chainId = solanaProcessor.network
+      config.chainIds.push(chainId)
+    }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
     // Part 2, prepare solana constractors
     for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
+      const chainId = solanaProcessor.network
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {

package/src/stark/starknet-plugin.ts

@@ -1,9 +1,9 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
   ContractConfig,
-  Data_StarknetEvent,
   DataBinding,
   HandlerType,
+  InitResponse,
   ProcessConfigResponse,
   ProcessResult,
   StartRequest
@@ -11,25 +11,29 @@ import {
 
 import { ServerError, Status } from 'nice-grpc'
 import { TemplateInstanceState } from '../core/template.js'
+import { HandlerRegister } from '../core/handler-register.js'
 import { StarknetProcessorState } from './starknet-processor.js'
 import { hash } from 'starknet'
 
-interface Handlers {
-  callHandlers: ((trace: Data_StarknetEvent) => Promise<ProcessResult>)[]
-}
-
 export class StarknetPlugin extends Plugin {
   name: string = 'StarknetPlugin'
-  handlers: Handlers = {
-    callHandlers: []
-  }
+  handlerRegister = new HandlerRegister()
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      callHandlers: []
+  async init(config: InitResponse) {
+    for (const solanaProcessor of StarknetProcessorState.INSTANCE.getValues()) {
+      const chainId = solanaProcessor.config.chainId
+      config.chainIds.push(chainId)
     }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as any)
 
     for (const processor of StarknetProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.config.chainId
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       await processor.configure()
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
@@ -43,7 +47,7 @@ export class StarknetPlugin extends Plugin {
         endBlock: processor.config.endBlock
       })
       for (const callHandler of processor.callHandlers) {
-        const handlerId = handlers.callHandlers.push(callHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(callHandler.handler, chainId)
 
         if (callHandler.eventFilter) {
           contractConfig.starknetEventConfigs.push({
@@ -60,8 +64,6 @@ export class StarknetPlugin extends Plugin {
       // Finish up a contract
       config.contractConfigs.push(contractConfig)
     }
-
-    this.handlers = handlers
   }
 
   supportedHandlers = [HandlerType.STARKNET_EVENT]
@@ -91,12 +93,14 @@ export class StarknetPlugin extends Plugin {
     const result = binding.data?.starknetEvents?.result
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.callHandlers[handlerId](binding.data?.starknetEvents).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(result) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(binding.data?.starknetEvents)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(result) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }