@sentio/sdk 2.59.0-rc.8 → 2.59.0

package/src/aptos/aptos-plugin.ts

@@ -1,10 +1,9 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import { PartitionHandlerManager } from '../core/index.js'
 import {
   AccountConfig,
   ContractConfig,
   Data_AptCall,
-  Data_AptEvent,
-  Data_AptResource,
   DataBinding,
   HandlerType,
   MoveCallHandlerConfig,
@@ -12,6 +11,7 @@ import {
   MoveOwnerType,
   ProcessConfigResponse,
   ProcessResult,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 
@@ -27,13 +27,15 @@ import {
   AptosResourceProcessorTemplateState
 } from './aptos-resource-processor-template.js'
 import { AptosNetwork } from './network.js'
+import { AptEvent, AptCall, AptResource } from './data.js'
 
 interface Handlers {
-  aptosEventHandlers: ((event: Data_AptEvent) => Promise<ProcessResult>)[]
-  aptosCallHandlers: ((func: Data_AptCall) => Promise<ProcessResult>)[]
-  aptosResourceHandlers: ((resourceWithVersion: Data_AptResource) => Promise<ProcessResult>)[]
+  aptosEventHandlers: ((event: AptEvent) => Promise<ProcessResult>)[]
+  aptosCallHandlers: ((func: AptCall) => Promise<ProcessResult>)[]
+  aptosResourceHandlers: ((resourceWithVersion: AptResource) => Promise<ProcessResult>)[]
   aptosTransactionIntervalHandlers: ((txn: Data_AptCall) => Promise<ProcessResult>)[]
 }
+
 export class AptosPlugin extends Plugin {
   name: string = 'AptosPlugin'
   handlers: Handlers = {
@@ -43,6 +45,8 @@ export class AptosPlugin extends Plugin {
     aptosTransactionIntervalHandlers: []
   }
 
+  partitionManager = new PartitionHandlerManager()
+
   async start(request: StartRequest) {
     await initTokenList()
 
@@ -90,6 +94,7 @@ export class AptosPlugin extends Plugin {
       // 1. Prepare event handlers
       for (const handler of aptosProcessor.eventHandlers) {
         const handlerId = handlers.aptosEventHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.APT_EVENT, handlerId, handler.partitionHandler)
         const eventHandlerConfig: MoveEventHandlerConfig = {
           filters: handler.filters.map((f) => {
             return {
@@ -108,6 +113,7 @@ export class AptosPlugin extends Plugin {
       // 2. Prepare function handlers
       for (const handler of aptosProcessor.callHandlers) {
         const handlerId = handlers.aptosCallHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.APT_CALL, handlerId, handler.partitionHandler)
         const functionHandlerConfig: MoveCallHandlerConfig = {
           filters: handler.filters.map((filter) => {
             return {
@@ -139,6 +145,7 @@ export class AptosPlugin extends Plugin {
       })
       for (const handler of aptosProcessor.resourceChangeHandlers) {
         const handlerId = handlers.aptosResourceHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.APT_RESOURCE, handlerId, handler.partitionHandler)
         accountConfig.moveResourceChangeConfigs.push({
           handlerId: handlerId,
           handlerName: handler.handlerName,
@@ -150,6 +157,7 @@ export class AptosPlugin extends Plugin {
       //  Prepare interval handlers
       for (const handler of aptosProcessor.transactionIntervalHandlers) {
         const handlerId = handlers.aptosTransactionIntervalHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.APT_CALL, handlerId, handler.partitionHandler)
         accountConfig.moveIntervalConfigs.push({
           intervalConfig: {
             handlerId: handlerId,
@@ -179,6 +187,7 @@ export class AptosPlugin extends Plugin {
       })
       for (const handler of aptosProcessor.resourceIntervalHandlers) {
         const handlerId = handlers.aptosResourceHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.APT_RESOURCE, handlerId, handler.partitionHandler)
         if (handler.timeIntervalInMinutes || handler.versionInterval) {
           accountConfig.moveIntervalConfigs.push({
             intervalConfig: {
@@ -225,12 +234,46 @@ export class AptosPlugin extends Plugin {
     }
   }
 
+  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
+    let data: any
+    switch (request.handlerType) {
+      case HandlerType.APT_EVENT:
+        if (!request.data?.aptEvent) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "aptEvent can't be empty")
+        }
+        data = new AptEvent(request.data.aptEvent)
+        break
+      case HandlerType.APT_CALL:
+        if (!request.data?.aptCall) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "aptCall can't be empty")
+        }
+        data = new AptCall(request.data.aptCall)
+        break
+      case HandlerType.APT_RESOURCE:
+        if (!request.data?.aptResource) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "aptResource can't be empty")
+        }
+        data = new AptResource(request.data.aptResource)
+        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 processAptosEvent(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data?.aptEvent) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
     }
     const promises: Promise<ProcessResult>[] = []
-    const event = binding.data.aptEvent
+    const event = new AptEvent(binding.data.aptEvent)
 
     for (const handlerId of binding.handlerIds) {
       const promise = this.handlers.aptosEventHandlers[handlerId](event).catch((e) => {
@@ -251,7 +294,7 @@ export class AptosPlugin extends Plugin {
     if (!binding.data?.aptResource) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Resource can't be empty")
     }
-    const resource = binding.data.aptResource
+    const resource = new AptResource(binding.data.aptResource)
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
@@ -273,7 +316,7 @@ export class AptosPlugin extends Plugin {
     if (!binding.data?.aptCall) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Call can't be empty")
     }
-    const call = binding.data.aptCall
+    const call = new AptCall(binding.data.aptCall)
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {

package/src/aptos/aptos-processor.ts

@@ -1,25 +1,17 @@
 import { defaultMoveCoder, MoveCoder } from './index.js'
 
 import {
+  EntryFunctionPayloadResponse,
   Event,
   MoveResource,
   UserTransactionResponse,
-  EntryFunctionPayloadResponse,
-  MultisigPayloadResponse,
   WriteSetChangeWriteResource
 } from '@aptos-labs/ts-sdk'
 
 import { AptosBindOptions, AptosNetwork } from './network.js'
 import { AptosContext, AptosResourcesContext, AptosTransactionContext } from './context.js'
 import { ListStateStorage } from '@sentio/runtime'
-import {
-  MoveFetchConfig,
-  Data_AptResource,
-  HandleInterval,
-  Data_AptEvent,
-  Data_AptCall,
-  MoveAccountFetchConfig
-} from '@sentio/protos'
+import { Data_AptResource, HandleInterval, MoveAccountFetchConfig, MoveFetchConfig } from '@sentio/protos'
 import { ServerError, Status } from 'nice-grpc'
 import {
   accountTypeString,
@@ -33,10 +25,11 @@ import {
   TransactionIntervalHandler
 } from '../move/index.js'
 import { ALL_ADDRESS, Labels, PromiseOrVoid } from '../core/index.js'
-import { TypeDescriptor, matchType, NestedDecodedStruct } from '@typemove/move'
-import { decodeResourceChange, ResourceChange } from '@typemove/aptos'
-import { GeneralTransactionResponse } from './models.js'
+import { matchType, NestedDecodedStruct, TypeDescriptor } from '@typemove/move'
+import { ResourceChange } from '@typemove/aptos'
+import { GeneralTransactionResponse, HandlerOptions } from './models.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { AptCall, AptEvent, AptResource } from './data.js'
 
 const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
   resourceChanges: false,
@@ -66,9 +59,9 @@ export class AptosProcessorState extends ListStateStorage<AptosTransactionProces
 export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT extends AptosTransactionContext<T>> {
   readonly moduleName: string
   config: IndexConfigure
-  eventHandlers: EventHandler<Data_AptEvent>[] = []
-  callHandlers: CallHandler<Data_AptCall>[] = []
-  resourceChangeHandlers: ResourceChangeHandler<Data_AptResource>[] = []
+  eventHandlers: EventHandler<AptEvent>[] = []
+  callHandlers: CallHandler<AptCall>[] = []
+  resourceChangeHandlers: ResourceChangeHandler<AptResource>[] = []
   transactionIntervalHandlers: TransactionIntervalHandler[] = []
   coder: MoveCoder
 
@@ -85,10 +78,10 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
   protected onMoveEvent(
     handler: (event: Event, ctx: AptosContext) => PromiseOrVoid,
     filter: EventFilter | EventFilter[],
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, Event>
   ): this {
     let _filters: EventFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -106,12 +99,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         if (!data.rawTransaction) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'event is null')
         }
-        const txn = JSON.parse(data.rawTransaction) as UserTransactionResponse
-        if (txn.events == null) {
-          txn.events = []
-        }
-
-        const evt = JSON.parse(data.rawEvent)
+        const txn = data.transaction
 
         const ctx = new AptosContext(
           processor.moduleName,
@@ -123,13 +111,21 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
           processor.config.baseLabels
         )
 
-        const decoded = await processor.coder.decodeEvent<any>(evt)
-        await handler(decoded || evt, ctx)
-
+        const decoded = await data.decodeEvent(processor.coder)
+        await handler(decoded || data.event, ctx)
         return ctx.stopAndGetResult()
       },
       filters: _filters,
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: AptEvent): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const decoded = await data.decodeEvent(processor.coder)
+          return p(decoded || data.event)
+        }
+        return p
+      }
     })
     return this
   }
@@ -137,10 +133,10 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
   protected onEntryFunctionCall(
     handler: (call: EntryFunctionPayloadResponse, ctx: AptosContext) => PromiseOrVoid,
     filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, EntryFunctionPayloadResponse>
   ): this {
     let _filters: FunctionNameAndCallFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -158,7 +154,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         if (!data.rawTransaction) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
         }
-        const tx = JSON.parse(data.rawTransaction) as UserTransactionResponse
+        const tx = data.transaction
 
         const ctx = new AptosContext(
           processor.moduleName,
@@ -170,18 +166,22 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
           processor.config.baseLabels
         )
         if (tx) {
-          let payload = tx.payload
-          if (payload.type === 'multisig_payload') {
-            payload = (payload as MultisigPayloadResponse).transaction_payload ?? payload
-          }
-
-          const decoded = await processor.coder.decodeFunctionPayload(payload as EntryFunctionPayloadResponse)
+          const decoded = await data.decodeCall(processor.coder)
           await handler(decoded, ctx)
         }
         return ctx.stopAndGetResult()
       },
       filters: _filters,
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: AptCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const decoded = await data.decodeCall(processor.coder)
+          return p(decoded)
+        }
+        return p
+      }
     })
     return this
   }
@@ -192,9 +192,9 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
       includeFailed?: boolean
       sender?: string
     },
-    fetchConfig?: Partial<MoveFetchConfig>
+    handleOptions?: HandlerOptions<MoveFetchConfig, UserTransactionResponse>
   ): this {
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handleOptions })
 
     const processor = this
     const filter: FunctionNameAndCallFilter = { function: '', includeFailed: transactionFilter?.includeFailed }
@@ -211,10 +211,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         if (!data.rawTransaction) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
         }
-        const call = JSON.parse(data.rawTransaction) as UserTransactionResponse
-        if (call.events == null) {
-          call.events = []
-        }
+        const call = data.transaction
         const ctx = new AptosContext(
           processor.moduleName,
           processor.config.network,
@@ -228,19 +225,31 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         return ctx.stopAndGetResult()
       },
       filters: [filter],
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: AptCall): Promise<string | undefined> => {
+        const p = handleOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          return p(data.transaction)
+        }
+        return p
+      }
     })
     return this
   }
 
-  public onEvent(handler: (event: Event, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): this {
-    this.onMoveEvent(handler, { type: '' }, fetchConfig)
+  public onEvent(
+    handler: (event: Event, ctx: AptosContext) => void,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, Event>
+  ): this {
+    this.onMoveEvent(handler, { type: '' }, handlerOptions)
     return this
   }
 
   public onResourceChange<T>(
     handler: (changes: ResourceChange<T>[], ctx: AptosResourcesContext) => PromiseOrVoid,
-    typeDesc: TypeDescriptor<T> | string
+    typeDesc: TypeDescriptor<T> | string,
+    handlerOptions?: HandlerOptions<object, ResourceChange<T>[]>
   ): this {
     if (typeof typeDesc === 'string') {
       typeDesc = parseMoveType(typeDesc)
@@ -255,6 +264,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         if (!data.rawResources || !data.version) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'resource is null')
         }
+        const aptResource = new AptResource(data)
         const timestamp = Number(data.timestampMicros)
         const ctx = new AptosResourcesContext(
           processor.config.network,
@@ -263,10 +273,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
           timestamp,
           processor.config.baseLabels
         )
-        let resources = await decodeResourceChange<T>(
-          data.rawResources.map((r) => JSON.parse(r)),
-          ctx.coder
-        )
+        let resources = await aptResource.decodeResources<T>(processor.coder)
 
         if (hasAny) {
           resources = resources.filter((r) => {
@@ -280,7 +287,16 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         }
         return ctx.stopAndGetResult()
       },
-      type: hasAny ? typeDesc.qname : typeDesc.getNormalizedSignature()
+      type: hasAny ? typeDesc.qname : typeDesc.getNormalizedSignature(),
+      partitionHandler: async (data): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const resources = await data.decodeResources<T>(processor.coder)
+          return p(resources)
+        }
+        return p
+      }
     })
     return this
   }
@@ -289,7 +305,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
     handler: (transaction: T, ctx: CT) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     versionInterval: HandleInterval | undefined,
-    fetchConfig: Partial<MoveFetchConfig> | undefined
+    handlerOptions?: HandlerOptions<MoveFetchConfig, T>
   ): this {
     const processor = this
     this.transactionIntervalHandlers.push({
@@ -318,7 +334,16 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
       },
       timeIntervalInMinutes: timeInterval,
       versionInterval: versionInterval,
-      fetchConfig: { ...DEFAULT_FETCH_CONFIG, ...fetchConfig }
+      fetchConfig: { ...DEFAULT_FETCH_CONFIG, ...handlerOptions },
+      partitionHandler: async (data): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const transaction = JSON.parse(data.rawTransaction) as T
+          return p(transaction)
+        }
+        return p
+      }
     })
     return this
   }
@@ -327,7 +352,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
     handler: (transaction: T, ctx: CT) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, T>
   ): this {
     return this.onInterval(
       handler,
@@ -336,7 +361,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         backfillInterval: backfillTimeIntervalInMinutes
       },
       undefined,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -344,13 +369,13 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
     handler: (transaction: T, context: CT) => PromiseOrVoid,
     versionInterval = 100000,
     backfillVersionInterval = 400000,
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, T>
   ): this {
     return this.onInterval(
       handler,
       undefined,
       { recentInterval: versionInterval, backfillInterval: backfillVersionInterval },
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -377,6 +402,7 @@ export class AptosModulesProcessor extends AptosTransactionProcessor<
 
 export class AptosGlobalProcessor {
   private baseProcessor
+
   private constructor(options: AptosBindOptions) {
     this.baseProcessor = new AptosTransactionProcessor('*', options)
     return proxyProcessor(this)
@@ -405,9 +431,9 @@ export class AptosGlobalProcessor {
     ) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, GeneralTransactionResponse>
   ): this {
-    this.baseProcessor.onTimeInterval(handler, timeIntervalInMinutes, backfillTimeIntervalInMinutes, fetchConfig)
+    this.baseProcessor.onTimeInterval(handler, timeIntervalInMinutes, backfillTimeIntervalInMinutes, handlerOptions)
     return this
   }
 
@@ -418,9 +444,9 @@ export class AptosGlobalProcessor {
     ) => PromiseOrVoid,
     versionInterval = 100000,
     backfillVersionInterval = 400000,
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, GeneralTransactionResponse>
   ): this {
-    this.baseProcessor.onVersionInterval(handler, versionInterval, backfillVersionInterval, fetchConfig)
+    this.baseProcessor.onVersionInterval(handler, versionInterval, backfillVersionInterval, handlerOptions)
     return this
   }
 }
@@ -454,7 +480,7 @@ export class AptosResourcesProcessor {
     timeInterval: HandleInterval | undefined,
     versionInterval: HandleInterval | undefined,
     type: string | undefined,
-    fetchConfig: Partial<MoveAccountFetchConfig> | undefined,
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>,
     handlerName = getHandlerName()
   ): this {
     const processor = this
@@ -464,6 +490,7 @@ export class AptosResourcesProcessor {
         if (data.timestampMicros > Number.MAX_SAFE_INTEGER) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
         }
+        const aptResource = new AptResource(data)
         const timestamp = Number(data.timestampMicros)
 
         const ctx = new AptosResourcesContext(
@@ -473,13 +500,22 @@ export class AptosResourcesProcessor {
           timestamp,
           processor.config.baseLabels
         )
-        await handler(data.rawResources.map((r) => JSON.parse(r)) as MoveResource[], ctx)
+        await handler(aptResource.resources, ctx)
         return ctx.stopAndGetResult()
       },
       timeIntervalInMinutes: timeInterval,
       versionInterval: versionInterval,
       type: type,
-      fetchConfig: { ...DEFAULT_RESOURCE_FETCH_CONFIG, ...fetchConfig }
+      fetchConfig: { ...DEFAULT_RESOURCE_FETCH_CONFIG, ...handlerOptions },
+      partitionHandler: async (data: Data_AptResource): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const aptResource = new AptResource(data)
+          return p(aptResource.resources)
+        }
+        return p
+      }
     })
     return this
   }
@@ -489,7 +525,7 @@ export class AptosResourcesProcessor {
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string,
-    fetchConfig?: Partial<MoveAccountFetchConfig>
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     return this.onInterval(
       handler,
@@ -499,7 +535,7 @@ export class AptosResourcesProcessor {
       },
       undefined,
       type,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -508,14 +544,14 @@ export class AptosResourcesProcessor {
     versionInterval = 100000,
     backfillVersionInterval = 400000,
     typePrefix?: string,
-    fetchConfig?: Partial<MoveAccountFetchConfig>
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     return this.onInterval(
       handler,
       undefined,
       { recentInterval: versionInterval, backfillInterval: backfillVersionInterval },
       typePrefix,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -539,6 +575,7 @@ export class AptosResourcesProcessor {
         if (!data.rawResources || !data.version) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'resource is null')
         }
+        const aptResource = new AptResource(data)
         const ctx = new AptosResourcesContext(
           processor.config.network,
           processor.config.address,
@@ -547,10 +584,11 @@ export class AptosResourcesProcessor {
           processor.config.baseLabels
         )
 
-        let resources = (await decodeResourceChange(
-          data.rawResources.map((r) => JSON.parse(r)),
-          ctx.coder
-        )) as NestedDecodedStruct<MoveResource, WriteSetChangeWriteResource, T>[]
+        let resources = (await aptResource.decodeResources<T>(ctx.coder)) as NestedDecodedStruct<
+          MoveResource,
+          WriteSetChangeWriteResource,
+          T
+        >[]
 
         if (hasAny) {
           resources = resources.filter((r) => {

package/src/aptos/aptos-resource-processor-template.ts

@@ -7,6 +7,7 @@ import { HandleInterval, MoveAccountFetchConfig } from '@sentio/protos'
 import { MoveResource } from '@aptos-labs/ts-sdk'
 import { PromiseOrVoid } from '../core/index.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from './models.js'
 
 export class AptosResourceProcessorTemplateState extends ListStateStorage<AptosResourceProcessorTemplate> {
   static INSTANCE = new AptosResourceProcessorTemplateState()
@@ -18,7 +19,7 @@ class Handler {
   timeIntervalInMinutes?: HandleInterval
   handlerName: string
   handler: (resources: MoveResource[], ctx: AptosResourcesContext) => PromiseOrVoid
-  fetchConfig: MoveAccountFetchConfig
+  handlerOptions: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
 }
 
 export class AptosResourceProcessorTemplate {
@@ -55,7 +56,7 @@ export class AptosResourceProcessorTemplate {
         h.timeIntervalInMinutes,
         h.checkpointInterval,
         h.type,
-        h.fetchConfig,
+        h.handlerOptions,
         h.handlerName
       )
     }
@@ -90,7 +91,7 @@ export class AptosResourceProcessorTemplate {
     timeInterval: HandleInterval | undefined,
     checkpointInterval: HandleInterval | undefined,
     type: string | undefined,
-    fetchConfig: Partial<MoveAccountFetchConfig> | undefined
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     this.handlers.push({
       handlerName: getHandlerName(),
@@ -98,7 +99,7 @@ export class AptosResourceProcessorTemplate {
       timeIntervalInMinutes: timeInterval,
       checkpointInterval: checkpointInterval,
       type,
-      fetchConfig: { ...DEFAULT_RESOURCE_FETCH_CONFIG, ...fetchConfig }
+      handlerOptions: { ...DEFAULT_RESOURCE_FETCH_CONFIG, ...handlerOptions }
     })
     return this
   }
@@ -108,7 +109,7 @@ export class AptosResourceProcessorTemplate {
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string,
-    fetchConfig?: Partial<MoveAccountFetchConfig>
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     return this.onInterval(
       handler,
@@ -118,7 +119,7 @@ export class AptosResourceProcessorTemplate {
       },
       undefined,
       type,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -127,14 +128,14 @@ export class AptosResourceProcessorTemplate {
     checkpointInterval = 100000,
     backfillCheckpointInterval = 400000,
     type?: string,
-    fetchConfig?: Partial<MoveAccountFetchConfig>
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     return this.onInterval(
       handler,
       undefined,
       { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
       type,
-      fetchConfig
+      handlerOptions
     )
   }
 }