@typemove/move 1.0.0-rc.9 → 1.0.1-rc.1

package/src/abstract-codegen.ts

@@ -1,23 +1,10 @@
-import {
-  InternalMoveFunction,
-  InternalMoveFunctionVisibility,
-  InternalMoveModule,
-  InternalMoveStruct,
-} from './internal-models.js'
+import { InternalMoveFunction, InternalMoveModule, InternalMoveStruct } from './internal-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,
-  upperFirst,
-  VECTOR_STR,
-  camel,
-} from './utils.js'
+import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER, VECTOR_STR } from './utils.js'
 import { TypeDescriptor } from './types.js'
 import { ChainAdapter } from './chain-adapter.js'
 
@@ -34,14 +21,10 @@ interface Config {
 
 // TODO be able to generate cjs
 export abstract class AbstractCodegen<ModuleTypes, StructType> {
-  // TEST_NET: NetworkType
-  // MAIN_NET: NetworkType
   ADDRESS_TYPE: string
-  REFERENCE_TYPE: string
+  SYSTEM_PACKAGE: string
   PREFIX: string
   STRUCT_FIELD_NAME: string = 'data'
-  GENERATE_CLIENT = false
-  GENERATE_ON_ENTRY = true
   PAYLOAD_OPTIONAL = false
   SYSTEM_MODULES = new Set(['0x1', '0x2', '0x3'])
   ESM = true
@@ -60,6 +43,14 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
     return JSON.parse(fs.readFileSync(fullPath, 'utf-8'))
   }
 
+  protected defaultCoderPackage() {
+    return `@typemove/${this.PREFIX.toLowerCase()}`
+  }
+
+  generateLoadAll(isSystem: boolean): string {
+    return 'loadAllTypes(defaultMoveCoder())'
+  }
+
   async generate(
     srcDir: string,
     outputDir: string,
@@ -80,10 +71,7 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
 
     // when generating user code, don't need to generate framework account
     for (const sysModule of this.SYSTEM_MODULES) {
-      loader.accountImports.set(
-        sysModule,
-        new AccountModulesImportInfo(sysModule, sysModule)
-      )
+      loader.accountImports.set(sysModule, new AccountModulesImportInfo(sysModule, sysModule))
     }
     // const client = getRpcClient(network)
 
@@ -100,7 +88,7 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
       }
       const codeGen = new AccountCodegen(this, loader, abi, modules, {
         fileName: path.basename(file, '.json'),
-        outputDir: outputDir,
+        outputDir: outputDir
         // network,
       })
 
@@ -109,9 +97,7 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
 
     while (loader.pendingAccounts.size > 0) {
       for (const account of loader.pendingAccounts) {
-        console.log(
-          `download dependent module for account ${account} at ${this.chainAdapter.endpoint}`
-        )
+        console.log(`download dependent module for account ${account} at ${this.chainAdapter.endpoint}`)
 
         try {
           const rawModules = await this.chainAdapter.fetchModules(
@@ -120,24 +106,15 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
           )
           const modules = this.chainAdapter.toInternalModules(rawModules)
 
-          fs.writeFileSync(
-            path.resolve(srcDir, account + '.json'),
-            JSON.stringify(rawModules, null, '\t')
-          )
+          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,
-            }
-          )
+          const codeGen = new AccountCodegen(this, loader, rawModules, modules, {
+            fileName: account,
+            outputDir: outputDir
+            // network,
+          })
 
           outputs.push(...codeGen.generate())
         } catch (e) {
@@ -154,7 +131,7 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
 
     for (const output of outputs) {
       // const content = output.fileContent
-      const content = format(output.fileContent, { parser: 'typescript' })
+      const content = await format(output.fileContent, { parser: 'typescript' })
       fs.writeFileSync(path.join(outputDir, output.fileName), content)
     }
 
@@ -165,33 +142,16 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
 `
     for (const output of outputs) {
       const parsed = path.parse(output.fileName)
-      rootFileContent += `export * as _${parsed.name.replaceAll(
-        '-',
-        '_'
-      )} from './${parsed.name}${this.maybeEsmPrefix()}'\n`
+      rootFileContent += `export * as _${parsed.name.replaceAll('-', '_')} from './${
+        parsed.name
+      }${this.maybeEsmPrefix()}'\n`
     }
     fs.writeFileSync(rootFile, rootFileContent)
 
     return outputs.length + 1
   }
 
-  // generateNetworkOption(network: NetworkType) {
-  //   switch (network) {
-  //     case this.TEST_NET:
-  //       return 'TEST_NET'
-  //   }
-  //   return 'MAIN_NET'
-  // }
-
-  protected generateModuleExtra(
-    module: InternalMoveModule,
-    allEventStructs: Map<string, InternalMoveStruct>
-    // network: NetworkType
-  ) {
-    return ''
-  }
-
-  protected generateBuilder(module: InternalMoveModule) {
+  protected generateExtra(module: InternalMoveModule) {
     return ''
   }
 
@@ -201,16 +161,6 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
     // network: NetworkType
   ) {
     const qname = moduleQname(module)
-    // const functions = this.GENERATE_ON_ENTRY
-    //   ? module.exposedFunctions
-    //       .map((f) => this.generateForEntryFunctions(module, f))
-    //       .filter((s) => s !== '')
-    //   : []
-    const clientFunctions = this.GENERATE_CLIENT
-      ? module.exposedFunctions
-          .map((f) => this.generateClientFunctions(module, f))
-          .filter((s) => s !== '')
-      : []
     const eventStructs = new Map<string, InternalMoveStruct>()
     for (const [type, struct] of allEventStructs.entries()) {
       if (type.startsWith(qname + SPLITTER)) {
@@ -222,43 +172,25 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
     const events = Array.from(eventStructs.values())
       .map((e) => this.generateForEvents(module, e))
       .filter((s) => s !== '')
-    const structs = module.structs.map((s) =>
-      this.generateStructs(module, s, eventTypes)
-    )
-    const callArgs = module.exposedFunctions.map((f) =>
-      this.generateCallArgsStructs(module, f)
-    )
+    const structs = module.structs.map((s) => this.generateStructs(module, s, eventTypes))
+    const callArgs = module.exposedFunctions.map((f) => this.generateCallArgsStructs(module, f))
 
     const moduleName = normalizeToJSName(module.name)
-    let client = ''
-
-    if (clientFunctions.length > 0) {
-      client = `
-      export class Client extends ModuleClient {
-        ${clientFunctions.join('\n')}
-      }
-      `
-    }
-
-    // TODO how to deal with callArgs
     return `
-  ${this.generateModuleExtra(module, allEventStructs)}
 
   export namespace ${moduleName} {
     ${structs.join('\n')}
     
-    ${client}
-    ${this.generateBuilder(module)}
+    ${this.generateExtra(module)}
+    
+    ${events.join('\n')}
+    
+    ${callArgs.join('\n')}
   }
   `
   }
 
-  generateStructs(
-    module: InternalMoveModule,
-    struct: InternalMoveStruct,
-    events: Set<string>,
-    typeOnly = false
-  ) {
+  generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>, typeOnly = false) {
     const typeParams = struct.typeParams || []
     const genericString = this.generateStructTypeParameters(struct)
     const genericStringAny = this.generateStructTypeParameters(struct, true)
@@ -359,91 +291,17 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
   //   return genericString
   // }
 
-  generateCallArgsStructs(
-    module: InternalMoveModule,
-    func: InternalMoveFunction
-  ) {
-    if (!func.isEntry) {
-      return
-    }
-
-    const fields = this.chainAdapter
-      .getMeaningfulFunctionParams(func.params)
-      .map((param) => {
-        return (
-          this.generateTypeForDescriptor(param, module.address) +
-          (this.PAYLOAD_OPTIONAL ? ' | undefined' : '')
-        )
-      })
-
-    const camelFuncName = upperFirst(camel(func.name))
-
-    const genericString = this.generateFunctionTypeParameters(func)
-    return `
-  export interface ${camelFuncName}Payload${genericString}
-      extends TypedFunctionPayload<[${fields.join(',')}]> {
-    arguments_decoded: [${fields.join(',')}],
-    type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}]
-  }
-  `
-  }
-
-  generateClientFunctions(
-    module: InternalMoveModule,
-    func: InternalMoveFunction
-  ) {
-    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
-      return ''
-    }
-    if (func.isEntry) {
-      return ''
-    }
-    // const moduleName = normalizeToJSName(module.name)
-    const funcName = camel(func.name)
-    const fields = this.chainAdapter
-      .getMeaningfulFunctionParams(func.params)
-      .map((param) => {
-        return this.generateTypeForDescriptor(param, module.address)
-      })
-    const genericString = this.generateFunctionTypeParameters(func)
-
-    const returns = func.return.map((param) => {
-      return this.generateTypeForDescriptor(param, module.address)
-    })
-
-    const source = `
-  ${funcName}${genericString}(type_arguments: [${func.typeParams
-      .map((_) => 'string')
-      .join(', ')}], args: [${fields.join(
-      ','
-    )}], version?: bigint): Promise<[${returns.join(',')}]> {
-    return this.viewDecoded('${module.address}::${module.name}::${
-      func.name
-    }', type_arguments, args, version) as any
-  }`
-    return source
+  generateCallArgsStructs(module: InternalMoveModule, func: InternalMoveFunction) {
+    return ''
   }
 
-  // generateForEntryFunctions(
-  //   module: InternalMoveModule,
-  //   func: InternalMoveFunction
-  // ) {
-  //   return ''
-  // }
-
-  generateForEvents(
-    module: InternalMoveModule,
-    struct: InternalMoveStruct
-  ): string {
+  generateForEvents(module: InternalMoveModule, struct: InternalMoveStruct): string {
     return ''
   }
 
-  generateTypeForDescriptor(
-    type: TypeDescriptor,
-    currentAddress: string
-  ): string {
+  generateTypeForDescriptor(type: TypeDescriptor, currentAddress: string): string {
     if (type.reference) {
-      return this.REFERENCE_TYPE
+      return this.ADDRESS_TYPE
     }
 
     switch (type.qname) {
@@ -479,36 +337,23 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
         // only for aptos
         return 'string'
       }
-      if (
-        elementTypeQname.startsWith('T') &&
-        !elementTypeQname.includes(SPLITTER)
-      ) {
+      if (elementTypeQname.startsWith('T') && !elementTypeQname.includes(SPLITTER)) {
         return `${elementTypeQname}[] | string`
       }
-      return (
-        this.generateTypeForDescriptor(type.typeArgs[0], currentAddress) + '[]'
-      )
+      return this.generateTypeForDescriptor(type.typeArgs[0], currentAddress) + '[]'
     }
 
     const simpleName = this.generateSimpleType(type.qname, currentAddress)
     if (simpleName.length === 0) {
       console.error('unexpected error')
     }
-    if (
-      simpleName.toLowerCase() === VECTOR_STR ||
-      simpleName.toLowerCase().startsWith(VECTOR_STR + SPLITTER)
-    ) {
+    if (simpleName.toLowerCase() === VECTOR_STR || simpleName.toLowerCase().startsWith(VECTOR_STR + SPLITTER)) {
       console.error('unexpected vector type error')
     }
     if (type.typeArgs.length > 0) {
       // return simpleName
       return (
-        simpleName +
-        '<' +
-        type.typeArgs
-          .map((t) => this.generateTypeForDescriptor(t, currentAddress))
-          .join(',') +
-        '>'
+        simpleName + '<' + type.typeArgs.map((t) => this.generateTypeForDescriptor(t, currentAddress)).join(',') + '>'
       )
     }
     return simpleName
@@ -531,13 +376,19 @@ export abstract class AbstractCodegen<ModuleTypes, StructType> {
   }
 
   generateImports() {
+    let refImports = `import { ${this.ADDRESS_TYPE} } from "${this.SYSTEM_PACKAGE}"`
+    if (this.ADDRESS_TYPE === 'string') {
+      refImports = ''
+    }
+
     const imports = `
     import { TypeDescriptor, ANY_TYPE } from "@typemove/move"
     import {
-      MoveCoder, defaultMoveCoder, TypedEventInstance } from "@typemove/${this.PREFIX.toLowerCase()}"
-    import { ${this.ADDRESS_TYPE}, ${
-      this.ADDRESS_TYPE === this.REFERENCE_TYPE ? '' : `${this.REFERENCE_TYPE},`
-    } ModuleClient } from "@typemove/${this.PREFIX.toLowerCase()}"
+      MoveCoder, TypedEventInstance } from "@typemove/${this.PREFIX.toLowerCase()}"
+      
+    import { defaultMoveCoder } from "${this.defaultCoderPackage()}"
+
+    ${refImports}
     `
     return imports
   }
@@ -588,9 +439,7 @@ export class AccountCodegen<ModuleType, StructType> {
     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)
+        const tsAccountModule = './' + (this.loader.accountImports.get(account)?.moduleName || account)
         if (isFrameworkAccount(account) && !isFrameworkAccount(address)) {
           // Decide where to find runtime library
           moduleImports.push(
@@ -598,25 +447,14 @@ export class AccountCodegen<ModuleType, StructType> {
             // `import _${account} = builtin._${account} `
           )
         } else {
-          moduleImports.push(
-            `import * as _${account} from "${tsAccountModule}${this.moduleGen.maybeEsmPrefix()}"`
-          )
+          moduleImports.push(`import * as _${account} from "${tsAccountModule}${this.moduleGen.maybeEsmPrefix()}"`)
         }
 
         dependedAccounts.push(account)
       }
     }
 
-    let loadAllTypes = `loadAllTypes(defaultMoveCoder())`
-
-    if (this.moduleGen.SYSTEM_MODULES.has(address)) {
-      loadAllTypes = `
-        loadAllTypes(defaultMoveCoder())
-      `
-    }
-
-    const eventsMap: Map<string, InternalMoveStruct> =
-      this.moduleGen.chainAdapter.getAllEventStructs(this.modules)
+    const eventsMap: Map<string, InternalMoveStruct> = this.moduleGen.chainAdapter.getAllEventStructs(this.modules)
 
     const source = `
     /* Autogenerated file. Do not edit manually. */
@@ -629,9 +467,7 @@ export class AccountCodegen<ModuleType, StructType> {
 
     ${moduleImports.join('\n')}
 
-    ${this.modules
-      .map((m) => this.moduleGen.generateModule(m, eventsMap))
-      .join('\n')}
+    ${this.modules.map((m) => this.moduleGen.generateModule(m, eventsMap)).join('\n')}
 
     const MODULES = JSON.parse('${JSON.stringify(this.abi)}')
 
@@ -641,15 +477,15 @@ export class AccountCodegen<ModuleType, StructType> {
         coder.load(m as any)
       }
     }
-
-    ${loadAllTypes}
+    
+    ${this.moduleGen.generateLoadAll(this.moduleGen.SYSTEM_MODULES.has(address))}
     ` // source
 
     return [
       {
         fileName: this.config.fileName + '.ts',
-        fileContent: source,
-      },
+        fileContent: source
+      }
     ]
   }
 }