@sentio/sdk 2.60.0-rc.3 → 2.60.0-rc.5

package/src/iota/iota-object-processor-template.ts

@@ -0,0 +1,277 @@
+import { HandleInterval, MoveAccountFetchConfig, MoveFetchConfig } from '@sentio/protos'
+import { ListStateStorage } from '@sentio/runtime'
+import { IotaAddressContext, IotaContext, IotaObjectContext } from './context.js'
+import { IotaMoveObject, IotaTransactionBlockResponse } from '@iota/iota-sdk/client'
+import { PromiseOrVoid } from '../core/index.js'
+import {
+  DEFAULT_ACCOUNT_FETCH_CONFIG,
+  IotaAccountProcessorState,
+  IotaAddressProcessor,
+  IotaBaseObjectOrAddressProcessor,
+  IotaObjectBindOptions,
+  IotaObjectProcessor,
+  IotaWrappedObjectProcessor
+} from './iota-object-processor.js'
+import { TemplateInstanceState } from '../core/template.js'
+import { IotaBindOptions } from './iota-processor.js'
+import { TransactionFilter, accountAddressString } from '../move/index.js'
+import { ServerError, Status } from 'nice-grpc'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+
+class ObjectHandler<HandlerType> {
+  type?: string
+  checkpointInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  handlerName: string
+  handler: HandlerType
+  fetchConfig: MoveAccountFetchConfig
+}
+
+export class IotaAccountProcessorTemplateState extends ListStateStorage<
+  IotaObjectOrAddressProcessorTemplate<any, any, any>
+> {
+  static INSTANCE = new IotaAccountProcessorTemplateState()
+}
+
+export abstract class IotaObjectOrAddressProcessorTemplate<
+  HandlerType,
+  OptionType extends IotaObjectBindOptions | IotaBindOptions,
+  ProcessorType extends IotaBaseObjectOrAddressProcessor<HandlerType>
+> {
+  id: number
+  objectHandlers: ObjectHandler<HandlerType>[] = []
+  binds = new Set<string>()
+
+  constructor() {
+    this.id = IotaAccountProcessorTemplateState.INSTANCE.getValues().length
+    IotaAccountProcessorTemplateState.INSTANCE.addValue(this)
+    return proxyProcessor(this)
+  }
+
+  protected abstract createProcessor(options: IotaObjectBindOptions | IotaBindOptions): ProcessorType
+
+  bind(options: OptionType, ctx: IotaContext): void {
+    options.network = options.network || ctx.network
+    options.startCheckpoint = options.startCheckpoint || ctx.checkpoint
+    let id = (options as IotaObjectBindOptions).objectId || (options as IotaBindOptions).address
+
+    if (id === '*') {
+      throw new ServerError(Status.INVALID_ARGUMENT, "can't bind template instance with *")
+    }
+    id = accountAddressString(id)
+
+    const sig = [options.network, id].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.checkpointInterval,
+        h.type,
+        h.fetchConfig,
+        h.handlerName
+      )
+    }
+    const config = processor.config
+
+    ctx.update({
+      states: {
+        configUpdated: true
+      }
+    })
+    TemplateInstanceState.INSTANCE.addValue({
+      templateId: this.id,
+      contract: {
+        name: '',
+        chainId: config.network,
+        address: config.address,
+        abi: ''
+      },
+      startBlock: config.startCheckpoint,
+      endBlock: config.endCheckpoint || 0n,
+      baseLabels: config.baseLabels
+    })
+    console.log(`successfully bind template ${sig}`)
+  }
+
+  unbind(options: OptionType, ctx: IotaContext): void {
+    options.network = options.network || ctx.network
+    options.startCheckpoint = options.startCheckpoint || ctx.checkpoint
+    let id = (options as IotaObjectBindOptions).objectId || (options as IotaBindOptions).address
+
+    if (id === '*') {
+      throw new ServerError(Status.INVALID_ARGUMENT, "can't delete template instance bind with *")
+    }
+    id = accountAddressString(id)
+
+    const sig = [options.network, id].join('_')
+    if (!this.binds.has(sig)) {
+      console.log(`the template instance ${sig} not existed or already unbind`)
+      return
+    }
+    this.binds.delete(sig)
+
+    let deleted = 0
+    const oldTemplateInstances = TemplateInstanceState.INSTANCE.unregister()
+    for (const templateInstance of oldTemplateInstances) {
+      if (templateInstance.contract?.chainId === options.network && templateInstance.contract.address == id) {
+        deleted++
+        continue
+      }
+      TemplateInstanceState.INSTANCE.addValue(templateInstance)
+    }
+
+    if (deleted !== 1) {
+      throw new ServerError(
+        Status.INVALID_ARGUMENT,
+        `Failed to delete template instance ${sig}, deleted ${deleted} times`
+      )
+    }
+
+    const oldProcessors = IotaAccountProcessorState.INSTANCE.unregister()
+    deleted = 0
+    for (const processor of oldProcessors) {
+      if (processor.templateId === this.id) {
+        if (processor.config.network == options.network && processor.config.address === id) {
+          deleted++
+          continue
+        }
+      }
+      IotaAccountProcessorState.INSTANCE.addValue(processor)
+    }
+
+    if (deleted !== 1) {
+      throw new ServerError(
+        Status.INVALID_ARGUMENT,
+        `Failed to delete processor for template ${this.id}, ${sig}. deleted ${deleted} times`
+      )
+    }
+
+    console.log(`successfully unbind template ${sig}`)
+
+    ctx.update({
+      states: {
+        configUpdated: true
+      }
+    })
+  }
+
+  protected onInterval(
+    handler: HandlerType,
+    timeInterval: HandleInterval | undefined,
+    checkpointInterval: HandleInterval | undefined,
+    type: string | undefined,
+    fetchConfig: Partial<MoveAccountFetchConfig> | undefined
+  ): this {
+    this.objectHandlers.push({
+      handlerName: getHandlerName(),
+      handler: handler,
+      timeIntervalInMinutes: timeInterval,
+      checkpointInterval: checkpointInterval,
+      type,
+      fetchConfig: { ...DEFAULT_ACCOUNT_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 onCheckpointInterval(
+    handler: HandlerType,
+    checkpointInterval = 100000,
+    backfillCheckpointInterval = 400000,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      type,
+      fetchConfig
+    )
+  }
+}
+
+class AddressTransactionHandler {
+  handler: (transaction: IotaTransactionBlockResponse, ctx: IotaContext) => void
+  filter?: TransactionFilter
+  fetchConfig?: Partial<MoveFetchConfig>
+}
+
+export class IotaAddressProcessorTemplate extends IotaObjectOrAddressProcessorTemplate<
+  (objects: IotaMoveObject[], ctx: IotaAddressContext) => PromiseOrVoid,
+  IotaBindOptions,
+  IotaAddressProcessor
+> {
+  private handlers: AddressTransactionHandler[] = []
+
+  createProcessor(options: IotaBindOptions): IotaAddressProcessor {
+    const p = IotaAddressProcessor.bind(options)
+    for (const handler of this.handlers) {
+      p.onTransactionBlock(handler.handler, handler.filter, handler.fetchConfig)
+    }
+    p.templateId = this.id
+    return p
+  }
+
+  onTransactionBlock(
+    handler: (transaction: IotaTransactionBlockResponse, ctx: IotaContext) => void,
+    filter?: TransactionFilter,
+    fetchConfig?: Partial<MoveFetchConfig>
+  ): this {
+    this.handlers.push({
+      handler,
+      filter,
+      fetchConfig
+    })
+    return this
+  }
+}
+
+export class IotaObjectProcessorTemplate extends IotaObjectOrAddressProcessorTemplate<
+  (self: IotaMoveObject, dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid,
+  IotaObjectBindOptions,
+  IotaObjectProcessor
+> {
+  createProcessor(options: IotaObjectBindOptions): IotaObjectProcessor {
+    const p = IotaObjectProcessor.bind(options)
+    p.templateId = this.id
+    return p
+  }
+}
+
+export class IotaWrappedObjectProcessorTemplate extends IotaObjectOrAddressProcessorTemplate<
+  (dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid,
+  IotaObjectBindOptions,
+  IotaWrappedObjectProcessor
+> {
+  createProcessor(options: IotaObjectBindOptions): IotaWrappedObjectProcessor {
+    const p = IotaWrappedObjectProcessor.bind(options)
+    p.templateId = this.id
+    return p
+  }
+}

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

@@ -0,0 +1,386 @@
+import {
+  Data_SuiCall,
+  Data_SuiObject,
+  Data_SuiObjectChange,
+  HandleInterval,
+  MoveAccountFetchConfig,
+  MoveFetchConfig,
+  MoveOwnerType,
+  ProcessResult
+} from '@sentio/protos'
+import { ListStateStorage } from '@sentio/runtime'
+import { IotaNetwork } from './network.js'
+import { IotaAddressContext, IotaContext, IotaObjectChangeContext, IotaObjectContext } from './context.js'
+import { IotaMoveObject, IotaObjectChange, IotaTransactionBlockResponse } from '@iota/iota-sdk/client'
+import { ALL_ADDRESS, PromiseOrVoid } from '../core/index.js'
+import { configure, DEFAULT_FETCH_CONFIG, IndexConfigure, IotaBindOptions } from './iota-processor.js'
+import { CallHandler, TransactionFilter, accountTypeString, ObjectChangeHandler } from '../move/index.js'
+import { ServerError, Status } from 'nice-grpc'
+import { TypeDescriptor } from '@typemove/move'
+import { TypedIotaMoveObject } from './models.js'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+
+export interface IotaObjectBindOptions {
+  objectId: string
+  network?: IotaNetwork
+  startCheckpoint?: bigint
+  endCheckpoint?: bigint
+  baseLabels?: { [key: string]: string }
+}
+
+export interface IotaObjectTypeBindOptions<T> {
+  objectType: TypeDescriptor<T>
+  network?: IotaNetwork
+  startCheckpoint?: bigint
+  endCheckpoint?: bigint
+  baseLabels?: { [key: string]: string }
+}
+
+interface ObjectHandler {
+  type?: string
+  checkPointInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  fetchConfig: MoveAccountFetchConfig
+  handler: (resource: Data_SuiObject) => Promise<ProcessResult>
+  handlerName: string
+}
+
+export const DEFAULT_ACCOUNT_FETCH_CONFIG: MoveAccountFetchConfig = {
+  owned: false
+}
+
+export class IotaAccountProcessorState extends ListStateStorage<IotaBaseObjectOrAddressProcessor<any>> {
+  static INSTANCE = new IotaAccountProcessorState()
+}
+
+export interface IotaInternalObjectsBindOptions extends IotaBindOptions {
+  ownerType: MoveOwnerType
+}
+
+export abstract class IotaBaseObjectOrAddressProcessor<HandlerType> {
+  config: IndexConfigure
+  ownerType: MoveOwnerType
+  templateId: number | undefined
+
+  objectHandlers: ObjectHandler[] = []
+  objectChangeHandlers: ObjectChangeHandler<Data_SuiObjectChange>[] = []
+
+  // static bind(options: IotaObjectsBindOptions): IotaBaseObjectsProcessor<any> {
+  //   return new IotaBaseObjectsProcessor(options)
+  // }
+
+  protected constructor(options: IotaInternalObjectsBindOptions) {
+    if (options.ownerType === MoveOwnerType.TYPE) {
+      this.config = {
+        startCheckpoint: options.startCheckpoint || 0n,
+        endCheckpoint: options.endCheckpoint,
+        address: options.address === '*' ? '*' : accountTypeString(options.address),
+        network: options.network || IotaNetwork.MAIN_NET,
+        baseLabels: options.baseLabels
+      }
+    } else {
+      this.config = configure(options)
+    }
+    this.ownerType = options.ownerType
+    IotaAccountProcessorState.INSTANCE.addValue(this)
+
+    return proxyProcessor(this)
+  }
+
+  getChainId(): string {
+    return this.config.network
+  }
+
+  // protected abstract transformObjects(objects: IotaMoveObject[]): IotaMoveObject[]
+
+  protected abstract doHandle(handler: HandlerType, data: Data_SuiObject, ctx: IotaObjectContext): Promise<any>
+
+  public onInterval(
+    handler: HandlerType, //(resources: IotaMoveObject[], ctx: IotaObjectsContext) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    checkpointInterval: HandleInterval | undefined,
+    type: string | undefined,
+    fetchConfig: Partial<MoveAccountFetchConfig> | undefined,
+    handlerName = getHandlerName()
+  ): this {
+    const processor = this
+    this.objectHandlers.push({
+      handlerName,
+      handler: async function (data) {
+        const ctx = new IotaObjectContext(
+          processor.config.network,
+          data.objectId,
+          data.objectVersion,
+          data.slot,
+          data.timestamp || new Date(0),
+          processor.config.baseLabels
+        )
+        await processor.doHandle(handler, data, ctx)
+        return ctx.stopAndGetResult()
+      },
+      timeIntervalInMinutes: timeInterval,
+      checkPointInterval: checkpointInterval,
+      type,
+      fetchConfig: { ...DEFAULT_ACCOUNT_FETCH_CONFIG, ...fetchConfig }
+    })
+    return this
+  }
+}
+
+abstract class IotaBaseObjectOrAddressProcessorInternal<
+  HandlerType
+> extends IotaBaseObjectOrAddressProcessor<HandlerType> {
+  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 onCheckpointInterval(
+    handler: HandlerType,
+    checkpointInterval = 100000,
+    backfillCheckpointInterval = 400000,
+    type?: string,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      type,
+      fetchConfig
+    )
+  }
+}
+
+export class IotaAddressProcessor extends IotaBaseObjectOrAddressProcessorInternal<
+  (objects: IotaMoveObject[], ctx: IotaAddressContext) => PromiseOrVoid
+> {
+  callHandlers: CallHandler<Data_SuiCall>[] = []
+
+  static bind(options: IotaBindOptions): IotaAddressProcessor {
+    return new IotaAddressProcessor({ ...options, ownerType: MoveOwnerType.ADDRESS })
+  }
+
+  protected async doHandle(
+    handler: (objects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: IotaObjectContext
+  ) {
+    return handler(data.rawObjects.map((o) => JSON.parse(o)) as IotaMoveObject[], ctx)
+  }
+
+  onTransactionBlock(
+    handler: (transaction: IotaTransactionBlockResponse, ctx: IotaContext) => PromiseOrVoid,
+    filter?: TransactionFilter,
+    fetchConfig?: Partial<MoveFetchConfig>
+  ) {
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
+    const _filter: TransactionFilter = {
+      fromAndToAddress: {
+        from: '',
+        to: this.config.address
+      },
+      ...filter
+    }
+
+    const processor = this
+
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data) {
+        if (!data.rawTransaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'transaction is null')
+        }
+        const tx = JSON.parse(data.rawTransaction) as IotaTransactionBlockResponse
+
+        const ctx = new IotaContext(
+          'object',
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        )
+        if (tx) {
+          await handler(tx, ctx)
+        }
+        return ctx.stopAndGetResult()
+      },
+      filters: [{ ..._filter, function: '' }],
+      fetchConfig: _fetchConfig
+    })
+    return this
+  }
+}
+
+export class IotaObjectProcessor extends IotaBaseObjectOrAddressProcessorInternal<
+  (self: IotaMoveObject, dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid
+> {
+  static bind(options: IotaObjectBindOptions): IotaObjectProcessor {
+    return new IotaObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.OBJECT,
+      baseLabels: options.baseLabels
+    })
+  }
+
+  protected async doHandle(
+    handler: (self: IotaMoveObject, dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: IotaObjectContext
+  ) {
+    if (!data.rawSelf) {
+      console.log(`Iota object not existed in ${ctx.checkpoint}, please specific a start time`)
+      return
+    }
+    return handler(
+      JSON.parse(data.rawSelf) as IotaMoveObject,
+      data.rawObjects.map((o) => JSON.parse(o)) as IotaMoveObject[],
+      ctx
+    )
+  }
+}
+
+export class IotaObjectTypeProcessor<T> extends IotaBaseObjectOrAddressProcessor<
+  (self: TypedIotaMoveObject<T>, dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid
+> {
+  objectType: TypeDescriptor<T>
+
+  static bind<T>(options: IotaObjectTypeBindOptions<T>): IotaObjectTypeProcessor<T> {
+    const processor = new IotaObjectTypeProcessor<T>({
+      address: ALL_ADDRESS, // current only support on all address
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.TYPE,
+      baseLabels: options.baseLabels
+    })
+    processor.objectType = options.objectType
+    return processor
+  }
+
+  protected async doHandle(
+    handler: (
+      self: TypedIotaMoveObject<T>,
+      dynamicFieldObjects: IotaMoveObject[],
+      ctx: IotaObjectContext
+    ) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: IotaObjectContext
+  ) {
+    if (!data.rawSelf) {
+      console.log(`Iota object not existed in ${ctx.checkpoint}, please specific a start time`)
+      return
+    }
+    const object = await ctx.coder.filterAndDecodeObjects(this.objectType, [JSON.parse(data.rawSelf) as IotaMoveObject])
+    return handler(object[0], data.rawObjects.map((o) => JSON.parse(o)) as IotaMoveObject[], ctx)
+  }
+
+  public onObjectChange(handler: (changes: IotaObjectChange[], ctx: IotaObjectChangeContext) => PromiseOrVoid): this {
+    if (this.config.network === IotaNetwork.TEST_NET) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'object change not supported in testnet')
+    }
+    const processor = this
+    this.objectChangeHandlers.push({
+      handlerName: getHandlerName(),
+      handler: async function (data: Data_SuiObjectChange) {
+        const ctx = new IotaObjectChangeContext(
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || new Date(0),
+          data.slot,
+          data.txDigest,
+          processor.config.baseLabels
+        )
+        await handler(data.rawChanges.map((r) => JSON.parse(r)) as IotaObjectChange[], ctx)
+        return ctx.stopAndGetResult()
+      },
+      type: this.objectType.getSignature()
+    })
+
+    return this
+  }
+
+  public onTimeInterval(
+    handler: (
+      self: TypedIotaMoveObject<T>,
+      dynamicFieldObjects: IotaMoveObject[],
+      ctx: IotaObjectContext
+    ) => PromiseOrVoid,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      },
+      undefined,
+      this.objectType.getSignature(),
+      fetchConfig
+    )
+  }
+
+  public onCheckpointInterval(
+    handler: (
+      self: TypedIotaMoveObject<T>,
+      dynamicFieldObjects: IotaMoveObject[],
+      ctx: IotaObjectContext
+    ) => PromiseOrVoid,
+    checkpointInterval = 100000,
+    backfillCheckpointInterval = 400000,
+    fetchConfig?: Partial<MoveAccountFetchConfig>
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      this.objectType.qname,
+      fetchConfig
+    )
+  }
+}
+
+export class IotaWrappedObjectProcessor extends IotaBaseObjectOrAddressProcessorInternal<
+  (dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid
+> {
+  static bind(options: IotaObjectBindOptions): IotaWrappedObjectProcessor {
+    return new IotaWrappedObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.WRAPPED_OBJECT,
+      baseLabels: options.baseLabels
+    })
+  }
+
+  protected async doHandle(
+    handler: (dynamicFieldObjects: IotaMoveObject[], ctx: IotaObjectContext) => PromiseOrVoid,
+    data: Data_SuiObject,
+    ctx: IotaObjectContext
+  ) {
+    return handler(data.rawObjects.map((o) => JSON.parse(o)) as IotaMoveObject[], ctx)
+  }
+}