@sentio/sdk 2.15.7-rc.2 → 2.16.0-rc.1

package/src/eth/eth-plugin.ts

@@ -18,11 +18,12 @@ import {
 import { ServerError, Status } from 'nice-grpc'
 import { ProcessorState } from './binds.js'
 import { AccountProcessorState } from './account-processor-state.js'
-import { ProcessorTemplateProcessorState, TemplateInstanceState } from './base-processor-template.js'
+import { ProcessorTemplateProcessorState } from './base-processor-template.js'
 import { GlobalProcessorState } from './base-processor.js'
 import { validateAndNormalizeAddress } from './eth.js'
 import { EthChainId } from '../core/chain.js'
 import { EthContext } from './context.js'
+import { TemplateInstanceState } from '../core/template.js'
 
 interface Handlers {
   eventHandlers: ((event: Data_EthLog) => Promise<ProcessResult>)[]
@@ -244,7 +245,13 @@ export class EthPlugin extends Plugin {
 
   async start(request: StartRequest) {
     const ctx = new NoopContext()
+    const allowedChainIds = new Set<string>(Object.values(EthChainId))
+
     for (const instance of request.templateInstances) {
+      if (!allowedChainIds.has(instance.contract?.chainId || '')) {
+        continue
+      }
+
       const template = ProcessorTemplateProcessorState.INSTANCE.getValues()[instance.templateId]
       if (!template) {
         throw new ServerError(Status.INVALID_ARGUMENT, 'Invalid template contract:' + instance)

package/src/sui/index.ts

@@ -1,4 +1,16 @@
-export * from './sui-processor.js'
+export { SuiBaseProcessor, type SuiBindOptions } from './sui-processor.js'
+export {
+  SuiAddressProcessor,
+  SuiObjectProcessor,
+  SuiWrappedObjectProcessor,
+  type SuiObjectBindOptions,
+} from './sui-object-processor.js'
+
+export {
+  // SuiAddressProcessorTemplate,
+  SuiObjectsProcessorTemplate,
+  SuiWrappedObjectProcessorTemplate,
+} from './sui-objects-processor-template.js'
 
 export * from './network.js'
 export * from './context.js'

package/src/sui/sui-object-processor.ts

@@ -0,0 +1,186 @@
+import { Data_SuiObject, HandleInterval, MoveAccountFetchConfig, MoveOwnerType, ProcessResult } from '@sentio/protos'
+import { ListStateStorage } from '@sentio/runtime'
+import { SuiNetwork } from './network.js'
+import { SuiObjectsContext } from './context.js'
+import { SuiMoveObject } from '@mysten/sui.js'
+import { PromiseOrVoid } from '../core/index.js'
+import { configure, IndexConfigure, SuiBindOptions } from './sui-processor.js'
+
+export interface SuiObjectBindOptions {
+  objectId: string
+  network?: SuiNetwork
+  startCheckpoint?: bigint
+  baseLabels?: { [key: string]: string }
+}
+
+interface ObjectHandler {
+  type?: string
+  versionInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  fetchConfig: MoveAccountFetchConfig
+  handler: (resource: Data_SuiObject) => Promise<ProcessResult>
+}
+
+export const DEFAULT_FETCH_CONFIG: MoveAccountFetchConfig = {
+  owned: true,
+}
+
+export class SuiAccountProcessorState extends ListStateStorage<SuiBaseObjectsProcessor<any>> {
+  static INSTANCE = new SuiAccountProcessorState()
+}
+
+export interface SuiInternalObjectsBindOptions extends SuiBindOptions {
+  ownerType: MoveOwnerType
+}
+
+export abstract class SuiBaseObjectsProcessor<HandlerType> {
+  config: IndexConfigure
+  ownerType: MoveOwnerType
+
+  objectHandlers: ObjectHandler[] = []
+
+  // static bind(options: SuiObjectsBindOptions): SuiBaseObjectsProcessor<any> {
+  //   return new SuiBaseObjectsProcessor(options)
+  // }
+
+  protected constructor(options: SuiInternalObjectsBindOptions) {
+    this.config = configure(options)
+    this.ownerType = options.ownerType
+    SuiAccountProcessorState.INSTANCE.addValue(this)
+  }
+
+  getChainId(): string {
+    return this.config.network
+  }
+
+  // protected abstract transformObjects(objects: SuiMoveObject[]): SuiMoveObject[]
+
+  protected abstract doHandle(handler: HandlerType, data: Data_SuiObject, ctx: SuiObjectsContext): PromiseOrVoid
+
+  public onInterval(
+    handler: HandlerType, //(resources: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    versionInterval: HandleInterval | undefined,
+    type: string | undefined,
+    fetchConfig: Partial<MoveAccountFetchConfig> | undefined
+  ): this {
+    const processor = this
+    this.objectHandlers.push({
+      handler: async function (data) {
+        const ctx = new SuiObjectsContext(
+          processor.config.network,
+          processor.config.address,
+          data.slot,
+          data.timestamp || new Date(0),
+          processor.config.baseLabels
+        )
+        await processor.doHandle(handler, data, ctx)
+        return ctx.getProcessResult()
+      },
+      timeIntervalInMinutes: timeInterval,
+      versionInterval: versionInterval,
+      type,
+      fetchConfig: { ...DEFAULT_FETCH_CONFIG, ...fetchConfig },
+    })
+    return this
+  }
+
+  public onTimeInterval(
+    handler: HandlerType,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes,
+      },
+      undefined,
+      type,
+      fetchConfig
+    )
+  }
+
+  public onSlotInterval(
+    handler: HandlerType,
+    slotInterval = 100000,
+    backfillSlotInterval = 400000,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: slotInterval, backfillInterval: backfillSlotInterval },
+      type,
+      fetchConfig
+    )
+  }
+}
+
+export class SuiAddressProcessor extends SuiBaseObjectsProcessor<
+  (objects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
+> {
+  static bind(options: SuiBindOptions): SuiAddressProcessor {
+    return new SuiAddressProcessor({ ...options, ownerType: MoveOwnerType.ADDRESS })
+  }
+
+  protected doHandle(
+    handler: (objects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: SuiObjectsContext
+  ): PromiseOrVoid {
+    return handler(data.objects as SuiMoveObject[], ctx)
+  }
+}
+
+export class SuiObjectProcessor extends SuiBaseObjectsProcessor<
+  (self: SuiMoveObject, dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
+> {
+  static bind(options: SuiObjectBindOptions): SuiObjectProcessor {
+    return new SuiObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      ownerType: MoveOwnerType.OBJECT,
+      baseLabels: options.baseLabels,
+    })
+  }
+
+  protected doHandle(
+    handler: (self: SuiMoveObject, dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: SuiObjectsContext
+  ): PromiseOrVoid {
+    if (!data.self) {
+      console.log(`Sui object not existed in ${ctx.slot}, please specific a start time`)
+      return
+    }
+    return handler(data.self as SuiMoveObject, data.objects as SuiMoveObject[], ctx)
+  }
+}
+
+export class SuiWrappedObjectProcessor extends SuiBaseObjectsProcessor<
+  (dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
+> {
+  static bind(options: SuiObjectBindOptions): SuiWrappedObjectProcessor {
+    return new SuiWrappedObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      ownerType: MoveOwnerType.WRAPPED_OBJECT,
+      baseLabels: options.baseLabels,
+    })
+  }
+
+  protected doHandle(
+    handler: (dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: SuiObjectsContext
+  ): PromiseOrVoid {
+    return handler(data.objects as SuiMoveObject[], ctx)
+  }
+}

package/src/sui/sui-objects-processor-template.ts

@@ -0,0 +1,153 @@
+import { HandleInterval, MoveAccountFetchConfig } from '@sentio/protos'
+import { ListStateStorage } from '@sentio/runtime'
+import { SuiContext, SuiObjectsContext } from './context.js'
+import { SuiMoveObject } from '@mysten/sui.js'
+import { PromiseOrVoid } from '../core/index.js'
+import {
+  DEFAULT_FETCH_CONFIG,
+  SuiBaseObjectsProcessor,
+  SuiObjectBindOptions,
+  SuiObjectProcessor,
+  SuiWrappedObjectProcessor,
+} from './sui-object-processor.js'
+import { TemplateInstanceState } from '../core/template.js'
+
+class ObjectHandler<HandlerType> {
+  type?: string
+  versionInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  handler: HandlerType
+  fetchConfig: MoveAccountFetchConfig
+}
+
+export class SuiAccountProcessorTemplateState extends ListStateStorage<SuiBaseObjectsProcessorTemplate<any, any>> {
+  static INSTANCE = new SuiAccountProcessorTemplateState()
+}
+
+export abstract class SuiBaseObjectsProcessorTemplate<
+  HandlerType,
+  // OptionType,
+  ProcessorType extends SuiBaseObjectsProcessor<HandlerType>
+> {
+  id: number
+  objectHandlers: ObjectHandler<HandlerType>[] = []
+  binds = new Set<string>()
+
+  protected constructor() {
+    this.id = SuiAccountProcessorTemplateState.INSTANCE.getValues().length
+    SuiAccountProcessorTemplateState.INSTANCE.addValue(this)
+  }
+
+  abstract createProcessor(options: SuiObjectBindOptions): ProcessorType
+
+  bind(options: SuiObjectBindOptions, ctx: SuiContext): void {
+    options.network = options.network || ctx.network
+    const sig = [options.network, options.objectId].join('_')
+    if (this.binds.has(sig)) {
+      console.log(`Same object id can be bind to one template only once, ignore duplicate bind: ${sig}`)
+      return
+    }
+    this.binds.add(sig)
+
+    const processor = this.createProcessor(options)
+    for (const h of this.objectHandlers) {
+      processor.onInterval(h.handler, h.timeIntervalInMinutes, h.versionInterval, h.type, h.fetchConfig)
+    }
+    const config = processor.config
+
+    ctx._res.states.configUpdated = true
+    TemplateInstanceState.INSTANCE.addValue({
+      templateId: this.id,
+      contract: {
+        name: '',
+        chainId: config.network,
+        address: config.address,
+        abi: '',
+      },
+      startBlock: config.startCheckpoint,
+      endBlock: 0n,
+    })
+  }
+
+  protected onInterval(
+    handler: HandlerType,
+    timeInterval: HandleInterval | undefined,
+    versionInterval: HandleInterval | undefined,
+    type: string | undefined,
+    fetchConfig: Partial<MoveAccountFetchConfig> | undefined
+  ): this {
+    this.objectHandlers.push({
+      handler: handler,
+      timeIntervalInMinutes: timeInterval,
+      versionInterval: versionInterval,
+      type,
+      fetchConfig: { ...DEFAULT_FETCH_CONFIG, ...fetchConfig },
+    })
+    return this
+  }
+
+  public onTimeInterval(
+    handler: HandlerType,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes,
+      },
+      undefined,
+      type,
+      fetchConfig
+    )
+  }
+
+  public onSlotInterval(
+    handler: HandlerType,
+    slotInterval = 100000,
+    backfillSlotInterval = 400000,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: slotInterval, backfillInterval: backfillSlotInterval },
+      type,
+      fetchConfig
+    )
+  }
+}
+
+// export class SuiAddressProcessorTemplate extends SuiBaseObjectsProcessorTemplate<
+//   (objects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+//   SuiBindOptions,
+//   SuiAddressProcessor
+// > {
+//   bind(options: SuiBindOptions, ctx: SuiContext): SuiAddressProcessor {
+//     return this.bindInternal(SuiAddressProcessorTemplate.bind(options), ctx)
+//   }
+// }
+
+export class SuiObjectsProcessorTemplate extends SuiBaseObjectsProcessorTemplate<
+  (self: SuiMoveObject, dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+  // SuiObjectBindOptions,
+  SuiObjectProcessor
+> {
+  createProcessor(options: SuiObjectBindOptions): SuiObjectProcessor {
+    return SuiObjectProcessor.bind(options)
+  }
+}
+
+export class SuiWrappedObjectProcessorTemplate extends SuiBaseObjectsProcessorTemplate<
+  (dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
+  // SuiObjectBindOptions,
+  SuiWrappedObjectProcessor
+> {
+  createProcessor(options: SuiObjectBindOptions): SuiWrappedObjectProcessor {
+    return SuiWrappedObjectProcessor.bind(options)
+  }
+}

package/src/sui/sui-plugin.ts

@@ -16,9 +16,14 @@ import {
 
 import { ServerError, Status } from 'nice-grpc'
 
-import { SuiAccountProcessorState, SuiProcessorState } from './sui-processor.js'
+import { SuiProcessorState } from './sui-processor.js'
+import { SuiAccountProcessorState } from './sui-object-processor.js'
 import { validateAndNormalizeAddress } from './utils.js'
 import { initCoinList } from './ext/coin.js'
+import { SuiChainId } from '../core/chain.js'
+import { SuiAccountProcessorTemplateState, SuiBaseObjectsProcessorTemplate } from './sui-objects-processor-template.js'
+import { SuiNetwork } from './network.js'
+import { SuiContext } from './context.js'
 
 interface Handlers {
   suiEventHandlers: ((event: Data_SuiEvent) => Promise<ProcessResult>)[]
@@ -33,8 +38,27 @@ export class SuiPlugin extends Plugin {
     suiEventHandlers: [],
     suiObjectHandlers: [],
   }
-  async start(start: StartRequest): Promise<void> {
+  async start(request: StartRequest): Promise<void> {
     await initCoinList()
+
+    const allowedChainIds = new Set<string>(Object.values(SuiChainId))
+    for (const instance of request.templateInstances) {
+      if (!allowedChainIds.has(instance.contract?.chainId || '')) {
+        continue
+      }
+
+      const template: SuiBaseObjectsProcessorTemplate<any, any> =
+        SuiAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId]
+
+      template.bind(
+        {
+          objectId: instance.contract?.address || '',
+          network: <SuiNetwork>instance.contract?.chainId || SuiNetwork.MAIN_NET,
+          startCheckpoint: instance.startBlock || 0n,
+        },
+        NoopContext
+      )
+    }
   }
 
   async configure(config: ProcessConfigResponse) {
@@ -107,6 +131,7 @@ export class SuiPlugin extends Plugin {
           },
           type: handler.type || '',
           ownerType: processor.ownerType,
+          fetchConfig: undefined,
         })
       }
       config.accountConfigs.push(accountConfig)
@@ -187,3 +212,5 @@ export class SuiPlugin extends Plugin {
 }
 
 PluginManager.INSTANCE.register(new SuiPlugin())
+
+const NoopContext = new SuiContext('', SuiChainId.SUI_MAINNET, '', new Date(), 0n, {} as any, 0, {})

package/src/sui/sui-processor.ts

@@ -1,22 +1,13 @@
-import {
-  Data_SuiCall,
-  Data_SuiEvent,
-  Data_SuiObject,
-  HandleInterval,
-  MoveFetchConfig,
-  MoveOnIntervalConfig_OwnerType,
-  ProcessResult,
-} from '@sentio/protos'
+import { Data_SuiCall, Data_SuiEvent, MoveFetchConfig } from '@sentio/protos'
 import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
 import { SuiNetwork } from './network.js'
 import { ServerError, Status } from 'nice-grpc'
-import { SuiContext, SuiObjectsContext } from './context.js'
+import { SuiContext } from './context.js'
 import {
   getProgrammableTransaction,
   getTransactionKind,
   MoveCallSuiTransaction,
   SuiEvent,
-  SuiMoveObject,
   SuiTransactionBlockResponse,
 } from '@mysten/sui.js'
 import {
@@ -29,35 +20,32 @@ import {
 } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
 import { defaultMoveCoder, MoveCoder } from './move-coder.js'
-import { Labels, PromiseOrVoid } from '../core/index.js'
-// import { dynamic_field } from './builtin/0x2.js'
+import { Labels } from '../core/index.js'
+import { Required } from 'utility-types'
 
 const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
   resourceChanges: false,
   allEvents: true,
 }
 
-class IndexConfigure {
-  address: string
-  network: SuiNetwork
-  startCheckpoint: bigint
-  baseLabels?: Labels
+export type IndexConfigure = Required<SuiBindOptions, 'startCheckpoint' | 'network'>
+
+export function configure(options: SuiBindOptions): IndexConfigure {
+  return {
+    startCheckpoint: options.startCheckpoint || 0n,
+    address: options.address,
+    network: options.network || SuiNetwork.MAIN_NET,
+    baseLabels: options.baseLabels,
+  }
 }
 
-export class SuiBindOptions {
+export interface SuiBindOptions {
   address: string
   network?: SuiNetwork
   startCheckpoint?: bigint
   baseLabels?: Labels
 }
 
-export class SuiObjectBindOptions {
-  objectId: string
-  network?: SuiNetwork
-  startCheckpoint?: bigint
-  baseLabels?: { [key: string]: string }
-}
-
 export class SuiProcessorState extends ListStateStorage<SuiBaseProcessor> {
   static INSTANCE = new SuiProcessorState()
 }
@@ -206,173 +194,3 @@ export class SuiBaseProcessor {
     return this
   }
 }
-
-class ObjectHandler {
-  type?: string
-  versionInterval?: HandleInterval
-  timeIntervalInMinutes?: HandleInterval
-  handler: (resource: Data_SuiObject) => Promise<ProcessResult>
-}
-
-export class SuiAccountProcessorState extends ListStateStorage<SuiBaseObjectsProcessor<any>> {
-  static INSTANCE = new SuiAccountProcessorState()
-}
-
-class SuiObjectsBindOptions extends SuiBindOptions {
-  ownerType: MoveOnIntervalConfig_OwnerType
-}
-
-abstract class SuiBaseObjectsProcessor<HandlerType> {
-  config: IndexConfigure
-  ownerType: MoveOnIntervalConfig_OwnerType
-
-  objectHandlers: ObjectHandler[] = []
-
-  // static bind(options: SuiObjectsBindOptions): SuiBaseObjectsProcessor<any> {
-  //   return new SuiBaseObjectsProcessor(options)
-  // }
-
-  protected constructor(options: SuiObjectsBindOptions) {
-    this.config = configure(options)
-    this.ownerType = options.ownerType
-    SuiAccountProcessorState.INSTANCE.addValue(this)
-  }
-
-  getChainId(): string {
-    return this.config.network
-  }
-
-  // protected abstract transformObjects(objects: SuiMoveObject[]): SuiMoveObject[]
-
-  protected abstract doHandle(handler: HandlerType, data: Data_SuiObject, ctx: SuiObjectsContext): PromiseOrVoid
-
-  protected onInterval(
-    handler: HandlerType, //(resources: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
-    timeInterval: HandleInterval | undefined,
-    versionInterval: HandleInterval | undefined,
-    type: string | undefined
-  ): this {
-    const processor = this
-    this.objectHandlers.push({
-      handler: async function (data) {
-        const ctx = new SuiObjectsContext(
-          processor.config.network,
-          processor.config.address,
-          data.slot,
-          data.timestamp || new Date(0),
-          processor.config.baseLabels
-        )
-        await processor.doHandle(handler, data, ctx)
-        return ctx.getProcessResult()
-      },
-      timeIntervalInMinutes: timeInterval,
-      versionInterval: versionInterval,
-      type,
-    })
-    return this
-  }
-
-  public onTimeInterval(
-    handler: HandlerType,
-    timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240,
-    type?: string
-  ): this {
-    return this.onInterval(
-      handler,
-      {
-        recentInterval: timeIntervalInMinutes,
-        backfillInterval: backfillTimeIntervalInMinutes,
-      },
-      undefined,
-      type
-    )
-  }
-
-  public onSlotInterval(
-    handler: HandlerType,
-    slotInterval = 100000,
-    backfillSlotInterval = 400000,
-    type?: string
-  ): this {
-    return this.onInterval(
-      handler,
-      undefined,
-      { recentInterval: slotInterval, backfillInterval: backfillSlotInterval },
-      type
-    )
-  }
-}
-
-function configure(options: SuiBindOptions): IndexConfigure {
-  return {
-    startCheckpoint: options.startCheckpoint || 0n,
-    address: options.address,
-    network: options.network || SuiNetwork.MAIN_NET,
-    baseLabels: options.baseLabels,
-  }
-}
-
-export class SuiAddressProcessor extends SuiBaseObjectsProcessor<
-  (objects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
-> {
-  static bind(options: SuiBindOptions): SuiAddressProcessor {
-    return new SuiAddressProcessor({ ...options, ownerType: MoveOnIntervalConfig_OwnerType.ADDRESS })
-  }
-
-  protected doHandle(
-    handler: (objects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
-    data: Data_SuiObject,
-    ctx: SuiObjectsContext
-  ): PromiseOrVoid {
-    return handler(data.objects as SuiMoveObject[], ctx)
-  }
-}
-// export class SuiDynamicFieldObjectsProcessor extends SuiBaseObjectsProcessor<dynamic_field.Field<any, any>> {
-export class SuiObjectProcessor extends SuiBaseObjectsProcessor<
-  (self: SuiMoveObject, dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
-> {
-  static bind(options: SuiObjectBindOptions): SuiObjectProcessor {
-    return new SuiObjectProcessor({
-      address: options.objectId,
-      network: options.network,
-      startCheckpoint: options.startCheckpoint,
-      ownerType: MoveOnIntervalConfig_OwnerType.OBJECT,
-      baseLabels: options.baseLabels,
-    })
-  }
-
-  protected doHandle(
-    handler: (self: SuiMoveObject, dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
-    data: Data_SuiObject,
-    ctx: SuiObjectsContext
-  ): PromiseOrVoid {
-    if (!data.self) {
-      console.log(`Sui object not existed in ${ctx.slot}, please specific a start time`)
-      return
-    }
-    return handler(data.self as SuiMoveObject, data.objects as SuiMoveObject[], ctx)
-  }
-}
-
-export class SuiWrappedObjectProcessor extends SuiBaseObjectsProcessor<
-  (dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid
-> {
-  static bind(options: SuiObjectBindOptions): SuiWrappedObjectProcessor {
-    return new SuiWrappedObjectProcessor({
-      address: options.objectId,
-      network: options.network,
-      startCheckpoint: options.startCheckpoint,
-      ownerType: MoveOnIntervalConfig_OwnerType.WRAPPED_OBJECT,
-      baseLabels: options.baseLabels,
-    })
-  }
-
-  protected doHandle(
-    handler: (dynamicFieldObjects: SuiMoveObject[], ctx: SuiObjectsContext) => PromiseOrVoid,
-    data: Data_SuiObject,
-    ctx: SuiObjectsContext
-  ): PromiseOrVoid {
-    return handler(data.objects as SuiMoveObject[], ctx)
-  }
-}