@sentio/sdk 2.59.0-rc.23 → 2.59.0-rc.25

package/src/sui/models.ts

@@ -10,3 +10,5 @@ export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction
    */
   arguments_decoded: T
 }
+
+export type { PartitionHandler, HandlerOptions } from '../core/index.js'

package/src/sui/sui-plugin.ts

@@ -13,10 +13,12 @@ import {
   MoveResourceChangeConfig,
   ProcessConfigResponse,
   ProcessResult,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
 
 import { ServerError, Status } from 'nice-grpc'
+import { PartitionHandlerManager } from '../core/index.js'
 
 import { SuiProcessorState } from './sui-processor.js'
 import { SuiAccountProcessorState, SuiAddressProcessor } from './sui-object-processor.js'
@@ -44,6 +46,8 @@ export class SuiPlugin extends Plugin {
     suiObjectHandlers: [],
     suiObjectChangeHandlers: []
   }
+
+  partitionManager = new PartitionHandlerManager()
   async start(request: StartRequest): Promise<void> {
     await initCoinList()
 
@@ -94,6 +98,7 @@ export class SuiPlugin extends Plugin {
       })
       for (const handler of suiProcessor.eventHandlers) {
         const handlerId = handlers.suiEventHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler)
         const eventHandlerConfig: MoveEventHandlerConfig = {
           filters: handler.filters.map((f) => {
             return {
@@ -110,6 +115,7 @@ export class SuiPlugin extends Plugin {
       }
       for (const handler of suiProcessor.callHandlers) {
         const handlerId = handlers.suiCallHandlers.push(handler.handler) - 1
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler)
         const functionHandlerConfig: MoveCallHandlerConfig = {
           filters: handler.filters.map((filter) => {
             return {
@@ -207,6 +213,68 @@ export class SuiPlugin extends Plugin {
     this.handlers = handlers
   }
 
+  supportedHandlers = [
+    HandlerType.SUI_EVENT,
+    HandlerType.SUI_CALL,
+    HandlerType.SUI_OBJECT,
+    HandlerType.SUI_OBJECT_CHANGE
+  ]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.SUI_EVENT:
+        return this.processSuiEvent(request)
+      case HandlerType.SUI_CALL:
+        return this.processSuiFunctionCall(request)
+      case HandlerType.SUI_OBJECT:
+        return this.processSuiObject(request)
+      case HandlerType.SUI_OBJECT_CHANGE:
+        return this.processSuiObjectChange(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
+    let data: any
+    switch (request.handlerType) {
+      case HandlerType.SUI_EVENT:
+        if (!request.data?.suiEvent) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "suiEvent can't be empty")
+        }
+        data = request.data.suiEvent
+        break
+      case HandlerType.SUI_CALL:
+        if (!request.data?.suiCall) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "suiCall can't be empty")
+        }
+        data = request.data.suiCall
+        break
+      case HandlerType.SUI_OBJECT:
+        if (!request.data?.suiObject) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "suiObject can't be empty")
+        }
+        data = request.data.suiObject
+        break
+      case HandlerType.SUI_OBJECT_CHANGE:
+        if (!request.data?.suiObjectChange) {
+          throw new ServerError(Status.INVALID_ARGUMENT, "suiObjectChange can't be empty")
+        }
+        data = request.data.suiObjectChange
+        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 processSuiEvent(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data?.suiEvent) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
@@ -282,28 +350,6 @@ export class SuiPlugin extends Plugin {
     }
     return mergeProcessResults(await Promise.all(promises))
   }
-
-  supportedHandlers = [
-    HandlerType.SUI_EVENT,
-    HandlerType.SUI_CALL,
-    HandlerType.SUI_OBJECT,
-    HandlerType.SUI_OBJECT_CHANGE
-  ]
-
-  processBinding(request: DataBinding): Promise<ProcessResult> {
-    switch (request.handlerType) {
-      case HandlerType.SUI_EVENT:
-        return this.processSuiEvent(request)
-      case HandlerType.SUI_CALL:
-        return this.processSuiFunctionCall(request)
-      case HandlerType.SUI_OBJECT:
-        return this.processSuiObject(request)
-      case HandlerType.SUI_OBJECT_CHANGE:
-        return this.processSuiObjectChange(request)
-      default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
-    }
-  }
 }
 
 PluginManager.INSTANCE.register(new SuiPlugin())

package/src/sui/sui-processor.ts

@@ -19,6 +19,7 @@ import { defaultMoveCoder, MoveCoder } from './index.js'
 import { ALL_ADDRESS, Labels, PromiseOrVoid } from '../core/index.js'
 import { Required } from 'utility-types'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from './models.js'
 
 export const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
   resourceChanges: false,
@@ -76,10 +77,10 @@ export class SuiBaseProcessor {
   protected onMoveEvent(
     handler: (event: SuiEvent, ctx: SuiContext) => PromiseOrVoid,
     filter: EventFilter | EventFilter[],
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, SuiEvent>
   ): SuiBaseProcessor {
     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
@@ -123,7 +124,17 @@ export class SuiBaseProcessor {
         return ctx.stopAndGetResult()
       },
       filters: _filters,
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiEvent): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const evt = JSON.parse(data.rawEvent) as SuiEvent
+          const decoded = await processor.coder.decodeEvent<any>(evt)
+          return p(decoded || evt)
+        }
+        return p
+      }
     })
     return this
   }
@@ -131,10 +142,10 @@ export class SuiBaseProcessor {
   protected onEntryFunctionCall(
     handler: (call: MoveCallSuiTransaction, ctx: SuiContext) => PromiseOrVoid,
     filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, MoveCallSuiTransaction>
   ): SuiBaseProcessor {
     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
@@ -188,22 +199,39 @@ export class SuiBaseProcessor {
         return ctx.stopAndGetResult()
       },
       filters: _filters,
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const tx = JSON.parse(data.rawTransaction) as SuiTransactionBlockResponse
+          const calls: MoveCallSuiTransaction[] = getMoveCalls(tx)
+          // For simplicity, use the first call for partitioning
+          if (calls.length > 0) {
+            return p(calls[0])
+          }
+          return undefined
+        }
+        return p
+      }
     })
     return this
   }
 
-  onEvent(handler: (event: SuiEvent, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): this {
-    this.onMoveEvent(handler, { type: '' }, fetchConfig)
+  onEvent(
+    handler: (event: SuiEvent, ctx: SuiContext) => void,
+    handlerOptions?: HandlerOptions<MoveFetchConfig, SuiEvent>
+  ): this {
+    this.onMoveEvent(handler, { type: '' }, handlerOptions)
     return this
   }
 
   onTransactionBlock(
     handler: (transaction: SuiTransactionBlockResponse, ctx: SuiContext) => PromiseOrVoid,
     filter?: TransactionFilter,
-    fetchConfig?: Partial<MoveFetchConfig>
+    handlerOptions?: HandlerOptions<MoveFetchConfig, SuiTransactionBlockResponse>
   ): this {
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...handlerOptions })
 
     const processor = this
 
@@ -231,7 +259,16 @@ export class SuiBaseProcessor {
         return ctx.stopAndGetResult()
       },
       filters: [{ ...filter, function: '' }],
-      fetchConfig: _fetchConfig
+      fetchConfig: _fetchConfig,
+      partitionHandler: async (data: Data_SuiCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const tx = JSON.parse(data.rawTransaction) as SuiTransactionBlockResponse
+          return p(tx)
+        }
+        return p
+      }
     })
     return this
   }