@sentio/sdk 1.40.5 → 2.0.0-rc.1

package/src/{core → eth}/eth-plugin.ts

@@ -15,8 +15,8 @@ import {
 } from '@sentio/protos'
 
 import { ServerError, Status } from 'nice-grpc'
-import { ProcessorState } from '../binds'
-import { AccountProcessorState } from './account-processor'
+import { ProcessorState } from './binds'
+import { AccountProcessorState } from './account-processor-state'
 import { ProcessorTemplateProcessorState, TemplateInstanceState } from './base-processor-template'
 
 export class EthPlugin extends Plugin {
@@ -26,7 +26,7 @@ export class EthPlugin extends Plugin {
   private traceHandlers: ((trace: Data_EthTrace) => Promise<ProcessResult>)[] = []
   private blockHandlers: ((block: Data_EthBlock) => Promise<ProcessResult>)[] = []
 
-  configure(config: ProcessConfigResponse): void {
+  async configure(config: ProcessConfigResponse) {
     // This syntax is to copy values instead of using references
     config.templateInstances = [...TemplateInstanceState.INSTANCE.getValues()]
 
@@ -93,16 +93,18 @@ export class EthPlugin extends Plugin {
         }
 
         for (const filter of eventsHandler.filters) {
-          if (!filter.topics) {
-            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
-          }
+          const topics = await filter.getTopicFilter()
+
+          // 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) {
+          for (const ts of topics) {
             let hashes: string[] = []
             if (Array.isArray(ts)) {
               hashes = hashes.concat(ts)
@@ -141,16 +143,21 @@ export class EthPlugin extends Plugin {
         }
 
         for (const filter of eventsHandler.filters) {
-          if (!filter.topics) {
-            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          const topics = await filter.getTopicFilter()
+          // if (!filter.topics) {
+          //   throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          // }
+          let address = undefined
+          if (filter.address) {
+            address = filter.address.toString()
           }
           const logFilter: LogFilter = {
             addressType: filter.addressType,
-            address: filter.address,
+            address,
             topics: [],
           }
 
-          for (const ts of filter.topics) {
+          for (const ts of topics) {
             let hashes: string[] = []
             if (Array.isArray(ts)) {
               hashes = hashes.concat(ts)
@@ -184,7 +191,7 @@ export class EthPlugin extends Plugin {
     }
   }
 
-  start(request: StartRequest) {
+  async start(request: StartRequest) {
     for (const instance of request.templateInstances) {
       const template = ProcessorTemplateProcessorState.INSTANCE.getValues()[instance.templateId]
       if (!template) {

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

@@ -1,9 +1,9 @@
-import { BaseContract } from '@ethersproject/contracts'
-import { BoundContractView, ContractView } from './context'
-import { BindOptions } from './bind-options'
+import { BaseContract } from 'ethers'
+import { BoundContractView, ContractView } from '../core/context'
+import { BindOptions } from '../core/bind-options'
 import { BaseProcessor } from './base-processor'
-import { getProvider } from '@sentio/runtime'
-import { addProcessor } from '../binds'
+import { getProvider } from './provider'
+import { addProcessor } from './binds'
 
 export class GenericProcessor extends BaseProcessor<
   BaseContract,

package/src/eth/index.ts

@@ -0,0 +1,6 @@
+export { BaseProcessor } from './base-processor'
+export { GenericProcessor } from './generic-processor'
+export { BaseProcessorTemplate } from './base-processor-template'
+export { getProvider, DummyProvider } from './provider'
+export type { TypedCallTrace, Trace } from './trace'
+export { EthPlugin } from './eth-plugin'

package/src/eth/provider.ts

@@ -0,0 +1,82 @@
+import { Provider, Network, JsonRpcProvider } from 'ethers'
+import { Networkish } from 'ethers/providers'
+
+import PQueue from 'p-queue'
+import { Endpoints } from '@sentio/runtime'
+
+export const DummyProvider = new JsonRpcProvider('', Network.from(1))
+
+const providers = new Map<string, JsonRpcProvider>()
+
+export function getProvider(networkish?: Networkish): Provider {
+  if (!networkish) {
+    networkish = 1
+  }
+  const network = Network.from(networkish)
+  // TODO check if other key needed
+
+  const address = Endpoints.INSTANCE.chainServer.get(network.chainId.toString())
+  const key = network.chainId.toString() + '-' + address
+  let provider = providers.get(key)
+
+  if (provider) {
+    return provider
+  }
+
+  if (address === undefined) {
+    throw Error(
+      'Provider not found for chain ' +
+        network.chainId +
+        ', configured chains: ' +
+        [...Endpoints.INSTANCE.chainServer.keys()].join(' ')
+    )
+  }
+  provider = new QueuedStaticJsonRpcProvider(address, network, Endpoints.INSTANCE.concurrency)
+  providers.set(network.chainId.toString(), provider)
+  return provider
+}
+
+// export function setProvider(config: Record<string, ChainConfig>, concurrency = 4, useChainServer = false) {
+//   Endpoints.INSTANCE.providers = new Map<bigint, Provider>()
+//
+//   for (const chainIdStr in config) {
+//     if (isNaN(Number.parseInt(chainIdStr))) {
+//       continue
+//     }
+//
+//     const chainConfig = config[chainIdStr]
+//     const chainId = BigInt(chainIdStr)
+//
+//     // let providers: StaticJsonRpcProvider[] = []
+//     // for (const http of chainConfig.Https) {
+//     //   providers.push(new StaticJsonRpcProvider(http, chainId))
+//     // }
+//     // random shuffle
+//     // providers = providers.sort(() => Math.random() - 0.5)
+//
+//     // const provider = new FallbackProvider(providers)
+//
+//     let rpcAddress = ''
+//     if (useChainServer && chainConfig.ChainServer) {
+//       rpcAddress = chainConfig.ChainServer
+//     } else {
+//       const idx = Math.floor(Math.random() * chainConfig.Https.length)
+//       rpcAddress = chainConfig.Https[idx]
+//     }
+//
+//     Endpoints.INSTANCE.providers.set(chainId, provider)
+//   }
+// }
+
+class QueuedStaticJsonRpcProvider extends JsonRpcProvider {
+  executor: PQueue
+
+  constructor(url: string, network: Networkish, concurrency: number) {
+    super(url, Network.from(network))
+    this.executor = new PQueue({ concurrency: concurrency })
+  }
+
+  send(method: string, params: Array<any>): Promise<any> {
+    return this.executor.add(() => super.send(method, params))
+  }
+}

package/src/{core → eth}/trace.ts

@@ -1,13 +1,12 @@
 // https://github.com/openethereum/parity-ethereum/blob/55c90d4016505317034e3e98f699af07f5404b63/rpc/src/v1/types/trace.rs#L482
-import { Result } from '@ethersproject/abi'
+import { Result } from 'ethers'
 
-export interface TypedCallTrace<TArgsArray extends Array<any> = any, TArgsObject = any> extends Trace {
+export interface TypedCallTrace<TArgsArray extends Array<any> = any, TArgsObject = any> {
   args: TArgsArray & TArgsObject
 }
 
 export interface Trace {
   args?: Result
-
   action: TraceAction
   blockHash: string
   blockNumber: number

package/src/index.ts

@@ -1,13 +1,12 @@
-export { getProvider, setProvider, DummyProvider } from '@sentio/runtime'
 export { transformEtherError, EthersError } from './error'
 
-export { getProcessor, addProcessor, getContractByABI, addContractByABI } from './binds'
+export { getProcessor, addProcessor, getContractByABI, addContractByABI } from './eth/binds'
 
 // TODO maybe remove this
 export * from '@sentio/protos'
 
 export * from './core'
+export * from './eth'
 
 export * from './utils/chain'
-
 // export * from  './api'

package/src/target-ethers-sentio/event-handler.ts

@@ -1,5 +1,6 @@
-import { EventDeclaration, getFullSignatureAsSymbolForEvent } from 'typechain'
+import { EventDeclaration, Contract, getFullSignatureAsSymbolForEvent } from 'typechain'
 import { getFullSignatureForEventPatched } from './types'
+import { generateEventInputs } from '@sentio/ethers-v6/dist/codegen/events'
 
 export function generateEventHandler(event: EventDeclaration, contractName: string, includeArgTypes: boolean): string {
   const eventName = includeArgTypes ? getFullSignatureAsSymbolForEvent(event) : event.name
@@ -13,10 +14,7 @@ export function generateEventHandler(event: EventDeclaration, contractName: stri
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ${contractName}Processor.filters[
-        // @ts-ignore
-        '${filterName}'](${event.inputs.map(() => 'null').join(',')})
+      filter = templateContract.filters['${filterName}'](${event.inputs.map(() => 'null').join(',')})
     }
     return super.onEvent(handler, filter!, fetchConfig)
   }
@@ -30,3 +28,22 @@ export function generateEventHandlers(events: EventDeclaration[], contractName:
     return events.map((e) => generateEventHandler(e, contractName, true)).join('\n')
   }
 }
+
+function generateEventFilter(event: EventDeclaration, includeArgTypes: boolean): string {
+  const eventName = includeArgTypes ? getFullSignatureAsSymbolForEvent(event) : event.name
+
+  const filterName = getFullSignatureForEventPatched(event)
+  return `
+    ${eventName}(${generateEventInputs(event.inputs)}) { return templateContract.filters['${filterName}'](${event.inputs
+    .map((i) => i.name)
+    .join(',')}) }
+  `
+}
+
+export function generateEventFilters(events: EventDeclaration[]): string[] {
+  if (events.length === 1) {
+    return [generateEventFilter(events[0], false)]
+  } else {
+    return events.map((e) => generateEventFilter(e, true))
+  }
+}

package/src/target-ethers-sentio/file.ts

@@ -5,10 +5,10 @@ import {
   getFullSignatureAsSymbolForEvent,
 } from 'typechain'
 
-import { reservedKeywords } from '@typechain/ethers-v5/dist/codegen/reserved-keywords'
+import { reservedKeywords } from '@sentio/ethers-v6/dist/codegen/reserved-keywords'
 import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
 import { codegenCallTraceTypes, generateCallHandlers } from './functions-handler'
-import { generateEventHandlers } from './event-handler'
+import { generateEventFilters, generateEventHandlers } from './event-handler'
 import { generateBoundViewFunctions, generateViewFunctions } from './view-function'
 
 export function codeGenIndex(contract: Contract): string {
@@ -22,7 +22,7 @@ export function codeGenSentioFile(contract: Contract): string {
   const source = `
   ${Object.values(contract.functions).map(codegenCallTraceTypes).join('\n')}
 
-  const templateContract = ${contract.name}__factory.connect("", DummyProvider)
+  const templateContract = ${contract.name}__factory.connect("0x0", DummyProvider)
 
   export class ${contract.name}ContractView extends ContractView<${contract.name}> {
     constructor (contract: ${contract.name}) {
@@ -35,76 +35,76 @@ export function codeGenSentioFile(contract: Contract): string {
       .join('\n')}
   }
   
-  export class ${contract.name}BoundContractView extends BoundContractView<${contract.name}, ${
-    contract.name
-  }ContractView> {
-    // constructor (contract: ${contract.name}) {
-    //   super(contract);
-    // }
-
-    ${Object.values(contract.functions)
-      .filter((f) => !reservedKeywords.has(f[0].name))
-      .map((fs) => generateBoundViewFunctions(fs))
-      .join('\n')}
+  export class ${contract.name}BoundContractView extends BoundContractView<${contract.name}, 
+    ${contract.name}ContractView> {
+  ${Object.values(contract.functions)
+    .filter((f) => !reservedKeywords.has(f[0].name))
+    .map((fs) => generateBoundViewFunctions(fs))
+    .join('\n')}
   }
 
-  export type ${contract.name}Context = ContractContext<${contract.name}, ${contract.name}BoundContractView>
-
-  export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${contract.name}, ${
-    contract.name
-  }BoundContractView> {
-    bindInternal(options: BindOptions) {
-      if (!options.name) {
-        options.name = "${contract.name}"
-      }
-      let processor = getProcessor(options) as ${contract.name}Processor
-      if (!processor) {
-        processor = new ${contract.name}Processor(options)
-        addProcessor(options, processor)
-      }
-      return processor
-    }
+    export type ${contract.name}Context = ContractContext<${contract.name}, ${contract.name}BoundContractView>
 
+  export class ${contract.name}Processor extends BaseProcessor<${contract.name}, ${contract.name}BoundContractView> {
     ${Object.values(contract.events)
       .map((events) => generateEventHandlers(events, contract.name))
       .join('\n')}
-    
+
     ${Object.values(contract.functions)
-      .map((functions) => {
-        generateCallHandlers(functions, contract.name)
-      })
+      .map((f) => generateCallHandlers(f, contract.name))
       .join('\n')}
-    }
 
-    export class ${contract.name}Processor extends BaseProcessor<${contract.name}, ${contract.name}BoundContractView> {
-      ${Object.values(contract.events)
-        .map((events) => generateEventHandlers(events, contract.name))
-        .join('\n')}
-
-      ${Object.values(contract.functions)
-        .map((f) => generateCallHandlers(f, contract.name))
-        .join('\n')}
+  public static filters = {
+    ${Object.values(contract.events)
+      .map((events) => generateEventFilters(events))
+      .join(',')}
+  }
+  
+  protected CreateBoundContractView(): ${contract.name}BoundContractView {
+    const view = get${contract.name}Contract(this.config.address, this.config.network)
+    return new ${contract.name}BoundContractView(view)
+  }
 
-    public static filters = templateContract.filters
-    
-    protected CreateBoundContractView(): ${contract.name}BoundContractView {
-      const view = get${contract.name}Contract(this.config.address, this.config.network)
-      return new ${contract.name}BoundContractView(view)
+  public static bind(options: BindOptions): ${contract.name}Processor {
+     if (!options.name) {
+      options.name = "${contract.name}"
+    }
+    let processor = getProcessor(options) as ${contract.name}Processor
+    if (!processor) {
+      processor = new ${contract.name}Processor(options)
+      addProcessor(options, processor)
     }
+    return processor
+  }
+}
 
-    public static bind(options: BindOptions): ${contract.name}Processor {
-       if (!options.name) {
-        options.name = "${contract.name}"
-      }
-      let processor = getProcessor(options) as ${contract.name}Processor
-      if (!processor) {
-        processor = new ${contract.name}Processor(options)
-        addProcessor(options, processor)
-      }
-      return processor
+export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${contract.name}, ${
+    contract.name
+  }BoundContractView> {
+  bindInternal(options: BindOptions) {
+    if (!options.name) {
+      options.name = "${contract.name}"
+    }
+    let processor = getProcessor(options) as ${contract.name}Processor
+    if (!processor) {
+      processor = new ${contract.name}Processor(options)
+      addProcessor(options, processor)
     }
+    return processor
   }
 
+  ${Object.values(contract.events)
+    .map((events) => generateEventHandlers(events, contract.name))
+    .join('\n')}
+  
+  ${Object.values(contract.functions)
+    .map((functions) => {
+      generateCallHandlers(functions, contract.name)
+    })
+    .join('\n')}
+  }
+
+
   export function get${contract.name}Contract(address: string, network: Networkish = 1): ${contract.name}ContractView {
     let contract = getContractByABI("${contract.name}", address, network) as ${contract.name}ContractView
     if (!contract) {
@@ -143,8 +143,8 @@ export function codeGenSentioFile(contract: Contract): string {
 
   const imports = createImportsForUsedIdentifiers(
     {
-      ethers: ['BigNumber', 'BigNumberish', 'CallOverrides', 'BytesLike'],
-      '@ethersproject/providers': ['Networkish'],
+      ethers: ['BigNumberish', 'Overrides', 'BytesLike'],
+      'ethers/providers': ['Networkish'],
       '@sentio/sdk': [
         'addContractByABI',
         'getContractByABI',
@@ -152,6 +152,7 @@ export function codeGenSentioFile(contract: Contract): string {
         'getProcessor',
         'getProvider',
         'transformEtherError',
+        'Trace',
         'BindOptions',
         'BaseProcessor',
         'BaseProcessorTemplate',
@@ -198,7 +199,7 @@ export function codeGenTestUtilsFile(contract: Contract): string {
 
   const imports = createImportsForUsedIdentifiers(
     {
-      '@ethersproject/providers': ['Log'],
+      'ethers/providers': ['LogParams'],
       '.': [
         `get${contract.name}Contract`,
         ...Object.values(contract.events).flatMap((events) => {
@@ -218,23 +219,22 @@ export function codeGenTestUtilsFile(contract: Contract): string {
 
 function generateMockEventLogFunction(event: EventDeclaration, contractName: string, includeArgTypes: boolean): string {
   let eventName = event.name
-  let eventNameWithSignature = event.name
   if (includeArgTypes) {
     eventName = getFullSignatureAsSymbolForEvent(event) + '_'
-    eventNameWithSignature = getFullSignatureForEvent(event)
   }
 
   const eventArgs = event.inputs.map((input, i) => `event.${input.name ?? `arg${i.toString()}`}`)
 
   return `
-    export function mock${eventName}Log(contractAddress: string, event: ${eventName}EventObject): Log {
+    export function mock${eventName}Log(contractAddress: string, event: ${eventName}EventObject): LogParams {
       const contract = get${contractName}Contract(contractAddress)
       const encodedLog = contract.rawContract.interface.encodeEventLog(
-        contract.rawContract.interface.getEvent('${eventNameWithSignature}'),
+        '${getFullSignatureForEvent(event)}',
         [${eventArgs.join(', ')}]
       )
       return {
         ...mockField,
+        index: 0,
         address: contractAddress,
         data: encodedLog.data,
         topics: encodedLog.topics,

package/src/target-ethers-sentio/functions-handler.ts

@@ -1,9 +1,10 @@
 import {
   generateOutputComplexTypeAsArray,
   generateOutputComplexTypesAsObject,
-} from '@typechain/ethers-v5/dist/codegen/types'
+} from '@sentio/ethers-v6/dist/codegen/types'
+import { keccak256 } from 'ethers'
 import { FunctionDeclaration, getSignatureForFn } from 'typechain'
-import { utils } from 'ethers'
+// import { utils } from 'ethers'
 import { getFullSignatureAsSymbolForFunction } from './types'
 
 export function generateCallHandlers(fns: FunctionDeclaration[], contractName: string): string {
@@ -32,13 +33,16 @@ function codegenCallTraceType(fn: FunctionDeclaration, overloadedName?: string):
   return `
   export interface ${identifier}CallObject ${objectOutput}
     
-  export type ${identifier}CallTrace = TypedCallTrace<${arrayOutput}, ${identifier}CallObject>
+  export type ${identifier}CallTrace = TypedCallTrace<${arrayOutput}, ${identifier}CallObject> & Trace
   `
 }
 
 function generateCallHandler(fn: FunctionDeclaration, contractName: string, overloadedName?: string): string {
   const signature = getSignatureForFn(fn)
-  const sighash = utils.keccak256(utils.toUtf8Bytes(signature)).substring(0, 10)
+  // utils.toUtf8Bytes(signature))
+
+  const test = new TextEncoder().encode(signature)
+  const sighash = keccak256(test).substring(0, 10)
 
   return `
   onCall${capitalizeFirstChar(overloadedName ?? fn.name)}(

package/src/target-ethers-sentio/index.ts

@@ -1,4 +1,4 @@
-import Ethers from '@typechain/ethers-v5'
+import Ethers from '@sentio/ethers-v6'
 import { Config, extractAbi, extractDocumentation, FileDescription, parse, shortenFullJsonFilePath } from 'typechain'
 import { dirname, join, relative } from 'path'
 import { codeGenIndex, codeGenSentioFile, codeGenTestUtilsFile } from './file'

package/src/target-ethers-sentio/view-function.ts

@@ -1,6 +1,6 @@
 // https://github.com/dethcrypto/TypeChain/blob/015abb28bd22826611051f27e0ec96a00f9a0b61/packages/target-ethers-v5/src/codegen/functions.ts#L54
 import { FunctionDeclaration } from 'typechain'
-import { generateInputTypes, generateOutputTypes } from '@typechain/ethers-v5/dist/codegen/types'
+import { generateInputTypes, generateOutputTypes } from '@sentio/ethers-v6/dist/codegen/types'
 import { getFullSignatureAsSymbolForFunction, getFullSignatureForFunction } from './types'
 
 function generateReturnTypes(fn: FunctionDeclaration) {
@@ -20,20 +20,22 @@ export function generateViewFunction(fn: FunctionDeclaration, includeArgTypes: b
     return ''
   }
   const declName = includeArgTypes ? getFullSignatureAsSymbolForFunction(fn) : fn.name
-  const call = includeArgTypes ? 'this.contract["' + getFullSignatureForFunction(fn) + '"]' : 'this.contract.' + fn.name
-
+  const call = 'this.contract.getFunction("' + getFullSignatureForFunction(fn) + '")'
+  // if (overrides) {
+  //   return await ${call}(${
+  //   fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
+  // } overrides)
+  //     } else {
+  //       return await ${call}(${fn.inputs.map((input, index) => input.name || `arg${index}`).join(',')})
+  //     }
   return `
   async ${declName}(${generateInputTypes(fn.inputs, {
     useStructs: true,
-  })}overrides?: CallOverrides): ${generateReturnTypes(fn)} {
-    try {
-      if (overrides) {
-        return await ${call}(${
+  })}overrides?: Overrides): ${generateReturnTypes(fn)} {
+    try {    
+       return await ${call}(${
     fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
-  } overrides)
-      } else {
-        return await ${call}(${fn.inputs.map((input, index) => input.name || `arg${index}`).join(',')})
-      }
+  } overrides || {})
     } catch (e) {
       throw transformEtherError(e, undefined)
     }
@@ -57,20 +59,17 @@ export function generateBoundViewFunction(fn: FunctionDeclaration, includeArgTyp
   return `
   async ${declName ?? fn.name}(${generateInputTypes(fn.inputs, {
     useStructs: true,
-  })}overrides?: CallOverrides): ${generateReturnTypes(fn)} {
+  })}overrides?: Overrides): ${generateReturnTypes(fn)} {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         }
       }
-      if (overrides) {
-        return await this.view.${declName}(${
+      return await this.view.${declName}(${
     fn.inputs.length > 0 ? fn.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
-  } overrides)
-      } else {
-        return await this.view.${declName}(${fn.inputs.map((input, index) => input.name || `arg${index}`).join(',')})
-      }
+  } overrides || {})
+
     } catch (e) {
       throw transformEtherError(e, this.context)
     }

package/src/testing/metric-utils.ts

@@ -1,6 +1,6 @@
 import { MetricValue, ProcessResult } from '@sentio/protos'
 import { Numberish, BigDecimal } from '../core'
-import { BigNumber } from 'ethers'
+import { bytesToBigInt } from '../utils/conversion'
 
 export function MetricValueToNumber(v: Partial<MetricValue> | undefined): Numberish | undefined {
   if (v === undefined) {
@@ -11,7 +11,7 @@ export function MetricValueToNumber(v: Partial<MetricValue> | undefined): Number
     return v.doubleValue
   }
   if (v.bigInteger !== undefined) {
-    let intValue = BigNumber.from(v.bigInteger.data).toBigInt()
+    let intValue = bytesToBigInt(v.bigInteger.data)
     if (v.bigInteger.negative) {
       intValue = -intValue
     }