@sentio/sdk 1.0.0-development → 1.0.0-rc.3

package/src/core/event-tracker.ts

@@ -0,0 +1,69 @@
+import { BaseContext } from './base-context'
+import { EventTrackingResult } from '../gen'
+import { NamedResultDescriptor } from './metadata'
+import { MapStateStorage } from '../state/state-storage'
+
+export interface Event {
+  // The unique identifier of main identity associate with an event
+  // .e.g user id / toekn address / account address / contract address id
+  //
+  distinctId: string
+  payload?: Record<string, string>
+}
+
+export interface TrackerOptions {
+  totalByDay?: boolean
+  unique?: boolean
+  distinctByDays?: number[]
+}
+
+export class EventTrackerState extends MapStateStorage<EventTracker> {
+  static INSTANCE = new EventTrackerState()
+}
+
+// Track Event with an identity associate with it
+export class EventTracker extends NamedResultDescriptor {
+  static DEFAULT_OPTIONS: TrackerOptions = {
+    totalByDay: true,
+    unique: true,
+  }
+
+  static register(eventName: string, options?: TrackerOptions) {
+    const tracker = new EventTracker(eventName, { ...EventTracker.DEFAULT_OPTIONS, ...options })
+    return EventTrackerState.INSTANCE.getOrSetValue(eventName, tracker)
+  }
+
+  options: TrackerOptions
+  protected constructor(eventName: string, options: TrackerOptions) {
+    super(eventName)
+    this.options = options
+  }
+
+  trackEvent(ctx: BaseContext, event: Event) {
+    const res: EventTrackingResult = {
+      metadata: ctx.getMetaData(this.name, {}),
+      distinctEntityId: event.distinctId,
+      attributes: JSON.stringify({}),
+      runtimeInfo: undefined,
+    }
+    ctx.res.events.push(res)
+  }
+}
+
+export class AccountEventTracker extends EventTracker {
+  static DEFAULT_OPTIONS: TrackerOptions = {
+    totalByDay: true,
+    unique: true,
+    distinctByDays: [1, 7, 30],
+  }
+
+  static register(eventName?: string, options?: TrackerOptions) {
+    if (eventName) {
+      eventName = ['user', eventName].join('_')
+    } else {
+      eventName = 'user'
+    }
+    const tracker = new AccountEventTracker(eventName, { ...AccountEventTracker.DEFAULT_OPTIONS, ...options })
+    return EventTrackerState.INSTANCE.getOrSetValue(eventName, tracker)
+  }
+}

package/src/core/exporter.ts

@@ -0,0 +1,32 @@
+import { BaseContext } from './base-context'
+import { ExportResult } from '@sentio/sdk'
+import { NamedResultDescriptor } from './metadata'
+import { MapStateStorage } from '../state/state-storage'
+
+export type Export = Record<string, any>
+
+export class ExporterState extends MapStateStorage<Exporter> {
+  static INSTANCE = new ExporterState()
+}
+
+export class Exporter extends NamedResultDescriptor {
+  static register(name: string, channel: string) {
+    const exporter = new Exporter(name, channel)
+    return ExporterState.INSTANCE.getOrSetValue(name, exporter)
+  }
+
+  channel: string
+  protected constructor(name: string, channel: string) {
+    super(name)
+    this.channel = channel
+  }
+
+  emit(ctx: BaseContext, data: Export) {
+    const res: ExportResult = {
+      metadata: ctx.getMetaData(this.name, {}),
+      payload: JSON.stringify(data),
+      runtimeInfo: undefined,
+    }
+    ctx.res.exports.push(res)
+  }
+}

package/src/core/generic-processor.ts

@@ -0,0 +1,34 @@
+import { BaseContract } from '@ethersproject/contracts'
+import { BoundContractView, ContractView } from './context'
+import { BindOptions } from './bind-options'
+import { BaseProcessor } from './base-processor'
+import { getProvider } from '../provider'
+import { addProcessor } from '../binds'
+
+export class GenericProcessor extends BaseProcessor<
+  BaseContract,
+  BoundContractView<BaseContract, ContractView<BaseContract>>
+> {
+  eventABI: string[]
+  constructor(eventABI: string[], options: BindOptions) {
+    super(options)
+    this.eventABI = eventABI
+  }
+
+  protected CreateBoundContractView(): BoundContractView<BaseContract, ContractView<BaseContract>> {
+    const contract = new BaseContract(this.config.address, this.eventABI, getProvider(this.config.network))
+    return new BoundContractView(new ContractView<BaseContract>(contract))
+  }
+
+  public static bind(eventABI: string[] | string, options: BindOptions): GenericProcessor {
+    if (!Array.isArray(eventABI)) {
+      eventABI = [eventABI]
+    }
+    if (!options.name) {
+      options.name = 'Generic'
+    }
+    const processor = new GenericProcessor(eventABI, options)
+    addProcessor(options, processor)
+    return processor
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,22 @@
+export { BigDecimal } from './big-decimal'
+export { ContractContext, ContractView, BoundContractView } from './context'
+export { CounterBinding, Meter, GaugeBinding, Counter, Gauge, MetricOptions } from './meter'
+export { EventTracker, AccountEventTracker } from './event-tracker'
+export { type Numberish, toBigInteger, toMetricValue } from './numberish'
+
+export { BindOptions } from './bind-options'
+
+export { BaseProcessor } from './base-processor'
+export { GenericProcessor } from './generic-processor'
+export { BaseProcessorTemplate } from './base-processor-template'
+export { SuiBaseProcessor, SuiBindOptions } from './sui-processor'
+
+export { SolanaContext } from './solana-context'
+export { SolanaBindOptions } from './solana-options'
+export { SolanaBaseProcessor } from './solana-processor'
+
+export type { TypedCallTrace, Trace } from './trace'
+
+export { EthPlugin } from './eth-plugin'
+export { SolanaPlugin } from './solana-plugin'
+export { SuiPlugin } from './sui-plugin'

package/src/core/logger.ts

@@ -0,0 +1,49 @@
+import { BaseContext } from './base-context'
+import { LogLevel } from '../gen'
+import { NamedResultDescriptor } from './metadata'
+
+export type Attributes = Record<string, any>
+
+export class Logger extends NamedResultDescriptor {
+  private readonly ctx: BaseContext
+
+  constructor(ctx: BaseContext, name = '') {
+    super(name)
+    this.ctx = ctx
+  }
+
+  withName(name: string) {
+    return new Logger(this.ctx, name)
+  }
+
+  log(level: LogLevel, message: any, attributes: Attributes = {}) {
+    if (typeof message !== 'string' && !(message instanceof String)) {
+      message = JSON.stringify(message)
+    }
+
+    this.ctx.res.logs.push({
+      // name: this.name,
+      metadata: this.ctx.getMetaData(this.name, {}), // GetRecordMetaData(this.ctx, this, {}),
+      level,
+      message,
+      attributes: JSON.stringify(attributes),
+      runtimeInfo: undefined,
+    })
+  }
+
+  info(msg: any, attributes: Attributes = {}) {
+    this.log(LogLevel.INFO, msg, attributes)
+  }
+
+  warn(msg: any, attributes: Attributes = {}) {
+    this.log(LogLevel.WARNING, msg, attributes)
+  }
+
+  error(msg: any, attributes: Attributes = {}) {
+    this.log(LogLevel.ERROR, msg, attributes)
+  }
+
+  critical(msg: any, attributes: Attributes = {}) {
+    this.log(LogLevel.CRITICAL, msg, attributes)
+  }
+}

package/src/core/metadata.ts

@@ -0,0 +1,11 @@
+import { normalizeName } from './meter'
+
+export type Labels = { [key: string]: string }
+
+export class NamedResultDescriptor {
+  name: string
+
+  constructor(name: string) {
+    this.name = normalizeName(name)
+  }
+}

package/src/core/meter.ts

@@ -0,0 +1,179 @@
+import { BaseContext } from './base-context'
+import { Numberish, toMetricValue } from './numberish'
+import { Labels, NamedResultDescriptor } from './metadata'
+import { AggregationConfig, AggregationType, MetricConfig, MetricType } from '../gen'
+import { MapStateStorage } from '../state/state-storage'
+
+export function normalizeName(name: string): string {
+  const regex = new RegExp('![_.a-zA-Z0-9]')
+  return name.slice(0, 100).replace(regex, '_')
+}
+
+export function normalizeKey(name: string): string {
+  if (name === 'labels') {
+    return 'labels_'
+  }
+  return normalizeName(name)
+}
+
+export function normalizeValue(name: string): string {
+  return name.slice(0, 100)
+}
+
+export function normalizeLabels(labels: Labels): Labels {
+  const normLabels: Labels = {}
+  for (const key in labels) {
+    normLabels[normalizeKey(key)] = normalizeValue(labels[key])
+  }
+  return normLabels
+}
+
+export class MetricOptions {
+  unit?: string
+  description?: string
+  sparse?: boolean
+  aggregationConfig?: Partial<AggregationConfig>
+}
+
+export class CounterOptions {
+  unit?: string
+  description?: string
+  sparse?: boolean
+}
+
+// enum MetricType {
+//   Counter = 0,
+//   Gauge = 1,
+// }
+
+export class Metric extends NamedResultDescriptor {
+  config: MetricConfig
+  constructor(type: MetricType, name: string, option?: MetricOptions) {
+    super(name)
+    this.config = MetricConfig.fromPartial({ name: this.name, type: type, ...option })
+    const aggregationConfig = this.config.aggregationConfig
+    if (aggregationConfig && aggregationConfig.intervalInMinutes.length) {
+      if (aggregationConfig.intervalInMinutes.length > 1) {
+        console.error('current only support one intervalInMinutes, only first interval will be used for', name)
+      }
+      if (aggregationConfig.intervalInMinutes[0] > 0 && aggregationConfig.types.length === 0) {
+        aggregationConfig.types = [AggregationType.SUM, AggregationType.COUNT]
+      }
+    }
+  }
+}
+
+export class MetricState extends MapStateStorage<Metric> {
+  static INSTANCE = new MetricState()
+
+  getOrRegisterMetric(type: MetricType, name: string, option?: CounterOptions | MetricOptions): Metric {
+    const metricMap = this.getOrRegister()
+    let metric = metricMap.get(name)
+    if (metric && metric.config.type !== type) {
+      throw Error(`redefine ${name} of metric type ${type} that is previously ${metric.config.type}`)
+    }
+
+    if (!metric) {
+      if (type === MetricType.COUNTER) {
+        metric = new Counter(name, option)
+      } else {
+        metric = new Gauge(name, option)
+      }
+    }
+    metricMap.set(name, metric)
+    return metric
+  }
+}
+
+export class Counter extends Metric {
+  static register(name: string, option?: CounterOptions): Counter {
+    return MetricState.INSTANCE.getOrRegisterMetric(MetricType.COUNTER, name, option) as Counter
+  }
+
+  constructor(name: string, option?: MetricOptions) {
+    super(MetricType.COUNTER, name, option)
+  }
+
+  add(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    this.record(ctx, value, labels, true)
+  }
+
+  sub(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    this.record(ctx, value, labels, false)
+  }
+
+  private record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
+    ctx.res.counters.push({
+      metadata: ctx.getMetaData(this.name, labels),
+      metricValue: toMetricValue(value),
+      add: add,
+      runtimeInfo: undefined,
+    })
+  }
+}
+
+export class CounterBinding {
+  private readonly ctx: BaseContext
+  private readonly counter: Counter
+
+  constructor(name: string, ctx: BaseContext) {
+    this.counter = new Counter(name)
+    this.ctx = ctx
+  }
+
+  add(value: Numberish, labels: Labels = {}) {
+    this.counter.add(this.ctx, value, labels)
+  }
+
+  sub(value: Numberish, labels: Labels = {}) {
+    this.counter.sub(this.ctx, value, labels)
+  }
+}
+
+export class Gauge extends Metric {
+  static register(name: string, option?: MetricOptions): Gauge {
+    return MetricState.INSTANCE.getOrRegisterMetric(MetricType.GAUGE, name, option) as Gauge
+  }
+
+  constructor(name: string, option?: MetricOptions) {
+    super(MetricType.GAUGE, name, option)
+  }
+
+  record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    ctx.res.gauges.push({
+      metadata: ctx.getMetaData(this.config.name, labels),
+      metricValue: toMetricValue(value),
+      runtimeInfo: undefined,
+    })
+  }
+}
+
+export class GaugeBinding {
+  private readonly gauge: Gauge
+  private readonly ctx: BaseContext
+
+  constructor(name: string, ctx: BaseContext) {
+    this.gauge = new Gauge(name)
+    this.ctx = ctx
+  }
+
+  record(value: Numberish, labels: Labels = {}) {
+    this.gauge.record(this.ctx, value, labels)
+  }
+}
+
+export class Meter {
+  private readonly ctx: BaseContext
+
+  constructor(ctx: BaseContext) {
+    this.ctx = ctx
+  }
+
+  Counter(name: string): CounterBinding {
+    return new CounterBinding(name, this.ctx)
+  }
+
+  Gauge(name: string): GaugeBinding {
+    return new GaugeBinding(name, this.ctx)
+  }
+}

package/src/core/numberish.ts

@@ -0,0 +1,121 @@
+import { BigNumber } from 'ethers'
+import { BigInteger, MetricValue } from '../gen'
+import { BigDecimal } from '.'
+import { BN } from '@project-serum/anchor'
+import Long from 'long'
+
+export type Numberish = number | BigNumber | bigint | BigDecimal
+
+export function toMetricValue(value: Numberish): MetricValue {
+  if (value instanceof BigNumber) {
+    return MetricValue.fromPartial({
+      bigInteger: toBigInteger(value.toBigInt()),
+    })
+  }
+  if (value instanceof BigDecimal) {
+    // Carefully consider the use case here
+    if (value.isInteger()) {
+      return MetricValue.fromPartial({
+        bigInteger: bigDecimalToBigInteger(value),
+      })
+    } else {
+      if (value.isNaN()) {
+        throw new Error('Cannot record NaN value')
+      }
+      if (!value.isFinite()) {
+        // NaN also not finite
+        throw new Error('Cannot record infinite value')
+      }
+      return MetricValue.fromPartial({
+        bigDecimal: value.toString(), // e.g. -7.350918e-428
+      })
+    }
+  }
+  if (BN.isBN(value)) {
+    return MetricValue.fromPartial({
+      bigInteger: bnToBigInteger(value),
+    })
+  }
+  if (typeof value === 'bigint' || Number.isInteger(value)) {
+    return MetricValue.fromPartial({
+      bigInteger: toBigInteger(value),
+    })
+  }
+
+  if (typeof value === 'number') {
+    if (Number.isNaN(value)) {
+      throw new Error('Cannot record NaN value')
+    }
+    if (!Number.isFinite(value)) {
+      throw new Error('Cannot record infinite value')
+    }
+  }
+
+  return MetricValue.fromPartial({
+    doubleValue: Number(value),
+  })
+}
+
+function bigDecimalToBigInteger(a: BigDecimal): BigInteger {
+  const negative = a.isNegative()
+  if (negative) {
+    a = a.abs()
+  }
+  return hexToBigInteger(a.toString(16), negative)
+}
+
+function bnToBigInteger(a: BN): BigInteger {
+  const negative = a.isNeg()
+  if (negative) {
+    a = a.abs()
+  }
+  return hexToBigInteger(a.toString(16), negative)
+}
+
+function intToBigInteger(a: bigint | number): BigInteger {
+  const negative = a < 0
+  if (negative) {
+    a = -a
+  }
+  return hexToBigInteger(a.toString(16), negative)
+}
+
+export function toBigInteger(a: Numberish): BigInteger {
+  if (a instanceof BigDecimal) {
+    return bigDecimalToBigInteger(a)
+  }
+  if (a instanceof BN) {
+    return bnToBigInteger(a)
+  }
+  if (a instanceof BigNumber) {
+    return intToBigInteger(a.toBigInt())
+  }
+  return intToBigInteger(a)
+
+  // Following code is actually very slow
+  // while (a > 0) {
+  //   const d = a & 0xffn
+  //   a >>= 8n
+  //   value.push(Number(d))
+  // }
+  //
+  // return {
+  //   negative, value: new Uint8Array(value.reverse()),
+  // }
+}
+
+function hexToBigInteger(hex: string, negative: boolean): BigInteger {
+  if (hex.length % 2 === 1) {
+    hex = '0' + hex
+  }
+  const buffer = Buffer.from(hex, 'hex')
+
+  return {
+    negative: negative,
+    data: new Uint8Array(buffer),
+  }
+}
+
+export function toBigInt(v: Long): bigint {
+  return BigInt(v.toString())
+}

package/src/core/solana-context.ts

@@ -0,0 +1,35 @@
+import { BaseContext } from './base-context'
+import Long from 'long'
+import { Labels } from './metadata'
+import { RecordMetaData } from '@sentio/sdk'
+import { CHAIN_IDS } from '../utils/chain'
+import { normalizeLabels } from './meter'
+
+export class SolanaContext extends BaseContext {
+  network: string
+  address: string
+  programName: string
+  blockNumber: Long
+
+  constructor(programName: string, network: string, address: string, slot: Long) {
+    super()
+    this.network = network || CHAIN_IDS.SOLANA_MAINNET
+    this.programName = programName
+    this.address = address
+    this.blockNumber = slot
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: this.programName,
+      blockNumber: this.blockNumber,
+      transactionIndex: 0,
+      transactionHash: '', // TODO add
+      logIndex: 0,
+      chainId: this.network,
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/core/solana-options.ts

@@ -0,0 +1,10 @@
+import Long from 'long'
+
+export class SolanaBindOptions {
+  address: string
+  network?: string
+  name?: string
+  startBlock?: Long | number
+  endBlock?: Long | number
+  processInnerInstruction?: boolean
+}

package/src/core/solana-plugin.ts

@@ -0,0 +1,97 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  ContractConfig,
+  Data_SolInstruction,
+  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 { SolanaProcessorState } from './solana-processor'
+import { Instruction as SolInstruction } from '@project-serum/anchor/dist/cjs/coder/borsh/instruction'
+
+export class SolanaPlugin implements Plugin {
+  name: string = 'SolanaPlugin'
+
+  configure(config: ProcessConfigResponse): void {
+    // Part 2, prepare solana constractors
+    for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: solanaProcessor.contractName,
+          chainId: solanaProcessor.network,
+          address: solanaProcessor.address,
+          abi: '',
+        },
+        logConfigs: [],
+        traceConfigs: [],
+        intervalConfigs: [],
+        startBlock: solanaProcessor.config.startSlot,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: {
+          innerInstruction: solanaProcessor.processInnerInstruction,
+          parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
+          rawDataInstruction: solanaProcessor.decodeInstruction !== null,
+        },
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.SOL_INSTRUCTION]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.SOL_INSTRUCTION:
+        return this.processSolInstruction(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processSolInstruction(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+    }
+
+    const instruction = request.data.solInstruction || Data_SolInstruction.decode(request.data.raw) // JSON.parse(jsonString)
+    const promises: Promise<ProcessResult>[] = []
+
+    // Only have instruction handlers for solana processors
+    for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
+      if (processor.address === instruction.programAccountId) {
+        let parsedInstruction: SolInstruction | null = null
+        if (instruction.parsed) {
+          parsedInstruction = processor.getParsedInstruction(instruction.parsed as { type: string; info: any })
+        } else if (instruction.instructionData) {
+          parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
+        }
+        if (parsedInstruction == null) {
+          continue
+        }
+        const insHandler = processor.getInstructionHandler(parsedInstruction)
+        if (insHandler == null) {
+          continue
+        }
+        const res = await processor.handleInstruction(
+          parsedInstruction,
+          instruction.accounts,
+          insHandler,
+          instruction.slot
+        )
+
+        promises.push(Promise.resolve(res))
+      }
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new SolanaPlugin())