@sentio/sdk 2.59.0-rc.9 → 2.59.1-rc.1

package/src/eth/base-processor.ts

@@ -29,7 +29,7 @@ import sha3 from 'js-sha3'
 import { ListStateStorage } from '@sentio/runtime'
 import { EthChainId } from '@sentio/chain'
 import { getHandlerName, proxyHandlers, proxyProcessor } from '../utils/metrics.js'
-import { ALL_ADDRESS } from '../core/index.js'
+import { ALL_ADDRESS, HandlerOptions } from '../core/index.js'
 import { parseLog, decodeTrace } from './abi-decoder/index.js'
 
 export interface AddressOrTypeEventFilter extends DeferredTopicFilter {
@@ -45,6 +45,7 @@ export class EventsHandler {
   handler: (event: Data_EthLog) => Promise<ProcessResult>
   preprocessHandler?: (event: Data_EthLog, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>
   fetchConfig: EthFetchConfig
+  partitionHandler?: (event: Data_EthLog) => Promise<string | undefined>
 }
 
 export class TraceHandler {
@@ -53,6 +54,7 @@ export class TraceHandler {
   handler: (trace: Data_EthTrace) => Promise<ProcessResult>
   preprocessHandler?: (event: Data_EthTrace, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>
   fetchConfig: EthFetchConfig
+  partitionHandler?: (trace: Data_EthTrace) => Promise<string | undefined>
 }
 
 export class BlockHandler {
@@ -62,13 +64,15 @@ export class BlockHandler {
   handler: (block: Data_EthBlock) => Promise<ProcessResult>
   preprocessHandler?: (event: Data_EthBlock, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>
   fetchConfig: EthFetchConfig
+  partitionHandler?: (block: Data_EthBlock) => Promise<string | undefined>
 }
 
 export class TransactionHandler {
-  handler: (block: Data_EthTransaction) => Promise<ProcessResult>
+  handler: (tx: Data_EthTransaction) => Promise<ProcessResult>
   handlerName: string
   preprocessHandler?: (event: Data_EthTransaction, preprocessStore: { [k: string]: any }) => Promise<PreprocessResult>
   fetchConfig: EthFetchConfig
+  partitionHandler?: (tx: Data_EthTransaction) => Promise<string | undefined>
 }
 
 class BindInternalOptions {
@@ -124,7 +128,7 @@ export class GlobalProcessor {
     handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     blockInterval = 250,
     backfillBlockInterval = 1000,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: GlobalContext,
@@ -140,7 +144,7 @@ export class GlobalProcessor {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -149,7 +153,7 @@ export class GlobalProcessor {
     handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: GlobalContext,
@@ -162,7 +166,7 @@ export class GlobalProcessor {
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
       undefined,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -175,7 +179,7 @@ export class GlobalProcessor {
     handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
-    fetchConfig: Partial<EthFetchConfig> | undefined,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: GlobalContext,
@@ -237,14 +241,24 @@ export class GlobalProcessor {
       },
       timeIntervalInMinutes: timeInterval,
       blockInterval: blockInterval,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
+      partitionHandler: async (data: Data_EthBlock): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const { block } = formatEthData(data)
+          if (!block) return undefined
+          return p(block)
+        }
+        return p
+      }
     })
     return this
   }
 
   public onTransaction(
     handler: (transaction: TransactionResponseParams, ctx: GlobalContext) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TransactionResponseParams>,
     preprocessHandler: (
       transaction: TransactionResponseParams,
       ctx: GlobalContext,
@@ -305,7 +319,16 @@ export class GlobalProcessor {
         )
         return preprocessHandler(transaction, ctx, preprocessStore)
       },
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
+      partitionHandler: async (data: Data_EthTransaction): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const { transaction } = formatEthData(data)
+          return p(transaction)
+        }
+        return p
+      }
     })
     return this
   }
@@ -313,7 +336,7 @@ export class GlobalProcessor {
   public onTrace(
     signatures: string | string[],
     handler: (trace: Trace, ctx: GlobalContext) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, Trace>,
     preprocessHandler: (
       trace: Trace,
       ctx: GlobalContext,
@@ -336,7 +359,7 @@ export class GlobalProcessor {
 
     this.traceHandlers.push({
       signatures,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
       handlerName: getHandlerName(),
       handler: async function (data: Data_EthTrace) {
         const { trace, block, transaction, transactionReceipt } = formatEthData(data)
@@ -376,6 +399,16 @@ export class GlobalProcessor {
           processor.config.baseLabels
         )
         return preprocessHandler(trace, ctx, preprocessStore)
+      },
+      partitionHandler: async (data: Data_EthTrace): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const { trace } = formatEthData(data)
+          if (!trace) return undefined
+          return p(trace)
+        }
+        return p
       }
     })
     return this
@@ -425,7 +458,7 @@ export abstract class BaseProcessor<
 
   public onEvent(
     handler: (event: TypedEvent, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TypedEvent>,
     preprocessHandler: (
       event: TypedEvent,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -441,13 +474,13 @@ export abstract class BaseProcessor<
         _filters.push(filter())
       }
     }
-    return this.onEthEvent(handler, _filters, fetchConfig, preprocessHandler)
+    return this.onEthEvent(handler, _filters, handlerOptions, preprocessHandler)
   }
 
   protected onEthEvent(
     handler: (event: TypedEvent, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     filter: DeferredTopicFilter | DeferredTopicFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TypedEvent>,
     preprocessHandler: (
       event: TypedEvent,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -468,7 +501,7 @@ export abstract class BaseProcessor<
     const processor = this
     this.eventHandlers.push({
       filters: _filters,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
       handlerName,
       handler: async function (data: Data_EthLog, preparedData?: PreparedData) {
         const { log, block, transaction, transactionReceipt } = formatEthData(data)
@@ -488,7 +521,7 @@ export abstract class BaseProcessor<
 
         let parsed: LogDescription | null = null
         try {
-          parsed = await parseLog(processor, log)
+          parsed = await getCachedParsedLog(data, processor, log)
         } catch (e) {
           // RangeError data out-of-bounds
           if (e instanceof Error) {
@@ -553,7 +586,7 @@ export abstract class BaseProcessor<
 
         let parsed: LogDescription | null = null
         try {
-          parsed = await parseLog(processor, log)
+          parsed = await getCachedParsedLog(data, processor, log)
         } catch (e) {
           // RangeError data out-of-bounds
           if (e instanceof Error) {
@@ -569,6 +602,26 @@ export abstract class BaseProcessor<
           return preprocessHandler(event, ctx, preprocessStore)
         }
         return PreprocessResult.fromPartial({})
+      },
+      partitionHandler: async (data: Data_EthLog): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const { log } = formatEthData(data)
+          if (!log) return undefined
+          let parsed: LogDescription | null = null
+          try {
+            parsed = await getCachedParsedLog(data, processor, log)
+          } catch (e) {
+            return undefined
+          }
+          if (parsed) {
+            const event: TypedEvent = { ...log, name: parsed.name, args: fixEmptyKey(parsed) }
+            return p(event)
+          }
+          return undefined
+        }
+        return p
       }
     })
     return this
@@ -578,7 +631,7 @@ export abstract class BaseProcessor<
     handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     blockInterval = 250,
     backfillBlockInterval = 1000,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -592,7 +645,7 @@ export abstract class BaseProcessor<
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -601,7 +654,7 @@ export abstract class BaseProcessor<
     handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -612,7 +665,7 @@ export abstract class BaseProcessor<
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
       undefined,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -621,7 +674,7 @@ export abstract class BaseProcessor<
     handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
-    fetchConfig: Partial<EthFetchConfig> | undefined,
+    handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>,
     preprocessHandler: (
       block: RichBlock,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -685,7 +738,17 @@ export abstract class BaseProcessor<
       },
       timeIntervalInMinutes: timeInterval,
       blockInterval: blockInterval,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
+      partitionHandler: async (data: Data_EthBlock): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const { block } = formatEthData(data)
+          if (!block) return undefined
+          return p(block)
+        }
+        return p
+      }
     })
     return this
   }
@@ -693,7 +756,7 @@ export abstract class BaseProcessor<
   protected onEthTrace(
     signatures: string | string[],
     handler: (trace: TypedCallTrace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TypedCallTrace>,
     preprocessHandler: (
       trace: TypedCallTrace,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -710,7 +773,7 @@ export abstract class BaseProcessor<
 
     this.traceHandlers.push({
       signatures,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
+      fetchConfig: EthFetchConfig.fromPartial(handlerOptions || {}),
       handlerName,
       handler: async function (data: Data_EthTrace, preparedData?: PreparedData) {
         const contractView = processor.CreateBoundContractView()
@@ -800,6 +863,35 @@ export abstract class BaseProcessor<
           processor.config.baseLabels
         )
         return preprocessHandler(typedTrace, ctx, preprocessStore)
+      },
+      partitionHandler: async (data: Data_EthTrace): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const contractView = processor.CreateBoundContractView()
+          const contractInterface = contractView.rawContract.interface
+          const { trace } = formatEthData(data)
+          if (!trace) return undefined
+          const sighash = trace.action.input?.slice(0, 10)
+          if (!sighash) return undefined
+          const fragment = contractInterface.getFunction(sighash)
+          if (!fragment) return undefined
+          const typedTrace = trace as TypedCallTrace
+          typedTrace.name = fragment.name
+          typedTrace.functionSignature = fragment.format()
+          if (trace.action.input) {
+            const traceData = '0x' + trace.action.input.slice(10)
+            try {
+              typedTrace.args = await decodeTrace(processor, fragment.inputs, traceData)
+            } catch (e) {
+              if (!trace.error) {
+                throw e
+              }
+            }
+          }
+          return p(typedTrace)
+        }
+        return p
       }
     })
     return this
@@ -807,7 +899,7 @@ export abstract class BaseProcessor<
 
   public onTrace(
     handler: (event: TypedCallTrace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TypedCallTrace>,
     preprocessHandler: (
       trace: TypedCallTrace,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -825,6 +917,25 @@ export abstract class BaseProcessor<
         sighashes.push(sighash)
       }
     }
-    return this.onEthTrace(sighashes, handler, fetchConfig, preprocessHandler)
+    return this.onEthTrace(sighashes, handler, handlerOptions, preprocessHandler)
+  }
+}
+
+// Helper function to get cached or parse log data
+async function getCachedParsedLog(data: any, processor: any, log: any): Promise<LogDescription | null> {
+  // Check if parsed log is already cached on data object
+  if ((data as any).__parsedLog !== undefined) {
+    return (data as any).__parsedLog
+  }
+
+  try {
+    const parsed = await parseLog(processor, log)
+    // Cache the parsed result on the data object
+    ;(data as any).__parsedLog = parsed
+    return parsed
+  } catch (e) {
+    // Cache the null result to avoid retrying
+    ;(data as any).__parsedLog = null
+    throw e
   }
 }