@sentio/sdk 0.6.5 → 1.0.0-rc.2

package/src/aptos/api.ts

@@ -0,0 +1,11 @@
+import { AptosQueryClient, AptosQueryDefinition } from '../gen/chainquery/protos/chainquery'
+import { createChannel, createClient } from 'nice-grpc'
+
+export function getChainQueryClient(address?: string): AptosQueryClient {
+  if (!address) {
+    address = global.ENDPOINTS.chainQueryAPI
+  }
+  const channel = createChannel(address)
+
+  return createClient(AptosQueryDefinition, channel)
+}

package/src/aptos/aptos-plugin.ts

@@ -0,0 +1,217 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  AccountConfig,
+  AptosCallHandlerConfig,
+  AptosEventHandlerConfig,
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+} from '../gen/processor/protos/processor'
+import { DEFAULT_MAX_BLOCK, errorString, mergeProcessResults, USER_PROCESSOR, Utf8ArrayToStr } from '../service'
+
+import { ServerError, Status } from 'nice-grpc'
+
+import { MoveResource, Transaction_UserTransaction } from 'aptos-sdk/src/generated'
+import { AptosAccountProcessorState, AptosProcessorState, MoveResourcesWithVersionPayload } from './aptos-processor'
+import { toBigInt } from '../core/numberish'
+import Long from 'long'
+
+export class AptosPlugin implements Plugin {
+  name: string = 'AptosPlugin'
+
+  private aptosEventHandlers: ((event: any) => Promise<ProcessResult>)[] = []
+  private aptosCallHandlers: ((func: any) => Promise<ProcessResult>)[] = []
+  private aptosResourceHandlers: ((resourceWithVersion: MoveResourcesWithVersionPayload) => Promise<ProcessResult>)[] =
+    []
+
+  configure(config: ProcessConfigResponse): void {
+    for (const aptosProcessor of AptosProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: aptosProcessor.moduleName,
+          chainId: aptosProcessor.getChainId(),
+          address: aptosProcessor.config.address,
+          abi: '',
+        },
+        intervalConfigs: [],
+        logConfigs: [],
+        traceConfigs: [],
+        startBlock: Long.fromString(aptosProcessor.config.startVersion.toString()),
+        endBlock: DEFAULT_MAX_BLOCK,
+        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 || '',
+            }
+          }),
+          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 ? true : false,
+              includeFailed: filter.includeFailed || false,
+            }
+          }),
+          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: Long.fromValue(aptosProcessor.config.startVersion.toString()),
+        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]
+
+  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)
+      // case HandlerType.INSTRUCTION:
+      //   return this.processInstruction(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processAptosEvent(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    const promises: Promise<ProcessResult>[] = []
+    let event: Transaction_UserTransaction
+    if (binding.data.aptEvent?.event) {
+      event = binding.data.aptEvent?.event as Transaction_UserTransaction
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      event = JSON.parse(jsonString)
+    }
+
+    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) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+
+    const resource: MoveResourcesWithVersionPayload = {
+      resources: [],
+      version: 0n,
+      timestamp: 0,
+    }
+    if (binding.data.aptResource?.resources) {
+      if (binding.data.aptResource.timestampMicros.greaterThan(Number.MAX_SAFE_INTEGER)) {
+        throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
+      }
+      resource.timestamp = binding.data.aptResource.timestampMicros.toNumber()
+      resource.version = toBigInt(binding.data.aptResource.version)
+      resource.resources = binding.data.aptResource.resources as MoveResource[]
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      const json = JSON.parse(jsonString)
+      if (Long.fromString(json.timestamp).greaterThan(Number.MAX_SAFE_INTEGER)) {
+        throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
+      }
+      resource.timestamp = parseInt(json.timestamp)
+      resource.version = toBigInt(json.version)
+    }
+
+    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 event: ' + JSON.stringify(resource) + '\n' + errorString(e)
+          )
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processAptosFunctionCall(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    let call: Transaction_UserTransaction
+    if (binding.data.aptCall?.call) {
+      call = binding.data.aptCall?.call as Transaction_UserTransaction
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      call = JSON.parse(jsonString)
+    }
+
+    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,305 @@
+import {
+  MoveResource,
+  Transaction_UserTransaction,
+  TransactionPayload_EntryFunctionPayload,
+} from 'aptos-sdk/src/generated'
+
+import { TYPE_REGISTRY, TypeRegistry } from './type-registry'
+import { AptosBindOptions, AptosNetwork, getChainId } from './network'
+import { AptosContext, AptosResourceContext } from './context'
+import { EventInstance } from './models'
+import { ListStateStorage } from '../state/state-storage'
+import { HandleInterval, ProcessResult } from '../gen'
+
+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: Transaction_UserTransaction) => Promise<ProcessResult>
+}
+
+class CallHandler {
+  filters: FunctionNameAndCallFilter[]
+  handler: (call: Transaction_UserTransaction) => Promise<ProcessResult>
+}
+
+export class MoveResourcesWithVersionPayload {
+  resources: MoveResource[]
+  version: bigint
+  timestamp: number
+}
+
+class ResourceHandlder {
+  type?: string
+  versionInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  handler: (resource: MoveResourcesWithVersionPayload) => 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(TYPE_REGISTRY)
+  }
+
+  // getABI(): MoveModule | undefined {
+  //   return undefined
+  // }
+
+  public onTransaction(
+    handler: (transaction: Transaction_UserTransaction, ctx: AptosContext) => void,
+    includedFailed = false
+  ): AptosBaseProcessor {
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
+    this.callHandlers.push({
+      handler: async function (tx) {
+        const ctx = new AptosContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          BigInt(tx.version),
+          tx
+        )
+        if (tx) {
+          await handler(tx, ctx)
+        }
+        return ctx.getProcessResult()
+      },
+      filters: [{ function: '', includeFailed: includedFailed }],
+    })
+    return this
+  }
+
+  public onEvent(
+    handler: (event: EventInstance, ctx: AptosContext) => void,
+    filter: EventFilter | EventFilter[]
+  ): AptosBaseProcessor {
+    let _filters: EventFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
+
+    this.eventHandlers.push({
+      handler: async function (txn) {
+        const ctx = new AptosContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          BigInt(txn.version),
+          txn
+        )
+        if (txn && txn.events) {
+          const events = txn.events
+          txn.events = []
+          for (const evt of events) {
+            const eventInstance = evt as EventInstance
+            const decoded = TYPE_REGISTRY.decodeEvent<any>(eventInstance)
+            await handler(decoded || eventInstance, ctx)
+          }
+        }
+        return ctx.getProcessResult()
+      },
+      filters: _filters,
+    })
+    return this
+  }
+
+  public onEntryFunctionCall(
+    handler: (call: TransactionPayload_EntryFunctionPayload, ctx: AptosContext) => void,
+    filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[]
+  ): AptosBaseProcessor {
+    let _filters: FunctionNameAndCallFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
+
+    this.callHandlers.push({
+      handler: async function (tx) {
+        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 = TYPE_REGISTRY.decodeFunctionPayload(payload)
+          await handler(decoded, ctx)
+        }
+        return ctx.getProcessResult()
+      },
+      filters: _filters,
+    })
+    return this
+  }
+
+  getChainId(): string {
+    return getChainId(this.config.network)
+  }
+
+  loadTypes(registry: TypeRegistry) {
+    if (registry.contains(this.config.address, this.moduleName)) {
+      return
+    }
+    this.loadTypesInternal(registry)
+  }
+
+  protected loadTypesInternal(registry: TypeRegistry) {
+    // 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
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
+    this.resourcesHandlers.push({
+      handler: async function (arg) {
+        const ctx = new AptosResourceContext(
+          processor.config.network,
+          processor.config.address,
+          arg.version,
+          arg.timestamp
+        )
+        await handler(arg.resources, 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,
+  }
+}

package/src/aptos/context.ts

@@ -0,0 +1,75 @@
+import Long from 'long'
+import { RecordMetaData } from '../gen'
+import { Labels } from '../core/metadata'
+import { normalizeLabels } from '../core/meter'
+import { BaseContext } from '../core/base-context'
+import { Transaction_UserTransaction } from 'aptos-sdk/src/generated'
+import { AptosNetwork, getChainId } from './network'
+
+export class AptosContext extends BaseContext {
+  address: string
+  network: AptosNetwork
+  moduleName: string
+  version: bigint
+  transaction: Transaction_UserTransaction
+
+  constructor(
+    moduleName: string,
+    network: AptosNetwork,
+    address: string,
+    version: bigint,
+    transaction?: Transaction_UserTransaction
+  ) {
+    super()
+    this.address = address
+    this.network = network
+    this.moduleName = moduleName
+    this.version = version
+    if (transaction) {
+      this.transaction = transaction
+    }
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: this.moduleName,
+      blockNumber: Long.fromString(this.version.toString()),
+      transactionIndex: 0,
+      transactionHash: this.transaction?.hash || '', // TODO
+      logIndex: 0,
+      chainId: getChainId(this.network),
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}
+
+export class AptosResourceContext extends BaseContext {
+  address: string
+  network: AptosNetwork
+  version: bigint
+  timestampInMicros: number
+
+  constructor(network: AptosNetwork, address: string, version: bigint, timestampInMicros: number) {
+    super()
+    this.address = address
+    this.network = network
+    this.version = version
+    this.timestampInMicros = timestampInMicros
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: 'resources',
+      blockNumber: Long.fromString(this.version.toString()),
+      transactionIndex: 0,
+      transactionHash: '',
+      logIndex: 0,
+      chainId: getChainId(this.network),
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/aptos/index.ts

@@ -0,0 +1,10 @@
+export type { Transaction_UserTransaction, TransactionPayload_EntryFunctionPayload } from 'aptos-sdk/src/generated'
+export type { EventInstance, TypedEventInstance, TypedEntryFunctionPayload, TypedMoveResource } from './models'
+export { TYPE_REGISTRY, TypeRegistry } from './type-registry'
+export type { FunctionNameAndCallFilter, EventFilter, CallFilter, ArgumentsFilter } from './aptos-processor'
+export { AptosBaseProcessor, AptosAccountProcessor } from './aptos-processor'
+export { AptosContext, AptosResourceContext } from './context'
+export { AptosBindOptions, AptosNetwork, getRpcClient } from './network'
+export * from './api'
+
+export { AptosPlugin } from './aptos-plugin'

package/src/aptos/models.ts

@@ -0,0 +1,34 @@
+import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from 'aptos-sdk/src/generated'
+
+export type EventInstance = Event & {
+  version: string
+}
+
+export type TypedEventInstance<T> = EventInstance & {
+  // Typed data converted from ABI
+  // undefined if there is converting error, usually because the ABI/data
+  // mismatch
+  data_typed: T
+
+  type_arguments: string[]
+}
+
+// Don't use intermedidate type to make IDE happier
+export type TypedEntryFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
+  arguments_typed: T
+}
+
+export type TypedMoveResource<T> = MoveResource & {
+  data_typed: T
+  type_arguments: string[]
+}
+
+export interface StructWithTag {
+  type: string
+  data: any
+}
+
+export interface StructWithType<T> extends StructWithTag {
+  data_typed: T
+  type_arguments: string[]
+}

package/src/aptos/network.ts

@@ -0,0 +1,42 @@
+import { CHAIN_IDS, CHAIN_MAP, getChainName } from '../utils/chain'
+import { AptosClient } from 'aptos-sdk'
+
+export enum AptosNetwork {
+  MAIN_NET = 1,
+  TEST_NET = 2,
+  // DEV_NET,
+}
+
+export function getChainId(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return CHAIN_IDS.APTOS_TESTNET
+  }
+  return CHAIN_IDS.APTOS_MAINNET
+}
+
+export function getAptosChainName(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return getChainName(CHAIN_IDS.APTOS_TESTNET)
+  }
+  return getChainName(CHAIN_IDS.APTOS_MAINNET)
+}
+
+export function getRpcEndpoint(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return 'https://testnet.aptoslabs.com/'
+  }
+  return 'https://mainnet.aptoslabs.com/'
+}
+
+export function getRpcClient(network: AptosNetwork): AptosClient {
+  return new AptosClient(getRpcEndpoint(network))
+}
+
+export class AptosBindOptions {
+  address: string
+  network?: AptosNetwork = AptosNetwork.MAIN_NET
+  startVersion?: bigint | number
+}