@sentio/sdk 1.13.1 → 1.14.0

package/template/node_modules/@sentio/sdk/src/target-ethers-sentio/codegen.ts

@@ -1,315 +0,0 @@
-import {
-  Contract,
-  createImportsForUsedIdentifiers,
-  EventDeclaration,
-  FunctionDeclaration,
-  getFullSignatureAsSymbolForEvent,
-} from 'typechain'
-
-import { reservedKeywords } from '@typechain/ethers-v5/dist/codegen/reserved-keywords'
-import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
-import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
-import { codegenCallTraceTypes, codegenFunctions } from './functions'
-
-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))
-      .flatMap((v) => v.filter((f) => f.stateMutability == 'view').map(generateViewFunction))
-      .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))
-      .flatMap((v) => v.filter((f) => f.stateMutability == 'view').map(generateBoundViewFunction))
-      .join('\n')}
-  }
-
-  export type ${contract.name}Context = Context<${contract.name}, ${contract.name}BoundContractView>
-
-  export class ${contract.name}ProcessorTemplate extends BaseProcessorTemplate<${contract.name}, ${
-    contract.name
-  }BoundContractView> {
-    bindInternal(options: BindOptions) {
-      let processor = getProcessor("${contract.name}", options) as ${contract.name}Processor
-      if (!processor) {
-        const finalOptions = Object.assign({}, options)
-        finalOptions.name = getContractName("${contract.name}", options.name, options.address, options.network)
-        processor = new ${contract.name}Processor(finalOptions)
-        addProcessor("${contract.name}", options, processor)
-      }
-      return processor
-    }
-
-    ${Object.values(contract.events)
-      .map((events) => {
-        if (events.length === 1) {
-          return generateOnEventFunction(events[0], contract.name, false)
-        } else {
-          return events.map((e) => generateOnEventFunction(e, contract.name, true)).join('\n')
-        }
-      })
-      .join('\n')}
-    
-    ${Object.values(contract.functions)
-      .map((f) => codegenFunctions(f, contract.name))
-      .join('\n')}
-    }
-
-    export class ${contract.name}Processor extends BaseProcessor<${contract.name}, ${contract.name}BoundContractView> {
-      ${Object.values(contract.events)
-        .map((events) => {
-          if (events.length === 1) {
-            return generateOnEventFunction(events[0], contract.name, false)
-          } else {
-            return events.map((e) => generateOnEventFunction(e, contract.name, true)).join('\n')
-          }
-        })
-        .join('\n')}
-
-      ${Object.values(contract.functions)
-        .map((f) => codegenFunctions(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 {
-      let processor = getProcessor("${contract.name}", options) as ${contract.name}Processor
-      if (!processor) {
-        // const wrapper = get${contract.name}Contract(options.address, options.network)
-
-        const finalOptions = Object.assign({}, options)
-        finalOptions.name = getContractName("${contract.name}", options.name, options.address, options.network)
-        processor = new ${contract.name}Processor(finalOptions)
-        addProcessor("${contract.name}", 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]
-      }
-    })
-  })
-  // 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',
-        'Context',
-        'ContractView',
-        'DummyProvider',
-        'getContractName',
-        '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 generateOnEventFunction(event: EventDeclaration, contractName: string, includeArgTypes: boolean): string {
-  let eventName = event.name
-  if (includeArgTypes) {
-    eventName = getFullSignatureAsSymbolForEvent(event) + '_'
-  }
-
-  const filterName = getFullSignatureForEvent(event)
-
-  return `
-  onEvent${eventName}(
-    handler: (event: ${eventName}Event, ctx: ${contractName}Context) => void,
-    filter?: ${eventName}EventFilter | ${eventName}EventFilter[]
-  ) {
-    if (!filter) {
-      filter = ${contractName}Processor.filters['${filterName}'](${event.inputs.map(() => 'null').join(',')})
-    }
-    return super.onEvent(handler, filter)
-  }
-  `
-}
-
-function generateViewFunction(func: FunctionDeclaration): string {
-  return `
-  async ${func.name}(${generateInputTypes(func.inputs, { useStructs: true })}overrides?: CallOverrides) {
-    try {
-      if (overrides) {
-        return await this.contract.${func.name}(${
-    func.inputs.length > 0 ? func.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
-  } overrides)
-      } else {
-        return await this.contract.${func.name}(${func.inputs
-    .map((input, index) => input.name || `arg${index}`)
-    .join(',')})
-      }
-    } catch (e) {
-      throw transformEtherError(e, undefined)
-    }
-  }
-  `
-}
-
-function generateBoundViewFunction(func: FunctionDeclaration): string {
-  return `
-  async ${func.name}(${generateInputTypes(func.inputs, { useStructs: true })}overrides?: CallOverrides) {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: this.context.blockNumber.toNumber(),
-        }
-      }
-      if (overrides) {
-        return await this.view.${func.name}(${
-    func.inputs.length > 0 ? func.inputs.map((input, index) => input.name || `arg${index}`).join(',') + ',' : ''
-  } overrides)
-      } else {
-        return await this.view.${func.name}(${func.inputs.map((input, index) => input.name || `arg${index}`).join(',')})
-      }
-    } catch (e) {
-      throw transformEtherError(e, this.context)
-    }
-  }
-  `
-}
-
-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)
-  }
-
-  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}'),
-        Object.values(event)
-      )
-      return {
-        ...mockField,
-        address: contractAddress,
-        data: encodedLog.data,
-        topics: encodedLog.topics,
-      }
-    }
-  `
-}

package/template/node_modules/@sentio/sdk/src/target-ethers-sentio/functions.ts

@@ -1,68 +0,0 @@
-import {
-  generateOutputComplexTypeAsArray,
-  generateOutputComplexTypesAsObject,
-} from '@typechain/ethers-v5/dist/codegen/types'
-import { FunctionDeclaration, getSignatureForFn } from 'typechain'
-import { utils } from 'ethers'
-
-export function codegenFunctions(fns: FunctionDeclaration[], contractName: string): string {
-  if (fns.length === 1) {
-    return generateFunction(fns[0], contractName)
-  }
-
-  return fns.map((fn) => generateFunction(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 generateFunction(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 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 capitalizeFirstChar(input: string): string {
-  if (!input) {
-    return input
-  }
-  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
-}

package/template/node_modules/@sentio/sdk/src/target-ethers-sentio/index.ts

@@ -1,50 +0,0 @@
-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 './codegen'
-
-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),
-        },
-      ]
-    }
-  }
-}

package/template/node_modules/@sentio/sdk/src/target-ethers-sentio/tsconfig.json

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