@sentio/sdk 2.0.0-rc.9 → 2.0.0

package/src/aptos/builtin/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as _0x1 from './0x1.js'
+export * as _0x3 from './0x3.js'

package/src/aptos/codegen/codegen.ts

@@ -0,0 +1,461 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { format } from 'prettier'
+import { MoveFunction, MoveModule, MoveModuleBytecode, MoveStruct } from '../move-types.js'
+import { AccountModulesImportInfo, AccountRegister, generateType, normalizeToJSName } from './typegen.js'
+import { getMeaningfulFunctionParams, isFrameworkAccount, moduleQname, SPLITTER } from '../utils.js'
+import chalk from 'chalk'
+import { AptosNetwork, getAptosChainName } from '../network.js'
+import { parseMoveType } from '../types.js'
+import { AptosClient } from 'aptos-sdk'
+import { camelCase } from 'lodash-es'
+
+export async function codegen(abisDir: string, outDir = 'src/types/aptos') {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+  console.log(chalk.green('Generated Types for Aptos'))
+  await generate(abisDir, outDir)
+}
+
+function getRpcEndpoint(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return 'https://testnet.aptoslabs.com/'
+  }
+  return 'https://mainnet.aptoslabs.com/'
+}
+
+function getRpcClient(network: AptosNetwork): AptosClient {
+  return new AptosClient(getRpcEndpoint(network))
+}
+
+async function generate(srcDir: string, outputDir: string) {
+  await generateForNetwork(srcDir, outputDir, AptosNetwork.MAIN_NET)
+  await generateForNetwork(path.join(srcDir, 'testnet'), path.join(outputDir, 'testnet'), AptosNetwork.TEST_NET)
+}
+
+async function generateForNetwork(srcDir: string, outputDir: string, network: AptosNetwork) {
+  if (!fs.existsSync(srcDir)) {
+    return
+  }
+  if (network === AptosNetwork.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 modules = JSON.parse(fs.readFileSync(fullPath, 'utf-8'))
+
+    for (const module of modules) {
+      if (module.abi) {
+        loader.register(module.abi, path.basename(file, '.json'))
+      }
+    }
+    const codeGen = new AccountCodegen(loader, 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 ${getAptosChainName(network)}`)
+
+      try {
+        const modules = await client.getAccountModules(account)
+        fs.writeFileSync(path.resolve(srcDir, account + '.json'), JSON.stringify(modules, null, '\t'))
+
+        for (const module of modules) {
+          if (module.abi) {
+            loader.register(module.abi, account)
+          }
+        }
+        const codeGen = new AccountCodegen(loader, 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)
+  }
+}
+
+interface OutputFile {
+  fileName: string
+  fileContent: string
+}
+
+interface Config {
+  fileName: string
+  outputDir: string
+  network: AptosNetwork
+}
+
+export class AccountCodegen {
+  modules: MoveModuleBytecode[]
+  config: Config
+  loader: AccountRegister
+
+  constructor(loader: AccountRegister, modules: MoveModuleBytecode[], config: Config) {
+    // const json = fs.readFileSync(config.srcFile, 'utf-8')
+    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) {
+      if (module.abi && module.abi.address) {
+        address = module.abi.address
+      }
+    }
+    if (!address) {
+      return []
+    }
+
+    const imports = `
+    import { 
+      MoveCoder, AptosBindOptions, AptosBaseProcessor, 
+      TypedEventInstance, AptosNetwork, TypedEntryFunctionPayload,
+      AptosContext, CallFilter
+    } from "@sentio/sdk/aptos"
+    import { AptosFetchConfig } from "@sentio/protos"
+    import { Address, MoveModule } from "@sentio/sdk/aptos"
+    `
+
+    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/aptos/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) => generateModule(m, this.config.network)).join('\n')}
+    
+    export function loadAllTypes(_r: MoveCoder) {
+      ${dependedAccounts.map((a) => `_${a}.loadAllTypes(_r)`).join('\n')}
+
+      ${this.modules
+        .map((m) => {
+          if (m.abi) {
+            return `_r.load(${normalizeToJSName(m.abi.name)}.ABI)`
+          }
+          console.error('Find Module with empty ABI')
+          return ''
+        })
+        .join('\n')}
+    }
+    ` // source
+
+    return [
+      {
+        fileName: this.config.fileName + '.ts',
+        fileContent: source,
+      },
+    ]
+  }
+}
+
+function generateNetworkOption(network: AptosNetwork) {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return 'TEST_NET'
+  }
+  return 'MAIN_NET'
+}
+
+function generateModule(moduleByteCode: MoveModuleBytecode, network: AptosNetwork) {
+  if (!moduleByteCode.abi) {
+    return ''
+  }
+  const module = moduleByteCode.abi
+
+  const functions = module.exposed_functions.map((f) => generateOnEntryFunctions(module, f)).filter((s) => s !== '')
+
+  const eventStructs = getEventStructs(module)
+  const eventTypes = new Set(eventStructs.keys())
+  const events = Array.from(eventStructs.values())
+    .map((e) => generateOnEvents(module, e))
+    .filter((s) => s !== '')
+  const structs = module.structs.map((s) => generateStructs(module, s, eventTypes))
+  const callArgs = module.exposed_functions.map((f) => generateCallArgsStructs(module, f))
+
+  const moduleName = normalizeToJSName(module.name)
+  let processor = ''
+  if (functions.length > 0 || events.length > 0) {
+    processor = `export class ${moduleName} extends AptosBaseProcessor {
+
+    constructor(options: AptosBindOptions) {
+      super("${module.name}", options)
+    }
+    static DEFAULT_OPTIONS: AptosBindOptions = {
+      address: "${module.address}",
+      network: AptosNetwork.${generateNetworkOption(network)}       
+    }
+
+    static bind(options: Partial<AptosBindOptions> = {}): ${moduleName} {
+      return new ${moduleName}({ ...${moduleName}.DEFAULT_OPTIONS, ...options })
+    }
+    
+    ${functions.join('\n')}
+    
+    ${events.join('\n')}
+    
+    loadTypesInternal(registry: MoveCoder) {
+      loadAllTypes(registry)
+    }
+  }
+  `
+  }
+
+  return `
+  ${processor}
+
+  export namespace ${moduleName} {
+    ${structs.join('\n')}
+    
+    ${callArgs.join('\n')}
+       
+    export function loadTypes(_r: MoveCoder) {
+      loadAllTypes(_r)
+    }
+    export const ABI: MoveModule = JSON.parse('${JSON.stringify(module)}')
+ }
+  `
+}
+
+function generateStructs(module: MoveModule, struct: MoveStruct, events: Set<string>) {
+  const genericString = generateStructTypeParameters(struct)
+  const genericStringAny = generateStructTypeParameters(struct, true)
+
+  const structName = normalizeToJSName(struct.name)
+
+  const fields = struct.fields.map((field) => {
+    return `${field.name}: ${generateType(field.type, module.address)}`
+  })
+
+  let eventPayload = ''
+  if (events.has(moduleQname(module) + SPLITTER + struct.name)) {
+    eventPayload = `
+    export interface ${structName}Instance extends 
+        TypedEventInstance<${structName}${genericStringAny}> {
+      data_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}
+  `
+}
+
+function generateFunctionTypeParameters(func: MoveFunction) {
+  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
+}
+
+function generateStructTypeParameters(struct: MoveStruct, 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
+}
+
+function generateCallArgsStructs(module: MoveModule, func: MoveFunction) {
+  if (!func.is_entry) {
+    return
+  }
+
+  const fields = getMeaningfulFunctionParams(func).map((param) => {
+    return `${generateType(param, module.address)}`
+  })
+
+  const camelFuncName = capitalizeFirstChar(camelCase(func.name))
+
+  const genericString = 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(', ')}]
+  }
+  `
+}
+
+function generateOnEntryFunctions(module: MoveModule, func: MoveFunction) {
+  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: AptosContext) => void, filter?: CallFilter, fetchConfig?: AptosFetchConfig): ${moduleName} {
+    this.onEntryFunctionCall(func, {
+      ...filter,
+      function: '${module.name}::${func.name}'
+    },
+    fetchConfig)
+    return this
+  }`
+
+  return source
+}
+
+function getEventStructs(module: MoveModule) {
+  const qname = moduleQname(module)
+  const structMap = new Map<string, MoveStruct>()
+  const eventMap = new Map<string, MoveStruct>()
+
+  for (const struct of module.structs) {
+    structMap.set(qname + SPLITTER + struct.name, struct)
+  }
+
+  for (const struct of module.structs) {
+    for (const field of struct.fields) {
+      const t = parseMoveType(field.type)
+      if (t.qname === '0x1::event::EventHandle') {
+        const event = t.typeArgs[0].qname
+        const eventStruct = structMap.get(event)
+        if (eventStruct) {
+          eventMap.set(event, eventStruct)
+        }
+      }
+    }
+  }
+
+  return eventMap
+}
+
+function generateOnEvents(module: MoveModule, struct: MoveStruct): 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: AptosContext) => void, fetchConfig?: AptosFetchConfig): ${moduleName} {
+    this.onEvent(func, {
+      type: '${module.name}::${struct.name}'
+    },
+    fetchConfig)
+    return this
+  }
+  `
+  return source
+}
+
+function capitalizeFirstChar(input: string): string {
+  if (!input) {
+    return input
+  }
+  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
+}

package/src/aptos/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/aptos/codegen/run.ts

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

package/src/aptos/codegen/tsconfig.json

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

package/src/aptos/codegen/typegen.ts

@@ -0,0 +1,165 @@
+import { MoveModule } from '../move-types.js'
+import { parseMoveType, TypeDescriptor } from '../types.js'
+import { moduleQname, moduleQnameForType, SPLITTER, VECTOR_STR } from '../utils.js'
+
+function generateTypeForDescriptor(type: TypeDescriptor, currentAddress: string): string {
+  // TODO &signer is defintely an address, but what if &OTHER_TYPE?
+  if (type.qname.startsWith('&')) {
+    return 'Address'
+  }
+
+  switch (type.qname) {
+    case 'signer': // TODO check this
+    case 'address':
+      return 'Address'
+    case '0x1::string::String':
+      return 'string'
+    case 'bool':
+      return 'Boolean'
+    case 'u8':
+    case 'u16':
+    case 'u32':
+      return 'number'
+    case 'u64':
+    case 'u128':
+      return 'bigint'
+  }
+
+  if (type.qname === VECTOR_STR) {
+    // vector<u8> as hex string
+    const elementTypeQname = type.typeArgs[0].qname
+    if (elementTypeQname === 'u8') {
+      return 'string'
+    }
+    if (elementTypeQname.startsWith('T') && !elementTypeQname.includes(SPLITTER)) {
+      return `${elementTypeQname}[] | string`
+    }
+    return generateTypeForDescriptor(type.typeArgs[0], currentAddress) + '[]'
+  }
+
+  const simpleName = generateSimpleType(type.qname, currentAddress)
+  if (simpleName.length === 0) {
+    console.error('unexpected error')
+  }
+  if (simpleName.includes('vector')) {
+    console.error('unexpected error')
+  }
+  if (type.typeArgs.length > 0) {
+    // return simpleName
+    return simpleName + '<' + type.typeArgs.map((t) => generateTypeForDescriptor(t, currentAddress)).join(',') + '>'
+  }
+  return simpleName
+}
+
+function generateSimpleType(type: string, currentAddress: string): string {
+  const parts = type.split(SPLITTER)
+
+  for (let i = 0; i < parts.length; i++) {
+    parts[i] = normalizeToJSName(parts[i])
+  }
+
+  if (parts.length < 2) {
+    return parts[0]
+  }
+  if (parts[0] === currentAddress) {
+    return parts.slice(1).join('.')
+  }
+  return '_' + parts.join('.')
+}
+
+// TODO ctx need to have type parameters
+export function generateType(type: string, currentAddress: string): string {
+  return generateTypeForDescriptor(parseMoveType(type), currentAddress)
+}
+
+export class AccountModulesImportInfo {
+  // account to module
+  imports: Map<string, Set<string>>
+  account: string
+  moduleName: string
+
+  constructor(account: string, tsModuleName: string) {
+    this.account = account
+    this.moduleName = tsModuleName
+    this.imports = new Map<string, Set<string>>()
+  }
+
+  addImport(account: string, module: string) {
+    if (account === this.account) {
+      return
+    }
+    let accountModules = this.imports.get(account)
+    if (!accountModules) {
+      accountModules = new Set<string>()
+      this.imports.set(account, accountModules)
+    }
+    accountModules.add(module)
+  }
+}
+
+export class AccountRegister {
+  accountImports = new Map<string, AccountModulesImportInfo>()
+  pendingAccounts = new Set<string>()
+
+  // loadedAccount = new Set<string>()
+  typeDescriptors = new Map<string, TypeDescriptor>()
+
+  private loadTypeDescriptor(type: string) {
+    let descriptor = this.typeDescriptors.get(type)
+
+    // const descriptparseMoveType(type)
+    if (!descriptor) {
+      descriptor = parseMoveType(type)
+      this.typeDescriptors.set(type, descriptor)
+    }
+    return descriptor
+  }
+
+  register(module: MoveModule, tsModuleName: string): AccountModulesImportInfo {
+    const currentModuleFqn = moduleQname(module)
+
+    let accountModuleImports = this.accountImports.get(module.address)
+    if (!accountModuleImports) {
+      accountModuleImports = new AccountModulesImportInfo(module.address, tsModuleName)
+      this.accountImports.set(module.address, accountModuleImports)
+      // the account has already be processed, delete pending task
+      this.pendingAccounts.delete(module.address)
+    }
+
+    for (const struct of module.structs) {
+      for (const field of struct.fields) {
+        for (const type of this.loadTypeDescriptor(field.type).dependedTypes()) {
+          const [account, module] = moduleQnameForType(type)
+          accountModuleImports.addImport(account, module)
+          if (!this.accountImports.has(account)) {
+            this.pendingAccounts.add(account)
+          }
+        }
+      }
+    }
+
+    for (const func of module.exposed_functions) {
+      if (!func.is_entry) {
+        continue
+      }
+      for (const param of func.params) {
+        for (const type of this.loadTypeDescriptor(param).dependedTypes()) {
+          const [account, module] = moduleQnameForType(type)
+          accountModuleImports.addImport(account, module)
+          if (!this.accountImports.has(account)) {
+            this.pendingAccounts.add(account)
+          }
+        }
+      }
+    }
+    this.accountImports.set(currentModuleFqn, accountModuleImports)
+    return accountModuleImports
+  }
+}
+
+export function normalizeToJSName(name: string) {
+  if (name === 'package' || name === 'volatile') {
+    return name + '_'
+  }
+  return name
+}