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

package/src/core/base-processor.ts

@@ -0,0 +1,217 @@
+import { BytesLike } from '@ethersproject/bytes'
+import { Block, Log, getNetwork } from '@ethersproject/providers'
+import { BaseContract, Event, EventFilter } from '@ethersproject/contracts'
+import Long from 'long'
+
+import { BoundContractView, ContractContext, ContractView } from './context'
+import { AddressType, HandleInterval, ProcessResult } from '../gen'
+import { BindInternalOptions, BindOptions } from './bind-options'
+import { PromiseOrVoid } from '../promise-or-void'
+import { Trace } from './trace'
+
+export interface AddressOrTypeEventFilter extends EventFilter {
+  addressType?: AddressType
+}
+
+export class EventsHandler {
+  filters: AddressOrTypeEventFilter[]
+  handler: (event: Log) => Promise<ProcessResult>
+}
+
+export class TraceHandler {
+  signature: string
+  handler: (trace: Trace) => Promise<ProcessResult>
+}
+
+export class BlockHandlder {
+  blockInterval?: HandleInterval
+  timeIntervalInMinutes?: HandleInterval
+  handler: (block: Block) => Promise<ProcessResult>
+}
+
+export abstract class BaseProcessor<
+  TContract extends BaseContract,
+  TBoundContractView extends BoundContractView<TContract, ContractView<TContract>>
+> {
+  blockHandlers: BlockHandlder[] = []
+  eventHandlers: EventsHandler[] = []
+  traceHandlers: TraceHandler[] = []
+
+  config: BindInternalOptions
+
+  constructor(config: BindOptions) {
+    this.config = {
+      address: config.address,
+      name: config.name || '',
+      network: config.network ? config.network : 1,
+      startBlock: new Long(0),
+    }
+    if (config.startBlock) {
+      if (typeof config.startBlock === 'number') {
+        this.config.startBlock = Long.fromNumber(config.startBlock)
+      } else {
+        this.config.startBlock = config.startBlock
+      }
+    }
+    if (config.endBlock) {
+      if (typeof config.endBlock === 'number') {
+        this.config.endBlock = Long.fromNumber(config.endBlock)
+      } else {
+        this.config.endBlock = config.endBlock
+      }
+    }
+  }
+
+  protected abstract CreateBoundContractView(): TBoundContractView
+
+  public getChainId(): number {
+    return getNetwork(this.config.network).chainId
+  }
+
+  public onEvent(
+    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    filter: EventFilter | EventFilter[]
+  ) {
+    const chainId = this.getChainId()
+
+    let _filters: EventFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    const contractView = this.CreateBoundContractView()
+    const contractName = this.config.name
+    this.eventHandlers.push({
+      filters: _filters,
+      handler: async function (log) {
+        const ctx = new ContractContext<TContract, TBoundContractView>(
+          contractName,
+          contractView,
+          chainId,
+          undefined,
+          log
+        )
+        // let event: Event = <Event>deepCopy(log);
+        const event: Event = <Event>log
+        const parsed = contractView.rawContract.interface.parseLog(log)
+        if (parsed) {
+          event.args = parsed.args
+          event.decode = (data: BytesLike, topics?: Array<any>) => {
+            return contractView.rawContract.interface.decodeEventLog(parsed.eventFragment, data, topics)
+          }
+          event.event = parsed.name
+          event.eventSignature = parsed.signature
+
+          // TODO fix this bug
+          await handler(event, ctx)
+          return ctx.getProcessResult()
+        }
+        return ProcessResult.fromPartial({})
+      },
+    })
+    return this
+  }
+
+  public onBlock(handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid) {
+    return this.onBlockInterval(handler)
+  }
+
+  public onBlockInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    blockInterval = 1000,
+    backfillBlockInterval = 4000
+  ) {
+    return this.onInterval(handler, undefined, {
+      recentInterval: blockInterval,
+      backfillInterval: backfillBlockInterval,
+    })
+  }
+
+  public onTimeInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240
+  ) {
+    return this.onInterval(
+      handler,
+      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
+      undefined
+    )
+  }
+
+  public onInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    blockInterval: HandleInterval | undefined
+  ) {
+    const chainId = this.getChainId()
+    const contractView = this.CreateBoundContractView()
+    const contractName = this.config.name
+
+    this.blockHandlers.push({
+      handler: async function (block: Block) {
+        const ctx = new ContractContext<TContract, TBoundContractView>(
+          contractName,
+          contractView,
+          chainId,
+          block,
+          undefined
+        )
+        await handler(block, ctx)
+        return ctx.getProcessResult()
+      },
+      timeIntervalInMinutes: timeInterval,
+      blockInterval: blockInterval,
+    })
+    return this
+  }
+
+  public onAllEvents(handler: (event: Log, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid) {
+    const _filters: EventFilter[] = []
+    const tmpContract = this.CreateBoundContractView()
+
+    for (const key in tmpContract.filters) {
+      _filters.push(tmpContract.filters[key]())
+    }
+    return this.onEvent(function (log, ctx) {
+      return handler(log, ctx)
+    }, _filters)
+  }
+
+  protected onTrace(
+    signature: string,
+    handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+  ) {
+    const chainId = this.getChainId()
+    const contractView = this.CreateBoundContractView()
+    const contractName = this.config.name
+
+    this.traceHandlers.push({
+      signature,
+      handler: async function (trace: Trace) {
+        const contractInterface = contractView.rawContract.interface
+        const fragment = contractInterface.getFunction(signature)
+        if (!trace.action.input) {
+          return ProcessResult.fromPartial({})
+        }
+        const traceData = '0x' + trace.action.input.slice(10)
+        trace.args = contractInterface._abiCoder.decode(fragment.inputs, traceData)
+
+        const ctx = new ContractContext<TContract, TBoundContractView>(
+          contractName,
+          contractView,
+          chainId,
+          undefined,
+          undefined,
+          trace
+        )
+        await handler(trace, ctx)
+        return ctx.getProcessResult()
+      },
+    })
+    return this
+  }
+}

package/src/core/big-decimal.ts

@@ -0,0 +1 @@
+export { BigNumber as BigDecimal } from 'bignumber.js'

package/src/core/bind-options.ts

@@ -0,0 +1,45 @@
+import { Networkish } from '@ethersproject/networks'
+import Long from 'long'
+import { getNetwork } from '@ethersproject/providers'
+
+export class BindOptions {
+  // Contract address
+  address: string
+  // Optional, if not set, then use eth mainnet
+  network?: Networkish = 1
+  // Optional, override default contract name
+  name?: string
+  startBlock?: Long | number
+  endBlock?: Long | number
+}
+
+export function getOptionsSignature(opts: BindOptions): string {
+  const sig = [opts.address]
+  if (opts.network) {
+    sig.push(getNetwork(opts.network).chainId.toString())
+  }
+  if (opts.name) {
+    sig.push(opts.name)
+  }
+  if (opts.startBlock) {
+    sig.push(opts.startBlock.toString())
+  }
+  if (opts.endBlock) {
+    sig.push(opts.endBlock.toString())
+  }
+  return sig.join('_')
+}
+
+export class BindInternalOptions {
+  address: string
+  network: Networkish
+  name: string
+  startBlock: Long
+  endBlock?: Long
+}
+
+export class AccountBindOptions {
+  address: string
+  network?: Networkish
+  startBlock?: Long | number
+}

package/src/core/context.ts

@@ -0,0 +1,183 @@
+import { RecordMetaData, ProcessResult } from '../gen'
+import { BaseContract, EventFilter } from 'ethers'
+import { Block, Log } from '@ethersproject/abstract-provider'
+import { normalizeLabels } from './meter'
+import Long from 'long'
+import { Trace } from './trace'
+import { Labels } from './metadata'
+import { CHAIN_IDS } from '../utils/chain'
+import { BaseContext } from './base-context'
+
+export abstract class EthContext extends BaseContext {
+  chainId: number
+  address: string
+  log?: Log
+  block?: Block
+  trace?: Trace
+  blockNumber: Long
+  transactionHash?: string
+
+  protected constructor(chainId: number, address: string, block?: Block, log?: Log, trace?: Trace) {
+    super()
+    this.chainId = chainId
+    this.log = log
+    this.block = block
+    this.trace = trace
+    this.address = address
+    if (log) {
+      this.blockNumber = Long.fromNumber(log.blockNumber, true)
+      this.transactionHash = log.transactionHash
+    } else if (block) {
+      this.blockNumber = Long.fromNumber(block.number, true)
+    } else if (trace) {
+      this.blockNumber = Long.fromNumber(trace.blockNumber, true)
+      this.transactionHash = trace.transactionHash
+    }
+  }
+
+  protected abstract getContractName(): string
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    if (this.log) {
+      return {
+        address: this.address,
+        contractName: this.getContractName(),
+        blockNumber: this.blockNumber,
+        transactionIndex: this.log.transactionIndex,
+        transactionHash: this.transactionHash || '',
+        logIndex: this.log.logIndex,
+        chainId: this.chainId.toString(),
+        name: name,
+        labels: normalizeLabels(labels),
+      }
+    }
+    if (this.block) {
+      return {
+        address: this.address,
+        contractName: this.getContractName(),
+        blockNumber: this.blockNumber,
+        transactionIndex: -1,
+        transactionHash: '',
+        logIndex: -1,
+        chainId: this.chainId.toString(),
+        name: name,
+        labels: normalizeLabels(labels),
+      }
+    }
+    if (this.trace) {
+      return {
+        address: this.address,
+        contractName: this.getContractName(),
+        blockNumber: this.blockNumber,
+        transactionIndex: this.trace.transactionPosition,
+        transactionHash: this.transactionHash || '',
+        logIndex: -1,
+        chainId: this.chainId.toString(),
+        name: name,
+        labels: normalizeLabels(labels),
+      }
+    }
+    throw new Error("Invaid ctx argument can't happen")
+  }
+}
+
+export class AccountContext extends EthContext {
+  constructor(chainId: number, address: string, block?: Block, log?: Log, trace?: Trace) {
+    super(chainId, address, block, log, trace)
+  }
+  protected getContractName(): string {
+    return 'account'
+  }
+}
+
+export class ContractContext<
+  TContract extends BaseContract,
+  TContractBoundView extends BoundContractView<TContract, ContractView<TContract>>
+> extends EthContext {
+  contract: TContractBoundView
+  contractName: string
+
+  constructor(
+    contractName: string,
+    view: TContractBoundView,
+    chainId: number,
+    block?: Block,
+    log?: Log,
+    trace?: Trace
+  ) {
+    super(chainId, view.rawContract.address, block, log, trace)
+    view.context = this
+    this.contractName = contractName
+    this.contract = view
+  }
+
+  protected getContractName(): string {
+    return this.contractName
+  }
+}
+
+export class ContractView<TContract extends BaseContract> {
+  filters: { [name: string]: (...args: Array<any>) => EventFilter }
+  protected contract: TContract
+
+  constructor(contract: TContract) {
+    this.contract = contract
+    this.filters = contract.filters
+  }
+
+  get rawContract() {
+    return this.contract
+  }
+
+  get provider() {
+    return this.contract.provider
+  }
+}
+
+export class BoundContractView<TContract extends BaseContract, TContractView extends ContractView<TContract>> {
+  protected view: TContractView
+  // context will be set right after context creation (in context's constructor)
+  context: ContractContext<TContract, BoundContractView<TContract, TContractView>>
+
+  constructor(view: TContractView) {
+    this.view = view
+  }
+
+  get rawContract() {
+    return this.view.rawContract
+  }
+
+  get provider() {
+    return this.view.provider
+  }
+
+  get filters() {
+    return this.view.filters
+  }
+}
+
+export class SuiContext extends BaseContext {
+  address: string
+  moduleName: string
+  blockNumber: Long
+
+  constructor(address: string, slot: Long) {
+    super()
+    this.address = address
+    this.blockNumber = slot
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: this.moduleName,
+      blockNumber: this.blockNumber,
+      transactionIndex: 0,
+      transactionHash: '', // TODO
+      logIndex: 0,
+      chainId: CHAIN_IDS.SUI_DEVNET, // TODO set in context
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/core/eth-plugin.ts

@@ -0,0 +1,255 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  AccountConfig,
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  LogFilter,
+  LogHandlerConfig,
+  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 { Block, Log } from '@ethersproject/abstract-provider'
+import { Trace } from '@sentio/sdk'
+import { ProcessorState } from '../binds'
+import { AccountProcessorState } from './account-processor'
+import Long from 'long'
+
+export class EthPlugin implements Plugin {
+  name: string = 'EthPlugin'
+
+  private eventHandlers: ((event: Log) => Promise<ProcessResult>)[] = []
+  private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
+  private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
+
+  configure(config: ProcessConfigResponse): void {
+    for (const processor of ProcessorState.INSTANCE.getValues()) {
+      // If server favor incremental update this need to change
+      // Start basic config for contract
+      const chainId = processor.getChainId()
+      // this.processorsByChainId.set(chainId, processor)
+
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: processor.config.name,
+          chainId: chainId.toString(),
+          address: processor.config.address,
+          abi: '',
+        },
+        intervalConfigs: [],
+        logConfigs: [],
+        traceConfigs: [],
+        startBlock: processor.config.startBlock,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      if (processor.config.endBlock) {
+        contractConfig.endBlock = processor.config.endBlock
+      }
+
+      // Step 1. Prepare all the block handlers
+      for (const blockHandler of processor.blockHandlers) {
+        const handlerId = this.blockHandlers.push(blockHandler.handler) - 1
+        // TODO wrap the block handler into one
+
+        contractConfig.intervalConfigs.push({
+          slot: 0,
+          slotInterval: blockHandler.blockInterval,
+          minutes: 0,
+          minutesInterval: blockHandler.timeIntervalInMinutes,
+          handlerId: handlerId,
+        })
+      }
+
+      // Step 2. Prepare all trace handlers
+      for (const traceHandler of processor.traceHandlers) {
+        const handlerId = this.traceHandlers.push(traceHandler.handler) - 1
+        contractConfig.traceConfigs.push({
+          signature: traceHandler.signature,
+          handlerId: handlerId,
+        })
+      }
+
+      // Step 3. Prepare all the event handlers
+      for (const eventsHandler of processor.eventHandlers) {
+        // associate id with filter
+        const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1
+        const logConfig: LogHandlerConfig = {
+          handlerId: handlerId,
+          filters: [],
+        }
+
+        for (const filter of eventsHandler.filters) {
+          if (!filter.topics) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          }
+          const logFilter: LogFilter = {
+            addressType: undefined,
+            address: contractConfig.contract?.address,
+            topics: [],
+          }
+
+          for (const ts of filter.topics) {
+            let hashes: string[] = []
+            if (Array.isArray(ts)) {
+              hashes = hashes.concat(ts)
+            } else if (ts) {
+              hashes.push(ts)
+            }
+            logFilter.topics.push({ hashes: hashes })
+          }
+          logConfig.filters.push(logFilter)
+        }
+        contractConfig.logConfigs.push(logConfig)
+      }
+
+      // Finish up a contract
+      config.contractConfigs.push(contractConfig)
+    }
+
+    // part 1.b prepare EVM account processors
+    for (const processor of AccountProcessorState.INSTANCE.getValues()) {
+      const accountConfig: AccountConfig = {
+        address: processor.config.address,
+        chainId: processor.getChainId().toString(),
+        startBlock: processor.config.startBlock ? Long.fromValue(processor.config.startBlock) : Long.ZERO,
+        aptosIntervalConfigs: [],
+        intervalConfigs: [],
+        logConfigs: [],
+      }
+      // TODO add interval
+      for (const eventsHandler of processor.eventHandlers) {
+        // associate id with filter
+        const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1
+        const logConfig: LogHandlerConfig = {
+          handlerId: handlerId,
+          filters: [],
+        }
+
+        for (const filter of eventsHandler.filters) {
+          if (!filter.topics) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          }
+          const logFilter: LogFilter = {
+            addressType: filter.addressType,
+            address: filter.address,
+            topics: [],
+          }
+
+          for (const ts of filter.topics) {
+            let hashes: string[] = []
+            if (Array.isArray(ts)) {
+              hashes = hashes.concat(ts)
+            } else if (ts) {
+              hashes.push(ts)
+            }
+            logFilter.topics.push({ hashes: hashes })
+          }
+          logConfig.filters.push(logFilter)
+        }
+        accountConfig.logConfigs.push(logConfig)
+      }
+
+      config.accountConfigs.push(accountConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.ETH_LOG, HandlerType.ETH_BLOCK, HandlerType.ETH_TRACE]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    // return Promise.resolve(undefined);
+    switch (request.handlerType) {
+      case HandlerType.ETH_LOG:
+        return this.processLog(request)
+      case HandlerType.ETH_TRACE:
+        return this.processTrace(request)
+      case HandlerType.ETH_BLOCK:
+        return this.processBlock(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processLog(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+    let log: Log
+    if (request.data.ethLog) {
+      log = request.data.ethLog.log as Log
+    } else {
+      const jsonString = Utf8ArrayToStr(request.data.raw)
+      log = JSON.parse(jsonString)
+    }
+
+    for (const handlerId of request.handlerIds) {
+      const handler = this.eventHandlers[handlerId]
+      promises.push(
+        handler(log).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing log: ' + JSON.stringify(log) + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processTrace(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be empty")
+    }
+    let trace: Trace
+    if (binding.data.ethTrace?.trace) {
+      trace = binding.data.ethTrace.trace as Trace
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      trace = JSON.parse(jsonString)
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.traceHandlers[handlerId](trace).catch((e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing trace: ' + JSON.stringify(trace) + '\n' + errorString(e)
+          )
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processBlock(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
+    }
+    let block: Block
+    if (binding.data.ethBlock?.block) {
+      block = binding.data.ethBlock.block as Block
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      block = JSON.parse(jsonString)
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.blockHandlers[handlerId](block).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing block: ' + block.number + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new EthPlugin())