@sentio/sdk 1.39.0 → 1.40.0-rc.1

package/src/builtin/internal/weth9_processor.ts

@@ -20,6 +20,7 @@ import {
   TypedCallTrace,
   toBlockTag,
 } from "@sentio/sdk";
+import { EthFetchConfig } from "@sentio/protos";
 import { PromiseOrValue } from "./common";
 import { WETH9, WETH9__factory } from "./index";
 import {
@@ -326,7 +327,8 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
 
   onEventApproval(
     handler: (event: ApprovalEvent, ctx: WETH9Context) => void,
-    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+    filter?: ApprovalEventFilter | ApprovalEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -335,12 +337,13 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         "Approval(address,address,uint256)"
       ](null, null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventTransfer(
     handler: (event: TransferEvent, ctx: WETH9Context) => void,
-    filter?: TransferEventFilter | TransferEventFilter[]
+    filter?: TransferEventFilter | TransferEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -349,12 +352,13 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         "Transfer(address,address,uint256)"
       ](null, null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventDeposit(
     handler: (event: DepositEvent, ctx: WETH9Context) => void,
-    filter?: DepositEventFilter | DepositEventFilter[]
+    filter?: DepositEventFilter | DepositEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -363,12 +367,13 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         "Deposit(address,uint256)"
       ](null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventWithdrawal(
     handler: (event: WithdrawalEvent, ctx: WETH9Context) => void,
-    filter?: WithdrawalEventFilter | WithdrawalEventFilter[]
+    filter?: WithdrawalEventFilter | WithdrawalEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -377,7 +382,7 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         "Withdrawal(address,uint256)"
       ](null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 }
 
@@ -387,7 +392,8 @@ export class WETH9Processor extends BaseProcessor<
 > {
   onEventApproval(
     handler: (event: ApprovalEvent, ctx: WETH9Context) => void,
-    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+    filter?: ApprovalEventFilter | ApprovalEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -396,12 +402,13 @@ export class WETH9Processor extends BaseProcessor<
         "Approval(address,address,uint256)"
       ](null, null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventTransfer(
     handler: (event: TransferEvent, ctx: WETH9Context) => void,
-    filter?: TransferEventFilter | TransferEventFilter[]
+    filter?: TransferEventFilter | TransferEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -410,12 +417,13 @@ export class WETH9Processor extends BaseProcessor<
         "Transfer(address,address,uint256)"
       ](null, null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventDeposit(
     handler: (event: DepositEvent, ctx: WETH9Context) => void,
-    filter?: DepositEventFilter | DepositEventFilter[]
+    filter?: DepositEventFilter | DepositEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -424,12 +432,13 @@ export class WETH9Processor extends BaseProcessor<
         "Deposit(address,uint256)"
       ](null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
   onEventWithdrawal(
     handler: (event: WithdrawalEvent, ctx: WETH9Context) => void,
-    filter?: WithdrawalEventFilter | WithdrawalEventFilter[]
+    filter?: WithdrawalEventFilter | WithdrawalEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
       // @ts-ignore
@@ -438,65 +447,84 @@ export class WETH9Processor extends BaseProcessor<
         "Withdrawal(address,uint256)"
       ](null, null);
     }
-    return super.onEvent(handler, filter!);
+    return super.onEvent(handler, filter!, fetchConfig);
   }
 
-  onCallName(handler: (call: NameCallTrace, ctx: WETH9Context) => void) {
-    return super.onTrace("0x06fdde03", handler);
+  onCallName(
+    handler: (call: NameCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
+  ) {
+    return super.onTrace("0x06fdde03", handler, fetchConfig);
   }
 
-  onCallApprove(handler: (call: ApproveCallTrace, ctx: WETH9Context) => void) {
-    return super.onTrace("0x095ea7b3", handler);
+  onCallApprove(
+    handler: (call: ApproveCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
+  ) {
+    return super.onTrace("0x095ea7b3", handler, fetchConfig);
   }
 
   onCallTotalSupply(
-    handler: (call: TotalSupplyCallTrace, ctx: WETH9Context) => void
+    handler: (call: TotalSupplyCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0x18160ddd", handler);
+    return super.onTrace("0x18160ddd", handler, fetchConfig);
   }
 
   onCallTransferFrom(
-    handler: (call: TransferFromCallTrace, ctx: WETH9Context) => void
+    handler: (call: TransferFromCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0x23b872dd", handler);
+    return super.onTrace("0x23b872dd", handler, fetchConfig);
   }
 
   onCallWithdraw(
-    handler: (call: WithdrawCallTrace, ctx: WETH9Context) => void
+    handler: (call: WithdrawCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0x2e1a7d4d", handler);
+    return super.onTrace("0x2e1a7d4d", handler, fetchConfig);
   }
 
   onCallDecimals(
-    handler: (call: DecimalsCallTrace, ctx: WETH9Context) => void
+    handler: (call: DecimalsCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0x313ce567", handler);
+    return super.onTrace("0x313ce567", handler, fetchConfig);
   }
 
   onCallBalanceOf(
-    handler: (call: BalanceOfCallTrace, ctx: WETH9Context) => void
+    handler: (call: BalanceOfCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0x70a08231", handler);
+    return super.onTrace("0x70a08231", handler, fetchConfig);
   }
 
-  onCallSymbol(handler: (call: SymbolCallTrace, ctx: WETH9Context) => void) {
-    return super.onTrace("0x95d89b41", handler);
+  onCallSymbol(
+    handler: (call: SymbolCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
+  ) {
+    return super.onTrace("0x95d89b41", handler, fetchConfig);
   }
 
   onCallTransfer(
-    handler: (call: TransferCallTrace, ctx: WETH9Context) => void
+    handler: (call: TransferCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0xa9059cbb", handler);
+    return super.onTrace("0xa9059cbb", handler, fetchConfig);
   }
 
-  onCallDeposit(handler: (call: DepositCallTrace, ctx: WETH9Context) => void) {
-    return super.onTrace("0xd0e30db0", handler);
+  onCallDeposit(
+    handler: (call: DepositCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
+  ) {
+    return super.onTrace("0xd0e30db0", handler, fetchConfig);
   }
 
   onCallAllowance(
-    handler: (call: AllowanceCallTrace, ctx: WETH9Context) => void
+    handler: (call: AllowanceCallTrace, ctx: WETH9Context) => void,
+    fetchConfig?: EthFetchConfig
   ) {
-    return super.onTrace("0xdd62ed3e", handler);
+    return super.onTrace("0xdd62ed3e", handler, fetchConfig);
   }
 
   public static filters = templateContract.filters;

package/src/core/account-processor.ts

@@ -1,8 +1,8 @@
 import { ListStateStorage } from '@sentio/runtime'
 import { ERC20__factory, ERC721__factory } from '../builtin/internal'
-import { AddressType, DummyProvider, ProcessResult } from '@sentio/sdk'
+import { AddressType, DummyProvider, EthFetchConfig, ProcessResult } from '@sentio/sdk'
 import { AccountBindOptions } from './bind-options'
-import { getNetwork } from '@ethersproject/providers'
+import { getNetwork, TransactionReceipt } from '@ethersproject/providers'
 import { TransferEvent as ERC20TransferEvent } from '../builtin/internal/ERC20'
 import { TransferEvent as ERC721TransferEvent } from '../builtin/internal/ERC721'
 import { AccountContext } from './context'
@@ -10,6 +10,8 @@ import { PromiseOrVoid } from '../promise-or-void'
 import { Event } from '@ethersproject/contracts'
 import { BytesLike } from '@ethersproject/bytes'
 import { AddressOrTypeEventFilter, EventsHandler } from './base-processor'
+import { Block } from '@ethersproject/abstract-provider'
+import { Transaction } from 'ethers'
 
 export class AccountProcessorState extends ListStateStorage<AccountProcessor> {
   static INSTANCE = new AccountProcessorState()
@@ -40,13 +42,18 @@ export class AccountProcessor {
    * Register custom handler function to process erc20 transfer event to this account
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
+   * @param fetchConfig
    */
   onERC20TransferIn(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    tokensAddresses: string[] = []
+    tokensAddresses: string[] = [],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC20(handler, tokensAddresses, (address: string) =>
-      ERC20_CONTRACT.filters.Transfer(null, this.config.address)
+    return this.onERC20(
+      handler,
+      tokensAddresses,
+      (address: string) => ERC20_CONTRACT.filters.Transfer(null, this.config.address),
+      fetchConfig
     )
   }
 
@@ -54,13 +61,18 @@ export class AccountProcessor {
    * Register custom handler function to process erc20 transfer event from this account
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
+   * @param fetchConfig
    */
   onERC20TransferOut(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    tokensAddresses: string[] = []
+    tokensAddresses: string[] = [],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC20(handler, tokensAddresses, (address: string) =>
-      ERC20_CONTRACT.filters.Transfer(this.config.address)
+    return this.onERC20(
+      handler,
+      tokensAddresses,
+      (address: string) => ERC20_CONTRACT.filters.Transfer(this.config.address),
+      fetchConfig
     )
   }
 
@@ -68,35 +80,47 @@ export class AccountProcessor {
    * Register custom handler function to process erc20 mint for this account
    * @param handler custom handler function
    * @param tokensAddresses all the erc20 token address to watch
+   * @param fetchConfig
    */
   onERC20Minted(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    tokensAddresses: string[] = []
+    tokensAddresses: string[] = [],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC20(handler, tokensAddresses, (address: string) =>
-      ERC20_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    return this.onERC20(
+      handler,
+      tokensAddresses,
+      (address: string) =>
+        ERC20_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
+      fetchConfig
     )
   }
 
   private onERC20(
     handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     tokensAddresses: string[] = [],
-    defaultFilter: (address: string) => AddressOrTypeEventFilter
+    defaultFilter: (address: string) => AddressOrTypeEventFilter,
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20)
+    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20, fetchConfig)
   }
 
   /**
    * Register custom handler function to process ERC721 transfer event to this account
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   * @param fetchConfig
    */
   onERC721TransferIn(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    collections: string[]
+    collections: string[],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC721(handler, collections, (address: string) =>
-      ERC721_CONTRACT.filters.Transfer(null, this.config.address)
+    return this.onERC721(
+      handler,
+      collections,
+      (address: string) => ERC721_CONTRACT.filters.Transfer(null, this.config.address),
+      fetchConfig
     )
   }
 
@@ -104,13 +128,18 @@ export class AccountProcessor {
    * Register custom handler function to process ERC721 transfer event from this account
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   * @param fetchConfig
    */
   onERC721TransferOut(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    collections: string[]
+    collections: string[],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC721(handler, collections, (address: string) =>
-      ERC721_CONTRACT.filters.Transfer(this.config.address)
+    return this.onERC721(
+      handler,
+      collections,
+      (address: string) => ERC721_CONTRACT.filters.Transfer(this.config.address),
+      fetchConfig
     )
   }
 
@@ -118,29 +147,37 @@ export class AccountProcessor {
    * Register custom handler function to process ERC721 mint for this account
    * @param handler custom handler function
    * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   * @param fetchConfig
    */
   onERC721Minted(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
-    collections: string[] = []
+    collections: string[] = [],
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC721(handler, collections, (address: string) =>
-      ERC721_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    return this.onERC721(
+      handler,
+      collections,
+      (address: string) =>
+        ERC721_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
+      fetchConfig
     )
   }
 
   private onERC721(
     handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
     collections: string[],
-    defaultFilter: (address: string) => AddressOrTypeEventFilter
+    defaultFilter: (address: string) => AddressOrTypeEventFilter,
+    fetchConfig?: EthFetchConfig
   ) {
-    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721)
+    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721, fetchConfig)
   }
 
   private onERC(
     handler: (event: any, ctx: AccountContext) => PromiseOrVoid,
     contractAddresses: string[],
     defaultFilter: (address: string) => AddressOrTypeEventFilter,
-    addressType: AddressType
+    addressType: AddressType,
+    fetchConfig?: EthFetchConfig
   ) {
     const filters = []
     for (const token of contractAddresses) {
@@ -154,12 +191,13 @@ export class AccountProcessor {
       filter.addressType = addressType
       filters.push(filter)
     }
-    return this.onEvent(handler, filters)
+    return this.onEvent(handler, filters, fetchConfig)
   }
 
   protected onEvent(
     handler: (event: Event, ctx: AccountContext) => PromiseOrVoid,
-    filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[]
+    filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     const chainId = this.getChainId()
 
@@ -191,9 +229,19 @@ export class AccountProcessor {
 
     this.eventHandlers.push({
       filters: _filters,
+      fetchConfig: fetchConfig || EthFetchConfig.fromPartial({}),
       handler: async function (data) {
         const log = data.log as Event
-        const ctx = new AccountContext(chainId, config.address, undefined, log)
+        const ctx = new AccountContext(
+          chainId,
+          config.address,
+          data.timestamp,
+          data.block as Block,
+          log,
+          undefined,
+          data.transaction as Transaction,
+          data.transactionReceipt as TransactionReceipt
+        )
         const event: Event = log
         const parsed = ERC20_CONTRACT.interface.parseLog(log)
         if (parsed) {

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

@@ -4,7 +4,7 @@ import { BaseContract, EventFilter } from 'ethers'
 import { Event } from '@ethersproject/contracts'
 import { BaseProcessor } from './base-processor'
 import { BindOptions, getOptionsSignature } from './bind-options'
-import { HandleInterval, TemplateInstance } from '@sentio/protos'
+import { EthFetchConfig, HandleInterval, TemplateInstance } from '@sentio/protos'
 import { getNetwork } from '@ethersproject/providers'
 import { PromiseOrVoid } from '../promise-or-void'
 import { Trace } from './trace'
@@ -34,10 +34,12 @@ export abstract class BaseProcessorTemplate<
   traceHandlers: {
     signature: string
     handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    fetchConfig?: EthFetchConfig
   }[] = []
   eventHandlers: {
     handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
     filter: EventFilter | EventFilter[]
+    fetchConfig?: EthFetchConfig
   }[] = []
 
   constructor() {
@@ -55,7 +57,10 @@ export abstract class BaseProcessorTemplate<
     const processor = this.bindInternal(options)
 
     for (const eh of this.eventHandlers) {
-      processor.onEvent(eh.handler, eh.filter)
+      processor.onEvent(eh.handler, eh.filter, eh.fetchConfig)
+    }
+    for (const th of this.traceHandlers) {
+      processor.onTrace(th.signature, th.handler, th.fetchConfig)
     }
     for (const bh of this.blockHandlers) {
       processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval)
@@ -84,11 +89,13 @@ export abstract class BaseProcessorTemplate<
 
   public onEvent(
     handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    filter: EventFilter | EventFilter[]
+    filter: EventFilter | EventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     this.eventHandlers.push({
       handler: handler,
       filter: filter,
+      fetchConfig: fetchConfig,
     })
     return this
   }

package/src/core/base-processor.ts

@@ -1,13 +1,22 @@
 import { BytesLike } from '@ethersproject/bytes'
-import { Block, Log, getNetwork } from '@ethersproject/providers'
+import { Block, Log, getNetwork, TransactionReceipt } from '@ethersproject/providers'
 import { BaseContract, Event, EventFilter } from '@ethersproject/contracts'
 
 import { BoundContractView, ContractContext, ContractView } from './context'
-import { AddressType, Data_EthBlock, Data_EthLog, Data_EthTrace, HandleInterval, ProcessResult } from '@sentio/protos'
+import {
+  AddressType,
+  Data_EthBlock,
+  Data_EthLog,
+  Data_EthTrace,
+  EthFetchConfig,
+  HandleInterval,
+  ProcessResult,
+} from '@sentio/protos'
 import { BindInternalOptions, BindOptions } from './bind-options'
 import { PromiseOrVoid } from '../promise-or-void'
 import { Trace } from './trace'
 import { ServerError, Status } from 'nice-grpc'
+import { Transaction } from 'ethers'
 
 export interface AddressOrTypeEventFilter extends EventFilter {
   addressType?: AddressType
@@ -16,11 +25,13 @@ export interface AddressOrTypeEventFilter extends EventFilter {
 export class EventsHandler {
   filters: AddressOrTypeEventFilter[]
   handler: (event: Data_EthLog) => Promise<ProcessResult>
+  fetchConfig: EthFetchConfig
 }
 
 export class TraceHandler {
   signature: string
   handler: (trace: Data_EthTrace) => Promise<ProcessResult>
+  fetchConfig: EthFetchConfig
 }
 
 export class BlockHandlder {
@@ -62,7 +73,8 @@ export abstract class BaseProcessor<
 
   public onEvent(
     handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    filter: EventFilter | EventFilter[]
+    filter: EventFilter | EventFilter[],
+    fetchConfig?: EthFetchConfig
   ) {
     const chainId = this.getChainId()
 
@@ -78,6 +90,7 @@ export abstract class BaseProcessor<
     const processor = this
     this.eventHandlers.push({
       filters: _filters,
+      fetchConfig: fetchConfig || EthFetchConfig.fromPartial({}),
       handler: async function (data: Data_EthLog) {
         if (!data.log) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
@@ -90,10 +103,12 @@ export abstract class BaseProcessor<
           contractName,
           contractView,
           chainId,
-          undefined,
+          data.timestamp,
+          data.block as Block,
           log,
           undefined,
-          data.timestamp
+          data.transaction as Transaction,
+          data.transactionReceipt as TransactionReceipt
         )
         // let event: Event = <Event>deepCopy(log);
         const event: Event = <Event>log
@@ -165,10 +180,10 @@ export abstract class BaseProcessor<
           contractName,
           contractView,
           chainId,
+          new Date(block.timestamp * 1000),
           block,
           undefined,
-          undefined,
-          new Date(block.timestamp * 1000)
+          undefined
         )
         await handler(block, ctx)
         return ctx.getProcessResult()
@@ -191,9 +206,10 @@ export abstract class BaseProcessor<
     }, _filters)
   }
 
-  protected onTrace(
+  public onTrace(
     signature: string,
-    handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    fetchConfig?: EthFetchConfig
   ) {
     const chainId = this.getChainId()
     const contractName = this.config.name
@@ -201,6 +217,7 @@ export abstract class BaseProcessor<
 
     this.traceHandlers.push({
       signature,
+      fetchConfig: fetchConfig || EthFetchConfig.fromPartial({}),
       handler: async function (data: Data_EthTrace) {
         const contractView = processor.CreateBoundContractView()
         const contractInterface = contractView.rawContract.interface
@@ -219,10 +236,12 @@ export abstract class BaseProcessor<
           contractName,
           contractView,
           chainId,
-          undefined,
+          data.timestamp,
+          data.block as Block,
           undefined,
           trace,
-          data.timestamp
+          data.transaction as Transaction,
+          data.transactionReceipt as TransactionReceipt
         )
         await handler(trace, ctx)
         return ctx.getProcessResult()