@sentio/sdk 2.59.0-rc.9 → 2.59.1-rc.1

package/src/eth/builtin/internal/weth9-processor.ts

@@ -2,6 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 import { BigNumberish, Overrides } from "ethers";
+import { HandlerOptions } from "@sentio/sdk";
 import {
   addContractByABI,
   getContractByABI,
@@ -634,7 +635,7 @@ export class WETH9Processor extends BaseProcessor<
   onEventApproval(
     handler: (event: ApprovalEvent, ctx: WETH9Context) => void,
     filter?: ApprovalEventFilter | ApprovalEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>,
     preprocessHandler?: (
       event: ApprovalEvent,
       ctx: WETH9Context,
@@ -648,13 +649,18 @@ export class WETH9Processor extends BaseProcessor<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventTransfer(
     handler: (event: TransferEvent, ctx: WETH9Context) => void,
     filter?: TransferEventFilter | TransferEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>,
     preprocessHandler?: (
       event: TransferEvent,
       ctx: WETH9Context,
@@ -668,13 +674,18 @@ export class WETH9Processor extends BaseProcessor<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventDeposit(
     handler: (event: DepositEvent, ctx: WETH9Context) => void,
     filter?: DepositEventFilter | DepositEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, DepositEvent>,
     preprocessHandler?: (
       event: DepositEvent,
       ctx: WETH9Context,
@@ -684,13 +695,18 @@ export class WETH9Processor extends BaseProcessor<
     if (!filter) {
       filter = templateContract.filters["Deposit(address,uint256)"](null, null);
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventWithdrawal(
     handler: (event: WithdrawalEvent, ctx: WETH9Context) => void,
     filter?: WithdrawalEventFilter | WithdrawalEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawalEvent>,
     preprocessHandler?: (
       event: WithdrawalEvent,
       ctx: WETH9Context,
@@ -703,12 +719,17 @@ export class WETH9Processor extends BaseProcessor<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onCallName(
     handler: (call: NameCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, NameCallTrace>,
     preprocessHandler?: (
       call: NameCallTrace,
       ctx: WETH9Context,
@@ -717,14 +738,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x06fdde03",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallApprove(
     handler: (call: ApproveCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, ApproveCallTrace>,
     preprocessHandler?: (
       call: ApproveCallTrace,
       ctx: WETH9Context,
@@ -733,14 +754,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x095ea7b3",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallTotalSupply(
     handler: (call: TotalSupplyCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TotalSupplyCallTrace>,
     preprocessHandler?: (
       call: TotalSupplyCallTrace,
       ctx: WETH9Context,
@@ -749,14 +770,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x18160ddd",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallTransferFrom(
     handler: (call: TransferFromCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TransferFromCallTrace>,
     preprocessHandler?: (
       call: TransferFromCallTrace,
       ctx: WETH9Context,
@@ -765,14 +786,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x23b872dd",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallWithdraw(
     handler: (call: WithdrawCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawCallTrace>,
     preprocessHandler?: (
       call: WithdrawCallTrace,
       ctx: WETH9Context,
@@ -781,14 +802,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x2e1a7d4d",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallDecimals(
     handler: (call: DecimalsCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>,
     preprocessHandler?: (
       call: DecimalsCallTrace,
       ctx: WETH9Context,
@@ -797,14 +818,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x313ce567",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallBalanceOf(
     handler: (call: BalanceOfCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, BalanceOfCallTrace>,
     preprocessHandler?: (
       call: BalanceOfCallTrace,
       ctx: WETH9Context,
@@ -813,14 +834,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x70a08231",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallSymbol(
     handler: (call: SymbolCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, SymbolCallTrace>,
     preprocessHandler?: (
       call: SymbolCallTrace,
       ctx: WETH9Context,
@@ -829,14 +850,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0x95d89b41",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallTransfer(
     handler: (call: TransferCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TransferCallTrace>,
     preprocessHandler?: (
       call: TransferCallTrace,
       ctx: WETH9Context,
@@ -845,14 +866,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0xa9059cbb",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallDeposit(
     handler: (call: DepositCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, DepositCallTrace>,
     preprocessHandler?: (
       call: DepositCallTrace,
       ctx: WETH9Context,
@@ -861,14 +882,14 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0xd0e30db0",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
 
   onCallAllowance(
     handler: (call: AllowanceCallTrace, ctx: WETH9Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, AllowanceCallTrace>,
     preprocessHandler?: (
       call: AllowanceCallTrace,
       ctx: WETH9Context,
@@ -877,7 +898,7 @@ export class WETH9Processor extends BaseProcessor<
     return super.onEthTrace(
       "0xdd62ed3e",
       handler as any,
-      fetchConfig,
+      handlerOptions,
       preprocessHandler,
     );
   }
@@ -950,7 +971,7 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
   onEventApproval(
     handler: (event: ApprovalEvent, ctx: WETH9Context) => void,
     filter?: ApprovalEventFilter | ApprovalEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>,
     preprocessHandler?: (
       event: ApprovalEvent,
       ctx: WETH9Context,
@@ -964,13 +985,18 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventTransfer(
     handler: (event: TransferEvent, ctx: WETH9Context) => void,
     filter?: TransferEventFilter | TransferEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>,
     preprocessHandler?: (
       event: TransferEvent,
       ctx: WETH9Context,
@@ -984,13 +1010,18 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventDeposit(
     handler: (event: DepositEvent, ctx: WETH9Context) => void,
     filter?: DepositEventFilter | DepositEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, DepositEvent>,
     preprocessHandler?: (
       event: DepositEvent,
       ctx: WETH9Context,
@@ -1000,13 +1031,18 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
     if (!filter) {
       filter = templateContract.filters["Deposit(address,uint256)"](null, null);
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 
   onEventWithdrawal(
     handler: (event: WithdrawalEvent, ctx: WETH9Context) => void,
     filter?: WithdrawalEventFilter | WithdrawalEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawalEvent>,
     preprocessHandler?: (
       event: WithdrawalEvent,
       ctx: WETH9Context,
@@ -1019,7 +1055,12 @@ export class WETH9ProcessorTemplate extends BaseProcessorTemplate<
         null,
       );
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler);
+    return super.onEthEvent(
+      handler,
+      filter!,
+      handlerOptions,
+      preprocessHandler,
+    );
   }
 }
 

package/src/eth/codegen/event-handler.ts

@@ -11,13 +11,13 @@ export function generateEventHandler(event: EventDeclaration, contractName: stri
   onEvent${eventName}(
     handler: (event: ${eventNamePrefix}Event, ctx: ${contractName}Context) => void,
     filter?: ${eventNamePrefix}EventFilter | ${eventNamePrefix}EventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, ${eventNamePrefix}Event>,
     preprocessHandler?: (event: ${eventNamePrefix}Event, ctx: ${contractName}Context, preprocessStore: {[k: string]: any}) => Promise<PreprocessResult>
   ): this {
     if (!filter) {
       filter = templateContract.filters['${filterName}'](${event.inputs.map(() => 'null').join(',')})
     }
-    return super.onEthEvent(handler, filter!, fetchConfig, preprocessHandler)
+    return super.onEthEvent(handler, filter!, handlerOptions, preprocessHandler)
   }
   `
 }

package/src/eth/codegen/file.ts

@@ -196,6 +196,7 @@ export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${c
     {
       ethers: ['BigNumberish', 'Overrides', 'BytesLike', 'Interface'],
       // 'ethers/providers': ['Networkish'],
+      '@sentio/sdk': ['HandlerOptions'],
       '@sentio/sdk/eth': [
         'addContractByABI',
         'getContractByABI',

package/src/eth/codegen/functions-handler.ts

@@ -45,10 +45,10 @@ function generateCallHandler(fn: FunctionDeclaration, contractName: string, over
   return `
   onCall${upperFirst(overloadedName ?? fn.name)}(
     handler: (call: ${upperFirst(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void,
-    fetchConfig?: Partial<EthFetchConfig>,
+    handlerOptions?: HandlerOptions<EthFetchConfig, ${upperFirst(overloadedName ?? fn.name)}CallTrace>,
     preprocessHandler?: (call: ${upperFirst(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => Promise<PreprocessResult>
   ): this {
-    return super.onEthTrace("${sighash}", handler as any, fetchConfig, preprocessHandler);
+    return super.onEthTrace("${sighash}", handler as any, handlerOptions, preprocessHandler);
   }
 `
 }

package/src/eth/eth-plugin.ts

@@ -1,12 +1,13 @@
 import {
   errorString,
+  getProvider,
+  GLOBAL_CONFIG,
   mergeProcessResults,
   Plugin,
   PluginManager,
-  USER_PROCESSOR,
-  GLOBAL_CONFIG,
-  getProvider
+  USER_PROCESSOR
 } from '@sentio/runtime'
+import { PartitionHandlerManager } from '../core/index.js'
 import {
   AccountConfig,
   ContractConfig,
@@ -22,6 +23,7 @@ import {
   PreprocessResult,
   ProcessConfigResponse,
   ProcessResult,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 
@@ -68,6 +70,8 @@ export class EthPlugin extends Plugin {
     transactionHandlers: []
   }
 
+  partitionManager = new PartitionHandlerManager()
+
   async configure(config: ProcessConfigResponse) {
     const handlers: Handlers = {
       blockHandlers: [],
@@ -108,6 +112,7 @@ export class EthPlugin extends Plugin {
       for (const blockHandler of processor.blockHandlers) {
         preprocessHandlers.blockHandlers.push(blockHandler.preprocessHandler ?? defaultPreprocessHandler)
         const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.ETH_BLOCK, handlerId, blockHandler.partitionHandler)
         // TODO wrap the block handler into one
 
         contractConfig.intervalConfigs.push({
@@ -125,6 +130,7 @@ export class EthPlugin extends Plugin {
       for (const traceHandler of processor.traceHandlers) {
         preprocessHandlers.traceHandlers.push(traceHandler.preprocessHandler ?? defaultPreprocessHandler)
         const handlerId = handlers.traceHandlers.push(traceHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.ETH_TRACE, handlerId, traceHandler.partitionHandler)
         for (const signature of traceHandler.signatures) {
           contractConfig.traceConfigs.push({
             signature: signature,
@@ -140,6 +146,7 @@ export class EthPlugin extends Plugin {
         // associate id with filter
         preprocessHandlers.eventHandlers.push(eventsHandler.preprocessHandler ?? defaultPreprocessHandler)
         const handlerId = handlers.eventHandlers.push(eventsHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.ETH_LOG, handlerId, eventsHandler.partitionHandler)
         const logConfig: LogHandlerConfig = {
           handlerId: handlerId,
           handlerName: eventsHandler.handlerName,
@@ -213,6 +220,11 @@ export class EthPlugin extends Plugin {
       for (const transactionHandler of processor.transactionHandler) {
         preprocessHandlers.transactionHandlers.push(transactionHandler.preprocessHandler ?? defaultPreprocessHandler)
         const handlerId = handlers.transactionHandlers.push(transactionHandler.handler) - 1
+        this.partitionManager.registerPartitionHandler(
+          HandlerType.ETH_TRANSACTION,
+          handlerId,
+          transactionHandler.partitionHandler
+        )
         contractConfig.transactionConfig.push({
           handlerId: handlerId,
           handlerName: transactionHandler.handlerName,
@@ -323,6 +335,46 @@ export class EthPlugin extends Plugin {
     }
   }
 
+  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
+    let data: any
+    switch (request.handlerType) {
+      case HandlerType.ETH_LOG:
+        if (!request.data?.ethLog) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "ethLog can't be empty")
+        }
+        data = request.data.ethLog
+        break
+      case HandlerType.ETH_TRACE:
+        if (!request.data?.ethTrace) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "ethTrace can't be empty")
+        }
+        data = request.data.ethTrace
+        break
+      case HandlerType.ETH_BLOCK:
+        if (!request.data?.ethBlock) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "ethBlock can't be empty")
+        }
+        data = request.data.ethBlock
+        break
+      case HandlerType.ETH_TRANSACTION:
+        if (!request.data?.ethTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "ethTransaction can't be empty")
+        }
+        data = request.data.ethTransaction
+        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) {
     const allowedChainIds = new Set<string>(Object.values(EthChainId))
 

package/src/eth/eth.ts

@@ -143,7 +143,13 @@ export function formatEthData(data: {
   trace?: any
   transaction?: any
   transactionReceipt?: any
+  __formattedEthData?: any
 }) {
+  // Return cached result if it exists
+  if (data.__formattedEthData) {
+    return data.__formattedEthData
+  }
+
   const log = data.log ? formatLog(data.log) : undefined
   if (data.block && !data.block.transactions) {
     data.block.transactions = []
@@ -160,13 +166,18 @@ export function formatEthData(data: {
     transaction = formatTransactionResponse(data.transaction)
   }
   const transactionReceipt = data.transactionReceipt ? formatTransactionReceipt(data.transactionReceipt) : undefined
-  return {
+
+  const result = {
     log,
     block,
     trace,
     transaction,
     transactionReceipt
   }
+
+  // Cache the result on the input data object
+  data.__formattedEthData = result
+  return result
 }
 
 export function formatRichBlock(block: RichBlock): RichBlock {

package/src/fuel/codegen/codegen.ts

@@ -119,7 +119,7 @@ async function codegenInternal(abisDir: string, outDir: string): Promise<number>
 import { FuelAbstractProcessor, FuelContractContext, FuelProcessorConfig, TypedCall, FuelFetchConfig, FuelCall, FuelLog, addFuelProcessor, getFuelProcessor, FuelBaseProcessorTemplate } from '@sentio/sdk/fuel'
 import {${abi.commonTypesInUse.join(',')}} from './common.js'
 import {${importedTypes.join(',')}, ${abi.capitalizedName}} from './${abi.capitalizedName}.js'
-
+import { HandlerOptions } from '@sentio/sdk'
 import type { BigNumberish, BN } from 'fuels';
 import type { BytesLike, Bytes, StdString, StrSlice, RawSlice, B256Address, ChecksumAddress, Address } from 'fuels';
 
@@ -221,8 +221,8 @@ function genCallType(f: IFunction) {
 function genOnCallFunction(contractName: string, f: IFunction) {
   const name = upperFirst(f.name)
   return `
-  onCall${name}(handler: (call: ${contractName}.${name}Call, ctx: FuelContractContext<${contractName}>) => void | Promise<void>, config?: FuelFetchConfig) {
-    return super.onCall('${f.name}', (call, ctx) => handler(new ${contractName}.${name}Call(call), ctx), config)
+  onCall${name}(handler: (call: ${contractName}.${name}Call, ctx: FuelContractContext<${contractName}>) => void | Promise<void>, handlerOptions?: HandlerOptions<FuelFetchConfig, ${contractName}.${name}Call>) {
+    return super.onCall('${f.name}', (call, ctx) => handler(new ${contractName}.${name}Call(call), ctx), handlerOptions)
   }`
 }
 
@@ -255,8 +255,8 @@ function genOnLogFunction(contractName: string, [type, ids]: [string, string[]])
 
   if (ids.length == 1) {
     return `
-  onLog${name}(handler: (log: FuelLog<${type}>, ctx: FuelContractContext<${contractName}>) => void | Promise<void>) {
-    return super.onLog<${type}>([Log${name}Id], (log, ctx) => handler(log, ctx))
+  onLog${name}(handler: (log: FuelLog<${type}>, ctx: FuelContractContext<${contractName}>) => void | Promise<void>,  handlerOptions?: HandlerOptions<object, FuelLog<${type}>>) {
+    return super.onLog<${type}>([Log${name}Id], (log, ctx) => handler(log, ctx), handlerOptions)
   }`
   }
   const logIdFilterValues = ids.map((_, idx) => `Log${name}Id${idx}`)

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()) {