@sentio/sdk 2.59.0-rc.8 → 2.59.0

package/src/fuel/fuel-plugin.ts

@@ -1,4 +1,5 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import { PartitionHandlerManager } from '../core/index.js'
 import {
   ContractConfig,
   Data_FuelBlock,
@@ -8,6 +9,7 @@ import {
   HandlerType,
   ProcessConfigResponse,
   ProcessResult,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 
@@ -32,6 +34,8 @@ export class FuelPlugin extends Plugin {
     receiptHandlers: []
   }
 
+  partitionManager = new PartitionHandlerManager()
+
   async configure(config: ProcessConfigResponse) {
     const handlers: Handlers = {
       transactionHandlers: [],
@@ -54,6 +58,11 @@ export class FuelPlugin extends Plugin {
       })
       for (const txHandler of processor.txHandlers) {
         const handlerId = handlers.transactionHandlers.push(txHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(
+          HandlerType.FUEL_TRANSACTION,
+          handlerId,
+          txHandler.partitionHandler
+        )
         const handlerName = txHandler.handlerName
         if (processor instanceof FuelProcessor) {
           // on transaction
@@ -82,6 +91,11 @@ export class FuelPlugin extends Plugin {
 
       for (const receiptHandler of processor.receiptHandlers ?? []) {
         const handlerId = handlers.receiptHandlers.push(receiptHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(
+          HandlerType.FUEL_RECEIPT,
+          handlerId,
+          receiptHandler.partitionHandler
+        )
         const handlerName = receiptHandler.handlerName
         if (processor instanceof FuelProcessor) {
           contractConfig.fuelReceiptConfigs.push({
@@ -94,6 +108,7 @@ export class FuelPlugin extends Plugin {
 
       for (const blockHandler of processor.blockHandlers) {
         const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.FUEL_BLOCK, handlerId, blockHandler.partitionHandler)
         contractConfig.intervalConfigs.push({
           slot: 0,
           slotInterval: blockHandler.blockInterval,
@@ -132,6 +147,47 @@ export class FuelPlugin extends Plugin {
     }
   }
 
+  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
+    let data: any
+    switch (request.handlerType) {
+      case HandlerType.FUEL_TRANSACTION:
+        if (!request.data?.fuelTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "fuelTransaction can't be empty")
+        }
+        data = request.data.fuelTransaction
+        break
+      case HandlerType.FUEL_RECEIPT:
+        if (!request.data?.fuelLog) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "fuelReceipt can't be empty")
+        }
+        data = request.data.fuelLog
+        break
+      case HandlerType.FUEL_BLOCK:
+        if (!request.data?.fuelBlock) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "fuelBlock can't be empty")
+        }
+        data = request.data.fuelBlock
+        break
+      case HandlerType.FUEL_CALL:
+        // FUEL_CALL uses the same data as FUEL_TRANSACTION
+        if (!request.data?.fuelTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "fuelTransaction can't be empty for FUEL_CALL")
+        }
+        data = request.data.fuelTransaction
+        break
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+    const partitions = await this.partitionManager.processPartitionForHandlerType(
+      request.handlerType,
+      request.handlerIds,
+      data
+    )
+    return {
+      partitions
+    }
+  }
+
   async start(request: StartRequest) {
     try {
       for (const processor of FuelProcessorState.INSTANCE.getValues()) {

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)
@@ -184,15 +198,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
           return ctx.stopAndGetResult()
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          }
+          return ProcessResult.fromPartial({})
         }
       },
       fetchConfig: {
@@ -206,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])
@@ -244,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)
@@ -255,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 = {
@@ -288,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)
@@ -298,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) {
@@ -346,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
@@ -354,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,
@@ -363,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

@@ -38,6 +38,7 @@ export class EventHandler<T> {
   handlerName: string
   handler: (event: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (event: T) => Promise<string | undefined>
 }
 
 export class CallHandler<T> {
@@ -45,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> {
@@ -57,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 {
@@ -66,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 {
@@ -74,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

@@ -1,12 +1,13 @@
 import { Data_StarknetEvent, ProcessResult } from '@sentio/protos'
 import { StarknetChainId } from '@sentio/chain'
-import { CallData, constants, events, ParsedEvent, RpcProvider } from 'starknet'
+import { CallData, events, ParsedEvent, RpcProvider } from 'starknet'
 import { StarknetContext } from './context.js'
 import { StarknetEvent } from './event.js'
 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) {
@@ -83,18 +85,33 @@ export class StarknetProcessor {
           return mergeProcessResults(results)
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
+          return ProcessResult.fromPartial({})
+        }
+      },
+      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
           }
         }
-      },
-      eventFilter
+        return p
+      }
     }
     this.callHandlers.push(callHandler)
     return this
@@ -105,14 +122,15 @@ export type CallHandler<T> = {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   eventFilter?: string[]
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 function getRpcEndpoint(chainId: StarknetChainId | string) {
   switch (chainId) {
     case StarknetChainId.STARKNET_MAINNET:
-      return constants.NetworkName.SN_MAIN
+      return 'https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
     default:
-      return constants.NetworkName.SN_SEPOLIA
+      return 'https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
   }
 }