@sentio/sdk 1.40.5-rc.6 → 1.41.0-rc.1

package/src/core/bind-options.ts

@@ -1,5 +1,4 @@
-import { Networkish } from '@ethersproject/networks'
-import { getNetwork } from '@ethersproject/providers'
+import { Networkish, Network } from 'ethers/providers'
 
 export class BindOptions {
   // Contract address
@@ -15,7 +14,7 @@ export class BindOptions {
 export function getOptionsSignature(opts: BindOptions): string {
   const sig = [opts.address]
   if (opts.network) {
-    sig.push(getNetwork(opts.network).chainId.toString())
+    sig.push(Network.from(opts.network).chainId.toString())
   }
   if (opts.name) {
     sig.push(opts.name)

package/src/core/context.ts

@@ -1,17 +1,17 @@
+import { BaseContract, Transaction, TransactionReceipt, Block, ContractEvent } from 'ethers'
+import { LogParams } from 'ethers/providers'
+
 import { RecordMetaData } from '@sentio/protos'
-import { BaseContract, EventFilter, Transaction } from 'ethers'
-import { Block, Log } from '@ethersproject/abstract-provider'
 import { normalizeLabels } from './meter'
-import { Trace } from './trace'
+import { Trace } from '../eth/trace'
 import { Labels } from './metadata'
 import { CHAIN_IDS } from '../utils/chain'
 import { BaseContext } from './base-context'
-import { TransactionReceipt } from '@ethersproject/providers'
 
 export abstract class EthContext extends BaseContext {
   chainId: number
   address: string
-  private readonly log?: Log
+  private readonly log?: LogParams
   block?: Block
   private readonly trace?: Trace
   blockNumber: bigint | number
@@ -25,7 +25,7 @@ export abstract class EthContext extends BaseContext {
     address: string,
     timestamp?: Date,
     block?: Block,
-    log?: Log,
+    log?: LogParams,
     trace?: Trace,
     transaction?: Transaction,
     transactionReceipt?: TransactionReceipt
@@ -60,7 +60,7 @@ export abstract class EthContext extends BaseContext {
         blockNumber: BigInt(this.blockNumber),
         transactionIndex: this.log.transactionIndex,
         transactionHash: this.transactionHash || '',
-        logIndex: this.log.logIndex,
+        logIndex: this.log.index,
         chainId: this.chainId.toString(),
         name: name,
         labels: normalizeLabels(labels),
@@ -118,12 +118,15 @@ export class ContractContext<
     chainId: number,
     timestamp?: Date,
     block?: Block,
-    log?: Log,
+    log?: LogParams,
     trace?: Trace,
     transaction?: Transaction,
     transactionReceipt?: TransactionReceipt
   ) {
-    super(chainId, view.rawContract.address, timestamp, block, log, trace, transaction, transactionReceipt)
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const address = view.rawContract.getAddress() as string
+    super(chainId, address, timestamp, block, log, trace, transaction, transactionReceipt)
     view.context = this
     this.contractName = contractName
     this.contract = view
@@ -135,12 +138,10 @@ export class ContractContext<
 }
 
 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() {
@@ -148,7 +149,7 @@ export class ContractView<TContract extends BaseContract> {
   }
 
   get provider() {
-    return this.contract.provider
+    return this.contract.runner?.provider
   }
 }
 
@@ -170,7 +171,7 @@ export class BoundContractView<TContract extends BaseContract, TContractView ext
   }
 
   get filters() {
-    return this.view.filters
+    return this.view.rawContract.filters
   }
 }
 

package/src/core/core-plugin.ts

@@ -8,7 +8,7 @@ import { ExporterState } from './exporter'
 export class CorePlugin extends Plugin {
   name: string = 'CorePlugin'
 
-  configure(config: ProcessConfigResponse): void {
+  async configure(config: ProcessConfigResponse): Promise<void> {
     // part 0, prepare metrics and event tracking configs
     for (const metric of MetricState.INSTANCE.getValues()) {
       config.metricConfigs.push({

package/src/core/index.ts

@@ -6,13 +6,7 @@ export { type Numberish, toBigInteger, toMetricValue, toBlockTag } from './numbe
 
 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 type { TypedCallTrace, Trace } from './trace'
-
-export { EthPlugin } from './eth-plugin'
 export { SuiPlugin } from './sui-plugin'
 export { CorePlugin } from './core-plugin'

package/src/core/numberish.ts

@@ -1,9 +1,8 @@
-import { BigNumber } from 'ethers'
 import { BigInteger, MetricValue } from '@sentio/protos'
 import { BigDecimal } from '.'
-import { BlockTag } from '@ethersproject/providers'
+import { BlockTag } from 'ethers/providers'
 
-export type Numberish = number | BigNumber | bigint | BigDecimal | string
+export type Numberish = number | bigint | BigDecimal | string
 
 export function toBlockTag(a: number | bigint): BlockTag {
   if (typeof a === 'number') {
@@ -16,53 +15,52 @@ export function toBlockTag(a: number | bigint): BlockTag {
 }
 
 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')
-      }
+  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')
+    }
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
       return MetricValue.fromPartial({
-        bigDecimal: value.toString(), // e.g. -7.350918e-428
+        bigInteger: toBigInteger(value),
       })
     }
+
+    return MetricValue.fromPartial({
+      doubleValue: Number(value),
+    })
+  }
+  if (typeof value === 'bigint') {
+    return MetricValue.fromPartial({
+      bigInteger: toBigInteger(value),
+    })
   }
   if (typeof value === 'string') {
     return MetricValue.fromPartial({
       bigDecimal: value,
     })
   }
-  if (typeof value === 'bigint' || Number.isInteger(value)) {
+  // if (value instanceof BigDecimal) {
+  // Carefully consider the use case here
+  if (value.isInteger()) {
     return MetricValue.fromPartial({
-      bigInteger: toBigInteger(value),
+      bigInteger: bigDecimalToBigInteger(value),
     })
-  }
-
-  if (typeof value === 'number') {
-    if (Number.isNaN(value)) {
+  } else {
+    if (value.isNaN()) {
       throw new Error('Cannot record NaN value')
     }
-    if (!Number.isFinite(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
+    })
   }
-
-  return MetricValue.fromPartial({
-    doubleValue: Number(value),
-  })
+  // }
 }
 
 function bigDecimalToBigInteger(a: BigDecimal): BigInteger {
@@ -82,17 +80,18 @@ function intToBigInteger(a: bigint | number): BigInteger {
 }
 
 export function toBigInteger(a: Numberish): BigInteger {
-  if (a instanceof BigDecimal) {
-    return bigDecimalToBigInteger(a)
+  if (typeof a === 'number') {
+    return intToBigInteger(a)
   }
-
-  if (a instanceof BigNumber) {
-    return intToBigInteger(a.toBigInt())
+  if (typeof a === 'bigint') {
+    return intToBigInteger(a)
   }
   if (typeof a === 'string') {
     return intToBigInteger(BigInt(a))
   }
-
+  if (a instanceof BigDecimal) {
+    return bigDecimalToBigInteger(a)
+  }
   return intToBigInteger(a)
 
   // Following code is actually very slow

package/src/core/sui-plugin.ts

@@ -9,7 +9,7 @@ import { SuiProcessorState } from './sui-processor'
 export class SuiPlugin extends Plugin {
   name: string = 'SuiPlugin'
 
-  configure(config: ProcessConfigResponse): void {
+  async configure(config: ProcessConfigResponse) {
     for (const suiProcessor of SuiProcessorState.INSTANCE.getValues()) {
       const contractConfig: ContractConfig = {
         transactionConfig: [],

package/src/error.ts

@@ -1,6 +1,6 @@
 // Transform error in more readable format
 import { ContractContext } from './core/context'
-import { errors } from 'ethers'
+// import { errors } from 'ethers/providers'
 
 export class EthersError extends Error {
   e: Error

package/src/eth/account-processor-state.ts

@@ -0,0 +1,6 @@
+import { ListStateStorage } from '@sentio/runtime'
+import { AccountProcessor } from './account-processor'
+
+export class AccountProcessorState extends ListStateStorage<AccountProcessor> {
+  static INSTANCE = new AccountProcessorState()
+}

package/src/{core → eth}/account-processor.ts

@@ -1,24 +1,23 @@
-import { ListStateStorage } from '@sentio/runtime'
 import { ERC20__factory, ERC721__factory } from '../builtin/internal'
 import { AddressType, DummyProvider, EthFetchConfig, ProcessResult } from '@sentio/sdk'
-import { AccountBindOptions } from './bind-options'
-import { getNetwork, TransactionReceipt } from '@ethersproject/providers'
+import { AccountBindOptions } from '../core/bind-options'
+
+import { Network, LogParams } from 'ethers/providers'
+
 import { TransferEvent as ERC20TransferEvent } from '../builtin/internal/ERC20'
 import { TransferEvent as ERC721TransferEvent } from '../builtin/internal/ERC721'
-import { AccountContext } from './context'
+
+import { ERC20Processor } from '../builtin/internal/erc20_processor'
+import { ERC721Processor } from '../builtin/internal/erc721_processor'
+
+import { AccountContext } from '../core/context'
 import { PromiseOrVoid } from '../promise-or-void'
-import { Event } from '@ethersproject/contracts'
-import { BytesLike } from '@ethersproject/bytes'
 import { AddressOrTypeEventFilter, EventsHandler } from './base-processor'
-import { Block } from '@ethersproject/abstract-provider'
-import { Transaction } from 'ethers'
-
-export class AccountProcessorState extends ListStateStorage<AccountProcessor> {
-  static INSTANCE = new AccountProcessorState()
-}
+import { Transaction, Block, TransactionReceipt, LogDescription } from 'ethers'
+import { AccountProcessorState } from './account-processor-state'
 
-const ERC20_CONTRACT = ERC20__factory.connect('', DummyProvider)
-const ERC721_CONTRACT = ERC721__factory.connect('', DummyProvider)
+const ERC20_INTERFACE = ERC20__factory.createInterface()
+const ERC721_INTERFACE = ERC721__factory.createInterface()
 
 export class AccountProcessor {
   config: AccountBindOptions
@@ -41,7 +40,7 @@ export class AccountProcessor {
   }
 
   public getChainId(): number {
-    return getNetwork(this.config.network || 1).chainId
+    return Number(Network.from(this.config.network || 1).chainId)
   }
 
   /**
@@ -58,7 +57,7 @@ export class AccountProcessor {
     return this.onERC20(
       handler,
       tokensAddresses,
-      (address: string) => ERC20_CONTRACT.filters.Transfer(null, this.config.address),
+      (address: string) => ERC721Processor.filters.Transfer(null, this.config.address),
       fetchConfig
     )
   }
@@ -77,7 +76,7 @@ export class AccountProcessor {
     return this.onERC20(
       handler,
       tokensAddresses,
-      (address: string) => ERC20_CONTRACT.filters.Transfer(this.config.address),
+      (address: string) => ERC20Processor.filters.Transfer(this.config.address),
       fetchConfig
     )
   }
@@ -97,7 +96,7 @@ export class AccountProcessor {
       handler,
       tokensAddresses,
       (address: string) =>
-        ERC20_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
+        ERC20Processor.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
       fetchConfig
     )
   }
@@ -125,7 +124,7 @@ export class AccountProcessor {
     return this.onERC721(
       handler,
       collections,
-      (address: string) => ERC721_CONTRACT.filters.Transfer(null, this.config.address),
+      (address: string) => ERC721Processor.filters.Transfer(null, this.config.address),
       fetchConfig
     )
   }
@@ -144,7 +143,7 @@ export class AccountProcessor {
     return this.onERC721(
       handler,
       collections,
-      (address: string) => ERC721_CONTRACT.filters.Transfer(this.config.address),
+      (address: string) => ERC721Processor.filters.Transfer(this.config.address),
       fetchConfig
     )
   }
@@ -164,7 +163,7 @@ export class AccountProcessor {
       handler,
       collections,
       (address: string) =>
-        ERC721_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
+        ERC721Processor.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address),
       fetchConfig
     )
   }
@@ -201,7 +200,7 @@ export class AccountProcessor {
   }
 
   protected onEvent(
-    handler: (event: Event, ctx: AccountContext) => PromiseOrVoid,
+    handler: (event: LogDescription, ctx: AccountContext) => PromiseOrVoid,
     filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[],
     fetchConfig?: EthFetchConfig
   ) {
@@ -215,21 +214,21 @@ export class AccountProcessor {
       _filters.push(filter)
     }
 
-    let hasVaildConfig = false
-    for (const filter of _filters) {
-      if (filter.address) {
-        hasVaildConfig = true
-        break
-      }
-      if (filter.topics && filter.topics.length) {
-        hasVaildConfig = true
-        break
-      }
-    }
-
-    if (!hasVaildConfig) {
-      throw Error('no valid config has been found for this account')
-    }
+    // let hasVaildConfig = false
+    // for (const filter of _filters) {
+    //   if (filter.address) {
+    //     hasVaildConfig = true
+    //     break
+    //   }
+    //   if (filter.topics && filter.topics.length) {
+    //     hasVaildConfig = true
+    //     break
+    //   }
+    // }
+    //
+    // if (!hasVaildConfig) {
+    //   throw Error('no valid config has been found for this account')
+    // }
 
     const config = this.config
 
@@ -237,29 +236,20 @@ export class AccountProcessor {
       filters: _filters,
       fetchConfig: fetchConfig || EthFetchConfig.fromPartial({}),
       handler: async function (data) {
-        const log = data.log as Event
+        const log = data.log as { topics: Array<string>; data: string }
         const ctx = new AccountContext(
           chainId,
           config.address,
           data.timestamp,
           data.block as Block,
-          log,
+          log as any as LogParams,
           undefined,
           data.transaction as Transaction,
           data.transactionReceipt as TransactionReceipt
         )
-        const event: Event = log
-        const parsed = ERC20_CONTRACT.interface.parseLog(log)
+        const parsed = ERC20_INTERFACE.parseLog(log)
         if (parsed) {
-          event.args = parsed.args
-          event.decode = (data: BytesLike, topics?: Array<any>) => {
-            return ERC20_CONTRACT.interface.decodeEventLog(parsed.eventFragment, data, topics)
-          }
-          event.event = parsed.name
-          event.eventSignature = parsed.signature
-
-          // TODO fix this bug
-          await handler(event, ctx)
+          await handler(parsed, ctx)
           return ctx.getProcessResult()
         }
         return ProcessResult.fromPartial({})

package/src/{core → eth}/base-processor-template.ts

@@ -1,14 +1,13 @@
-import { BoundContractView, ContractContext, 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 { BoundContractView, ContractContext, ContractView } from '../core/context'
+import { BaseContract, ContractEvent, Block, LogDescription } from 'ethers'
+import { AddressOrTypeEventFilter, BaseProcessor } from './base-processor'
+import { BindOptions, getOptionsSignature } from '../core/bind-options'
 import { EthFetchConfig, HandleInterval, TemplateInstance } from '@sentio/protos'
-import { getNetwork } from '@ethersproject/providers'
 import { PromiseOrVoid } from '../promise-or-void'
 import { Trace } from './trace'
 import { ListStateStorage } from '@sentio/runtime'
+import { EventFilter, LogParams, Network } from 'ethers/providers'
+import { DeferredTopicFilter } from 'ethers/contract'
 
 export class ProcessorTemplateProcessorState extends ListStateStorage<
   BaseProcessorTemplate<BaseContract, BoundContractView<BaseContract, any>>
@@ -37,8 +36,8 @@ export abstract class BaseProcessorTemplate<
     fetchConfig?: EthFetchConfig
   }[] = []
   eventHandlers: {
-    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
-    filter: EventFilter | EventFilter[]
+    handler: (event: LogDescription, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    filter: DeferredTopicFilter | DeferredTopicFilter[]
     fetchConfig?: EthFetchConfig
   }[] = []
 
@@ -71,7 +70,7 @@ export abstract class BaseProcessorTemplate<
       contract: {
         address: options.address,
         name: options.name || '',
-        chainId: options.network ? getNetwork(options.network).chainId.toString() : '1',
+        chainId: options.network ? Network.from(options.network).chainId.toString() : '1',
         abi: '',
       },
       startBlock: 0n,
@@ -88,8 +87,8 @@ export abstract class BaseProcessorTemplate<
   }
 
   public onEvent(
-    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    filter: EventFilter | EventFilter[],
+    handler: (event: LogDescription, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    filter: DeferredTopicFilter | DeferredTopicFilter[],
     fetchConfig?: EthFetchConfig
   ) {
     this.eventHandlers.push({

package/src/{core → eth}/base-processor.ts

@@ -1,8 +1,18 @@
-import { BytesLike } from '@ethersproject/bytes'
-import { Block, Log, getNetwork, TransactionReceipt } from '@ethersproject/providers'
-import { BaseContract, Event, EventFilter } from '@ethersproject/contracts'
+import {
+  Block,
+  ContractEvent,
+  Log,
+  TransactionReceipt,
+  BytesLike,
+  BaseContract,
+  Transaction,
+  DeferredTopicFilter,
+  LogDescription,
+  EventFragment,
+} from 'ethers'
+import { EventFilter, LogParams, Network } from 'ethers/providers'
 
-import { BoundContractView, ContractContext, ContractView } from './context'
+import { BoundContractView, ContractContext, ContractView } from '../core/context'
 import {
   AddressType,
   Data_EthBlock,
@@ -12,14 +22,14 @@ import {
   HandleInterval,
   ProcessResult,
 } from '@sentio/protos'
-import { BindInternalOptions, BindOptions } from './bind-options'
+import { BindInternalOptions, BindOptions } from '../core/bind-options'
 import { PromiseOrVoid } from '../promise-or-void'
 import { Trace } from './trace'
 import { ServerError, Status } from 'nice-grpc'
-import { Transaction } from 'ethers'
 
-export interface AddressOrTypeEventFilter extends EventFilter {
+export interface AddressOrTypeEventFilter extends DeferredTopicFilter {
   addressType?: AddressType
+  address?: string
 }
 
 export class EventsHandler {
@@ -74,17 +84,16 @@ export abstract class BaseProcessor<
   protected abstract CreateBoundContractView(): TBoundContractView
 
   public getChainId(): number {
-    return getNetwork(this.config.network).chainId
+    return Number(Network.from(this.config.network).chainId)
   }
 
   public onEvent(
-    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    filter: EventFilter | EventFilter[],
+    handler: (event: LogDescription, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    filter: DeferredTopicFilter | DeferredTopicFilter[],
     fetchConfig?: EthFetchConfig
   ) {
     const chainId = this.getChainId()
-
-    let _filters: EventFilter[] = []
+    let _filters: DeferredTopicFilter[] = []
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -101,7 +110,7 @@ export abstract class BaseProcessor<
         if (!data.log) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
         }
-        const log = data.log as Log
+        const log = data.log as LogParams
 
         const contractView = processor.CreateBoundContractView()
 
@@ -116,19 +125,11 @@ export abstract class BaseProcessor<
           data.transaction as Transaction,
           data.transactionReceipt as TransactionReceipt
         )
-        // 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
+        const logParam = log as any as { topics: Array<string>; data: string }
 
-          // TODO fix this bug
-          await handler(event, ctx)
+        const parsed = contractView.rawContract.interface.parseLog(logParam)
+        if (parsed) {
+          await handler(parsed, ctx)
           return ctx.getProcessResult()
         }
         return ProcessResult.fromPartial({})
@@ -200,12 +201,17 @@ export abstract class BaseProcessor<
     return this
   }
 
-  public onAllEvents(handler: (event: Log, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid) {
-    const _filters: EventFilter[] = []
+  public onAllEvents(
+    handler: (event: LogDescription, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+  ) {
+    const _filters: DeferredTopicFilter[] = []
     const tmpContract = this.CreateBoundContractView()
 
-    for (const key in tmpContract.filters) {
-      _filters.push(tmpContract.filters[key]())
+    for (const fragment of tmpContract.rawContract.interface.fragments) {
+      if (fragment.type === 'event') {
+        const filter = tmpContract.rawContract.filters[fragment.format()]
+        _filters.push(filter())
+      }
     }
     return this.onEvent(function (log, ctx) {
       return handler(log, ctx)
@@ -228,7 +234,7 @@ export abstract class BaseProcessor<
         const contractView = processor.CreateBoundContractView()
         const contractInterface = contractView.rawContract.interface
         const fragment = contractInterface.getFunction(signature)
-        if (!data.trace) {
+        if (!data.trace || !fragment) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'trace is null')
         }
         const trace = data.trace as Trace
@@ -236,7 +242,7 @@ export abstract class BaseProcessor<
           return ProcessResult.fromPartial({})
         }
         const traceData = '0x' + trace.action.input.slice(10)
-        trace.args = contractInterface._abiCoder.decode(fragment.inputs, traceData)
+        trace.args = contractInterface.getAbiCoder().decode(fragment.inputs, traceData)
 
         const ctx = new ContractContext<TContract, TBoundContractView>(
           contractName,

package/src/{binds.ts → eth/binds.ts}

@@ -1,7 +1,8 @@
-import { BindOptions, getOptionsSignature } from './core/bind-options'
-import { BaseProcessor, ContractView } from './core'
-import { Networkish } from '@ethersproject/networks'
-import { getNetwork } from '@ethersproject/providers'
+import { BindOptions, getOptionsSignature } from '../core/bind-options'
+import { ContractView } from '../core'
+import { BaseProcessor } from './base-processor'
+import { Networkish, Network } from 'ethers/providers'
+
 import { BaseContract } from 'ethers'
 import { MapStateStorage } from '@sentio/runtime'
 
@@ -13,7 +14,7 @@ export class ProcessorState extends MapStateStorage<BaseProcessor<any, any>> {
 const contracts = new Map<string, ContractView<BaseContract>>()
 
 function getKey(abiName: string, address: string, network: Networkish) {
-  const chainId = getNetwork(network).chainId.toString()
+  const chainId = Network.from(network).chainId.toString()
   return [abiName, address.toLowerCase(), chainId].join('_')
 }