@sentio/sdk 2.59.0-rc.3 → 2.59.0-rc.31

package/src/eth/base-processor.ts

@@ -3,17 +3,13 @@ import { BaseContract, DeferredTopicFilter, LogDescription, TransactionResponseP
 import { BoundContractView, ContractContext, ContractView, GlobalContext } from './context.js'
 import {
   AddressType,
-  Data_EthBlock,
-  Data_EthLog,
-  Data_EthTrace,
-  Data_EthTransaction,
   EthFetchConfig,
   HandleInterval,
   PreparedData,
   PreprocessResult,
   ProcessResult
 } from '@sentio/protos'
-import { BindOptions } from './bind-options.js'
+import { BindOptions, TimeOrBlock } from './bind-options.js'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ServerError, Status } from 'nice-grpc'
 import {
@@ -27,9 +23,10 @@ import {
 } from './eth.js'
 import sha3 from 'js-sha3'
 import { ListStateStorage } from '@sentio/runtime'
+import { type Data_EthLog, type Data_EthTrace, type Data_EthTransaction, type Data_EthBlock } 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 +42,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 +51,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,21 +61,23 @@ 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 {
   address: string
   network: EthChainId
   name: string
-  startBlock: bigint
-  endBlock?: bigint
+  start: TimeOrBlock
+  end?: TimeOrBlock
   baseLabels?: { [key: string]: string }
 }
 
@@ -101,13 +102,20 @@ export class GlobalProcessor {
       address: ALL_ADDRESS,
       name: config.name || 'Global',
       network: config.network || EthChainId.ETHEREUM,
-      startBlock: 0n
+      start: config.start || {
+        block: 0
+      },
+      end: config.end
     }
     if (config.startBlock) {
-      this.config.startBlock = BigInt(config.startBlock)
+      this.config.start = {
+        block: config.startBlock
+      }
     }
     if (config.endBlock) {
-      this.config.endBlock = BigInt(config.endBlock)
+      this.config.end = {
+        block: config.endBlock
+      }
     }
 
     return proxyProcessor(this)
@@ -117,7 +125,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,
@@ -133,7 +141,7 @@ export class GlobalProcessor {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -142,7 +150,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,
@@ -155,7 +163,7 @@ export class GlobalProcessor {
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
       undefined,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -168,7 +176,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,
@@ -230,14 +238,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,
@@ -298,7 +316,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
   }
@@ -306,7 +333,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,
@@ -329,7 +356,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)
@@ -369,6 +396,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
@@ -390,14 +427,21 @@ export abstract class BaseProcessor<
       address: validateAndNormalizeAddress(config.address),
       name: config.name || '',
       network: config.network || EthChainId.ETHEREUM,
-      startBlock: 0n,
+      start: config.start || {
+        block: 0
+      },
+      end: config.end,
       baseLabels: config.baseLabels
     }
     if (config.startBlock) {
-      this.config.startBlock = BigInt(config.startBlock)
+      this.config.start = {
+        block: config.startBlock
+      }
     }
     if (config.endBlock) {
-      this.config.endBlock = BigInt(config.endBlock)
+      this.config.end = {
+        block: config.endBlock
+      }
     }
 
     return proxyProcessor(this)
@@ -411,7 +455,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>,
@@ -427,13 +471,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>,
@@ -454,7 +498,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)
@@ -474,7 +518,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) {
@@ -539,7 +583,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) {
@@ -555,6 +599,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
@@ -564,7 +628,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>,
@@ -578,7 +642,7 @@ export abstract class BaseProcessor<
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -587,7 +651,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>,
@@ -598,7 +662,7 @@ export abstract class BaseProcessor<
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
       undefined,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler
     )
   }
@@ -607,7 +671,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>,
@@ -671,7 +735,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
   }
@@ -679,7 +753,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>,
@@ -696,7 +770,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()
@@ -786,6 +860,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
@@ -793,7 +896,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>,
@@ -811,6 +914,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
   }
 }

package/src/eth/bind-options.ts

@@ -7,11 +7,18 @@ export class BindOptions {
   network?: EthChainId = EthChainId.ETHEREUM
   // Optional, override default contract name
   name?: string
+  start?: TimeOrBlock
+  end?: TimeOrBlock
   startBlock?: bigint | number
   endBlock?: bigint | number
   baseLabels?: { [key: string]: string }
 }
 
+export interface TimeOrBlock {
+  block?: bigint | number
+  time?: Date
+}
+
 export function getOptionsSignature(opts: BindOptions): string {
   const sig = [opts.address]
   if (opts.network) {