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

package/src/btc/btc-plugin.ts

@@ -1,10 +1,9 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
   ContractConfig,
-  Data_BTCBlock,
-  Data_BTCTransaction,
   DataBinding,
   HandlerType,
+  InitResponse,
   ProcessConfigResponse,
   ProcessResult,
   ProcessStreamResponse_Partitions,
@@ -13,31 +12,31 @@ import {
 
 import { ServerError, Status } from 'nice-grpc'
 import { PartitionHandlerManager } from '../core/index.js'
+import { HandlerRegister } from '../core/handler-register.js'
 import { TemplateInstanceState } from '../core/template.js'
 import { BTCProcessorState } from './btc-processor.js'
 import { filters2Proto, TransactionFilter } from './filter.js'
 
-interface Handlers {
-  txHandlers: ((trace: Data_BTCTransaction) => Promise<ProcessResult>)[]
-  blockHandlers: ((trace: Data_BTCBlock) => Promise<ProcessResult>)[]
-}
-
 export class BTCPlugin extends Plugin {
   name: string = 'BTCPlugin'
-  handlers: Handlers = {
-    txHandlers: [],
-    blockHandlers: []
-  }
-
+  handlerRegister = new HandlerRegister()
   partitionManager = new PartitionHandlerManager()
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      txHandlers: [],
-      blockHandlers: []
+  async init(config: InitResponse) {
+    for (const aptosProcessor of BTCProcessorState.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 BTCProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.config.chainId
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {
@@ -50,7 +49,7 @@ export class BTCPlugin extends Plugin {
         endBlock: processor.config.endBlock
       })
       for (const callHandler of processor.callHandlers) {
-        const handlerId = handlers.txHandlers.push(callHandler.handler) - 1
+        const handlerId = this.handlerRegister.register(callHandler.handler, chainId)
         this.partitionManager.registerPartitionHandler(
           HandlerType.BTC_TRANSACTION,
           handlerId,
@@ -78,7 +77,7 @@ export class BTCPlugin 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.BTC_BLOCK, handlerId, blockHandler.partitionHandler)
         contractConfig.intervalConfigs.push({
           slot: 0,
@@ -100,8 +99,6 @@ export class BTCPlugin extends Plugin {
       // Finish up a contract
       config.contractConfigs.push(contractConfig)
     }
-
-    this.handlers = handlers
   }
 
   supportedHandlers = [HandlerType.BTC_TRANSACTION, HandlerType.BTC_BLOCK]
@@ -161,12 +158,14 @@ export class BTCPlugin extends Plugin {
     const result = binding.data?.btcTransaction
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.txHandlers[handlerId](binding.data?.btcTransaction).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing transaction: ' + JSON.stringify(result) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(binding.data?.btcTransaction)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing transaction: ' + JSON.stringify(result) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -184,12 +183,14 @@ export class BTCPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of request.handlerIds) {
-      const promise = this.handlers.blockHandlers[handlerId](block).catch((e) => {
-        throw new ServerError(
-          Status.INTERNAL,
-          'error processing block: ' + JSON.stringify(block) + '\n' + errorString(e)
-        )
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(block)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing block: ' + JSON.stringify(block) + '\n' + errorString(e)
+          )
+        })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }

package/src/core/core-plugin.ts

@@ -1,5 +1,5 @@
 import { Plugin, PluginManager } from '@sentio/runtime'
-import { ProcessConfigResponse } from '@sentio/protos'
+import { InitResponse, ProcessConfigResponse } from '@sentio/protos'
 
 import { MetricState, MetricStateNew } from './meter.js'
 import { ExporterState } from './exporter.js'
@@ -14,6 +14,14 @@ export class CorePlugin extends Plugin {
     // This syntax is to copy values instead of using references
     config.templateInstances = [...TemplateInstanceState.INSTANCE.getValues()]
 
+    this.initStartupConfig(config)
+  }
+
+  async init(config: InitResponse): Promise<void> {
+    this.initStartupConfig(config)
+  }
+
+  initStartupConfig(config: InitResponse | ProcessConfigResponse): void {
     for (const metric of MetricState.INSTANCE.getValues()) {
       config.metricConfigs.push({
         ...metric.config
@@ -24,7 +32,6 @@ export class CorePlugin extends Plugin {
         ...metric.config
       })
     }
-
     for (const event of EventLoggerState.INSTANCE.getValues()) {
       config.eventLogConfigs.push({
         ...event.config
@@ -45,6 +52,13 @@ export class CorePlugin extends Plugin {
           .join('\n\n')
       }
     }
+    if (DatabaseSchemaState.INSTANCE.getValues().length > 0) {
+      config.dbSchema = {
+        gqlSchema: DatabaseSchemaState.INSTANCE.getValues()
+          .map((e) => e.source)
+          .join('\n\n')
+      }
+    }
   }
 }
 

package/src/core/handler-options.ts

@@ -15,6 +15,13 @@ export type HandlerOptions<F, D> = Partial<F> & {
    * Can be a static string or a function that computes the key from the data.
    */
   partitionKey?: string | PartitionHandler<D>
+
+  /**
+   * Optional whether to skip decoding
+   * By default the processor will do decoding (e.g. replace string number to bigint, byte array to base64, etc),
+   * however in some case you might skip the decoding (meaning no data_decoded field) and only access the raw data field
+   */
+  skipDecoding?: boolean
 }
 
 /**

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/base-processor.ts

@@ -1,4 +1,4 @@
-import { BaseContract, DeferredTopicFilter, LogDescription, TransactionResponseParams } from 'ethers'
+import { BaseContract, DeferredTopicFilter, LogDescription, LogParams, TransactionResponseParams } from 'ethers'
 
 import { BoundContractView, ContractContext, ContractView, GlobalContext } from './context.js'
 import {
@@ -93,6 +93,7 @@ export class GlobalProcessor {
   blockHandlers: BlockHandler[] = proxyHandlers([])
   transactionHandler: TransactionHandler[] = proxyHandlers([])
   traceHandlers: TraceHandler[] = proxyHandlers([])
+  eventHandlers: EventsHandler[] = []
 
   static bind(config: Omit<BindOptions, 'address'>): GlobalProcessor {
     const processor = new GlobalProcessor(config)
@@ -333,6 +334,47 @@ export class GlobalProcessor {
     return this
   }
 
+  public onEvent(
+    handler: (rawLog: LogParams, ctx: GlobalContext) => PromiseOrVoid,
+    filter?: AddressOrTypeEventFilter | AddressOrTypeEventFilter[],
+    handlerOptions?: HandlerOptions<EthFetchConfig, TypedEvent>
+  ): this {
+    let _filters: AddressOrTypeEventFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else if (filter) {
+      _filters.push(filter)
+    }
+    const chainId = this.getChainId()
+
+    this.eventHandlers.push({
+      filters: _filters,
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
+      handlerName: getHandlerName(),
+      handler: async function (data) {
+        const { log, block, transaction, transactionReceipt } = formatEthData(data)
+        if (!log) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+        }
+        const ctx = new GlobalContext(
+          chainId,
+          transaction?.to || '*',
+          data.timestamp,
+          block,
+          log,
+          undefined,
+          transaction,
+          transactionReceipt
+        )
+
+        await handler(log, ctx)
+        return ctx.stopAndGetResult()
+      }
+    })
+    return this
+  }
+
   public onTrace(
     signatures: string | string[],
     handler: (trace: Trace, ctx: GlobalContext) => PromiseOrVoid,