@sentio/sdk 2.59.0-rc.23 → 2.59.0-rc.25

package/src/fuel/fuel-processor-template.ts

@@ -8,6 +8,7 @@ import { FuelBlock, FuelLog, FuelTransaction } from './types.js'
 import { DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig } from './transaction.js'
 import { FuelProcessor, FuelProcessorConfig, getOptionsSignature } from './fuel-processor.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from '../core/index.js'
 
 export class FuelProcessorTemplateProcessorState extends ListStateStorage<FuelBaseProcessorTemplate<Contract>> {
   static INSTANCE = new FuelProcessorTemplateProcessorState()
@@ -21,6 +22,7 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid
     blockInterval?: HandleInterval
     timeIntervalInMinutes?: HandleInterval
+    handlerOptions?: HandlerOptions<object, FuelBlock>
     // fetchConfig?: FuelFetchConfig
   }[] = []
 
@@ -28,13 +30,14 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     logIdFilter: string | string[]
     handlerName: string
     handler: (logs: FuelLog<any>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handlerOptions?: HandlerOptions<object, FuelLog<any>>
     // fetchConfig?: FuelFetchConfig
   }[] = []
 
   transactionHandlers: {
     handlerName: string
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid
-    fetchConfig: FuelFetchConfig
+    handlerOptions?: HandlerOptions<FuelFetchConfig, FuelTransaction>
   }[] = []
 
   constructor() {
@@ -62,13 +65,13 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     const processor = this.bindInternal({ ...options, chainId: ctx.chainId })
 
     for (const eh of this.logHandlers) {
-      processor.onLog(eh.logIdFilter, eh.handler, eh.handlerName)
+      processor.onLog(eh.logIdFilter, eh.handler, eh.handlerOptions, eh.handlerName)
     }
     for (const bh of this.blockHandlers) {
-      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.handlerName)
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.handlerOptions, bh.handlerName)
     }
     for (const th of this.transactionHandlers) {
-      processor.onTransaction(th.handler, undefined, th.handlerName)
+      processor.onTransaction(th.handler, th.handlerOptions, th.handlerName)
     }
 
     const instance: TemplateInstance = {
@@ -94,13 +97,15 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
 
   protected onLog<T>(
     logIdFilter: string | string[],
-    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions: HandlerOptions<object, FuelLog<T>> = {}
     // fetchConfig?: Partial<FuelFetchConfig>
   ) {
     this.logHandlers.push({
       logIdFilter,
       handlerName: getHandlerName(),
-      handler
+      handler,
+      handlerOptions
       // fetchConfig: { ...fetchConfig}
     })
     return this
@@ -140,14 +145,16 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
   public onInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined
+    blockInterval: HandleInterval | undefined,
+    handlerOptions: HandlerOptions<object, FuelBlock> = {}
     // fetchConfig?: FuelFetchConfig
   ) {
     this.blockHandlers.push({
       handlerName: getHandlerName(),
       handler,
       timeIntervalInMinutes: timeInterval,
-      blockInterval
+      blockInterval,
+      handlerOptions
       // fetchConfig: { ...fetchConfig }
     })
     return this
@@ -155,12 +162,12 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
 
   protected onTransaction(
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
-    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
+    handlerOptions: HandlerOptions<FuelFetchConfig, FuelTransaction> = DEFAULT_FUEL_FETCH_CONFIG
   ) {
     this.transactionHandlers.push({
       handlerName: getHandlerName(),
       handler,
-      fetchConfig: config
+      handlerOptions
     })
     return this
   }

package/src/fuel/fuel-processor.ts

@@ -27,7 +27,7 @@ import {
   FuelTransaction,
   ReceiptHandler
 } from './types.js'
-import { PromiseOrVoid } from '../core/index.js'
+import { PromiseOrVoid, HandlerOptions } from '../core/index.js'
 import { ServerError, Status } from 'nice-grpc'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
@@ -88,7 +88,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
 
   public onTransaction(
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
-    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG,
+    handlerOptions?: HandlerOptions<FuelFetchConfig, FuelTransaction>,
     handlerName = getHandlerName()
   ) {
     const callHandler = {
@@ -115,7 +115,21 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
       },
       fetchConfig: {
         filters: [],
-        ...config
+        ...handlerOptions
+      },
+      partitionHandler: async (call: Data_FuelTransaction): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const abiMap = this.config.abi
+            ? {
+                [this.config.address]: this.config.abi
+              }
+            : {}
+          const tx = await decodeFuelTransactionWithAbi(call.transaction, abiMap, this.provider)
+          return p(tx)
+        }
+        return p
       }
     }
     this.txHandlers.push(callHandler)
@@ -198,6 +212,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   public onLog<T>(
     logIdFilter: string | string[],
     handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions?: HandlerOptions<object, FuelLog<T>>,
     handlerName = getHandlerName()
   ) {
     const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
@@ -236,6 +251,25 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
         log: {
           logIds: Array.from(logIds)
         }
+      },
+      partitionHandler: async (data: Data_FuelReceipt): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const tx = await decodeFuelTransaction(data.transaction, this.provider)
+            const index = Number(data.receiptIndex)
+            const receipt = tx.receipts[index]
+            const log = decodeLog(receipt, this.config.abi)
+            if (log) {
+              return p({ receiptIndex: index, ...log })
+            }
+          } catch (e) {
+            console.error(e)
+          }
+          return undefined
+        }
+        return p
       }
     } as ReceiptHandler
     this.receiptHandlers.push(logHandler)
@@ -247,7 +281,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
    */
   public onTransfer(
     filter: ContractTransferFilter,
-    handler: (transfer: ReceiptTransfer | ReceiptTransferOut, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handler: (transfer: ReceiptTransfer | ReceiptTransferOut, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions?: HandlerOptions<object, ReceiptTransfer | ReceiptTransferOut>
   ) {
     const { from, to, assetId } = filter
     const h = {
@@ -280,6 +315,22 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
           to,
           assetId
         }
+      },
+      partitionHandler: async (data: Data_FuelReceipt): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const tx = await decodeFuelTransaction(data.transaction, this.provider)
+            const index = Number(data.receiptIndex)
+            const receipt = tx.receipts[index] as ReceiptTransfer | ReceiptTransferOut
+            return p(receipt)
+          } catch (e) {
+            console.error(e)
+          }
+          return undefined
+        }
+        return p
       }
     } as ReceiptHandler
     this.receiptHandlers.push(h)
@@ -290,8 +341,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
+    handlerOptions?: HandlerOptions<object, FuelBlock>,
     handlerName = getHandlerName()
-    // fetchConfig: Partial<FuelFetchConfig> | undefined
   ): this {
     if (timeInterval) {
       if (timeInterval.backfillInterval < timeInterval.recentInterval) {
@@ -338,6 +389,31 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
         )
         await handler(block, ctx)
         return ctx.stopAndGetResult()
+      },
+      partitionHandler: async (data: Data_FuelBlock): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const header = data.block
+          if (!header) return undefined
+          const block: FuelBlock = {
+            id: header.id,
+            height: bn(header.height),
+            time: header.time,
+            header: {
+              applicationHash: header.applicationHash,
+              daHeight: bn(header.daHeight),
+              eventInboxRoot: header.eventInboxRoot,
+              messageOutboxRoot: header.messageOutboxRoot,
+              prevRoot: header.prevRoot,
+              stateTransitionBytecodeVersion: header.stateTransitionBytecodeVersion,
+              transactionsCount: header.transactionsCount,
+              transactionsRoot: header.transactionsRoot
+            }
+          }
+          return p(block)
+        }
+        return p
       }
     })
     return this
@@ -346,8 +422,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   public onBlockInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     blockInterval = 250,
-    backfillBlockInterval = 1000
-    // fetchConfig?: Partial<FuelFetchConfig>
+    backfillBlockInterval = 1000,
+    handlerOptions?: HandlerOptions<object, FuelBlock>
   ): this {
     return this.onInterval(
       handler,
@@ -355,22 +431,22 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
       {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
-      }
-      // fetchConfig,
+      },
+      handlerOptions
     )
   }
 
   public onTimeInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240
-    // fetchConfig?: Partial<FuelFetchConfig>,
+    backfillTimeIntervalInMinutes = 240,
+    handlerOptions?: HandlerOptions<object, FuelBlock>
   ): this {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      undefined
-      // fetchConfig
+      undefined,
+      handlerOptions
     )
   }
 }

package/src/fuel/types.ts

@@ -29,12 +29,14 @@ export type CallHandler<T> = {
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig?: Partial<FuelCallHandlerConfig>
   assetConfig?: Partial<FuelAssetHandlerConfig>
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export type ReceiptHandler = {
   handlerName: string
   handler: (receipt: Data_FuelReceipt) => Promise<ProcessResult>
   receiptConfig?: Partial<FuelReceiptHandlerConfig>
+  partitionHandler?: (receipt: Data_FuelReceipt) => Promise<string | undefined>
 }
 
 export type BlockHandler = {
@@ -43,6 +45,7 @@ export type BlockHandler = {
   handler: (block: Data_FuelBlock) => Promise<ProcessResult>
   handlerName: string
   fetchConfig?: Partial<OnIntervalConfig>
+  partitionHandler?: (block: Data_FuelBlock) => Promise<string | undefined>
 }
 
 export interface FuelLog<T> {

package/src/move/filter.ts

@@ -46,6 +46,7 @@ export class CallHandler<T> {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export class ObjectChangeHandler<T> {
@@ -58,6 +59,7 @@ export class ResourceChangeHandler<T> {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   type: string
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export class ResourceIntervalHandler {
@@ -67,6 +69,7 @@ export class ResourceIntervalHandler {
   handler: (resource: Data_AptResource) => Promise<ProcessResult>
   handlerName: string
   fetchConfig: MoveAccountFetchConfig
+  partitionHandler?: (resource: Data_AptResource) => Promise<string | undefined>
 }
 
 export class TransactionIntervalHandler {
@@ -75,4 +78,5 @@ export class TransactionIntervalHandler {
   handler: (tx: Data_AptCall) => Promise<ProcessResult>
   handlerName: string
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (tx: Data_AptCall) => Promise<string | undefined>
 }

package/src/move/shared-network-codegen.ts

@@ -96,12 +96,12 @@ export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType>
 
     const camelFuncName = upperFirst(camel(func.name))
     const source = `
-  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
+  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, ${moduleName}.${camelFuncName}Payload>): ${moduleName} {
     this.onEntryFunctionCall(func, {
       ...filter,
       function: '${module.name}::${func.name}'
     },
-    fetchConfig)
+    handlerOptions)
     return this
   }`
 
@@ -113,8 +113,8 @@ export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType>
     const source = `
 onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
       this.PREFIX
-    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type"|"account">): ${moduleName} {
-  this.onMoveEvent(func, {...eventFilter ?? {}, type: '${module.name}::${struct.name}' }, fetchConfig)
+    }Context) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, ${moduleName}.${normalizeToJSName(struct.name)}Instance>, eventFilter?: Omit<EventFilter, "type"|"account">): ${moduleName} {
+  this.onMoveEvent(func, {...eventFilter ?? {}, type: '${module.name}::${struct.name}' }, handlerOptions)
   return this
 }`
     return source
@@ -123,6 +123,7 @@ onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.nam
   generateImports() {
     return `
     import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move"
+    import { HandlerOptions } from "@sentio/sdk"
     import {
       ${this.PREFIX}BindOptions, ${this.PREFIX}BaseProcessor,
       ${this.PREFIX}Network, TypedFunctionPayload,

package/src/solana/solana-processor.ts

@@ -5,6 +5,7 @@ import { SolanaBindOptions } from './solana-options.js'
 import { ListStateStorage } from '@sentio/runtime'
 import { Labels } from '../core/index.js'
 import { SolanaChainId } from '@sentio/chain'
+import { HandlerOptions } from '../core/handler-options.js'
 
 type IndexConfigure = {
   startSlot: bigint
@@ -17,12 +18,17 @@ export interface InstructionCoder {
 
 export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
 
+export interface InstructionHandlerEntry {
+  handler: SolanaInstructionHandler
+  handlerOptions?: HandlerOptions<object, Instruction>
+}
+
 export class SolanaProcessorState extends ListStateStorage<SolanaBaseProcessor> {
   static INSTANCE: SolanaProcessorState = new SolanaProcessorState()
 }
 
 export class SolanaBaseProcessor {
-  public instructionHandlerMap: Map<string, SolanaInstructionHandler> = new Map()
+  public instructionHandlerMap: Map<string, InstructionHandlerEntry> = new Map()
   address: string
   endpoint: string
   contractName: string
@@ -61,8 +67,12 @@ export class SolanaBaseProcessor {
     SolanaProcessorState.INSTANCE.addValue(this)
   }
 
-  public onInstruction(instructionName: string, handler: SolanaInstructionHandler) {
-    this.instructionHandlerMap.set(instructionName, handler)
+  public onInstruction(
+    instructionName: string,
+    handler: SolanaInstructionHandler,
+    handlerOptions?: HandlerOptions<object, Instruction>
+  ) {
+    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions })
     return this
   }
 
@@ -78,21 +88,33 @@ export class SolanaBaseProcessor {
     return null
   }
 
-  public getInstructionHandler(parsedInstruction: Instruction): SolanaInstructionHandler | undefined {
+  public getInstructionHandler(parsedInstruction: Instruction): InstructionHandlerEntry | undefined {
     return this.instructionHandlerMap.get(parsedInstruction.name)
   }
 
   public async handleInstruction(
     parsedInstruction: Instruction,
     accounts: string[],
-    handler: SolanaInstructionHandler,
+    handlerEntry: InstructionHandlerEntry,
     slot: bigint
   ): Promise<ProcessResult> {
     const ctx = new SolanaContext(this.contractName, this.network, this.address, slot, this.baseLabels)
-    await handler(parsedInstruction, ctx, accounts)
+    await handlerEntry.handler(parsedInstruction, ctx, accounts)
     return ctx.stopAndGetResult()
   }
 
+  public async getPartitionKey(
+    parsedInstruction: Instruction,
+    handlerEntry: InstructionHandlerEntry
+  ): Promise<string | undefined> {
+    const p = handlerEntry.handlerOptions?.partitionKey
+    if (!p) return undefined
+    if (typeof p === 'function') {
+      return p(parsedInstruction)
+    }
+    return p
+  }
+
   public startSlot(startSlot: bigint | number) {
     this.config.startSlot = BigInt(startSlot)
     return this

package/src/stark/starknet-processor.ts

@@ -7,6 +7,7 @@ import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
 import { StarknetProcessorConfig } from './types.js'
 import { StarknetContractView } from './contract.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from '../core/handler-options.js'
 
 export class StarknetProcessor {
   callHandlers: CallHandler<Data_StarknetEvent>[] = []
@@ -42,7 +43,8 @@ export class StarknetProcessor {
 
   public onEvent(
     event: string | string[],
-    handler: (events: StarknetEvent<ParsedEvent>, ctx: StarknetContext<StarknetContractView>) => void | Promise<void>
+    handler: (events: StarknetEvent<ParsedEvent>, ctx: StarknetContext<StarknetContractView>) => void | Promise<void>,
+    handlerOptions?: HandlerOptions<object, StarknetEvent<ParsedEvent>>
   ) {
     const eventFilter = Array.isArray(event) ? event : [event]
     if (!this.config.abi) {
@@ -86,7 +88,30 @@ export class StarknetProcessor {
           return ProcessResult.fromPartial({})
         }
       },
-      eventFilter
+      eventFilter,
+      partitionHandler: async (call: Data_StarknetEvent): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const eventData = [call.result] as any[]
+            const abiEvents = events.getAbiEvents(abi)
+            const abiStructs = CallData.getAbiStruct(abi)
+            const abiEnums = CallData.getAbiEnum(abi)
+            const parsedEvents = events.parseEvents(eventData, abiEvents, abiStructs, abiEnums)
+            if (parsedEvents.length > 0) {
+              const { from_address, transaction_hash } = call.result!
+              const e = new StarknetEvent(from_address, transaction_hash, parsedEvents[0])
+              return p(e)
+            }
+            return undefined
+          } catch (e) {
+            console.error(e)
+            return undefined
+          }
+        }
+        return p
+      }
     }
     this.callHandlers.push(callHandler)
     return this
@@ -97,6 +122,7 @@ export type CallHandler<T> = {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   eventFilter?: string[]
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 function getRpcEndpoint(chainId: StarknetChainId | string) {

package/src/sui/builtin/0x1.ts

@@ -36,6 +36,7 @@ import {
 } from "@typemove/sui";
 
 import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move";
+import { HandlerOptions } from "@sentio/sdk";
 import {
   SuiBindOptions,
   SuiBaseProcessor,
@@ -722,13 +723,16 @@ export class bit_vector extends SuiBaseProcessor {
 
   onEventBitVector(
     func: (event: bit_vector.BitVectorInstance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<
+      MoveFetchConfig,
+      bit_vector.BitVectorInstance
+    >,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): bit_vector {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "bit_vector::BitVector" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }
@@ -1066,13 +1070,16 @@ export class fixed_point32 extends SuiBaseProcessor {
 
   onEventFixedPoint32(
     func: (event: fixed_point32.FixedPoint32Instance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<
+      MoveFetchConfig,
+      fixed_point32.FixedPoint32Instance
+    >,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): fixed_point32 {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "fixed_point32::FixedPoint32" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }
@@ -2003,13 +2010,13 @@ export class string$ extends SuiBaseProcessor {
 
   onEventString(
     func: (event: string$.StringInstance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, string$.StringInstance>,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): string$ {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "string::String" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }
@@ -2509,13 +2516,16 @@ export class type_name extends SuiBaseProcessor {
 
   onEventTypeName(
     func: (event: type_name.TypeNameInstance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<
+      MoveFetchConfig,
+      type_name.TypeNameInstance
+    >,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): type_name {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "type_name::TypeName" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }
@@ -4578,13 +4588,13 @@ export class uq32_32 extends SuiBaseProcessor {
 
   onEventUQ32_32(
     func: (event: uq32_32.UQ32_32Instance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, uq32_32.UQ32_32Instance>,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): uq32_32 {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "uq32_32::UQ32_32" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }
@@ -5092,13 +5102,13 @@ export class uq64_64 extends SuiBaseProcessor {
 
   onEventUQ64_64(
     func: (event: uq64_64.UQ64_64Instance, ctx: SuiContext) => void,
-    fetchConfig?: Partial<MoveFetchConfig>,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, uq64_64.UQ64_64Instance>,
     eventFilter?: Omit<EventFilter, "type" | "account">,
   ): uq64_64 {
     this.onMoveEvent(
       func,
       { ...(eventFilter ?? {}), type: "uq64_64::UQ64_64" },
-      fetchConfig,
+      handlerOptions,
     );
     return this;
   }