@sentio/sdk 2.4.0 → 2.5.0-rc.1

package/src/aptos/utils.ts

@@ -1,25 +1,7 @@
-import { MoveFunction, MoveModule } from './move-types.js'
+import { TypeDescriptor } from '../move/index.js'
 
-export const SPLITTER = '::'
-
-export const VECTOR_STR = 'vector'
-
-export function isFrameworkAccount(account: string) {
-  return account === '0x1' || account === '0x2' || account === '0x3'
-}
-
-export function moduleQname(module: MoveModule): string {
-  return module.address.toLowerCase() + SPLITTER + module.name
-}
-
-export function moduleQnameForType(type: string): [string, string] {
-  const parts = type.split(SPLITTER).slice(0, 2)
-  return [parts[0], parts[1]]
-}
-
-export function getMeaningfulFunctionParams(func: MoveFunction): string[] {
-  let params = func.params
-  if (func.params[0] === '&signer') {
+export function getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+  if (params[0].qname === 'signer' && params[0].reference) {
     params = params.slice(1)
   }
   return params

package/src/eth/tests/erc20.ts

@@ -33,7 +33,7 @@ ERC20Processor.bind({
 ERC20Processor.bind({ address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', network: 56, name: 'usdc' })
   .onEventTransfer(
     async function (event, ctx) {
-      // ctx.meter.Counter('c2').add(2)
+      ctx.meter.Counter('c2').add(2)
       // const t: Promise<string> =
       // ctx.eventLogger.emit('transfer', { distinctId: event.args.from, xx: 33,  y: Promise.resolve("s")})
       // ctx.eventLogger.emit('transfer', { distinctId: event.args.from, x: { y: Promise.resolve("s")} })

package/src/move/abstract-codegen.ts

@@ -0,0 +1,426 @@
+import { NeutralMoveFunction, NeutralMoveModule, NeutralMoveStruct } from './neutral-models.js'
+import path from 'path'
+import fs from 'fs'
+import { AccountModulesImportInfo, AccountRegister } from './account.js'
+import chalk from 'chalk'
+import { format } from 'prettier'
+import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER } from './utils.js'
+import { generateTypeForDescriptor } from './ts-type.js'
+import { camelCase } from 'lodash-es'
+import { TypeDescriptor } from './types.js'
+
+interface OutputFile {
+  fileName: string
+  fileContent: string
+}
+
+interface Config<NetworkType> {
+  fileName: string
+  outputDir: string
+  network: NetworkType
+}
+
+export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
+  TEST_NET: NetworkType
+  MAIN_NET: NetworkType
+  ADDRESS_TYPE: string
+  PREFIX: string
+  STRUCT_FIELD_NAME: string = 'data'
+
+  abstract fetchModules(account: string, network: NetworkType): Promise<ModuleTypes>
+  abstract toNeutral(modules: ModuleTypes): NeutralMoveModule[]
+  abstract getEventStructs(module: NeutralMoveModule): Map<string, NeutralMoveStruct>
+
+  abstract getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[]
+
+  readModulesFile(fullPath: string) {
+    return JSON.parse(fs.readFileSync(fullPath, 'utf-8'))
+  }
+
+  async generate(srcDir: string, outputDir: string) {
+    await this.generateForNetwork(srcDir, outputDir, this.MAIN_NET)
+    await this.generateForNetwork(path.join(srcDir, 'testnet'), path.join(outputDir, 'testnet'), this.TEST_NET)
+  }
+
+  async generateForNetwork(srcDir: string, outputDir: string, network: NetworkType) {
+    if (!fs.existsSync(srcDir)) {
+      return
+    }
+    if (network === this.TEST_NET) {
+      console.log('Found testnet directory, generate code for testnet modules')
+    }
+    const files = fs.readdirSync(srcDir)
+    outputDir = path.resolve(outputDir)
+    const outputs: OutputFile[] = []
+
+    fs.mkdirSync(outputDir, { recursive: true })
+
+    const loader = new AccountRegister()
+
+    // when generating user code, don't need to generate framework account
+    loader.accountImports.set('0x1', new AccountModulesImportInfo('0x1', '0x1'))
+    loader.accountImports.set('0x2', new AccountModulesImportInfo('0x2', '0x2'))
+    loader.accountImports.set('0x3', new AccountModulesImportInfo('0x3', '0x3'))
+    // const client = getRpcClient(network)
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) {
+        continue
+      }
+      const fullPath = path.resolve(srcDir, file)
+      const abi = this.readModulesFile(fullPath)
+      const modules = this.toNeutral(abi)
+
+      for (const module of modules) {
+        loader.register(module, path.basename(file, '.json'))
+      }
+      const codeGen = new AccountCodegen(this, loader, abi, modules, {
+        fileName: path.basename(file, '.json'),
+        outputDir: outputDir,
+        network,
+      })
+
+      outputs.push(...codeGen.generate())
+    }
+
+    while (loader.pendingAccounts.size > 0) {
+      for (const account of loader.pendingAccounts) {
+        console.log(`download dependent module for account ${account} at ${network}`)
+
+        try {
+          const rawModules = await this.fetchModules(account, network)
+          const modules = this.toNeutral(rawModules)
+
+          fs.writeFileSync(path.resolve(srcDir, account + '.json'), JSON.stringify(rawModules, null, '\t'))
+
+          for (const module of modules) {
+            loader.register(module, account)
+          }
+          const codeGen = new AccountCodegen(this, loader, rawModules, modules, {
+            fileName: account,
+            outputDir: outputDir,
+            network,
+          })
+
+          outputs.push(...codeGen.generate())
+        } catch (e) {
+          console.error(
+            chalk.red(
+              'Error downloading account module, check if you choose the right network，or download account modules manually into your director'
+            )
+          )
+          console.error(e)
+          process.exit(1)
+        }
+      }
+    }
+
+    for (const output of outputs) {
+      const content = format(output.fileContent, { parser: 'typescript' })
+      fs.writeFileSync(path.join(outputDir, output.fileName), content)
+    }
+
+    const rootFile = path.join(outputDir, 'index.ts')
+    fs.writeFileSync(
+      rootFile,
+      `/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+`
+    )
+    for (const output of outputs) {
+      const parsed = path.parse(output.fileName)
+      const content = `export * as _${parsed.name} from './${parsed.name}.js'\n`
+      fs.appendFileSync(rootFile, content)
+    }
+  }
+
+  generateNetworkOption(network: NetworkType) {
+    switch (network) {
+      case this.TEST_NET:
+        return 'TEST_NET'
+    }
+    return 'MAIN_NET'
+  }
+
+  generateModule(module: NeutralMoveModule, network: NetworkType) {
+    const functions = module.exposed_functions
+      .map((f) => this.generateOnEntryFunctions(module, f))
+      .filter((s) => s !== '')
+
+    const eventStructs = this.getEventStructs(module)
+    const eventTypes = new Set(eventStructs.keys())
+    const events = Array.from(eventStructs.values())
+      .map((e) => this.generateOnEvents(module, e))
+      .filter((s) => s !== '')
+    const structs = module.structs.map((s) => this.generateStructs(module, s, eventTypes))
+    const callArgs = module.exposed_functions.map((f) => this.generateCallArgsStructs(module, f))
+
+    const moduleName = normalizeToJSName(module.name)
+    let processor = ''
+    if (functions.length > 0 || events.length > 0) {
+      processor = `export class ${moduleName} extends ${this.PREFIX}BaseProcessor {
+
+    constructor(options: ${this.PREFIX}BindOptions) {
+      super("${module.name}", options)
+    }
+    static DEFAULT_OPTIONS: ${this.PREFIX}BindOptions = {
+      address: "${module.address}",
+      network: ${this.PREFIX}Network.${this.generateNetworkOption(network)}       
+    }
+
+    static bind(options: Partial<${this.PREFIX}BindOptions> = {}): ${moduleName} {
+      return new ${moduleName}({ ...${moduleName}.DEFAULT_OPTIONS, ...options })
+    }
+    
+    ${functions.join('\n')}
+    
+    ${events.join('\n')}
+  }
+  `
+    }
+
+    return `
+  ${processor}
+
+  export namespace ${moduleName} {
+    ${structs.join('\n')}
+    
+    ${callArgs.join('\n')}
+ }
+  `
+  }
+
+  generateStructs(module: NeutralMoveModule, struct: NeutralMoveStruct, events: Set<string>) {
+    const genericString = this.generateStructTypeParameters(struct)
+    const genericStringAny = this.generateStructTypeParameters(struct, true)
+
+    const structName = normalizeToJSName(struct.name)
+
+    const fields = struct.fields.map((field) => {
+      const type = generateTypeForDescriptor(field.type, module.address, this.ADDRESS_TYPE)
+      return `${field.name}: ${type}`
+    })
+
+    let eventPayload = ''
+    if (events.has(moduleQname(module) + SPLITTER + struct.name)) {
+      eventPayload = `
+    export interface ${structName}Instance extends 
+        TypedEventInstance<${structName}${genericStringAny}> {
+      ${this.STRUCT_FIELD_NAME}_decoded: ${structName}${genericStringAny}
+      type_arguments: [${struct.generic_type_params.map((_) => 'string').join(', ')}]
+    }
+    `
+    }
+
+    return `
+  export class ${structName}${genericString} {
+    static TYPE_QNAME = '${module.address}::${module.name}::${struct.name}'
+    ${fields.join('\n')} 
+  }
+  
+  ${eventPayload}
+  `
+  }
+
+  generateFunctionTypeParameters(func: NeutralMoveFunction) {
+    let genericString = ''
+    if (func.generic_type_params && func.generic_type_params.length > 0) {
+      const params = func.generic_type_params
+        .map((v, idx) => {
+          return `T${idx}=any`
+        })
+        .join(',')
+      genericString = `<${params}>`
+    }
+    return genericString
+  }
+
+  generateStructTypeParameters(struct: NeutralMoveStruct, useAny = false) {
+    let genericString = ''
+
+    if (struct.generic_type_params && struct.generic_type_params.length > 0) {
+      const params = struct.generic_type_params
+        .map((v, idx) => {
+          return useAny ? 'any' : 'T' + idx
+        })
+        .join(',')
+      genericString = `<${params}>`
+    }
+    return genericString
+  }
+
+  generateCallArgsStructs(module: NeutralMoveModule, func: NeutralMoveFunction) {
+    if (!func.is_entry) {
+      return
+    }
+
+    const fields = this.getMeaningfulFunctionParams(func.params).map((param) => {
+      return generateTypeForDescriptor(param, module.address, this.ADDRESS_TYPE)
+    })
+
+    const camelFuncName = capitalizeFirstChar(camelCase(func.name))
+
+    const genericString = this.generateFunctionTypeParameters(func)
+    return `
+  export interface ${camelFuncName}Payload${genericString}
+      extends TypedEntryFunctionPayload<[${fields.join(',')}]> {
+    arguments_decoded: [${fields.join(',')}],
+    type_arguments: [${func.generic_type_params.map((_) => 'string').join(', ')}]
+  }
+  `
+  }
+
+  generateOnEntryFunctions(module: NeutralMoveModule, func: NeutralMoveFunction) {
+    if (!func.is_entry) {
+      return ''
+    }
+
+    // const genericString = generateFunctionTypeParameters(func)
+    const moduleName = normalizeToJSName(module.name)
+
+    const camelFuncName = capitalizeFirstChar(camelCase(func.name))
+    const source = `
+  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): ${moduleName} {
+    this.onEntryFunctionCall(func, {
+      ...filter,
+      function: '${module.name}::${func.name}'
+    },
+    fetchConfig)
+    return this
+  }`
+
+    return source
+  }
+
+  generateOnEvents(module: NeutralMoveModule, struct: NeutralMoveStruct): string {
+    // for struct that has drop + store
+    // if (!isEvent(struct, module)) {
+    //   return ''
+    // }
+
+    // const genericString = generateStructTypeParameters(struct)
+
+    const moduleName = normalizeToJSName(module.name)
+    const source = `
+  onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
+      this.PREFIX
+    }Context) => void, fetchConfig?: MoveFetchConfig): ${moduleName} {
+    this.onMoveEvent(func, {
+      type: '${module.name}::${struct.name}'
+    },
+    fetchConfig)
+    return this
+  }
+  `
+    return source
+  }
+}
+
+export class AccountCodegen<ModuleType, NetworkType> {
+  modules: NeutralMoveModule[]
+  config: Config<NetworkType>
+  abi: ModuleType
+  loader: AccountRegister
+  moduleGen: AbstractCodegen<ModuleType, NetworkType>
+
+  constructor(
+    moduleGen: AbstractCodegen<ModuleType, NetworkType>,
+    loader: AccountRegister,
+    abi: ModuleType,
+    modules: NeutralMoveModule[],
+    config: Config<NetworkType>
+  ) {
+    // const json = fs.readFileSync(config.srcFile, 'utf-8')
+    this.moduleGen = moduleGen
+    this.abi = abi
+    this.modules = modules
+    this.config = config
+    this.loader = loader
+  }
+
+  generate(): OutputFile[] {
+    if (!this.modules) {
+      return []
+    }
+    // const baseName = path.basename(this.config.fileName, '.json')
+
+    let address: string | undefined
+    for (const module of this.modules) {
+      address = module.address
+    }
+    if (!address) {
+      return []
+    }
+
+    const imports = `
+    import { CallFilter } from "@sentio/sdk/move"
+    import { 
+      MoveCoder, defaultMoveCoder, ${this.moduleGen.PREFIX}BindOptions, ${this.moduleGen.PREFIX}BaseProcessor, 
+      TypedEventInstance, ${this.moduleGen.PREFIX}Network, TypedEntryFunctionPayload,
+      ${this.moduleGen.PREFIX}Context } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
+    import { MoveFetchConfig } from "@sentio/protos"
+    import { ${this.moduleGen.ADDRESS_TYPE} } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}"
+    `
+
+    const dependedAccounts: string[] = []
+
+    const moduleImports: string[] = []
+
+    const info = this.loader.accountImports.get(address)
+
+    if (info) {
+      for (const [account] of info.imports.entries()) {
+        // Remap to user's filename if possible, TODO codepath not well tested
+        const tsAccountModule = './' + (this.loader.accountImports.get(account)?.moduleName || account)
+        if (isFrameworkAccount(account) && !isFrameworkAccount(address)) {
+          // Decide where to find runtime library
+          moduleImports.push(`import { _${account} } from "@sentio/sdk/${this.moduleGen.PREFIX.toLowerCase()}/builtin"`)
+        } else {
+          moduleImports.push(`import * as _${account} from "${tsAccountModule}.js"`)
+        }
+
+        dependedAccounts.push(account)
+      }
+    }
+
+    const source = `
+    /* Autogenerated file. Do not edit manually. */
+    /* tslint:disable */
+    /* eslint-disable */
+  
+    /* Generated modules for account ${address} */
+  
+    ${imports}
+    
+    ${moduleImports.join('\n')}
+    
+    ${this.modules.map((m) => this.moduleGen.generateModule(m, this.config.network)).join('\n')}
+    
+    const MODULES = JSON.parse('${JSON.stringify(this.abi)}')
+
+    export function loadAllTypes(coder: MoveCoder) {
+      ${dependedAccounts.map((a) => `_${a}.loadAllTypes(coder)`).join('\n')}
+      for (const m of Object.values(MODULES)) {
+        coder.load(m as any)
+      }
+    }
+    
+    loadAllTypes(defaultMoveCoder())
+    ` // source
+
+    return [
+      {
+        fileName: this.config.fileName + '.ts',
+        fileContent: source,
+      },
+    ]
+  }
+}
+
+function capitalizeFirstChar(input: string): string {
+  if (!input) {
+    return input
+  }
+  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
+}

package/src/move/abstract-move-coder.ts

@@ -0,0 +1,170 @@
+import { moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
+import { parseMoveType, TypeDescriptor } from './types.js'
+import { NeutralMoveFunction, NeutralMoveModule, NeutralMoveStruct } from './neutral-models.js'
+import { bytesToBigInt } from '../utils/index.js'
+
+type StructWithTag<Base> = Base & {
+  type: string
+  data: any
+}
+
+type DecodedStructWithTag<B, T> = StructWithTag<B> & {
+  data_decoded: T
+  type_arguments: string[]
+}
+
+export abstract class AbstractMoveCoder<StructType> {
+  private moduleMapping = new Map<string, NeutralMoveModule>()
+  private typeMapping = new Map<string, NeutralMoveStruct>()
+  private funcMapping = new Map<string, NeutralMoveFunction>()
+
+  contains(account: string, name: string) {
+    return this.moduleMapping.has(account + '::' + name)
+  }
+
+  loadNeutral(module: NeutralMoveModule) {
+    if (this.contains(module.address, module.name)) {
+      return
+    }
+    this.moduleMapping.set(moduleQname(module), module)
+
+    for (const struct of module.structs) {
+      // TODO move to util
+      const key = [module.address, module.name, struct.name].join(SPLITTER)
+      this.typeMapping.set(key, struct)
+    }
+
+    for (const func of module.exposed_functions) {
+      if (!func.is_entry) {
+        continue
+      }
+      const key = [module.address, module.name, func.name].join(SPLITTER)
+      this.funcMapping.set(key, func)
+    }
+  }
+
+  protected dataToBigInt(data: any): bigint {
+    if (Array.isArray(data)) {
+      // Only sui function need this, strange
+      const bytes = data as number[]
+      return bytesToBigInt(new Uint8Array(bytes.slice().reverse()))
+    } else {
+      return BigInt(data)
+    }
+  }
+
+  protected getMoveStruct(type: string): NeutralMoveStruct {
+    const struct = this.typeMapping.get(type)
+    if (!struct) {
+      throw new Error('Failed to load type' + type + ' type are not imported anywhere')
+    }
+    return struct
+  }
+
+  protected getMoveFunction(type: string): NeutralMoveFunction {
+    const func = this.funcMapping.get(type)
+    if (!func) {
+      throw new Error('Failed to load function' + type + ' type are not imported anywhere')
+    }
+    return func
+  }
+
+  protected decode(data: any, type: TypeDescriptor): any {
+    // process simple type
+    if (type.reference) {
+      return data
+    }
+    switch (type.qname) {
+      case 'signer': // TODO check this, aptos only
+      case 'address':
+      case 'Address':
+      case '0x2::object::ID':
+      case '0x2::coin::Coin':
+      case '0x1::string::String':
+      case 'bool':
+      case 'Bool':
+      case 'u8':
+      case 'U8':
+      case 'u16':
+      case 'U16':
+      case 'u32':
+      case 'U32':
+        return data
+      case 'u64':
+      case 'U64':
+      case 'u128':
+      case 'U128':
+        return this.dataToBigInt(data)
+    }
+
+    // process vector
+    if (type.qname === VECTOR_STR) {
+      // vector<u8> as hex string
+      if (type.typeArgs[0].qname === 'u8' || type.typeArgs[0].qname === 'U8') {
+        return data
+      }
+
+      const res = []
+      for (const entry of data) {
+        res.push(this.decode(entry, type.typeArgs[0]))
+      }
+      return res
+    }
+
+    // Process complex type
+    const struct = this.getMoveStruct(type.qname)
+
+    const typeCtx = new Map<string, TypeDescriptor>()
+    for (const [idx, typeArg] of type.typeArgs.entries()) {
+      typeCtx.set('T' + idx, typeArg)
+    }
+
+    const typedData: any = {}
+
+    for (const field of struct.fields) {
+      let filedType = field.type
+      filedType = filedType.applyTypeArgs(typeCtx)
+      const value = this.decode(data[field.name], filedType)
+      typedData[field.name] = value
+    }
+    return typedData
+  }
+
+  protected filterAndDecodeInternal<T>(
+    typeQname: string,
+    structs: StructWithTag<StructType>[]
+  ): DecodedStructWithTag<StructType, T>[] {
+    if (!structs) {
+      return []
+    }
+    const results: DecodedStructWithTag<StructType, T>[] = []
+    for (const resource of structs) {
+      if (resource.type.split('<')[0] !== typeQname) {
+        continue
+      }
+      const result = this.decodedInternal(resource)
+      if (result) {
+        results.push(result as DecodedStructWithTag<StructType, T>)
+      }
+    }
+    return results
+  }
+
+  protected decodedInternal<T>(typeStruct: StructWithTag<StructType>): DecodedStructWithTag<StructType, T> | undefined {
+    const typeDescriptor = parseMoveType(typeStruct.type)
+    const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature())
+
+    let dataTyped = undefined
+    try {
+      dataTyped = this.decode(typeStruct.data, typeDescriptor)
+    } catch (e) {
+      console.error('Decoding error for ', JSON.stringify(typeStruct), e)
+      return undefined
+    }
+    return {
+      ...typeStruct,
+      data_decoded: dataTyped,
+      type_arguments: typeArguments,
+    } as DecodedStructWithTag<StructType, T>
+  }
+}