@sentio/sdk 1.20.1 → 1.21.0

package/src/aptos-codegen/codegen.ts

@@ -1,29 +1,81 @@
-import { MoveModuleBytecode } from 'aptos/src/generated'
 import fs from 'fs'
 import path from 'path'
-import { MoveFunction, MoveModule } from 'aptos/src/generated'
-import { MoveStruct } from 'aptos/src/generated/models/MoveStruct'
 import prettier from 'prettier'
+import { MoveFunction, MoveModule, MoveStruct, MoveModuleBytecode } from 'aptos/src/generated'
+import { generateType, AccountRegister } from './typegen'
+import { isFrameworkAccount } from '../aptos/utils'
+
+export function generate(srcDir: string, outputDir: string) {
+  const files = fs.readdirSync(srcDir)
+  outputDir = path.resolve(outputDir)
+
+  fs.mkdirSync(outputDir, { recursive: true })
+
+  const loader = new AccountRegister()
+
+  // The first path, identify import relation and module name (filename) of those imports
+  for (const file of files) {
+    if (!file.endsWith('.json')) {
+      continue
+    }
+    // Reading file is duplicated, but since they are small files probably file
+    // TODO add file manager class
+    const json = fs.readFileSync(path.join(srcDir, file), 'utf-8')
+    const modules = JSON.parse(json)
+
+    for (const module of modules) {
+      if (module.abi) {
+        loader.register(module.abi, path.basename(file, '.json'))
+      }
+    }
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.json')) {
+      continue
+    }
+    const codeGen = new AccountCodegen(loader, {
+      srcFile: path.join(srcDir, file),
+      outputDir: outputDir,
+    })
+
+    codeGen.generate()
+  }
+
+  // when generating user code, don't need to generate framework account
+  loader.pendingAccounts.delete('0x1')
+  loader.pendingAccounts.delete('0x2')
+  loader.pendingAccounts.delete('0x3')
+
+  if (loader.pendingAccounts.size > 0) {
+    // TODO automatic download dependencies
+    console.error('Missing ABIs from the following accounts', loader.pendingAccounts)
+  }
+}
 
 interface Config {
   srcFile: string
   outputDir: string
 }
 
-export class AptosCodegen {
+export class AccountCodegen {
   modules: MoveModuleBytecode[]
   config: Config
+  loader: AccountRegister
 
-  constructor(config: Config) {
+  constructor(loader: AccountRegister, config: Config) {
     const json = fs.readFileSync(config.srcFile, 'utf-8')
     this.modules = JSON.parse(json)
     this.config = config
+    this.loader = loader
   }
 
   generate() {
     if (!this.modules) {
       return
     }
+    const baseName = path.basename(this.config.srcFile, '.json')
+
     let address: string | undefined
     for (const module of this.modules) {
       if (module.abi && module.abi.address) {
@@ -34,7 +86,37 @@ export class AptosCodegen {
       return
     }
 
-    const imports = `import { aptos } from "@sentio/sdk"`
+    const imports = `
+    import { aptos } from "@sentio/sdk"
+    import { Address, MoveModule } from "aptos/src/generated"
+    `
+
+    const dependedAccounts: string[] = []
+
+    const moduleImports: string[] = []
+
+    const info = this.loader.accountImports.get(address)
+
+    if (info) {
+      for (const [account, moduleImported] of info.imports.entries()) {
+        // Remap to user's filename if possible, TODO codepath not well tested
+        let tsAccountModule = './' + (this.loader.accountImports.get(account)?.moduleName || account)
+        if (isFrameworkAccount(account) && !isFrameworkAccount(address)) {
+          // Decide where to find runtime library
+          let srcRoot = 'lib'
+          if (__dirname.includes('sdk/src/aptos-codegen')) {
+            srcRoot = 'src'
+          }
+          tsAccountModule = `@sentio/sdk/${srcRoot}/builtin/aptos/${account}`
+        }
+        const items = Array.from(moduleImported)
+        moduleImports.push(`import { ${items.join(',')} } from "${tsAccountModule}"`)
+
+        // Ideally we should use per module's load types, but it doesn't matter since we are loading the entire
+        // account modules anyway
+        items.forEach((m) => dependedAccounts.push(m))
+      }
+    }
 
     let source = `
     /* Autogenerated file. Do not edit manually. */
@@ -45,16 +127,27 @@ export class AptosCodegen {
   
     ${imports}
     
-    ${this.modules.map(generateModule).join('\n')}
+    ${moduleImports.join('\n')}
+    
+    ${this.modules.map((m) => generateModule(m, dependedAccounts)).join('\n')}
+    
+    function loadAllTypes(registry: aptos.TypeRegistry) {
+      ${dependedAccounts.map((m) => `${m}.loadTypes(registry)`).join('\n')}
+
+      ${this.modules
+        .map((m) => {
+          return `registry.load(${m.abi?.name}.ABI)`
+        })
+        .join('\n')}
+    }
     ` // source
 
-    const baseName = path.basename(this.config.srcFile, '.json')
     source = prettier.format(source, { parser: 'typescript' })
     fs.writeFileSync(path.join(this.config.outputDir, baseName + '.ts'), source)
   }
 }
 
-function generateModule(moduleByteCode: MoveModuleBytecode) {
+function generateModule(moduleByteCode: MoveModuleBytecode, dependedModules: string[]) {
   if (!moduleByteCode.abi) {
     return ''
   }
@@ -62,21 +155,125 @@ function generateModule(moduleByteCode: MoveModuleBytecode) {
 
   const functions = module.exposed_functions.map((f) => generateOnEntryFunctions(module, f)).filter((s) => s !== '')
   const events = module.structs.map((e) => generateOnEvents(module, e)).filter((s) => s !== '')
+  const structs = module.structs.map((s) => generateStructs(module, s))
+  const callArgs = module.exposed_functions.map((f) => generateCallArgsStructs(module, f))
 
-  return `
-  export class ${module.name} extends aptos.AptosBaseProcessor {
-    static DEFAULT_OPTIONS: aptos.NamedAptosBindOptions = {
+  let processor = ''
+  if (functions.length > 0 || events.length > 0) {
+    processor = `export class ${module.name} extends aptos.AptosBaseProcessor {
+
+    constructor(options: aptos.AptosBindOptions) {
+      super("${module.name}", options)
+    }
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions = {
       address: "${module.address}",
       network: aptos.AptosNetwork.TEST_NET       
     }
-    static bind(options = ${module.name}.DEFAULT_OPTIONS): ${module.name} {
-      return new ${module.name}({ ...options, name: "${module.name}" })
+
+    static bind(options: Partial<aptos.AptosBindOptions> = {}): ${module.name} {
+      return new ${module.name}({ ...${module.name}.DEFAULT_OPTIONS, ...options })
     }
     
     ${functions.join('\n')}
     
     ${events.join('\n')}
-  }`
+    
+    loadTypesInternal(registry: aptos.TypeRegistry) {
+      loadAllTypes(registry)
+    }
+  }
+  `
+  }
+
+  return `
+  ${processor}
+
+  export namespace ${module.name} {
+    ${structs.join('\n')}
+    
+    ${callArgs.join('\n')}
+       
+    export function loadTypes(registry: aptos.TypeRegistry) {
+      loadAllTypes(registry)
+    }
+    export const ABI: MoveModule = JSON.parse('${JSON.stringify(module)}')
+ }
+  `
+}
+
+function generateStructs(module: MoveModule, struct: MoveStruct) {
+  const genericString = generateStructTypeParameters(struct)
+
+  const fields = struct.fields.map((field) => {
+    return `${field.name}: ${generateType(field.type)}`
+  })
+
+  let eventPayload = ''
+  if (isEvent(struct)) {
+    eventPayload = `
+    export interface ${struct.name}Instance${genericString} extends 
+        aptos.TypedEventInstance<${struct.name}${genericString}> {
+      data_typed: ${struct.name}${genericString}
+    }
+    `
+  }
+
+  return `
+  export class ${struct.name}${genericString} {
+    ${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
+      })
+      .join(',')
+    genericString = `<${params}>`
+  }
+  return genericString
+}
+
+function generateStructTypeParameters(struct: MoveStruct) {
+  let genericString = ''
+
+  if (struct.generic_type_params && struct.generic_type_params.length > 0) {
+    const params = struct.generic_type_params
+      .map((v, idx) => {
+        return 'T' + idx
+      })
+      .join(',')
+    genericString = `<${params}>`
+  }
+  return genericString
+}
+
+function generateCallArgsStructs(module: MoveModule, func: MoveFunction) {
+  if (!func.is_entry) {
+    return
+  }
+
+  // the first param is always signer so ignore
+  // TODO check if there is any edge case
+  const fields = func.params.slice(1).map((param) => {
+    return `${generateType(param)}`
+  })
+
+  const camelFuncName = capitalizeFirstChar(camelize(func.name))
+
+  const genericString = generateFunctionTypeParameters(func)
+  return `
+  export interface ${camelFuncName}Payload${genericString} 
+      extends aptos.TypedEntryFunctionPayload<[${fields.join(',')}]> {
+    arguments_typed: [${fields.join(',')}]
+  }
+  `
 }
 
 function generateOnEntryFunctions(module: MoveModule, func: MoveFunction) {
@@ -84,9 +281,11 @@ function generateOnEntryFunctions(module: MoveModule, func: MoveFunction) {
     return ''
   }
 
+  const genericString = generateFunctionTypeParameters(func)
+
   const camelFuncName = capitalizeFirstChar(camelize(func.name))
   const source = `
-  onEntry${camelFuncName}(func: (call: aptos.TransactionPayload_EntryFunctionPayload, ctx: aptos.AptosContext) => void): ${module.name} {
+  onEntry${camelFuncName}${genericString}(func: (call: ${module.name}.${camelFuncName}Payload${genericString}, ctx: aptos.AptosContext) => void): ${module.name} {
     this.onEntryFunctionCall(func, {
       function: '${module.name}::${func.name}'
     })
@@ -96,15 +295,19 @@ function generateOnEntryFunctions(module: MoveModule, func: MoveFunction) {
   return source
 }
 
+function isEvent(struct: MoveStruct) {
+  return struct.abilities.includes('drop') && struct.abilities.includes('store') && struct.name.endsWith('Event')
+}
+
 function generateOnEvents(module: MoveModule, struct: MoveStruct): string {
   // for struct that has drop + store
-  if (!struct.abilities.includes('drop') || !struct.abilities.includes('store') || !struct.name.endsWith('Event')) {
+  if (!isEvent(struct)) {
     return ''
   }
   const source = `
-  onEvent${struct.name}(func: (event: aptos.Event, ctx: aptos.AptosContext) => void): ${module.name} {
+  onEvent${struct.name}(func: (event: ${module.name}.${struct.name}Instance, ctx: aptos.AptosContext) => void): ${module.name} {
     this.onEvent(func, {
-      type: '${module.address}::${module.name}::${struct.name}'
+      type: '${module.name}::${struct.name}'
     })
     return this
   }

package/src/aptos-codegen/typegen.test.ts

@@ -0,0 +1,29 @@
+import { parseMoveType } from './typegen'
+import { assert } from 'chai'
+
+describe('type gen', () => {
+  test('type gen for generic', async () => {
+    const res = parseMoveType('x<g1<a,g2<c,d>>,b,g3<a,b>,e>')
+
+    assert(res.qname === 'x')
+    assert(res.typeArgs[0].typeArgs[1].qname === 'g2')
+    assert(res.typeArgs[0].typeArgs[1].typeArgs[1].qname === 'd')
+  })
+
+  test('type gen for non generic', async () => {
+    const res = parseMoveType('xyz')
+
+    assert(res.qname === 'xyz')
+    assert(res.typeArgs.length === 0)
+  })
+
+  // test('type type gen', async () => {
+  //
+  //   const res = parseGenericType('x<g1<a,g2<c,d>>,b,g3<a,b>,e>')
+  //   console.log(res)
+  //
+  //   assert(res.symbol === 'x')
+  //   assert(res.typeParams[0].typeParams[1].symbol === "g2")
+  //   assert(res.typeParams[0].typeParams[1].typeParams[1].symbol === "d")
+  // })
+})

package/src/aptos-codegen/typegen.ts

@@ -0,0 +1,216 @@
+import { MoveModule } from 'aptos/src/generated'
+import { TypeDescriptor } from '../aptos/types'
+import { moduleQname, moduleQnameForType, SPLITTER, VECTOR_STR } from '../aptos/utils'
+
+function generateTypeForDescriptor(type: TypeDescriptor): 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]) + '[]'
+  }
+
+  const simpleName = generateSimpleType(type.qname)
+  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)).join(',') + '>'
+  }
+  return simpleName
+}
+
+function generateSimpleType(type: string): string {
+  const parts = type.split(SPLITTER)
+  if (parts.length < 2) {
+    return parts[0]
+  }
+
+  return parts.slice(1).join('.')
+}
+
+export function parseMoveType(type: string) {
+  // type = type.replace('&', '')
+
+  type = type.replace('&mut ', '&')
+
+  // TODO replace ' ' is not exactly safe, need to double check this
+  type = type.replace(' ', '')
+
+  const stack: TypeDescriptor[] = [new TypeDescriptor('')]
+  let buffer = []
+
+  // xxx:asdf<g1<a,<c,d>>, b, g2<a,b>, e>
+  for (let i = 0; i < type.length; i++) {
+    const ch = type[i]
+    if (ch === '<') {
+      // const symbol = type.slice(symbolStart, i)
+      // symbolStart =
+      const symbol = buffer.join('')
+      buffer = []
+      stack[stack.length - 1].qname = symbol
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+    if (ch === '>') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      continue
+    }
+    if (ch === ',') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      // continue parse next param
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+
+    buffer.push(ch)
+  }
+
+  if (buffer.length > 0) {
+    stack[stack.length - 1].qname = buffer.join('')
+  }
+
+  const res = stack.pop()
+  if (!res || stack.length > 0) {
+    throw Error('Uxpectecd stack size')
+  }
+  return res
+}
+
+// TODO ctx need to have type parameters
+export function generateType(type: string, ctx?: any): string {
+  return generateTypeForDescriptor(parseMoveType(type))
+}
+
+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>()
+  typeRegistry = new Map<string, TypeDescriptor>()
+
+  private loadTypeDescriptor(type: string) {
+    let descriptor = this.typeRegistry.get(type)
+
+    // const descriptparseMoveType(type)
+    if (!descriptor) {
+      descriptor = parseMoveType(type)
+      this.typeRegistry.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
+  }
+}

package/src/binds.ts

@@ -3,54 +3,20 @@ import { BaseProcessor, ContractView } from './core'
 import { Networkish } from '@ethersproject/networks'
 import { getNetwork } from '@ethersproject/providers'
 import { BaseContract } from 'ethers'
-import { ContractNamer } from './contract-namer'
 
 function getKey(abiName: string, address: string, network: Networkish) {
   const chainId = getNetwork(network).chainId.toString()
   return [abiName, address.toLowerCase(), chainId].join('_')
 }
 
-// TODO move to processor state
-const addressToName = new Map<string, string>()
-const namerMap = new Map<string, ContractNamer>()
-
-// Get contract name by ABI, and other options
-// If there is contract using same ABI and different (address, network) pair
-// It will be renamed as ABI, ABI_1, ABI_2
-// Otherwise just use same contract name
-export function getContractName(
-  abiName: string,
-  contractName: string | undefined,
-  address: string,
-  network: Networkish = 1
-): string {
-  const key = getKey(abiName, address, network)
-  let name = addressToName.get(key)
-  if (name) {
-    return name
-  }
-  if (contractName) {
-    addressToName.set(key, contractName)
-    return contractName
-  }
-
-  let namer = namerMap.get(abiName)
-  if (!namer) {
-    namer = new ContractNamer(abiName)
-    namerMap.set(abiName, namer)
-  }
-  name = namer.nextName()
-  addressToName.set(key, name)
-  return name
-}
-
-export function getProcessor(abiName: string, opts: BindOptions) {
-  const sig = abiName + '_' + getOptionsSignature(opts)
+// Dedup processor that bind multiple times
+export function getProcessor(opts: BindOptions) {
+  const sig = getOptionsSignature(opts)
   return global.PROCESSOR_STATE.processorMap.get(sig)
 }
 
-export function addProcessor(abiName: string, opts: BindOptions, processor: BaseProcessor<any, any>) {
-  const sig = abiName + '_' + getOptionsSignature(opts)
+export function addProcessor(opts: BindOptions, processor: BaseProcessor<any, any>) {
+  const sig = getOptionsSignature(opts)
 
   global.PROCESSOR_STATE.processors.push(processor)
   global.PROCESSOR_STATE.processorMap.set(sig, processor)