@sentio/sdk 2.0.0-rc.2 → 2.0.0-rc.21

package/src/aptos/api.ts

@@ -0,0 +1,23 @@
+import { AptosQueryClient, AptosQueryDefinition } from '@sentio/protos/chainquery'
+import { createChannel, createClientFactory } from 'nice-grpc'
+import { Endpoints } from '@sentio/runtime'
+import { retryMiddleware } from 'nice-grpc-client-middleware-retry'
+import { AptosClient } from 'aptos-sdk'
+import { AptosNetwork, getChainId } from './network.js'
+
+export function getChainQueryClient(address?: string): AptosQueryClient {
+  if (!address) {
+    address = Endpoints.INSTANCE.chainQueryAPI
+  }
+  const channel = createChannel(address)
+
+  return createClientFactory().use(retryMiddleware).create(AptosQueryDefinition, channel)
+}
+
+export function getAptosClient(network = AptosNetwork.MAIN_NET): AptosClient | undefined {
+  const chainServer = Endpoints.INSTANCE.chainServer.get(getChainId(network))
+  if (chainServer) {
+    return new AptosClient(chainServer)
+  }
+  return undefined
+}

package/src/aptos/aptos-plugin.ts

@@ -0,0 +1,183 @@
+import { Plugin, PluginManager, errorString, mergeProcessResults, USER_PROCESSOR } from '@sentio/runtime'
+import {
+  AccountConfig,
+  AptosCallHandlerConfig,
+  AptosEventHandlerConfig,
+  ContractConfig,
+  Data_AptCall,
+  Data_AptEvent,
+  Data_AptResource,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+} from '@sentio/protos'
+
+import { ServerError, Status } from 'nice-grpc'
+
+import { AptosAccountProcessorState, AptosProcessorState } from './aptos-processor.js'
+
+export class AptosPlugin extends Plugin {
+  name: string = 'AptosPlugin'
+
+  private aptosEventHandlers: ((event: Data_AptEvent) => Promise<ProcessResult>)[] = []
+  private aptosCallHandlers: ((func: Data_AptCall) => Promise<ProcessResult>)[] = []
+  private aptosResourceHandlers: ((resourceWithVersion: Data_AptResource) => Promise<ProcessResult>)[] = []
+
+  async configure(config: ProcessConfigResponse) {
+    for (const aptosProcessor of AptosProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        transactionConfig: [],
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: aptosProcessor.moduleName,
+          chainId: aptosProcessor.getChainId(),
+          address: aptosProcessor.config.address,
+          abi: '',
+        },
+        intervalConfigs: [],
+        logConfigs: [],
+        traceConfigs: [],
+        startBlock: aptosProcessor.config.startVersion,
+        endBlock: 0n,
+        instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      // 1. Prepare event handlers
+      for (const handler of aptosProcessor.eventHandlers) {
+        const handlerId = this.aptosEventHandlers.push(handler.handler) - 1
+        const eventHandlerConfig: AptosEventHandlerConfig = {
+          filters: handler.filters.map((f) => {
+            return {
+              type: f.type,
+              account: f.account || '',
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+        }
+        contractConfig.aptosEventConfigs.push(eventHandlerConfig)
+      }
+
+      // 2. Prepare function handlers
+      for (const handler of aptosProcessor.callHandlers) {
+        const handlerId = this.aptosCallHandlers.push(handler.handler) - 1
+        const functionHandlerConfig: AptosCallHandlerConfig = {
+          filters: handler.filters.map((filter) => {
+            return {
+              function: filter.function,
+              typeArguments: filter.typeArguments || [],
+              withTypeArguments: !!filter.typeArguments,
+              includeFailed: filter.includeFailed || false,
+            }
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+        }
+        contractConfig.aptosCallConfigs.push(functionHandlerConfig)
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+
+    for (const aptosProcessor of AptosAccountProcessorState.INSTANCE.getValues()) {
+      const accountConfig: AccountConfig = {
+        address: aptosProcessor.config.address,
+        chainId: aptosProcessor.getChainId(),
+        startBlock: aptosProcessor.config.startVersion,
+        aptosIntervalConfigs: [],
+        intervalConfigs: [],
+        logConfigs: [],
+      }
+      for (const handler of aptosProcessor.resourcesHandlers) {
+        const handlerId = this.aptosResourceHandlers.push(handler.handler) - 1
+        accountConfig.aptosIntervalConfigs.push({
+          intervalConfig: {
+            handlerId: handlerId,
+            minutes: 0,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slot: 0,
+            slotInterval: handler.versionInterval,
+          },
+          type: handler.type || '',
+        })
+      }
+      config.accountConfigs.push(accountConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.APT_CALL, HandlerType.APT_RESOURCE, HandlerType.APT_EVENT]
+
+  async processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.APT_CALL:
+        return this.processAptosFunctionCall(request)
+      case HandlerType.APT_EVENT:
+        return this.processAptosEvent(request)
+      case HandlerType.APT_RESOURCE:
+        return this.processAptosResource(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processAptosEvent(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.aptEvent) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    const promises: Promise<ProcessResult>[] = []
+    const event = binding.data.aptEvent
+
+    for (const handlerId of binding.handlerIds) {
+      // only support aptos event for now
+      promises.push(
+        this.aptosEventHandlers[handlerId](event).catch((e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e)
+          )
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processAptosResource(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.aptResource) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Resource can't be empty")
+    }
+    const resource = binding.data.aptResource
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.aptosResourceHandlers[handlerId](resource).catch((e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing resource: ' + JSON.stringify(resource) + '\n' + errorString(e)
+          )
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processAptosFunctionCall(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.aptCall) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Call can't be empty")
+    }
+    const call = binding.data.aptCall
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      // only support aptos call for now
+      const promise = this.aptosCallHandlers[handlerId](call).catch((e) => {
+        throw new ServerError(Status.INTERNAL, 'error processing call: ' + JSON.stringify(call) + '\n' + errorString(e))
+      })
+      promises.push(promise)
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new AptosPlugin())

package/src/aptos/aptos-processor.ts

@@ -0,0 +1,331 @@
+import { MoveResource, Transaction_UserTransaction, TransactionPayload_EntryFunctionPayload } from './move-types.js'
+
+import { MOVE_CODER, MoveCoder } from './move-coder.js'
+import { AptosBindOptions, AptosNetwork, getChainId } from './network.js'
+import { AptosContext, AptosResourceContext } from './context.js'
+import { EventInstance } from './models.js'
+import { ListStateStorage } from '@sentio/runtime'
+import {
+  AptosFetchConfig,
+  Data_AptCall,
+  Data_AptEvent,
+  Data_AptResource,
+  HandleInterval,
+  ProcessResult,
+} from '@sentio/protos'
+import { ServerError, Status } from 'nice-grpc'
+
+type IndexConfigure = {
+  address: string
+  network: AptosNetwork
+  startVersion: bigint
+  // endSeqNumber?: Long
+}
+
+// TODO extends ArgumentsFilter
+export interface EventFilter {
+  type: string
+  account?: string
+}
+
+export interface FunctionNameAndCallFilter extends CallFilter {
+  function: string
+}
+
+// TODO extends ArgumentsFilter
+export interface CallFilter {
+  includeFailed?: boolean
+  typeArguments?: string[]
+}
+
+export interface ArgumentsFilter {
+  arguments?: string[]
+}
+
+class EventHandler {
+  filters: EventFilter[]
+  handler: (event: Data_AptEvent) => Promise<ProcessResult>
+  fetchConfig: AptosFetchConfig
+}
+
+class CallHandler {
+  filters: FunctionNameAndCallFilter[]
+  handler: (call: Data_AptCall) => Promise<ProcessResult>
+  fetchConfig: AptosFetchConfig
+}
+
+class ResourceHandlder {
+  type?: string
+  versionInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  handler: (resource: Data_AptResource) => Promise<ProcessResult>
+}
+
+export class AptosProcessorState extends ListStateStorage<AptosBaseProcessor> {
+  static INSTANCE = new AptosProcessorState()
+}
+
+export class AptosBaseProcessor {
+  readonly moduleName: string
+  config: IndexConfigure
+  eventHandlers: EventHandler[] = []
+  callHandlers: CallHandler[] = []
+
+  constructor(moduleName: string, options: AptosBindOptions) {
+    this.moduleName = moduleName
+    this.config = configure(options)
+    AptosProcessorState.INSTANCE.addValue(this)
+    this.loadTypes(MOVE_CODER)
+  }
+
+  // getABI(): MoveModule | undefined {
+  //   return undefined
+  // }
+
+  public onTransaction(
+    handler: (transaction: Transaction_UserTransaction, ctx: AptosContext) => void,
+    includedFailed = false,
+    fetchConfig?: AptosFetchConfig
+  ): AptosBaseProcessor {
+    const _fetchConfig = fetchConfig || AptosFetchConfig.fromPartial({})
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+    const processor = this
+    this.callHandlers.push({
+      handler: async function (data) {
+        if (!data.transaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
+        }
+        const call = data.transaction as Transaction_UserTransaction
+        const ctx = new AptosContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          BigInt(data.transaction.version),
+          call
+        )
+        await handler(call, ctx)
+        return ctx.getProcessResult()
+      },
+      filters: [{ function: '', includeFailed: includedFailed }],
+      fetchConfig: _fetchConfig,
+    })
+    return this
+  }
+
+  public onEvent(
+    handler: (event: EventInstance, ctx: AptosContext) => void,
+    filter: EventFilter | EventFilter[],
+    fetchConfig?: AptosFetchConfig
+  ): AptosBaseProcessor {
+    let _filters: EventFilter[] = []
+    const _fetchConfig = fetchConfig || AptosFetchConfig.fromPartial({})
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+
+    const processor = this
+
+    this.eventHandlers.push({
+      handler: async function (data) {
+        if (!data.transaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'event is null')
+        }
+        const txn = data.transaction as Transaction_UserTransaction
+        if (!txn.events.length) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'no event in the transactions')
+        }
+
+        const ctx = new AptosContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          BigInt(txn.version),
+          txn
+        )
+
+        const events = txn.events
+        txn.events = []
+        for (const evt of events) {
+          const eventInstance = evt as EventInstance
+          const decoded = MOVE_CODER.decodeEvent<any>(eventInstance)
+          await handler(decoded || eventInstance, ctx)
+        }
+
+        return ctx.getProcessResult()
+      },
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+    })
+    return this
+  }
+
+  public onEntryFunctionCall(
+    handler: (call: TransactionPayload_EntryFunctionPayload, ctx: AptosContext) => void,
+    filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
+    fetchConfig?: AptosFetchConfig
+  ): AptosBaseProcessor {
+    let _filters: FunctionNameAndCallFilter[] = []
+    const _fetchConfig = fetchConfig || AptosFetchConfig.fromPartial({})
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+    const processor = this
+
+    this.callHandlers.push({
+      handler: async function (data) {
+        if (!data.transaction) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
+        }
+        const tx = data.transaction as Transaction_UserTransaction
+
+        const ctx = new AptosContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          BigInt(tx.version),
+          tx
+        )
+        if (tx) {
+          const payload = tx.payload as TransactionPayload_EntryFunctionPayload
+          const decoded = MOVE_CODER.decodeFunctionPayload(payload)
+          await handler(decoded, ctx)
+        }
+        return ctx.getProcessResult()
+      },
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+    })
+    return this
+  }
+
+  getChainId(): string {
+    return getChainId(this.config.network)
+  }
+
+  loadTypes(registry: MoveCoder) {
+    if (registry.contains(this.config.address, this.moduleName)) {
+      return
+    }
+    this.loadTypesInternal(registry)
+  }
+
+  protected loadTypesInternal(registry: MoveCoder) {
+    // should be override by subclass
+    console.log('')
+  }
+}
+
+export class AptosAccountProcessorState extends ListStateStorage<AptosAccountProcessor> {
+  static INSTANCE = new AptosAccountProcessorState()
+}
+
+export class AptosAccountProcessor {
+  config: IndexConfigure
+
+  resourcesHandlers: ResourceHandlder[] = []
+
+  static bind(options: AptosBindOptions): AptosAccountProcessor {
+    return new AptosAccountProcessor(options)
+  }
+
+  protected constructor(options: AptosBindOptions) {
+    this.config = configure(options)
+    AptosAccountProcessorState.INSTANCE.addValue(this)
+  }
+
+  getChainId(): string {
+    return getChainId(this.config.network)
+  }
+
+  private onInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    timeInterval: HandleInterval | undefined,
+    versionInterval: HandleInterval | undefined,
+    type: string | undefined
+  ) {
+    const processor = this
+    this.resourcesHandlers.push({
+      handler: async function (data) {
+        if (data.timestampMicros > Number.MAX_SAFE_INTEGER) {
+          throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
+        }
+        const timestamp = Number(data.timestampMicros)
+
+        const ctx = new AptosResourceContext(
+          processor.config.network,
+          processor.config.address,
+          data.version,
+          timestamp
+        )
+        await handler(data.resources as MoveResource[], ctx)
+        return ctx.getProcessResult()
+      },
+      timeIntervalInMinutes: timeInterval,
+      versionInterval: versionInterval,
+      type: type,
+    })
+    return this
+  }
+
+  public onTimeInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240,
+    type?: string
+  ) {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes,
+      },
+      undefined,
+      type
+    )
+  }
+
+  public onVersionInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    versionInterval = 100000,
+    backfillVersionInterval = 400000,
+    typePrefix?: string
+  ) {
+    return this.onInterval(
+      handler,
+      undefined,
+      { recentInterval: versionInterval, backfillInterval: backfillVersionInterval },
+      typePrefix
+    )
+  }
+}
+
+function configure(options: AptosBindOptions): IndexConfigure {
+  let startVersion = 0n
+  if (options.startVersion !== undefined) {
+    if (typeof options.startVersion === 'number') {
+      startVersion = BigInt(options.startVersion)
+    } else {
+      startVersion = options.startVersion
+    }
+  }
+
+  return {
+    startVersion: startVersion,
+    address: options.address,
+    network: options.network || AptosNetwork.MAIN_NET,
+  }
+}