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

package/src/core/handler-register.ts

@@ -0,0 +1,79 @@
+import { ServerError, Status } from 'nice-grpc'
+import { ChainId } from '@sentio/chain'
+import { ProcessResult } from '@sentio/protos'
+
+export type HandlerFunction = (...args: any[]) => Promise<ProcessResult>
+
+interface HandlerEntry {
+  id: number
+  handler: HandlerFunction
+  chainId: ChainId | string
+}
+
+const chainToNumber: Map<string, number> = new Map()
+const numberToChain: Map<number, string> = new Map()
+
+for (const chainId of Object.values(ChainId)) {
+  const num = chainToNumber.size + 1
+  chainToNumber.set(chainId, num)
+  numberToChain.set(num, chainId)
+}
+
+const MAX_HANDLER_PER_CHAIN = 1000000 // Maximum handlers per chain
+
+export class HandlerRegister {
+  private handlerByChain: Map<number, HandlerEntry[]> = new Map()
+  private handlers: Map<number, HandlerEntry> = new Map()
+
+  /**
+   * Register a handler function with chain ID and handle type
+   * @returns handler ID
+   */
+  register(handler: HandlerFunction, chainId: ChainId | string): number {
+    const chainNum = chainToNumber.get(chainId) || 0
+    const entries = this.handlerByChain.get(chainNum) || []
+
+    const len = entries.length
+    const id = chainNum * MAX_HANDLER_PER_CHAIN + len + 1 // Use the first 32 bits for chain ID, next bits for index
+
+    const entry: HandlerEntry = {
+      id,
+      handler,
+      chainId
+    }
+    entries.push(entry)
+    this.handlerByChain.set(chainNum, entries)
+    this.handlers.set(id, entry)
+
+    return id
+  }
+
+  /**
+   * Get handler function by ID
+   */
+  getHandlerById(id: number): HandlerFunction {
+    const entry = this.handlers.get(id)
+    if (!entry) {
+      throw new ServerError(Status.INTERNAL, `Handler with ID ${id} not found.`)
+    }
+    return entry.handler
+  }
+
+  clear(chainId?: ChainId): void {
+    if (chainId) {
+      const chainNum = chainToNumber.get(chainId)
+      if (chainNum !== undefined) {
+        const chainHandlers = this.handlerByChain.get(chainNum)
+        if (chainHandlers) {
+          for (const entry of chainHandlers) {
+            this.handlers.delete(entry.id)
+          }
+        }
+        this.handlerByChain.delete(chainNum)
+      }
+    } else {
+      this.handlerByChain.clear()
+      this.handlers.clear()
+    }
+  }
+}

package/src/cosmos/cosmos-plugin.ts

@@ -1,33 +1,37 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
   ContractConfig,
-  Data_CosmosCall,
   DataBinding,
   HandlerType,
+  InitResponse,
   ProcessConfigResponse,
   ProcessResult,
   StartRequest
 } from '@sentio/protos'
 import { ServerError, Status } from 'nice-grpc'
 import { TemplateInstanceState } from '../core/template.js'
+import { HandlerRegister } from '../core/handler-register.js'
 import { CosmosProcessorState } from './types.js'
 
-interface Handlers {
-  callHandlers: ((trace: Data_CosmosCall) => Promise<ProcessResult>)[]
-}
-
 export class CosmosPlugin extends Plugin {
   name: string = 'CosmosPlugin'
-  handlers: Handlers = {
-    callHandlers: []
-  }
+  handlerRegister = new HandlerRegister()
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      callHandlers: []
+  async init(config: InitResponse) {
+    for (const aptosProcessor of CosmosProcessorState.INSTANCE.getValues()) {
+      const chainId = aptosProcessor.config.chainId
+      config.chainIds.push(chainId)
     }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as any)
 
     for (const processor of CosmosProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.config.chainId
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {
@@ -41,7 +45,7 @@ export class CosmosPlugin extends Plugin {
       })
 
       for (const callHandler of processor.callHandlers) {
-        const handlerId = handlers.callHandlers.push(callHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(callHandler.handler, chainId)
 
         contractConfig.cosmosLogConfigs.push({
           handlerId,
@@ -53,8 +57,6 @@ export class CosmosPlugin extends Plugin {
       // Finish up a contract
       config.contractConfigs.push(contractConfig)
     }
-
-    this.handlers = handlers
   }
 
   supportedHandlers = [HandlerType.COSMOS_CALL]
@@ -83,12 +85,14 @@ export class CosmosPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.callHandlers[handlerId](call).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(call.transaction) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(call)
+        .catch((e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(call.transaction) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }

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
       }