@sentio/sdk 2.4.0-rc.1 → 2.5.0-rc.1

package/src/aptos/codegen/codegen.ts

@@ -1,21 +1,20 @@
 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 { MoveModuleBytecode, toNeutralModule } from '../move-types.js'
+import { moduleQname, SPLITTER, TypeDescriptor } from '../../move/index.js'
 import chalk from 'chalk'
-import { AptosNetwork, getAptosChainName } from '../network.js'
-import { parseMoveType } from '../types.js'
+import { AptosNetwork } from '../network.js'
 import { AptosClient } from 'aptos-sdk'
-import { camelCase } from 'lodash-es'
+import { getMeaningfulFunctionParams } from '../utils.js'
+import { NeutralMoveModule, NeutralMoveStruct } from '../../move/neutral-models.js'
+import { AbstractCodegen } from '../../move/abstract-codegen.js'
 
 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)
+  const gen = new AptosCodegen()
+  await gen.generate(abisDir, outDir)
 }
 
 function getRpcEndpoint(network: AptosNetwork): string {
@@ -30,432 +29,47 @@ 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)
-      }
-    }
-  }
+class AptosCodegen extends AbstractCodegen<MoveModuleBytecode[], AptosNetwork> {
+  ADDRESS_TYPE = 'Address'
+  MAIN_NET = AptosNetwork.MAIN_NET
+  TEST_NET = AptosNetwork.TEST_NET
+  PREFIX = 'Aptos'
 
-  for (const output of outputs) {
-    const content = format(output.fileContent, { parser: 'typescript' })
-    fs.writeFileSync(path.join(outputDir, output.fileName), content)
+  async fetchModules(account: string, network: AptosNetwork): Promise<MoveModuleBytecode[]> {
+    const client = getRpcClient(network)
+    return await client.getAccountModules(account)
   }
 
-  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)
+  toNeutral(modules: MoveModuleBytecode[]): NeutralMoveModule[] {
+    return modules.flatMap((m) => (m.abi ? [toNeutralModule(m)] : []))
   }
-}
-
-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
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    return getMeaningfulFunctionParams(params)
   }
 
-  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 { CallFilter } from "@sentio/sdk/move"
-    import { 
-      MoveCoder, AptosBindOptions, AptosBaseProcessor, 
-      TypedEventInstance, AptosNetwork, TypedEntryFunctionPayload,
-      AptosContext } from "@sentio/sdk/aptos"
-    import { MoveFetchConfig } from "@sentio/protos"
-    import { Address, MoveModule } from "@sentio/sdk/aptos"
-    `
-
-    const dependedAccounts: string[] = []
-
-    const moduleImports: string[] = []
-
-    const info = this.loader.accountImports.get(address)
+  getEventStructs(module: NeutralMoveModule) {
+    const qname = moduleQname(module)
+    const structMap = new Map<string, NeutralMoveStruct>()
+    const eventMap = new Map<string, NeutralMoveStruct>()
 
-    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)
-      }
+    for (const struct of module.structs) {
+      structMap.set(qname + SPLITTER + struct.name, struct)
     }
 
-    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)`
+    for (const struct of module.structs) {
+      for (const field of struct.fields) {
+        const t = 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)
           }
-          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?: MoveFetchConfig): ${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?: MoveFetchConfig): ${moduleName} {
-    this.onEvent(func, {
-      type: '${module.name}::${struct.name}'
-    },
-    fetchConfig)
-    return this
-  }
-  `
-  return source
-}
 
-function capitalizeFirstChar(input: string): string {
-  if (!input) {
-    return input
+    return eventMap
   }
-  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
 }

package/src/aptos/models.ts

@@ -25,13 +25,3 @@ export type TypedMoveResource<T> = MoveResource & {
   data_decoded: T
   type_arguments: string[]
 }
-
-export interface StructWithTag {
-  type: string
-  data: any
-}
-
-export interface StructWithType<T> extends StructWithTag {
-  data_decoded: T
-  type_arguments: string[]
-}

package/src/aptos/move-coder.ts

@@ -1,118 +1,25 @@
 import {
   Event,
-  MoveFunction,
   MoveModule,
+  MoveModuleBytecode,
   MoveResource,
-  MoveStruct,
+  toNeutralModule,
   TransactionPayload_EntryFunctionPayload,
 } from './move-types.js'
 
-import { getMeaningfulFunctionParams, moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
-import { parseMoveType, TypeDescriptor } from './types.js'
-import {
-  TypedEventInstance,
-  TypedMoveResource,
-  StructWithTag,
-  StructWithType,
-  TypedEntryFunctionPayload,
-} from './models.js'
-
-export class MoveCoder {
-  private moduleMapping = new Map<string, MoveModule>()
-  private typeMapping = new Map<string, MoveStruct>()
-  private funcMapping = new Map<string, MoveFunction>()
-
-  contains(account: string, name: string) {
-    return this.moduleMapping.has(account + '::' + name)
-  }
-
-  load(module: MoveModule) {
-    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)
-    }
+import { TypedEventInstance, TypedMoveResource, TypedEntryFunctionPayload } from './models.js'
+import { getMeaningfulFunctionParams } from './utils.js'
+import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
 
-    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)
+export class MoveCoder extends AbstractMoveCoder<Event | MoveResource> {
+  load(module: MoveModuleBytecode) {
+    if (!module.abi) {
+      throw Error('Module without abi')
     }
-  }
-
-  getMoveStruct(type: string): MoveStruct {
-    const struct = this.typeMapping.get(type)
-    if (!struct) {
-      throw new Error('Failed to load type' + type)
-    }
-    return struct
-  }
-
-  getMoveFunction(type: string): MoveFunction {
-    const func = this.funcMapping.get(type)
-    if (!func) {
-      throw new Error('Failed to load function' + type)
-    }
-    return func
-  }
-
-  decode(data: any, type: TypeDescriptor): any {
-    // process simple type
-    if (type.qname.startsWith('&')) {
-      return data
-    }
-    switch (type.qname) {
-      case 'signer': // TODO check this
-      case 'address':
-      case '0x1::string::String':
-      case 'bool':
-      case 'u8':
-      case 'u16':
-      case 'u32':
-        return data
-      case 'u64':
-      case 'u128':
-        return BigInt(data)
-    }
-
-    // process vector
-    if (type.qname === VECTOR_STR) {
-      // vector<u8> as hex string
-      if (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 = parseMoveType(field.type)
-      filedType = filedType.applyTypeArgs(typeCtx)
-      const value = this.decode(data[field.name], filedType)
-      typedData[field.name] = value
+    if (this.contains(module.abi.address, module.abi.name)) {
+      return
     }
-    return typedData
+    this.loadNeutral(toNeutralModule(module))
   }
 
   decodeEvent<T>(event: Event): TypedEventInstance<T> | undefined {
@@ -128,57 +35,16 @@ export class MoveCoder {
     return this.filterAndDecodeInternal(typeQname, resources)
   }
 
-  private filterAndDecodeInternal<T>(typeQname: string, structs: StructWithTag[]): StructWithType<T>[] {
-    if (!structs) {
-      return []
-    }
-    const results: StructWithType<T>[] = []
-    for (const resource of structs) {
-      if (resource.type.split('<')[0] !== typeQname) {
-        continue
-      }
-      const result = this.decodedInternal(resource)
-      if (result) {
-        results.push(result as StructWithType<T>)
-      }
-    }
-    return results
-  }
-
-  private decodedInternal<T>(typeStruct: StructWithTag): StructWithType<T> | undefined {
-    const registry = MOVE_CODER
-    // this.loadTypes(registry)
-    // TODO check if module is not loaded
-
-    const typeDescriptor = parseMoveType(typeStruct.type)
-    const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature())
-
-    let dataTyped = undefined
-    try {
-      dataTyped = registry.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 StructWithType<T>
-  }
-
   decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
-    const registry = MOVE_CODER
-    // this.loadTypes(registry)
     const argumentsTyped: any[] = []
 
     try {
-      const func = registry.getMoveFunction(payload.function)
-      const params = getMeaningfulFunctionParams(func)
+      const func = this.getMoveFunction(payload.function)
+      const params = getMeaningfulFunctionParams(func.params)
       for (const [idx, arg] of payload.arguments.entries()) {
         // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
-        const argType = parseMoveType(params[idx])
-        argumentsTyped.push(registry.decode(arg, argType))
+        const argType = params[idx]
+        argumentsTyped.push(this.decode(arg, argType))
       }
     } catch (e) {
       console.error('Decoding error for ', JSON.stringify(payload), e)