@sentio/sdk 1.7.12 → 1.7.15

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,
+  };
+}

package/src/builtin/internal/Erc20.ts

@@ -0,0 +1,356 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "./common";
+
+export interface Erc20Interface extends utils.Interface {
+  functions: {
+    "allowance(address,address)": FunctionFragment;
+    "approve(address,uint256)": FunctionFragment;
+    "balanceOf(address)": FunctionFragment;
+    "decimals()": FunctionFragment;
+    "totalSupply()": FunctionFragment;
+    "transfer(address,uint256)": FunctionFragment;
+    "transferFrom(address,address,uint256)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic:
+      | "allowance"
+      | "approve"
+      | "balanceOf"
+      | "decimals"
+      | "totalSupply"
+      | "transfer"
+      | "transferFrom"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "allowance",
+    values: [PromiseOrValue<string>, PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "approve",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [PromiseOrValue<string>]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transfer",
+    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferFrom",
+    values: [
+      PromiseOrValue<string>,
+      PromiseOrValue<string>,
+      PromiseOrValue<BigNumberish>
+    ]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferFrom",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "Approval(address,address,uint256)": EventFragment;
+    "Transfer(address,address,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+}
+
+export interface ApprovalEventObject {
+  owner: string;
+  spender: string;
+  value: BigNumber;
+}
+export type ApprovalEvent = TypedEvent<
+  [string, string, BigNumber],
+  ApprovalEventObject
+>;
+
+export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
+
+export interface TransferEventObject {
+  from: string;
+  to: string;
+  value: BigNumber;
+}
+export type TransferEvent = TypedEvent<
+  [string, string, BigNumber],
+  TransferEventObject
+>;
+
+export type TransferEventFilter = TypedEventFilter<TransferEvent>;
+
+export interface Erc20 extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: Erc20Interface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    decimals(overrides?: CallOverrides): Promise<[number]>;
+
+    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  approve(
+    spender: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  balanceOf(
+    account: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  decimals(overrides?: CallOverrides): Promise<number>;
+
+  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+  transfer(
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  transferFrom(
+    from: PromiseOrValue<string>,
+    to: PromiseOrValue<string>,
+    amount: PromiseOrValue<BigNumberish>,
+    overrides?: Overrides & { from?: PromiseOrValue<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<number>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+  };
+
+  filters: {
+    "Approval(address,address,uint256)"(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+    Approval(
+      owner?: PromiseOrValue<string> | null,
+      spender?: PromiseOrValue<string> | null,
+      value?: null
+    ): ApprovalEventFilter;
+
+    "Transfer(address,address,uint256)"(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+    Transfer(
+      from?: PromiseOrValue<string> | null,
+      to?: PromiseOrValue<string> | null,
+      value?: null
+    ): TransferEventFilter;
+  };
+
+  estimateGas: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    decimals(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    allowance(
+      owner: PromiseOrValue<string>,
+      spender: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    approve(
+      spender: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    balanceOf(
+      account: PromiseOrValue<string>,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    transfer(
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferFrom(
+      from: PromiseOrValue<string>,
+      to: PromiseOrValue<string>,
+      amount: PromiseOrValue<BigNumberish>,
+      overrides?: Overrides & { from?: PromiseOrValue<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/src/builtin/internal/common.ts

@@ -0,0 +1,46 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type { Listener } from "@ethersproject/providers";
+import type { Event, EventFilter } from "ethers";
+
+export interface TypedEvent<
+  TArgsArray extends Array<any> = any,
+  TArgsObject = any
+> extends Event {
+  args: TArgsArray & TArgsObject;
+}
+
+export interface TypedEventFilter<_TEvent extends TypedEvent>
+  extends EventFilter {}
+
+export interface TypedListener<TEvent extends TypedEvent> {
+  (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+
+export interface OnEvent<TRes> {
+  <TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>,
+    listener: TypedListener<TEvent>
+  ): TRes;
+  (eventName: string, listener: Listener): TRes;
+}
+
+export type MinEthersFactory<C, ARGS> = {
+  deploy(...a: ARGS[]): Promise<C>;
+};
+
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<
+  infer C,
+  any
+>
+  ? C
+  : never;
+
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any>
+  ? Parameters<F["deploy"]>
+  : never;
+
+export type PromiseOrValue<T> = T | Promise<T>;