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

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

@@ -0,0 +1,242 @@
+import {
+  Contract,
+  createImportsForUsedIdentifiers,
+  EventDeclaration,
+  getFullSignatureAsSymbolForEvent,
+} from 'typechain'
+
+import { reservedKeywords } from '@typechain/ethers-v5/dist/codegen/reserved-keywords'
+import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
+import { codegenCallTraceTypes, generateCallHandlers } from './functions-handler'
+import { generateEventHandlers } from './event-handler'
+import { generateBoundViewFunctions, generateViewFunctions } from './view-function'
+
+export function codeGenIndex(contract: Contract): string {
+  return ` 
+  export * from '../internal/${contract.name.toLowerCase()}_processor'
+  export * from '../internal/${contract.name}'
+  `
+}
+
+export function codeGenSentioFile(contract: Contract): string {
+  const source = `
+  ${Object.values(contract.functions).map(codegenCallTraceTypes).join('\n')}
+
+  const templateContract = ${contract.name}__factory.connect("", DummyProvider)
+
+  export class ${contract.name}ContractView extends ContractView<${contract.name}> {
+    constructor (contract: ${contract.name}) {
+      super(contract);
+    }
+
+    ${Object.values(contract.functions)
+      .filter((f) => !reservedKeywords.has(f[0].name))
+      .map((fs) => generateViewFunctions(fs))
+      .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 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
+    }
+
+    ${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 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 = 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
+    }
+  }
+
+  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) {
+      const rawContract = ${contract.name}__factory.connect(address, getProvider(network))
+      contract = new ${contract.name}ContractView(rawContract)
+      addContractByABI("${contract.name}", address, network, contract)
+    }
+    return contract
+  }
+  `
+  const eventsImports = Object.values(contract.events).flatMap((events) => {
+    if (events.length === 1) {
+      return [`${events[0].name}Event`, `${events[0].name}EventFilter`]
+    } else {
+      return events.flatMap((e) => [
+        `${getFullSignatureAsSymbolForEvent(e)}_Event`,
+        `${getFullSignatureAsSymbolForEvent(e)}_EventFilter`,
+      ])
+    }
+  })
+
+  const structImports = Object.values(contract.structs).flatMap((structs) => {
+    return structs.flatMap((s) => {
+      if (!s.structName) {
+        return []
+      }
+      if (s.structName.namespace) {
+        return [s.structName.namespace]
+      } else {
+        return [s.structName.identifier + 'StructOutput', s.structName.identifier + 'Struct']
+      }
+    })
+  })
+  // dedup namespace
+  const uniqueStructImports = [...new Set(structImports)]
+
+  const imports = createImportsForUsedIdentifiers(
+    {
+      ethers: ['BigNumber', 'BigNumberish', 'CallOverrides', 'BytesLike'],
+      '@ethersproject/providers': ['Networkish'],
+      '@sentio/sdk': [
+        'addContractByABI',
+        'getContractByABI',
+        'addProcessor',
+        'getProcessor',
+        'getProvider',
+        'transformEtherError',
+        'BindOptions',
+        'BaseProcessor',
+        'BaseProcessorTemplate',
+        'BoundContractView',
+        'ContractContext',
+        'ContractView',
+        'DummyProvider',
+        'TypedCallTrace',
+      ],
+      './common': ['PromiseOrValue'],
+      './index': [`${contract.name}`, `${contract.name}__factory`],
+      [`./${contract.name}`]: eventsImports.concat(uniqueStructImports),
+    },
+    source
+  )
+
+  return imports + source
+}
+
+export function codeGenTestUtilsFile(contract: Contract): string {
+  const source = `
+  const mockField = {
+    blockHash:
+      "0x0000000000000000000000000000000000000000000000000000000000000000",
+    blockNumber: 0,
+    logIndex: 0,
+    removed: false,
+    transactionHash:
+      "0x0000000000000000000000000000000000000000000000000000000000000000",
+    transactionIndex: 0,
+  }
+  ${Object.values(contract.events)
+    .map((events) => {
+      if (events.length === 1) {
+        return generateMockEventLogFunction(events[0], contract.name, false)
+      } else {
+        return events.map((e) => generateMockEventLogFunction(e, contract.name, true)).join('\n')
+      }
+    })
+    .join('\n')}
+  `
+
+  const imports = createImportsForUsedIdentifiers(
+    {
+      '@ethersproject/providers': ['Log'],
+      '.': [
+        `get${contract.name}Contract`,
+        ...Object.values(contract.events).flatMap((events) => {
+          if (events.length === 1) {
+            return `${events[0].name}EventObject`
+          } else {
+            return events.flatMap((e) => `${getFullSignatureAsSymbolForEvent(e)}_EventObject`)
+          }
+        }),
+      ],
+    },
+    source
+  )
+
+  return imports + source
+}
+
+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 {
+      const contract = get${contractName}Contract(contractAddress)
+      const encodedLog = contract.rawContract.interface.encodeEventLog(
+        contract.rawContract.interface.getEvent('${eventNameWithSignature}'),
+        [${eventArgs.join(', ')}]
+      )
+      return {
+        ...mockField,
+        address: contractAddress,
+        data: encodedLog.data,
+        topics: encodedLog.topics,
+      }
+    }
+  `
+}

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

@@ -0,0 +1,57 @@
+import {
+  generateOutputComplexTypeAsArray,
+  generateOutputComplexTypesAsObject,
+} from '@typechain/ethers-v5/dist/codegen/types'
+import { FunctionDeclaration, getSignatureForFn } from 'typechain'
+import { utils } from 'ethers'
+import { getFullSignatureAsSymbolForFunction } from './types'
+
+export function generateCallHandlers(fns: FunctionDeclaration[], contractName: string): string {
+  if (fns.length === 1) {
+    return generateCallHandler(fns[0], contractName)
+  }
+
+  return fns.map((fn) => generateCallHandler(fn, contractName, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+export function codegenCallTraceTypes(fns: FunctionDeclaration[]): string {
+  if (fns.length === 1) {
+    return codegenCallTraceType(fns[0])
+  }
+
+  return fns.map((fn) => codegenCallTraceType(fn, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+function codegenCallTraceType(fn: FunctionDeclaration, overloadedName?: string): string {
+  const identifier = capitalizeFirstChar(overloadedName ?? fn.name)
+
+  const components = fn.inputs.map((input, i) => ({ name: input.name ?? `arg${i.toString()}`, type: input.type }))
+  const arrayOutput = generateOutputComplexTypeAsArray(components, { useStructs: true })
+  const objectOutput = generateOutputComplexTypesAsObject(components, { useStructs: true }) || '{}'
+
+  return `
+  export interface ${identifier}CallObject ${objectOutput}
+    
+  export type ${identifier}CallTrace = TypedCallTrace<${arrayOutput}, ${identifier}CallObject>
+  `
+}
+
+function generateCallHandler(fn: FunctionDeclaration, contractName: string, overloadedName?: string): string {
+  const signature = getSignatureForFn(fn)
+  const sighash = utils.keccak256(utils.toUtf8Bytes(signature)).substring(0, 10)
+
+  return `
+  onCall${capitalizeFirstChar(overloadedName ?? fn.name)}(
+    handler: (call: ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void
+  ) {
+    return super.onTrace("${sighash}", handler);
+  }
+`
+}
+
+function capitalizeFirstChar(input: string): string {
+  if (!input) {
+    return input
+  }
+  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
+}

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

@@ -0,0 +1,60 @@
+import Ethers from '@typechain/ethers-v5'
+import { Config, extractAbi, extractDocumentation, FileDescription, parse, shortenFullJsonFilePath } from 'typechain'
+import { dirname, join, relative } from 'path'
+import { codeGenIndex, codeGenSentioFile, codeGenTestUtilsFile } from './file'
+
+export default class EthersSentio extends Ethers {
+  constructor(config: Config) {
+    if (!config.outDir) {
+      throw new Error('Out put path not specificed')
+    }
+    super(config)
+  }
+
+  // TODO(pc): also have to override transformBinFile, transformFile
+  override transformAbiOrFullJsonFile(file: FileDescription): FileDescription[] | void {
+    const abi = extractAbi(file.contents)
+    if (abi.length === 0) {
+      return
+    }
+
+    const documentation = extractDocumentation(file.contents)
+
+    const jsonPath = relative(this.cfg.inputDir, shortenFullJsonFilePath(file.path, this.cfg.allFiles))
+    const contract = parse(abi, jsonPath, documentation)
+    const files = super.transformAbiOrFullJsonFile(file)
+
+    if (files !== undefined) {
+      // files.forEach(this.transformFilePath)
+      // for (const file of files) {
+      //   this.transformFilePath(file)
+      // }
+
+      return [
+        ...files,
+        {
+          path: join(dirname(files[0].path), `${contract.name.toLowerCase()}_processor.ts`),
+          contents: codeGenSentioFile(contract),
+        },
+        {
+          path: join(dirname(files[0].path), '..', contract.name.toLowerCase(), 'index.ts'),
+          contents: codeGenIndex(contract),
+        },
+        {
+          path: join(dirname(files[0].path), '..', contract.name.toLowerCase(), 'test-utils.ts'),
+          contents: codeGenTestUtilsFile(contract),
+        },
+      ]
+    }
+  }
+
+  override afterRun() {
+    const files = super.afterRun()
+    for (const [idx, file] of files.entries()) {
+      if (file.path.endsWith('__factory.ts')) {
+        file.contents = '// @ts-nocheck\n' + file.contents
+      }
+    }
+    return files
+  }
+}

package/src/target-ethers-sentio/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "..",
+    "outDir": "../../lib"
+  },
+  "exclude": ["lib"],
+  "include": ["."]
+}

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

@@ -0,0 +1,42 @@
+import { EventDeclaration, FunctionDeclaration } from 'typechain'
+import { EvmType } from 'typechain/dist/parser/parseEvmType'
+
+export function getFullSignatureAsSymbolForFunction(fn: FunctionDeclaration): string {
+  return `${fn.name}_${fn.inputs
+    .map((e) => {
+      if (e.type.type === 'array') {
+        return e.type.itemType.originalType + '_array'
+      } else {
+        return e.type.originalType
+      }
+    })
+    .join('_')}`
+}
+
+function formatType(type: EvmType): string {
+  if (type.type === 'array') {
+    return formatType(type.itemType) + '[]'
+  } else if (type.type === 'tuple') {
+    return '(' + type.components.map((s) => formatType(s.type)).join(',') + ')'
+  } else {
+    return type.originalType
+  }
+}
+
+// TODO contribute upstream
+export function getFullSignatureForEventPatched(event: EventDeclaration): string {
+  return `${event.name}(${event.inputs
+    .map((e) => {
+      return formatType(e.type)
+    })
+    .join(',')})`
+}
+
+// TODO check existed func
+export function getFullSignatureForFunction(fn: FunctionDeclaration): string {
+  return `${fn.name}(${fn.inputs
+    .map((e) => {
+      return formatType(e.type)
+    })
+    .join(',')})`
+}

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

@@ -0,0 +1,79 @@
+// 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 { getFullSignatureAsSymbolForFunction, getFullSignatureForFunction } from './types'
+
+function generateReturnTypes(fn: FunctionDeclaration) {
+  // sounds like returnResultObject should be true but we need to set false to make it work
+  return `Promise<${generateOutputTypes({ returnResultObject: false, useStructs: true }, fn.outputs)}>`
+}
+
+export function generateViewFunctions(functions: FunctionDeclaration[]): string {
+  if (functions.length === 1) {
+    return generateViewFunction(functions[0], false)
+  }
+  return functions.map((fn) => generateViewFunction(fn, true)).join('\n')
+}
+
+export function generateViewFunction(fn: FunctionDeclaration, includeArgTypes: boolean): string {
+  if (fn.stateMutability !== 'view' && fn.stateMutability !== 'pure') {
+    return ''
+  }
+  const declName = includeArgTypes ? getFullSignatureAsSymbolForFunction(fn) : fn.name
+  const call = includeArgTypes ? 'this.contract["' + getFullSignatureForFunction(fn) + '"]' : 'this.contract.' + fn.name
+
+  return `
+  async ${declName}(${generateInputTypes(fn.inputs, {
+    useStructs: true,
+  })}overrides?: CallOverrides): ${generateReturnTypes(fn)} {
+    try {
+      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(',')})
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined)
+    }
+  }
+  `
+}
+
+export function generateBoundViewFunctions(functions: FunctionDeclaration[]): string {
+  if (functions.length === 1) {
+    return generateBoundViewFunction(functions[0], false)
+  }
+  return functions.map((fn) => generateBoundViewFunction(fn, true)).join('\n')
+}
+
+export function generateBoundViewFunction(fn: FunctionDeclaration, includeArgTypes: boolean): string {
+  if (fn.stateMutability !== 'view' && fn.stateMutability !== 'pure') {
+    return ''
+  }
+  const declName = includeArgTypes ? getFullSignatureAsSymbolForFunction(fn) : fn.name
+
+  return `
+  async ${declName ?? fn.name}(${generateInputTypes(fn.inputs, {
+    useStructs: true,
+  })}overrides?: CallOverrides): ${generateReturnTypes(fn)} {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        }
+      }
+      if (overrides) {
+        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(',')})
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context)
+    }
+  }
+  `
+}

package/src/test-abi-code-gen.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import path from 'path'
+import { codeGenSolanaProcessor } from './solana-codegen/codegen'
+import { codeGenAptosProcessor } from './aptos-codegen/codegen'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+
+  codeGenAptosProcessor(path.join(abisDir, 'aptos'), path.join(targetDir, 'aptos'))
+  codeGenSolanaProcessor(path.join(abisDir, 'solana'), path.join(targetDir, 'solana'))
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/testing/index.ts

@@ -0,0 +1,4 @@
+export { TestProcessorServer } from './test-processor-server'
+export { MetricValueToNumber, firstCounterValue, firstGaugeValue } from './metric-utils'
+
+// export { loadTestProvidersFromEnv } from './test-provider' // TODO make the interface more standard and then export

package/src/testing/metric-utils.ts

@@ -0,0 +1,48 @@
+import { MetricValue, ProcessResult } from '../gen'
+import { Numberish, BigDecimal } from '../core'
+import { BigNumber } from 'ethers'
+
+export function MetricValueToNumber(v: Partial<MetricValue> | undefined): Numberish | undefined {
+  if (v === undefined) {
+    return undefined
+  }
+
+  if (v.doubleValue !== undefined) {
+    return v.doubleValue
+  }
+  if (v.bigInteger !== undefined) {
+    let intValue = BigNumber.from(v.bigInteger.data).toBigInt()
+    if (v.bigInteger.negative) {
+      intValue = -intValue
+    }
+    return intValue
+  }
+  if (v.bigDecimal !== undefined) {
+    return new BigDecimal(v.bigDecimal)
+  }
+  return undefined
+}
+
+export function firstCounterValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
+  if (!result) {
+    return undefined
+  }
+  for (const counter of result.counters) {
+    if (counter.metadata?.name === name) {
+      return MetricValueToNumber(counter.metricValue)
+    }
+  }
+  return undefined
+}
+
+export function firstGaugeValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
+  if (!result) {
+    return undefined
+  }
+  for (const gauge of result.gauges) {
+    if (gauge.metadata?.name === name) {
+      return MetricValueToNumber(gauge.metricValue)
+    }
+  }
+  return undefined
+}