@sentio/sdk 2.59.0-rc.3 → 2.59.0-rc.31

package/src/aptos/api.ts

@@ -14,6 +14,9 @@ import { AptosBaseContext } from './context.js'
 import { TypeDescriptor } from '@typemove/move'
 import { defaultMoveCoderForClient } from './move-coder.js'
 
+// Sentinel value to indicate "latest" ledger version
+export const LATEST_LEDGER_VERSION = Number.MAX_SAFE_INTEGER
+
 // Aptos Client inherit [[ Aptos ]] and add getTypedAccountResource method with could get resource and
 // decode it to the specified type
 export class RichAptosClient extends Aptos {
@@ -45,12 +48,21 @@ export class RichAptosClientWithContext extends RichAptosClient {
   }
 
   private transformArgs<T extends { options?: LedgerVersionArg }>(args: T): T {
-    if (!args.options?.ledgerVersion) {
+    // Check if ledgerVersion was explicitly provided
+    if (!args.options || !('ledgerVersion' in args.options)) {
+      // No ledgerVersion specified at all - use context version
       args.options = {
         ...args.options,
         ledgerVersion: this.ctx.version
       }
+    } else if (args.options.ledgerVersion === LATEST_LEDGER_VERSION) {
+      // Explicitly requested latest state using sentinel value
+      args.options = {
+        ...args.options,
+        ledgerVersion: undefined // This tells Aptos SDK to use latest
+      }
     }
+    // Otherwise, use the provided ledgerVersion as-is
     return args
   }
 

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()
 
@@ -60,6 +64,7 @@ export class AptosPlugin extends Plugin {
           address: instance.contract?.address || '',
           network: <AptosNetwork>instance.contract?.chainId || AptosNetwork.MAIN_NET,
           startVersion: instance.startBlock || 0n,
+          endVersion: instance.endBlock,
           baseLabels: instance.baseLabels
         },
         NoopContext
@@ -83,11 +88,13 @@ export class AptosPlugin extends Plugin {
           address: aptosProcessor.config.address,
           abi: ''
         },
-        startBlock: aptosProcessor.config.startVersion
+        startBlock: aptosProcessor.config.startVersion,
+        endBlock: aptosProcessor.config.endVersion
       })
       // 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 {
@@ -106,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 {
@@ -132,20 +140,24 @@ export class AptosPlugin extends Plugin {
       const accountConfig = AccountConfig.fromPartial({
         address: aptosProcessor.config.address,
         chainId: aptosProcessor.getChainId(),
-        startBlock: aptosProcessor.config.startVersion
+        startBlock: aptosProcessor.config.startVersion,
+        endBlock: aptosProcessor.config.endVersion
       })
       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,
-          type: handler.type
+          type: handler.type,
+          includeDeleted: false
         })
       }
 
       //  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,
@@ -170,10 +182,12 @@ export class AptosPlugin extends Plugin {
       const accountConfig = AccountConfig.fromPartial({
         address: aptosProcessor.config.address,
         chainId: aptosProcessor.getChainId(),
-        startBlock: aptosProcessor.config.startVersion
+        startBlock: aptosProcessor.config.startVersion,
+        endBlock: aptosProcessor.config.endVersion
       })
       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: {
@@ -195,7 +209,8 @@ export class AptosPlugin extends Plugin {
           accountConfig.moveResourceChangeConfigs.push({
             handlerId,
             handlerName: handler.handlerName,
-            type: handler.type
+            type: handler.type,
+            includeDeleted: false
           })
         }
       }
@@ -219,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) => {
@@ -245,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) {
@@ -267,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,
@@ -54,6 +47,7 @@ type IndexConfigure = {
   address: string
   network: AptosNetwork
   startVersion: bigint
+  endVersion?: bigint
   baseLabels?: Labels
   // endSeqNumber?: Long
 }
@@ -65,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
 
@@ -84,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
@@ -105,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,
@@ -122,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
   }
@@ -136,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
@@ -157,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,
@@ -169,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
   }
@@ -191,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 }
@@ -210,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,
@@ -227,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)
@@ -254,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,
@@ -262,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) => {
@@ -279,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
   }
@@ -288,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({
@@ -317,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
   }
@@ -326,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,
@@ -335,7 +361,7 @@ export class AptosTransactionProcessor<T extends GeneralTransactionResponse, CT
         backfillInterval: backfillTimeIntervalInMinutes
       },
       undefined,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -343,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
     )
   }
 
@@ -376,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)
@@ -404,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
   }
 
@@ -417,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
   }
 }
@@ -453,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
@@ -463,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(
@@ -472,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
   }
@@ -488,7 +525,7 @@ export class AptosResourcesProcessor {
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string,
-    fetchConfig?: Partial<MoveAccountFetchConfig>
+    handlerOptions?: HandlerOptions<MoveAccountFetchConfig, MoveResource[]>
   ): this {
     return this.onInterval(
       handler,
@@ -498,7 +535,7 @@ export class AptosResourcesProcessor {
       },
       undefined,
       type,
-      fetchConfig
+      handlerOptions
     )
   }
 
@@ -507,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
     )
   }
 
@@ -538,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,
@@ -546,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) => {
@@ -581,6 +620,7 @@ function configure(options: AptosBindOptions): IndexConfigure {
 
   return {
     startVersion: startVersion,
+    endVersion: options.endVersion ? BigInt(options.endVersion) : undefined,
     address: options.address === ALL_ADDRESS ? ALL_ADDRESS : accountTypeString(options.address), // aptos don't use address string in api, so only use type string
     network: options.network || AptosNetwork.MAIN_NET,
     baseLabels: options.baseLabels