@sentio/sdk 2.12.3 → 2.13.0-rc.10

package/src/sui/codegen/codegen.ts

@@ -1,38 +1,31 @@
-import { Connection, JsonRpcProvider, SuiMoveNormalizedModules } from '@mysten/sui.js'
+import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject } from '@mysten/sui.js'
 
 import { SuiNetwork } from '../network.js'
 import * as fs from 'fs'
 import chalk from 'chalk'
 import { InternalMoveModule, InternalMoveStruct } from '../../move/internal-models.js'
 import { AbstractCodegen } from '../../move/abstract-codegen.js'
-import { toInternalModule } from '../move-types.js'
-import { moduleQname, SPLITTER, structQname, TypeDescriptor } from '../../move/index.js'
-import { getMeaningfulFunctionParams } from '../utils.js'
+import { structQname } from '../../move/index.js'
 import { join } from 'path'
+import { SuiChainAdapter } from '../sui-chain-adapter.js'
 
-export async function codegen(abisDir: string, outDir = join('src', 'types', 'sui'), genExample = false) {
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'sui'),
+  genExample = false,
+  builtin = false
+) {
   if (!fs.existsSync(abisDir)) {
     return
   }
   const gen = new SuiCodegen()
-  const numFiles = await gen.generate(abisDir, outDir)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
   console.log(chalk.green(`Generated ${numFiles} for Sui`))
 }
 
-function getRpcEndpoint(network: SuiNetwork): string {
-  switch (network) {
-    case SuiNetwork.TEST_NET:
-      return 'https://fullnode.testnet.sui.io/'
-  }
-  return 'https://fullnode.mainnet.sui.io/'
-}
-
-function getRpcClient(network: SuiNetwork): JsonRpcProvider {
-  return new JsonRpcProvider(new Connection({ fullnode: getRpcEndpoint(network) }))
-}
-
-class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
+class SuiCodegen extends AbstractCodegen<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   ADDRESS_TYPE = 'SuiAddress'
+  // ADDRESS_TYPE = 'string'
   MAIN_NET = SuiNetwork.MAIN_NET
   TEST_NET = SuiNetwork.TEST_NET
   PREFIX = 'Sui'
@@ -40,30 +33,8 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
   // GENERATE_ON_ENTRY = true
   PAYLOAD_OPTIONAL = true
 
-  async fetchModules(account: string, network: SuiNetwork): Promise<SuiMoveNormalizedModules> {
-    const client = getRpcClient(network)
-    return await client.getNormalizedMoveModulesByPackage({ package: account })
-  }
-
-  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-    return getMeaningfulFunctionParams(params)
-  }
-
-  toInternalModules(modules: SuiMoveNormalizedModules): InternalMoveModule[] {
-    return Object.values(modules).map(toInternalModule)
-  }
-
-  getEventStructs(module: InternalMoveModule) {
-    const qname = moduleQname(module)
-    const eventMap = new Map<string, InternalMoveStruct>()
-
-    for (const struct of module.structs) {
-      const abilities = new Set(struct.abilities)
-      if (abilities.has('Drop') && abilities.has('Copy')) {
-        eventMap.set(qname + SPLITTER + struct.name, struct)
-      }
-    }
-    return eventMap
+  constructor() {
+    super(new SuiChainAdapter())
   }
 
   readModulesFile(fullPath: string) {
@@ -80,6 +51,8 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
         return `export type ${struct.name} = string`
       case '0x2::coin::Coin':
         return `export type ${struct.name}<T> = string`
+      case '0x2::balance::Balance':
+        return `export type ${struct.name}<T> = string`
       case '0x1::option::Option':
         return `export type Option<T> = T | undefined`
     }
@@ -91,6 +64,7 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
       case '0x2::object::ID':
       case '0x2::coin::Coin':
       case '0x1::option::Option':
+      case '0x2::balance::Balance':
         return ''
     }
     return super.generateOnEvents(module, struct)

package/src/sui/codegen/run.ts

@@ -6,7 +6,7 @@ if (process.argv.length > 3) {
   const abisDir = process.argv[2]
   const targetDir = process.argv[3]
 
-  await codegen(abisDir, targetDir)
+  await codegen(abisDir, targetDir, false, true)
 } else {
   console.error('Not enough argument')
   process.exit(1)

package/src/sui/context.ts

@@ -2,6 +2,7 @@ import { RecordMetaData } from '@sentio/protos'
 import { type Labels, BaseContext, normalizeLabels } from '../index.js'
 import { SuiNetwork, getChainId } from './network.js'
 import { SuiTransactionBlockResponse } from '@mysten/sui.js'
+import { MoveCoder, defaultMoveCoder } from './move-coder.js'
 
 export class SuiContext extends BaseContext {
   address: string
@@ -10,6 +11,8 @@ export class SuiContext extends BaseContext {
   timestamp: Date
   slot: bigint
   transaction: SuiTransactionBlockResponse
+  eventIndex: number
+  coder: MoveCoder
 
   constructor(
     moduleName: string,
@@ -17,7 +20,8 @@ export class SuiContext extends BaseContext {
     address: string,
     timestamp: Date,
     slot: bigint,
-    transaction?: SuiTransactionBlockResponse
+    transaction: SuiTransactionBlockResponse,
+    eventIndex: number
   ) {
     super()
     this.address = address.toLowerCase()
@@ -25,6 +29,8 @@ export class SuiContext extends BaseContext {
     this.moduleName = moduleName
     this.timestamp = timestamp
     this.slot = slot
+    this.eventIndex = eventIndex
+    this.coder = defaultMoveCoder(network)
     if (transaction) {
       this.transaction = transaction
     }
@@ -54,6 +60,7 @@ export class SuiObjectsContext extends BaseContext {
   network: SuiNetwork
   slot: bigint
   timestamp: Date
+  coder: MoveCoder
 
   constructor(network: SuiNetwork, address: string, slot: bigint, timestamp: Date) {
     super()
@@ -61,6 +68,7 @@ export class SuiObjectsContext extends BaseContext {
     this.network = network
     this.slot = slot
     this.timestamp = timestamp
+    this.coder = defaultMoveCoder(network)
   }
 
   getChainId(): string {

package/src/sui/index.ts

@@ -11,6 +11,7 @@ export * from './context.js'
 export * from './models.js'
 
 export type { SuiAddress } from './move-types.js'
+export { BUILTIN_TYPES } from '../move/types.js'
 
 export * from './move-coder.js'
 

package/src/sui/models.ts

@@ -1,13 +1,8 @@
 import type { SuiEvent, MoveCallSuiTransaction, SuiMoveObject } from '@mysten/sui.js'
+import { DecodedStruct } from '../move/types.js'
 
-export type TypedEventInstance<T> = SuiEvent & {
-  /**
-   * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-   */
-  data_decoded: T
-
-  type_arguments: string[]
-}
+export type TypedEventInstance<T> = DecodedStruct<SuiEvent, T>
+export type TypedSuiMoveObject<T> = DecodedStruct<SuiMoveObject, T>
 
 export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction & {
   /**
@@ -15,8 +10,3 @@ export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction
    */
   arguments_decoded: T
 }
-
-export type TypedSuiMoveObject<T> = SuiMoveObject & {
-  data_decoded: T
-  type_arguments: string[]
-}

package/src/sui/move-coder.ts

@@ -1,78 +1,79 @@
-import { TypedEventInstance, TypedFunctionPayload, TypedSuiMoveObject } from './models.js'
-import { AbstractMoveCoder, StructWithTag } from '../move/abstract-move-coder.js'
-import {
-  MoveCallSuiTransaction,
-  SuiEvent,
-  SuiMoveNormalizedModule,
-  SuiCallArg,
-  SuiMoveObject,
-  SuiRawData,
-} from '@mysten/sui.js'
+import { TypedEventInstance, TypedFunctionPayload } from './models.js'
+import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
+import { MoveCallSuiTransaction, SuiCallArg, SuiEvent, SuiMoveNormalizedModule, SuiMoveObject } from '@mysten/sui.js'
 import { toInternalModule } from './move-types.js'
-import { SPLITTER, TypeDescriptor } from '../move/index.js'
-import { getMeaningfulFunctionParams } from './utils.js'
+import { ANY_TYPE, DecodedStruct, parseMoveType, SPLITTER, TypeDescriptor } from '../move/index.js'
+import { SuiNetwork } from './network.js'
+import { SuiChainAdapter } from './sui-chain-adapter.js'
+import { InternalMoveModule } from '../move/internal-models.js'
 import { dynamic_field } from './builtin/0x2.js'
 
-export class MoveCoder extends AbstractMoveCoder<SuiEvent | SuiMoveObject> {
-  load(module: SuiMoveNormalizedModule) {
-    if (this.contains(module.address, module.name)) {
-      return
+export class MoveCoder extends AbstractMoveCoder<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
+  constructor(network: SuiNetwork) {
+    super(network)
+    this.adapter = new SuiChainAdapter()
+  }
+
+  load(module: SuiMoveNormalizedModule): InternalMoveModule {
+    let m = this.moduleMapping.get(module.address + '::' + module.name)
+    if (m) {
+      return m
     }
-    this.loadInternal(toInternalModule(module))
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
   }
 
   decode(data: any, type: TypeDescriptor): any {
     switch (type.qname) {
       case '0x2::object::ID':
       case '0x2::coin::Coin':
+      case '0x2::balance::Balance':
         return data
       case '0x1::option::Option':
-        // return this.decode(data, type.typeArgs[0])
-        return data
+        if (data === null) {
+          return data
+        }
+        return this.decode(data, type.typeArgs[0])
       default:
         return super.decode(data, type)
     }
   }
 
-  toStructWithTag(val: SuiEvent | SuiMoveObject): StructWithTag<SuiEvent> {
-    if (SuiEvent.is(val)) {
-      return {
-        ...val,
-        data: val.parsedJson as any,
-      }
-    }
-    if (SuiRawData.is(val)) {
-      return {
-        ...val,
-        data: val.fields as any,
-      }
-    }
-    return val as any
-  }
-
-  decodeEvent<T>(event: SuiEvent): TypedEventInstance<T> | undefined {
+  decodeEvent<T>(event: SuiEvent): Promise<TypedEventInstance<T> | undefined> {
     return this.decodedStruct<T>(event) as any
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: SuiEvent[]): TypedEventInstance<T>[] {
-    return this.filterAndDecodeStruct(typeQname, resources)
-  }
-
-  getObjectsFromDynamicFields<Name, Value>(objects: SuiMoveObject[]): dynamic_field.Field<Name, Value>[] {
-    return this.filterAndDecodeObjects(`0x2::dynamic_field::Field`, objects).map((o) => o.data_decoded) as any
+  filterAndDecodeEvents<T>(type: TypeDescriptor<T> | string, resources: SuiEvent[]): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources) as any
   }
 
-  filterAndDecodeObjects<T>(typeQname: string, objects: SuiMoveObject[]): TypedSuiMoveObject<T>[] {
-    return this.filterAndDecodeStruct(typeQname, objects)
+  async getDynamicFields<T1, T2>(
+    objects: SuiMoveObject[],
+    keyType: TypeDescriptor<T1> = ANY_TYPE,
+    valueType: TypeDescriptor<T2> = ANY_TYPE
+  ): Promise<dynamic_field.Field<T1, T2>[]> {
+    // const type = dynamic_field.Field.TYPE
+    // Not using the code above to avoid cycle initialize failed
+    const type = new TypeDescriptor<dynamic_field.Field<T1, T2>>('0x2::dynamic_field::Field')
+    type.typeArgs = [keyType, valueType]
+    const res = await this.filterAndDecodeObjects(type, objects)
+    return res.map((o) => o.data_decoded)
   }
 
-  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-    return getMeaningfulFunctionParams(params)
+  filterAndDecodeObjects<T>(
+    type: TypeDescriptor<T>,
+    objects: SuiMoveObject[]
+  ): Promise<DecodedStruct<SuiMoveObject, T>[]> {
+    return this.filterAndDecodeStruct(type, objects) as any
   }
 
-  decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): MoveCallSuiTransaction {
+  async decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): Promise<MoveCallSuiTransaction> {
     const functionType = [payload.package, payload.module, payload.function].join(SPLITTER)
-    const func = this.getMoveFunction(functionType)
-    const params = getMeaningfulFunctionParams(func.params)
+    const func = await this.getMoveFunction(functionType)
+    const params = this.adapter.getMeaningfulFunctionParams(func.params)
     const args = []
     for (const value of payload.arguments || []) {
       const argValue = value as any
@@ -93,7 +94,7 @@ export class MoveCoder extends AbstractMoveCoder<SuiEvent | SuiMoveObject> {
       }
     }
 
-    const argumentsTyped = this.decodeArray(args, params)
+    const argumentsTyped = await this.decodeArray(args, params)
     return {
       ...payload,
       arguments_decoded: argumentsTyped,
@@ -101,8 +102,12 @@ export class MoveCoder extends AbstractMoveCoder<SuiEvent | SuiMoveObject> {
   }
 }
 
-export const MOVE_CODER = new MoveCoder()
+const MOVE_CODER = new MoveCoder(SuiNetwork.MAIN_NET)
+const TESTNET_MOVE_CODER = new MoveCoder(SuiNetwork.TEST_NET)
 
-export function defaultMoveCoder(): MoveCoder {
-  return MOVE_CODER
+export function defaultMoveCoder(network: SuiNetwork = SuiNetwork.MAIN_NET): MoveCoder {
+  if (network == SuiNetwork.MAIN_NET) {
+    return MOVE_CODER
+  }
+  return TESTNET_MOVE_CODER
 }

package/src/sui/sui-chain-adapter.ts

@@ -0,0 +1,86 @@
+import { ChainAdapter, moduleQname, SPLITTER, TypeDescriptor } from '../move/index.js'
+import { toInternalModule } from './move-types.js'
+import { SuiNetwork } from './network.js'
+import { InternalMoveModule, InternalMoveStruct } from '../move/internal-models.js'
+import {
+  Connection,
+  JsonRpcProvider,
+  SuiMoveNormalizedModule,
+  SuiEvent,
+  SuiMoveObject,
+  SuiParsedData,
+} from '@mysten/sui.js'
+
+export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
+  static INSTANCE = new SuiChainAdapter()
+
+  async fetchModule(account: string, module: string, network: SuiNetwork): Promise<SuiMoveNormalizedModule> {
+    const client = getRpcClient(network)
+    return await client.getNormalizedMoveModule({ package: account, module })
+  }
+
+  async fetchModules(account: string, network: SuiNetwork): Promise<SuiMoveNormalizedModule[]> {
+    const client = getRpcClient(network)
+    const modules = await client.getNormalizedMoveModulesByPackage({ package: account })
+    return Object.values(modules)
+  }
+
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    if (params.length === 0) {
+      return params
+    }
+    return params.slice(0, params.length - 1)
+  }
+
+  toInternalModules(modules: SuiMoveNormalizedModule[]): InternalMoveModule[] {
+    return Object.values(modules).map(toInternalModule)
+  }
+
+  getEventStructs(module: InternalMoveModule) {
+    const qname = moduleQname(module)
+    const eventMap = new Map<string, InternalMoveStruct>()
+
+    for (const struct of module.structs) {
+      const abilities = new Set(struct.abilities)
+      if (abilities.has('Drop') && abilities.has('Copy')) {
+        eventMap.set(qname + SPLITTER + struct.name, struct)
+      }
+    }
+    return eventMap
+  }
+
+  getType(base: SuiEvent | SuiMoveObject): string {
+    return base.type
+  }
+
+  getData(val: SuiEvent | SuiMoveObject) {
+    if (SuiEvent.is(val)) {
+      return val.parsedJson as any
+    }
+    if (SuiParsedData.is(val)) {
+      return val.fields as any
+    }
+    // if (SuiMoveObject.is(val)) {
+    //   return val.fields as any
+    // }
+    // This may not be perfect, just think everything has
+    if ('fields' in val) {
+      if ('type' in val && Object.keys(val).length === 2) {
+        return val.fields as any
+      }
+    }
+    return val as any
+  }
+}
+
+function getRpcEndpoint(network: SuiNetwork): string {
+  switch (network) {
+    case SuiNetwork.TEST_NET:
+      return 'https://fullnode.testnet.sui.io/'
+  }
+  return 'https://fullnode.mainnet.sui.io/'
+}
+
+function getRpcClient(network: SuiNetwork): JsonRpcProvider {
+  return new JsonRpcProvider(new Connection({ fullnode: getRpcEndpoint(network) }))
+}

package/src/sui/sui-plugin.ts

@@ -86,6 +86,7 @@ export class SuiPlugin extends Plugin {
             minutesInterval: handler.timeIntervalInMinutes,
             slot: 0,
             slotInterval: handler.versionInterval,
+            fetchConfig: undefined,
           },
           type: handler.type || '',
           ownerType: processor.ownerType,

package/src/sui/sui-processor.ts

@@ -7,7 +7,7 @@ import {
   MoveOnIntervalConfig_OwnerType,
   ProcessResult,
 } from '@sentio/protos'
-import { ListStateStorage } from '@sentio/runtime'
+import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
 import { getChainId, SuiNetwork } from './network.js'
 import { ServerError, Status } from 'nice-grpc'
 import { SuiContext, SuiObjectsContext } from './context.js'
@@ -19,11 +19,17 @@ import {
   SuiMoveObject,
   SuiTransactionBlockResponse,
 } from '@mysten/sui.js'
-import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter } from '../move/index.js'
+import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter, parseMoveType } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
-import { defaultMoveCoder } from './move-coder.js'
+import { defaultMoveCoder, MoveCoder } from './move-coder.js'
+import { PromiseOrVoid } from '../core/index.js'
 // import { dynamic_field } from './builtin/0x2.js'
 
+const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
+  resourceChanges: false,
+  allEvents: true,
+}
+
 class IndexConfigure {
   address: string
   network: SuiNetwork
@@ -52,11 +58,13 @@ export class SuiBaseProcessor {
 
   eventHandlers: EventHandler<Data_SuiEvent>[] = []
   callHandlers: CallHandler<Data_SuiCall>[] = []
+  coder: MoveCoder
 
   constructor(name: string, options: SuiBindOptions) {
     this.moduleName = name
     this.config = configure(options)
     SuiProcessorState.INSTANCE.addValue(this)
+    this.coder = defaultMoveCoder(this.config.network)
   }
 
   getChainId(): string {
@@ -66,10 +74,10 @@ export class SuiBaseProcessor {
   public onMoveEvent(
     handler: (event: SuiEvent, ctx: SuiContext) => void,
     filter: EventFilter | EventFilter[],
-    fetchConfig?: MoveFetchConfig
+    fetchConfig?: Partial<MoveFetchConfig>
   ): SuiBaseProcessor {
     let _filters: EventFilter[] = []
-    const _fetchConfig = fetchConfig || MoveFetchConfig.fromPartial({})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -81,6 +89,7 @@ export class SuiBaseProcessor {
     // const moduleName = this.moduleName
 
     const processor = this
+    const allEventType = new Set(_filters.map((f) => processor.config.address + '::' + f.type))
 
     this.eventHandlers.push({
       handler: async function (data) {
@@ -92,26 +101,29 @@ export class SuiBaseProcessor {
           throw new ServerError(Status.INVALID_ARGUMENT, 'no event in the transactions')
         }
 
-        const ctx = new SuiContext(
-          processor.moduleName,
-          processor.config.network,
-          processor.config.address,
-          data.timestamp || new Date(0),
-          data.slot,
-          txn
-        )
+        const processResults = []
+        for (const [idx, evt] of (txn.events as SuiEvent[]).entries()) {
+          const typeQname = parseMoveType(evt.type).qname
+          if (!allEventType.has(typeQname)) {
+            continue
+          }
 
-        const events = txn.events
-        txn.events = []
-        for (const evt of events) {
-          // if ('moveEvent' in evt) {
-          //   const eventInstance = evt.moveEvent as SuiEvent
-          const decoded = defaultMoveCoder().decodeEvent<any>(evt)
+          const ctx = new SuiContext(
+            processor.moduleName,
+            processor.config.network,
+            processor.config.address,
+            data.timestamp || new Date(0),
+            data.slot,
+            txn,
+            idx
+          )
+
+          const decoded = await processor.coder.decodeEvent<any>(evt)
           await handler(decoded || evt, ctx)
-          // }
+          processResults.push(ctx.getProcessResult())
         }
 
-        return ctx.getProcessResult()
+        return mergeProcessResults(processResults)
       },
       filters: _filters,
       fetchConfig: _fetchConfig,
@@ -122,10 +134,10 @@ export class SuiBaseProcessor {
   public onEntryFunctionCall(
     handler: (call: MoveCallSuiTransaction, ctx: SuiContext) => void,
     filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
-    fetchConfig?: MoveFetchConfig
+    fetchConfig?: Partial<MoveFetchConfig>
   ): SuiBaseProcessor {
     let _filters: FunctionNameAndCallFilter[] = []
-    const _fetchConfig = fetchConfig || MoveFetchConfig.fromPartial({})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -150,7 +162,8 @@ export class SuiBaseProcessor {
           processor.config.address,
           data.timestamp || new Date(0),
           data.slot,
-          tx
+          tx,
+          0
         )
         if (tx) {
           const calls: MoveCallSuiTransaction[] = getMoveCalls(tx)
@@ -164,7 +177,7 @@ export class SuiBaseProcessor {
           const programmableTx = getProgrammableTransaction(txKind)
 
           const payload = calls[0]
-          const decoded = defaultMoveCoder().decodeFunctionPayload(payload, programmableTx?.inputs || [])
+          const decoded = await processor.coder.decodeFunctionPayload(payload, programmableTx?.inputs || [])
           await handler(decoded, ctx)
         }
         return ctx.getProcessResult()
@@ -214,7 +227,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   protected abstract transformObjects(objects: SuiMoveObject[]): HandlerType[]
 
   protected onInterval(
-    handler: (resources: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (resources: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     versionInterval: HandleInterval | undefined,
     type: string | undefined
@@ -239,7 +252,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   }
 
   public onTimeInterval(
-    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string
@@ -256,7 +269,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   }
 
   public onSlotInterval(
-    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     slotInterval = 100000,
     backfillSlotInterval = 400000,
     type?: string

package/src/sui/utils.ts

@@ -6,7 +6,6 @@ import {
   ProgrammableTransaction,
   SuiTransaction,
 } from '@mysten/sui.js'
-import { TypeDescriptor } from '../move/index.js'
 
 export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
   const txKind = getTransactionKind(txBlock)
@@ -33,10 +32,3 @@ export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
     return []
   })
 }
-
-export function getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-  if (params.length === 0) {
-    return params
-  }
-  return params.slice(0, params.length - 1)
-}