@sentio/sdk 1.7.13 → 1.7.16

package/src/base-processor-template.ts

@@ -0,0 +1,92 @@
+import { BoundContractView, Context, ContractView } from './context'
+import { Block } from '@ethersproject/abstract-provider'
+import { BaseContract, EventFilter } from 'ethers'
+import { Event } from '@ethersproject/contracts'
+import { BaseProcessor } from './base-processor'
+import { BindOptions, getOptionsSignature } from './bind-options'
+import { TemplateInstance } from './gen/processor/protos/processor'
+import Long from 'long'
+import { getNetwork } from '@ethersproject/providers'
+import { PromiseOrVoid } from './promise-or-void'
+
+export abstract class BaseProcessorTemplate<
+  TContract extends BaseContract,
+  TBoundContractView extends BoundContractView<TContract, ContractView<TContract>>
+> {
+  id: number
+  binds = new Set<string>()
+  blockHandlers: ((block: Block, ctx: Context<TContract, TBoundContractView>) => PromiseOrVoid)[] = []
+  eventHandlers: {
+    handler: (event: Event, ctx: Context<TContract, TBoundContractView>) => PromiseOrVoid
+    filter: EventFilter | EventFilter[]
+  }[] = []
+
+  constructor() {
+    this.id = global.PROCESSOR_STATE.templates.length
+    global.PROCESSOR_STATE.templates.push(this)
+  }
+
+  public bind(options: BindOptions) {
+    const sig = getOptionsSignature(options)
+    if (this.binds.has(sig)) {
+      return
+    }
+    this.binds.add(sig)
+
+    const processor = this.bindInternal(options)
+
+    for (const eh of this.eventHandlers) {
+      processor.onEvent(eh.handler, eh.filter)
+    }
+    for (const bh of this.blockHandlers) {
+      processor.onBlock(bh)
+    }
+
+    const instance: TemplateInstance = {
+      templateId: this.id,
+      contract: {
+        address: options.address,
+        name: options.name || '',
+        chainId: options.network ? getNetwork(options.network).chainId.toString() : '1',
+        abi: '',
+      },
+      startBlock: Long.ZERO,
+      endBlock: Long.ZERO,
+    }
+    if (options.startBlock) {
+      if (typeof options.startBlock === 'number') {
+        instance.startBlock = Long.fromNumber(options.startBlock)
+      } else {
+        instance.startBlock = options.startBlock
+      }
+    }
+    if (options.endBlock) {
+      if (typeof options.endBlock === 'number') {
+        instance.endBlock = Long.fromNumber(options.endBlock)
+      } else {
+        instance.endBlock = options.endBlock
+      }
+    }
+    global.PROCESSOR_STATE.templatesInstances.push(instance)
+
+    return processor
+  }
+
+  public onEvent(
+    handler: (event: Event, ctx: Context<TContract, TBoundContractView>) => PromiseOrVoid,
+    filter: EventFilter | EventFilter[]
+  ) {
+    this.eventHandlers.push({
+      handler: handler,
+      filter: filter,
+    })
+    return this
+  }
+
+  public onBlock(handler: (block: Block, ctx: Context<TContract, TBoundContractView>) => PromiseOrVoid) {
+    this.blockHandlers.push(handler)
+    return this
+  }
+
+  protected abstract bindInternal(options: BindOptions): BaseProcessor<TContract, TBoundContractView>
+}

package/src/base-processor.ts

@@ -0,0 +1,128 @@
+import { Event } from '@ethersproject/contracts'
+import { BytesLike } from '@ethersproject/bytes'
+import { Block, Log, getNetwork } from '@ethersproject/providers'
+import { BaseContract, EventFilter } from '@ethersproject/contracts'
+import Long from 'long'
+
+import { BoundContractView, Context, ContractView } from './context'
+import { O11yResult } from './gen/processor/protos/processor'
+import { BindInternalOptions, BindOptions } from './bind-options'
+import { PromiseOrVoid } from './promise-or-void'
+
+export class EventsHandler {
+  filters: EventFilter[]
+  handler: (event: Log) => Promise<O11yResult>
+}
+
+export abstract class BaseProcessor<
+  TContract extends BaseContract,
+  TBoundContractView extends BoundContractView<TContract, ContractView<TContract>>
+> {
+  blockHandlers: ((block: Block) => Promise<O11yResult>)[] = []
+  eventHandlers: EventsHandler[] = []
+
+  name: string
+  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: Context<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()
+    this.eventHandlers.push({
+      filters: _filters,
+      handler: async function (log) {
+        const ctx = new Context<TContract, TBoundContractView>(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 {
+            gauges: ctx.gauges,
+            counters: ctx.counters,
+          }
+        }
+        return {
+          gauges: [],
+          counters: [],
+        }
+      },
+    })
+    return this
+  }
+
+  public onBlock(handler: (block: Block, ctx: Context<TContract, TBoundContractView>) => PromiseOrVoid) {
+    const chainId = this.getChainId()
+    const contractView = this.CreateBoundContractView()
+
+    this.blockHandlers.push(async function (block: Block) {
+      const ctx = new Context<TContract, TBoundContractView>(contractView, chainId, block, undefined)
+      await handler(block, ctx)
+      return {
+        gauges: ctx.gauges,
+        counters: ctx.counters,
+      }
+    })
+    return this
+  }
+
+  public onAllEvents(handler: (event: Log, ctx: Context<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)
+  }
+}

package/src/bind-options.ts

@@ -0,0 +1,41 @@
+import { Networkish } from '@ethersproject/networks'
+import Long from 'long'
+import { getNetwork } from '@ethersproject/providers'
+
+export class BindOptions {
+  address: string
+  network?: Networkish = 1
+  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 SolanaBindOptions extends BindOptions {
+  declare network?: string
+  processInnerInstruction?: boolean
+}

package/src/binds.ts

@@ -0,0 +1,73 @@
+import { BindOptions, getOptionsSignature } from './bind-options'
+import { BaseProcessor } from './base-processor'
+import { Networkish } from '@ethersproject/networks'
+import { getNetwork } from '@ethersproject/providers'
+import { ContractView } from './context'
+import { BaseContract } from 'ethers'
+import { ContractNamer } from './contract-namer'
+
+function getKey(abiName: string, address: string, network: Networkish) {
+  const chainId = getNetwork(network).chainId.toString()
+  return [abiName, address.toLowerCase(), chainId].join('_')
+}
+
+// TODO move to processor state
+const addressToName = new Map<string, string>()
+const namerMap = new Map<string, ContractNamer>()
+
+// Get contract name by ABI, and other options
+// If there is contract using same ABI and different (address, network) pair
+// It will be renamed as ABI, ABI_1, ABI_2
+// Otherwise just use same contract name
+export function getContractName(
+  abiName: string,
+  contractName: string | undefined,
+  address: string,
+  network: Networkish = 1
+): string {
+  const key = getKey(abiName, address, network)
+  let name = addressToName.get(key)
+  if (name) {
+    return name
+  }
+  if (contractName) {
+    addressToName.set(key, contractName)
+    return contractName
+  }
+
+  let namer = namerMap.get(abiName)
+  if (!namer) {
+    namer = new ContractNamer(abiName)
+    namerMap.set(abiName, namer)
+  }
+  name = namer.nextName()
+  addressToName.set(key, name)
+  return name
+}
+
+export function getProcessor(abiName: string, opts: BindOptions) {
+  const sig = abiName + '_' + getOptionsSignature(opts)
+  return global.PROCESSOR_STATE.processorMap.get(sig)
+}
+
+export function addProcessor(abiName: string, opts: BindOptions, processor: BaseProcessor<any, any>) {
+  const sig = abiName + '_' + getOptionsSignature(opts)
+
+  global.PROCESSOR_STATE.processors.push(processor)
+  global.PROCESSOR_STATE.processorMap.set(sig, processor)
+}
+
+export function getContractByABI(abiName: string, address: string, network: Networkish) {
+  const key = getKey(abiName, address, network)
+  return global.PROCESSOR_STATE.contracts.get(key)
+}
+
+export function addContractByABI(
+  abiName: string,
+  address: string,
+  network: Networkish,
+  contract: ContractView<BaseContract>
+) {
+  const key = getKey(abiName, address, network)
+  return global.PROCESSOR_STATE.contracts.set(key, contract)
+}

package/src/builtin/erc20/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "../internal/erc20_processor";
+export * from "../internal/Erc20";

package/src/builtin/erc20/test-utils.ts

@@ -0,0 +1,49 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { Log } from "@ethersproject/providers";
+import { getErc20Contract, ApprovalEventObject, TransferEventObject } from ".";
+const mockField = {
+  blockHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0,
+};
+
+export function mockApprovalLog(
+  contractAddress: string,
+  event: ApprovalEventObject
+): Log {
+  const contract = getErc20Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Approval"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockTransferLog(
+  contractAddress: string,
+  event: TransferEventObject
+): Log {
+  const contract = getErc20Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Transfer"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}