@sentio/sdk 2.59.5-rc.1 → 2.60.0-rc.10

package/src/sui/network.ts

@@ -7,9 +7,6 @@ export type SuiNetwork = SuiChainId
 export const SuiNetwork = <const>{
   MAIN_NET: SuiChainId.SUI_MAINNET,
   TEST_NET: SuiChainId.SUI_TESTNET
-  // DEV_NET: SuiChainId.SUI_DEVNET,
-  // MOVEMENT_MAIN_NET: SuiChainId.SUI_MOVEMENT_MAINNET,
-  // MOVEMENT_TEST_NET: SuiChainId.SUI_MOVEMENT_TESTNET
 }
 
 export function getClient(network: SuiNetwork): SuiClient {

package/src/sui/sui-plugin-part.ts

@@ -0,0 +1,211 @@
+import { USER_PROCESSOR } from '@sentio/runtime'
+import {
+  AccountConfig,
+  ContractConfig,
+  HandlerType,
+  InitResponse,
+  MoveCallHandlerConfig,
+  MoveEventHandlerConfig,
+  MoveResourceChangeConfig,
+  ProcessConfigResponse,
+  StartRequest
+} from '@sentio/protos'
+
+import { PartitionHandlerManager } from '../core/index.js'
+import { HandlerRegister } from '../core/handler-register.js'
+
+import { SuiProcessorState } from './sui-processor.js'
+import { SuiAccountProcessorState, SuiAddressProcessor } from './sui-object-processor.js'
+import { initCoinList } from './ext/coin.js'
+import { SuiChainId } from '@sentio/chain'
+import {
+  SuiAccountProcessorTemplateState,
+  SuiObjectOrAddressProcessorTemplate
+} from './sui-object-processor-template.js'
+import { SuiNetwork } from './network.js'
+import { SuiContext } from './context.js'
+
+export class SuiPluginPart {
+  constructor(
+    private handlerRegister: HandlerRegister,
+    private partitionManager: PartitionHandlerManager
+  ) {}
+
+  async start(request: StartRequest): Promise<void> {
+    await initCoinList()
+
+    console.log('total instances:', request.templateInstances.length)
+    const allowedChainIds = new Set<string>([SuiChainId.SUI_MAINNET, SuiChainId.SUI_TESTNET])
+    for (const instance of request.templateInstances) {
+      if (!allowedChainIds.has(instance.contract?.chainId || '')) {
+        continue
+      }
+
+      console.log('start template instance', instance.templateId)
+      const template: SuiObjectOrAddressProcessorTemplate<any, any, any> =
+        SuiAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId]
+
+      template.bind(
+        {
+          address: instance.contract?.address || '',
+          objectId: instance.contract?.address || '',
+          network: <SuiNetwork>instance.contract?.chainId || SuiNetwork.MAIN_NET,
+          startCheckpoint: instance.startBlock || 0n,
+          endCheckpoint: instance.endBlock || 0n,
+          baseLabels: instance.baseLabels
+        },
+        NoopContext
+      )
+    }
+  }
+
+  async init(config: InitResponse) {
+    for (const state of [SuiProcessorState.INSTANCE, SuiAccountProcessorState.INSTANCE]) {
+      for (const suiProcessor of state.getValues()) {
+        config.chainIds.push(suiProcessor.config.network)
+      }
+    }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    // this.handlerRegister.clear(forChainId as any)
+
+    for (const suiProcessor of SuiProcessorState.INSTANCE.getValues()) {
+      const chainId = suiProcessor.config.network
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
+      const contractConfig = ContractConfig.fromPartial({
+        transactionConfig: [],
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: suiProcessor.moduleName,
+          chainId: suiProcessor.config.network,
+          address: suiProcessor.config.address,
+          abi: ''
+        },
+        startBlock: suiProcessor.config.startCheckpoint,
+        endBlock: suiProcessor.config.endCheckpoint
+      })
+      for (const handler of suiProcessor.eventHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler)
+        const eventHandlerConfig: MoveEventHandlerConfig = {
+          filters: handler.filters.map((f) => {
+            return {
+              type: f.type,
+              account: f.account || '',
+              eventAccount: f.eventAccount || ''
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        }
+        contractConfig.moveEventConfigs.push(eventHandlerConfig)
+      }
+      for (const handler of suiProcessor.callHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler)
+        const functionHandlerConfig: MoveCallHandlerConfig = {
+          filters: handler.filters.map((filter) => {
+            return {
+              function: filter.function,
+              typeArguments: filter.typeArguments || [],
+              withTypeArguments: !!filter.typeArguments,
+              includeFailed: filter.includeFailed || false,
+              publicKeyPrefix: filter.publicKeyPrefix || '',
+              fromAndToAddress: filter.fromAndToAddress
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        }
+        contractConfig.moveCallConfigs.push(functionHandlerConfig)
+      }
+      // deprecated, use objectType processor instead
+      for (const handler of suiProcessor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        const objectChangeHandler: MoveResourceChangeConfig = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        }
+        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler)
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+
+    for (const processor of SuiAccountProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.getChainId()
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
+      const accountConfig = AccountConfig.fromPartial({
+        address: processor.config.address,
+        chainId: processor.getChainId(),
+        startBlock: processor.config.startCheckpoint, // TODO maybe use another field
+        endBlock: processor.config.endCheckpoint
+      })
+
+      for (const handler of processor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+        const objectChangeHandler: MoveResourceChangeConfig = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        }
+        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler)
+      }
+
+      for (const handler of processor.objectHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId)
+
+        accountConfig.moveIntervalConfigs.push({
+          intervalConfig: {
+            handlerId: handlerId,
+            handlerName: handler.handlerName,
+            minutes: 0,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slot: 0,
+            slotInterval: handler.checkPointInterval,
+            fetchConfig: undefined
+          },
+          type: handler.type || '',
+          ownerType: processor.ownerType,
+          resourceFetchConfig: handler.fetchConfig,
+          fetchConfig: undefined
+        })
+      }
+
+      if (processor instanceof SuiAddressProcessor) {
+        for (const handler of processor.callHandlers) {
+          const handlerId = this.handlerRegister.register(handler.handler, chainId)
+          const functionHandlerConfig: MoveCallHandlerConfig = {
+            filters: handler.filters.map((filter) => {
+              return {
+                function: filter.function,
+                typeArguments: filter.typeArguments || [],
+                withTypeArguments: !!filter.typeArguments,
+                includeFailed: filter.includeFailed || false,
+                publicKeyPrefix: filter.publicKeyPrefix || '',
+                fromAndToAddress: filter.fromAndToAddress
+              }
+            }),
+            fetchConfig: handler.fetchConfig,
+            handlerId,
+            handlerName: handler.handlerName
+          }
+          accountConfig.moveCallConfigs.push(functionHandlerConfig)
+        }
+      }
+
+      config.accountConfigs.push(accountConfig)
+    }
+  }
+}
+
+const NoopContext = new SuiContext('', SuiChainId.SUI_MAINNET, '', new Date(), 0n, {} as any, 0, {})

package/src/sui/sui-plugin.ts

@@ -1,16 +1,8 @@
-import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import { errorString, mergeProcessResults, Plugin, PluginManager } from '@sentio/runtime'
 import {
-  AccountConfig,
-  ContractConfig,
-  Data_SuiCall,
-  Data_SuiEvent,
-  Data_SuiObject,
-  Data_SuiObjectChange,
   DataBinding,
   HandlerType,
-  MoveCallHandlerConfig,
-  MoveEventHandlerConfig,
-  MoveResourceChangeConfig,
+  InitResponse,
   ProcessConfigResponse,
   ProcessResult,
   ProcessStreamResponse_Partitions,
@@ -19,198 +11,35 @@ import {
 
 import { ServerError, Status } from 'nice-grpc'
 import { PartitionHandlerManager } from '../core/index.js'
+import { HandlerRegister } from '../core/handler-register.js'
 
-import { SuiProcessorState } from './sui-processor.js'
-import { SuiAccountProcessorState, SuiAddressProcessor } from './sui-object-processor.js'
-import { initCoinList } from './ext/coin.js'
 import { SuiChainId } from '@sentio/chain'
-import {
-  SuiAccountProcessorTemplateState,
-  SuiObjectOrAddressProcessorTemplate
-} from './sui-object-processor-template.js'
-import { SuiNetwork } from './network.js'
 import { SuiContext } from './context.js'
-
-interface Handlers {
-  suiEventHandlers: ((event: Data_SuiEvent) => Promise<ProcessResult>)[]
-  suiCallHandlers: ((func: Data_SuiCall) => Promise<ProcessResult>)[]
-  suiObjectHandlers: ((object: Data_SuiObject) => Promise<ProcessResult>)[]
-  suiObjectChangeHandlers: ((object: Data_SuiObjectChange) => Promise<ProcessResult>)[]
-}
+import { SuiPluginPart } from './sui-plugin-part.js'
+import { IotaPluginPart } from '../iota/iota-plugin-part.js'
 
 export class SuiPlugin extends Plugin {
   name: string = 'SuiPlugin'
-  handlers: Handlers = {
-    suiCallHandlers: [],
-    suiEventHandlers: [],
-    suiObjectHandlers: [],
-    suiObjectChangeHandlers: []
-  }
-
+  handlerRegister = new HandlerRegister()
   partitionManager = new PartitionHandlerManager()
-  async start(request: StartRequest): Promise<void> {
-    await initCoinList()
 
-    console.log('total instances:', request.templateInstances.length)
-    const allowedChainIds = new Set<string>(Object.values(SuiChainId))
-    for (const instance of request.templateInstances) {
-      if (!allowedChainIds.has(instance.contract?.chainId || '')) {
-        continue
-      }
+  suiPart = new SuiPluginPart(this.handlerRegister, this.partitionManager)
+  iotaPart = new IotaPluginPart(this.handlerRegister, this.partitionManager)
 
-      console.log('start template instance', instance.templateId)
-      const template: SuiObjectOrAddressProcessorTemplate<any, any, any> =
-        SuiAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId]
-
-      template.bind(
-        {
-          address: instance.contract?.address || '',
-          objectId: instance.contract?.address || '',
-          network: <SuiNetwork>instance.contract?.chainId || SuiNetwork.MAIN_NET,
-          startCheckpoint: instance.startBlock || 0n,
-          endCheckpoint: instance.endBlock || 0n,
-          baseLabels: instance.baseLabels
-        },
-        NoopContext
-      )
-    }
+  async start(request: StartRequest): Promise<void> {
+    await this.suiPart.start(request)
+    await this.iotaPart.start(request)
   }
 
-  async configure(config: ProcessConfigResponse) {
-    const handlers: Handlers = {
-      suiCallHandlers: [],
-      suiEventHandlers: [],
-      suiObjectHandlers: [],
-      suiObjectChangeHandlers: []
-    }
-    for (const suiProcessor of SuiProcessorState.INSTANCE.getValues()) {
-      const contractConfig = ContractConfig.fromPartial({
-        transactionConfig: [],
-        processorType: USER_PROCESSOR,
-        contract: {
-          name: suiProcessor.moduleName,
-          chainId: suiProcessor.config.network,
-          address: suiProcessor.config.address,
-          abi: ''
-        },
-        startBlock: suiProcessor.config.startCheckpoint,
-        endBlock: suiProcessor.config.endCheckpoint
-      })
-      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 {
-              type: f.type,
-              account: f.account || '',
-              eventAccount: f.eventAccount || ''
-            }
-          }),
-          fetchConfig: handler.fetchConfig,
-          handlerId,
-          handlerName: handler.handlerName
-        }
-        contractConfig.moveEventConfigs.push(eventHandlerConfig)
-      }
-      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 {
-              function: filter.function,
-              typeArguments: filter.typeArguments || [],
-              withTypeArguments: !!filter.typeArguments,
-              includeFailed: filter.includeFailed || false,
-              publicKeyPrefix: filter.publicKeyPrefix || '',
-              fromAndToAddress: filter.fromAndToAddress
-            }
-          }),
-          fetchConfig: handler.fetchConfig,
-          handlerId,
-          handlerName: handler.handlerName
-        }
-        contractConfig.moveCallConfigs.push(functionHandlerConfig)
-      }
-      // deprecated, use objectType processor instead
-      for (const handler of suiProcessor.objectChangeHandlers) {
-        const handlerId = handlers.suiObjectChangeHandlers.push(handler.handler) - 1
-        const objectChangeHandler: MoveResourceChangeConfig = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName,
-          includeDeleted: false
-        }
-        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler)
-      }
-      config.contractConfigs.push(contractConfig)
-    }
-
-    for (const processor of SuiAccountProcessorState.INSTANCE.getValues()) {
-      const accountConfig = AccountConfig.fromPartial({
-        address: processor.config.address,
-        chainId: processor.getChainId(),
-        startBlock: processor.config.startCheckpoint, // TODO maybe use another field
-        endBlock: processor.config.endCheckpoint
-      })
-
-      for (const handler of processor.objectChangeHandlers) {
-        const handlerId = handlers.suiObjectChangeHandlers.push(handler.handler) - 1
-        const objectChangeHandler: MoveResourceChangeConfig = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName,
-          includeDeleted: false
-        }
-        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler)
-      }
-
-      for (const handler of processor.objectHandlers) {
-        const handlerId = handlers.suiObjectHandlers.push(handler.handler) - 1
-
-        accountConfig.moveIntervalConfigs.push({
-          intervalConfig: {
-            handlerId: handlerId,
-            handlerName: handler.handlerName,
-            minutes: 0,
-            minutesInterval: handler.timeIntervalInMinutes,
-            slot: 0,
-            slotInterval: handler.checkPointInterval,
-            fetchConfig: undefined
-          },
-          type: handler.type || '',
-          ownerType: processor.ownerType,
-          resourceFetchConfig: handler.fetchConfig,
-          fetchConfig: undefined
-        })
-      }
-
-      if (processor instanceof SuiAddressProcessor) {
-        for (const handler of processor.callHandlers) {
-          const handlerId = handlers.suiCallHandlers.push(handler.handler) - 1
-          const functionHandlerConfig: MoveCallHandlerConfig = {
-            filters: handler.filters.map((filter) => {
-              return {
-                function: filter.function,
-                typeArguments: filter.typeArguments || [],
-                withTypeArguments: !!filter.typeArguments,
-                includeFailed: filter.includeFailed || false,
-                publicKeyPrefix: filter.publicKeyPrefix || '',
-                fromAndToAddress: filter.fromAndToAddress
-              }
-            }),
-            fetchConfig: handler.fetchConfig,
-            handlerId,
-            handlerName: handler.handlerName
-          }
-          accountConfig.moveCallConfigs.push(functionHandlerConfig)
-        }
-      }
+  async init(config: InitResponse) {
+    await this.suiPart.init(config)
+    await this.iotaPart.init(config)
+  }
 
-      config.accountConfigs.push(accountConfig)
-    }
-    this.handlers = handlers
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as any)
+    await this.suiPart.configure(config)
+    await this.iotaPart.configure(config)
   }
 
   supportedHandlers = [
@@ -284,12 +113,14 @@ export class SuiPlugin extends Plugin {
 
     for (const handlerId of binding.handlerIds) {
       promises.push(
-        this.handlers.suiEventHandlers[handlerId](event).catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e)
-          )
-        })
+        this.handlerRegister
+          .getHandlerById(handlerId)(event)
+          .catch((e: any) => {
+            throw new ServerError(
+              Status.INTERNAL,
+              'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e)
+            )
+          })
       )
     }
     return mergeProcessResults(await Promise.all(promises))
@@ -303,9 +134,14 @@ export class SuiPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.suiCallHandlers[handlerId](call).catch((e) => {
-        throw new ServerError(Status.INTERNAL, 'error processing call: ' + JSON.stringify(call) + '\n' + errorString(e))
-      })
+      const promise = this.handlerRegister
+        .getHandlerById(handlerId)(call)
+        .catch((e: any) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing call: ' + JSON.stringify(call) + '\n' + errorString(e)
+          )
+        })
       promises.push(promise)
     }
     return mergeProcessResults(await Promise.all(promises))
@@ -320,12 +156,14 @@ export class SuiPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
       promises.push(
-        this.handlers.suiObjectHandlers[handlerId](object).catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing object: ' + JSON.stringify(object) + '\n' + errorString(e)
-          )
-        })
+        this.handlerRegister
+          .getHandlerById(handlerId)(object)
+          .catch((e: any) => {
+            throw new ServerError(
+              Status.INTERNAL,
+              'error processing object: ' + JSON.stringify(object) + '\n' + errorString(e)
+            )
+          })
       )
     }
     return mergeProcessResults(await Promise.all(promises))
@@ -340,12 +178,14 @@ export class SuiPlugin extends Plugin {
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
       promises.push(
-        this.handlers.suiObjectChangeHandlers[handlerId](objectChange).catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing object change: ' + JSON.stringify(objectChange) + '\n' + errorString(e)
-          )
-        })
+        this.handlerRegister
+          .getHandlerById(handlerId)(objectChange)
+          .catch((e: any) => {
+            throw new ServerError(
+              Status.INTERNAL,
+              'error processing object change: ' + JSON.stringify(objectChange) + '\n' + errorString(e)
+            )
+          })
       )
     }
     return mergeProcessResults(await Promise.all(promises))

package/src/testing/iota-facet.ts

@@ -0,0 +1,143 @@
+import { MoveCallIotaTransaction, IotaTransactionBlockResponse } from '@iota/iota-sdk/client'
+import { DataBinding, HandlerType } from '@sentio/protos'
+import { TestProcessorServer } from './test-processor-server.js'
+import { accountTypeString, parseMoveType, SPLITTER } from '../move/index.js'
+import { IotaNetwork } from '../iota/index.js'
+import { getMoveCalls } from '../iota/utils.js'
+
+export class IotaFacet {
+  server: TestProcessorServer
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testEntryFunctionCall(transaction: IotaTransactionBlockResponse, network: IotaNetwork = IotaNetwork.MAIN_NET) {
+    return this.testEntryFunctionCalls([transaction], network)
+  }
+
+  testEntryFunctionCalls(transactions: IotaTransactionBlockResponse[], network: IotaNetwork = IotaNetwork.MAIN_NET) {
+    const bindings = []
+    for (const trans of transactions) {
+      const binding = this.buildEntryFunctionCallBinding(trans, network)
+      if (!binding) {
+        throw Error('Invalid test transaction: ' + JSON.stringify(trans))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings
+    })
+  }
+
+  private buildEntryFunctionCallBinding(
+    transaction: IotaTransactionBlockResponse,
+    network: IotaNetwork = IotaNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    const calls: MoveCallIotaTransaction[] = getMoveCalls(transaction)
+    // if (calls.length !== 1) {
+    //   throw Error('Transaction has more than one calls')
+    // }
+    for (const call of calls) {
+      const functionType = [accountTypeString(call.package), call.module, call.function].join(SPLITTER)
+
+      for (const config of this.server.contractConfigs) {
+        if (config.contract?.chainId !== network) {
+          continue
+        }
+        for (const callConfig of config.moveCallConfigs) {
+          for (const callFilter of callConfig.filters) {
+            if (accountTypeString(config.contract.address) + '::' + callFilter.function === functionType) {
+              return {
+                data: {
+                  suiCall: {
+                    rawTransaction: JSON.stringify(transaction),
+                    timestamp: new Date(),
+                    slot: 10000n
+                  }
+                },
+                handlerIds: [callConfig.handlerId],
+                handlerType: HandlerType.SUI_CALL
+              }
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testEvent(transaction: IotaTransactionBlockResponse, network: IotaNetwork = IotaNetwork.MAIN_NET) {
+    const binding = this.buildEventBinding(transaction, network)
+    if (!binding) {
+      throw Error('Invalid test event: ' + JSON.stringify(transaction))
+    }
+    return this.server.processBinding(binding)
+  }
+
+  // limitation, can't really do filter logic
+  testGlobalTransaction(transaction: IotaTransactionBlockResponse, network: IotaNetwork = IotaNetwork.MAIN_NET) {
+    const handlerIds = []
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.address === '*') {
+        for (const callConfig of config.moveCallConfigs) {
+          if (callConfig.filters.length === 1 && callConfig.filters[0].function === '') {
+            handlerIds.push(callConfig.handlerId)
+          }
+        }
+      }
+    }
+    if (handlerIds.length === 0) {
+      throw Error('Invalid test global transaction: ' + JSON.stringify(transaction))
+    }
+
+    const binding: DataBinding = {
+      handlerIds,
+      handlerType: HandlerType.SUI_CALL,
+      data: {
+        suiCall: {
+          rawTransaction: JSON.stringify(transaction),
+          timestamp: transaction.timestampMs ? new Date(transaction.timestampMs) : new Date(),
+          slot: BigInt(transaction.checkpoint || 0)
+        }
+      }
+    }
+    return this.server.processBinding(binding)
+  }
+
+  private buildEventBinding(
+    transaction: IotaTransactionBlockResponse,
+    network: IotaNetwork = IotaNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    // const allEvents = new Set(transaction.events.map(e => e.type))
+
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== network) {
+        continue
+      }
+      for (const eventConfig of config.moveEventConfigs) {
+        for (const eventFilter of eventConfig.filters) {
+          for (const event of transaction.events || []) {
+            if (
+              accountTypeString(config.contract.address) + '::' + eventFilter.type ===
+              parseMoveType(event.type).qname
+            ) {
+              return {
+                data: {
+                  suiEvent: {
+                    rawEvent: JSON.stringify(event),
+                    rawTransaction: JSON.stringify(transaction),
+                    timestamp: new Date(transaction.timestampMs || 0),
+                    slot: 10000n
+                  }
+                },
+                handlerIds: [eventConfig.handlerId],
+                handlerType: HandlerType.SUI_EVENT
+              }
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+}