@sentio/sdk 1.37.0-rc.2 → 1.37.0-rc.4

package/src/aptos/api.ts

@@ -1,11 +0,0 @@
-import { AptosQueryClient, AptosQueryDefinition } from '@sentio/protos/lib/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

@@ -1,216 +0,0 @@
-import { Plugin, PluginManager } from '@sentio/base'
-import {
-  AccountConfig,
-  AptosCallHandlerConfig,
-  AptosEventHandlerConfig,
-  ContractConfig,
-  DataBinding,
-  HandlerType,
-  ProcessConfigResponse,
-  ProcessResult,
-} from '@sentio/protos'
-
-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'
-
-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: aptosProcessor.config.startVersion,
-        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: 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]
-
-  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 > Number.MAX_SAFE_INTEGER) {
-        throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
-      }
-      resource.timestamp = Number(binding.data.aptResource.timestampMicros)
-      resource.version = 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 (BigInt(json.timestamp) > Number.MAX_SAFE_INTEGER) {
-        throw new ServerError(Status.INVALID_ARGUMENT, 'timestamp is too large')
-      }
-      resource.timestamp = parseInt(json.timestamp)
-      resource.version = BigInt(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

@@ -1,305 +0,0 @@
-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 '@sentio/base'
-import { HandleInterval, ProcessResult } from '@sentio/protos'
-
-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

@@ -1,74 +0,0 @@
-import { RecordMetaData } from '@sentio/protos'
-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: this.version,
-      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: this.version,
-      transactionIndex: 0,
-      transactionHash: '',
-      logIndex: 0,
-      chainId: getChainId(this.network),
-      name: name,
-      labels: normalizeLabels(labels),
-    }
-  }
-}

package/src/aptos/index.ts

@@ -1,10 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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
-}