@sentio/sdk 2.39.7-rc.8 → 2.40.0-rc.1

package/src/eth/account-processor.ts

@@ -1,5 +1,5 @@
 import { ERC20__factory, ERC721__factory } from './builtin/internal/index.js'
-import { AddressType, EthFetchConfig, ProcessResult } from '@sentio/protos'
+import { AddressType, EthFetchConfig, PreprocessResult, ProcessResult } from '@sentio/protos'
 
 import { PartiallyOptional, PromiseOrVoid } from '../core/index.js'
 
@@ -7,7 +7,7 @@ import { AccountBindOptions } from './bind-options.js'
 import { ERC20Processor, TransferEvent as ERC20TransferEvent } from './builtin/erc20.js'
 import { ERC721Processor, TransferEvent as ERC721TransferEvent } from './builtin/erc721.js'
 import { AccountContext } from './context.js'
-import { AddressOrTypeEventFilter, EventsHandler } from './base-processor.js'
+import { AddressOrTypeEventFilter, defaultPreprocessHandler, EventsHandler } from './base-processor.js'
 import { Block } from 'ethers'
 import { AccountProcessorState } from './account-processor-state.js'
 import { fixEmptyKey, formatEthData, TypedEvent } from './eth.js'
@@ -30,7 +30,7 @@ export class AccountProcessor {
   protected constructor(config: PartiallyOptional<AccountBindOptions, 'network'>) {
     this.config = {
       ...config,
-      network: config.network || EthChainId.ETHEREUM,
+      network: config.network || EthChainId.ETHEREUM
     }
   }
 
@@ -43,17 +43,23 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC20TransferIn(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     tokensAddresses: string[] = [],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC20TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC20(
       handler,
       tokensAddresses,
       (address: string) => ERC721Processor.filters.Transfer(null, this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -62,17 +68,23 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC20TransferOut(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     tokensAddresses: string[] = [],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC20TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC20(
       handler,
       tokensAddresses,
       (address: string) => ERC20Processor.filters.Transfer(this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -81,18 +93,24 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC20Minted(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     tokensAddresses: string[] = [],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC20TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC20(
       handler,
       tokensAddresses,
       (address: string) =>
         ERC20Processor.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -100,9 +118,13 @@ export class AccountProcessor {
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     tokensAddresses: string[] = [],
     defaultFilter: (address: string) => AddressOrTypeEventFilter,
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC20TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
-    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20, fetchConfig)
+    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20, fetchConfig, preprocessHandler)
   }
 
   /**
@@ -110,17 +132,23 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC721TransferIn(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     collections: string[],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC721TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC721(
       handler,
       collections,
       (address: string) => ERC721Processor.filters.Transfer(null, this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -129,17 +157,23 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC721TransferOut(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     collections: string[],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC721TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC721(
       handler,
       collections,
       (address: string) => ERC721Processor.filters.Transfer(this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -148,18 +182,24 @@ export class AccountProcessor {
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
    * @param fetchConfig
+   * @param preprocessHandler
    */
   onERC721Minted(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     collections: string[] = [],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC721TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onERC721(
       handler,
       collections,
       (address: string) =>
         ERC721Processor.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -167,9 +207,13 @@ export class AccountProcessor {
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     collections: string[],
     defaultFilter: (address: string) => AddressOrTypeEventFilter,
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: ERC721TransferEvent,
+      ctx: AccountContext
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
-    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721, fetchConfig)
+    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721, fetchConfig, preprocessHandler)
   }
 
   private onERC(
@@ -177,7 +221,8 @@ export class AccountProcessor {
     contractAddresses: string[],
     defaultFilter: (address: string) => AddressOrTypeEventFilter,
     addressType: AddressType,
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (event: any, ctx: AccountContext) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     const filters = []
     for (const token of contractAddresses) {
@@ -191,13 +236,14 @@ export class AccountProcessor {
       filter.addressType = addressType
       filters.push(filter)
     }
-    return this.onEvent(handler, filters, fetchConfig)
+    return this.onEvent(handler, filters, fetchConfig, preprocessHandler)
   }
 
   protected onEvent(
     handler: (event: TypedEvent, ctx: AccountContext) => PromiseOrVoid,
     filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (event: TypedEvent, ctx: AccountContext) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     const chainId = this.getChainId()
 
@@ -256,6 +302,31 @@ export class AccountProcessor {
         }
         return ProcessResult.fromPartial({})
       },
+      preprocessHandler: async function (data) {
+        const { log, block, transaction, transactionReceipt } = formatEthData(data)
+        if (!log) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+        }
+        // const log = data.log as { topics: Array<string>; data: string }
+        const ctx = new AccountContext(
+          chainId,
+          config.address,
+          data.timestamp,
+          data.block as Block,
+          log,
+          undefined,
+          transaction,
+          transactionReceipt
+        )
+
+        const logParam = log as any as { topics: Array<string>; data: string }
+        const parsed = ERC20_INTERFACE.parseLog(logParam)
+        if (parsed) {
+          const event: TypedEvent = { ...log, name: parsed.name, args: fixEmptyKey(parsed) }
+          return preprocessHandler(event, ctx)
+        }
+        return PreprocessResult.fromPartial({})
+      }
     })
 
     return this

package/src/eth/base-processor-template.ts

@@ -1,8 +1,8 @@
 import { BoundContractView, ContractContext, ContractView, EthContext } from './context.js'
 import { BaseContract } from 'ethers'
-import { BaseProcessor } from './base-processor.js'
+import { BaseProcessor, defaultPreprocessHandler } from './base-processor.js'
 import { BindOptions, getOptionsSignature } from './bind-options.js'
-import { EthFetchConfig, HandleInterval, TemplateInstance } from '@sentio/protos'
+import { EthFetchConfig, HandleInterval, TemplateInstance, PreprocessResult } from '@sentio/protos'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ListStateStorage } from '@sentio/runtime'
 import { BlockParams } from 'ethers/providers'
@@ -24,6 +24,10 @@ export abstract class BaseProcessorTemplate<
   binds = new Set<string>()
   blockHandlers: {
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    preprocessHandler: (
+      block: BlockParams,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult>
     blockInterval?: HandleInterval
     timeIntervalInMinutes?: HandleInterval
     fetchConfig?: EthFetchConfig
@@ -31,10 +35,18 @@ export abstract class BaseProcessorTemplate<
   traceHandlers: {
     signature: string
     handler: (trace: TypedCallTrace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    preprocessHandler: (
+      trace: TypedCallTrace,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult>
     fetchConfig?: EthFetchConfig
   }[] = []
   eventHandlers: {
     handler: (event: TypedEvent, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    preprocessHandler: (
+      event: TypedEvent,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult>
     filter: DeferredTopicFilter | DeferredTopicFilter[]
     fetchConfig?: EthFetchConfig
   }[] = []
@@ -64,14 +76,14 @@ export abstract class BaseProcessorTemplate<
 
     for (const eh of this.eventHandlers) {
       // @ts-ignore friendly
-      processor.onEthEvent(eh.handler, eh.filter, eh.fetchConfig)
+      processor.onEthEvent(eh.handler, eh.filter, eh.fetchConfig, eh.preprocessHandler)
     }
     for (const th of this.traceHandlers) {
       // @ts-ignore friendly
-      processor.onEthTrace(th.signature, th.handler, th.fetchConfig)
+      processor.onEthTrace(th.signature, th.handler, th.fetchConfig, th.preprocessHandler)
     }
     for (const bh of this.blockHandlers) {
-      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.fetchConfig)
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.fetchConfig, bh.preprocessHandler)
     }
 
     const instance: TemplateInstance = {
@@ -97,10 +109,15 @@ export abstract class BaseProcessorTemplate<
   protected onEthEvent(
     handler: (event: TypedEvent, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     filter: DeferredTopicFilter | DeferredTopicFilter[],
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      event: TypedEvent,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     this.eventHandlers.push({
       handler: handler,
+      preprocessHandler,
       filter: filter,
       fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
     })
@@ -111,7 +128,11 @@ export abstract class BaseProcessorTemplate<
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     blockInterval = 1000,
     backfillBlockInterval = 4000,
-    fetchConfig?: EthFetchConfig
+    fetchConfig?: EthFetchConfig,
+    preprocessHandler: (
+      block: BlockParams,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onInterval(
       handler,
@@ -120,7 +141,8 @@ export abstract class BaseProcessorTemplate<
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
       },
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -128,13 +150,18 @@ export abstract class BaseProcessorTemplate<
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillBlockInterval = 240,
-    fetchConfig?: EthFetchConfig
+    fetchConfig?: EthFetchConfig,
+    preprocessHandler: (
+      block: BlockParams,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillBlockInterval },
       undefined,
-      fetchConfig
+      fetchConfig,
+      preprocessHandler
     )
   }
 
@@ -142,18 +169,37 @@ export abstract class BaseProcessorTemplate<
     handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
-    fetchConfig: EthFetchConfig | undefined
+    fetchConfig: EthFetchConfig | undefined,
+    preprocessHandler: (
+      block: BlockParams,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
-    this.blockHandlers.push({ handler, timeIntervalInMinutes: timeInterval, blockInterval, fetchConfig })
+    this.blockHandlers.push({
+      handler,
+      preprocessHandler,
+      timeIntervalInMinutes: timeInterval,
+      blockInterval,
+      fetchConfig
+    })
     return this
   }
 
   public onTrace(
     signature: string,
     handler: (trace: TypedCallTrace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>
+    fetchConfig?: Partial<EthFetchConfig>,
+    preprocessHandler: (
+      trace: TypedCallTrace,
+      ctx: ContractContext<TContract, TBoundContractView>
+    ) => Promise<PreprocessResult> = defaultPreprocessHandler
   ) {
-    this.traceHandlers.push({ signature, handler, fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}) })
+    this.traceHandlers.push({
+      signature,
+      handler,
+      preprocessHandler,
+      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+    })
     return this
   }