@typemove/move 1.0.0-rc.5 → 1.0.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typemove/move",
-  "version": "1.0.0-rc.5",
+  "version": "1.0.0-rc.6",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/abstract-codegen.ts

@@ -26,17 +26,18 @@ interface OutputFile {
   fileContent: string
 }
 
-interface Config<NetworkType> {
+interface Config {
   fileName: string
   outputDir: string
-  network: NetworkType
+  // network: NetworkType
 }
 
 // TODO be able to generate cjs
-export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
-  TEST_NET: NetworkType
-  MAIN_NET: NetworkType
+export abstract class AbstractCodegen<ModuleTypes, StructType> {
+  // TEST_NET: NetworkType
+  // MAIN_NET: NetworkType
   ADDRESS_TYPE: string
+  REFERENCE_TYPE: string
   PREFIX: string
   STRUCT_FIELD_NAME: string = 'data'
   GENERATE_CLIENT = false
@@ -45,11 +46,9 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   SYSTEM_MODULES = new Set(['0x1', '0x2', '0x3'])
   ESM = true
 
-  chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>
+  chainAdapter: ChainAdapter<ModuleTypes, StructType>
 
-  protected constructor(
-    chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>
-  ) {
+  protected constructor(chainAdapter: ChainAdapter<ModuleTypes, StructType>) {
     this.chainAdapter = chainAdapter
   }
 
@@ -64,27 +63,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   async generate(
     srcDir: string,
     outputDir: string,
-    builtin = false
-  ): Promise<number> {
-    const num1 = await this.generateForNetwork(
-      srcDir,
-      outputDir,
-      this.MAIN_NET,
-      builtin
-    )
-    const num2 = await this.generateForNetwork(
-      path.join(srcDir, 'testnet'),
-      path.join(outputDir, 'testnet'),
-      this.TEST_NET,
-      builtin
-    )
-    return num1 + num2
-  }
-
-  async generateForNetwork(
-    srcDir: string,
-    outputDir: string,
-    network: NetworkType,
+    // network: NetworkType,
     builtin = false
   ) {
     if (!fs.existsSync(srcDir)) {
@@ -122,7 +101,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
       const codeGen = new AccountCodegen(this, loader, abi, modules, {
         fileName: path.basename(file, '.json'),
         outputDir: outputDir,
-        network,
+        // network,
       })
 
       outputs.push(...codeGen.generate())
@@ -131,13 +110,13 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     while (loader.pendingAccounts.size > 0) {
       for (const account of loader.pendingAccounts) {
         console.log(
-          `download dependent module for account ${account} at ${network}`
+          `download dependent module for account ${account} at ${this.chainAdapter.endpoint}`
         )
 
         try {
           const rawModules = await this.chainAdapter.fetchModules(
-            account,
-            network
+            account
+            // network
           )
           const modules = this.chainAdapter.toInternalModules(rawModules)
 
@@ -156,7 +135,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
             {
               fileName: account,
               outputDir: outputDir,
-              network,
+              // network,
             }
           )
 
@@ -196,26 +175,30 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     return outputs.length + 1
   }
 
-  generateNetworkOption(network: NetworkType) {
-    switch (network) {
-      case this.TEST_NET:
-        return 'TEST_NET'
-    }
-    return 'MAIN_NET'
-  }
+  // 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
+    allEventStructs: Map<string, InternalMoveStruct>
+    // network: NetworkType
   ) {
     return ''
   }
 
+  protected generateBuilder(module: InternalMoveModule) {
+    return ''
+  }
+
   generateModule(
     module: InternalMoveModule,
-    allEventStructs: Map<string, InternalMoveStruct>,
-    network: NetworkType
+    allEventStructs: Map<string, InternalMoveStruct>
+    // network: NetworkType
   ) {
     const qname = moduleQname(module)
     // const functions = this.GENERATE_ON_ENTRY
@@ -259,12 +242,13 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
 
     // TODO how to deal with callArgs
     return `
-  ${this.generateModuleExtra(module, allEventStructs, network)}
+  ${this.generateModuleExtra(module, allEventStructs)}
 
   export namespace ${moduleName} {
     ${structs.join('\n')}
     
     ${client}
+    ${this.generateBuilder(module)}
   }
   `
   }
@@ -445,7 +429,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     currentAddress: string
   ): string {
     if (type.reference) {
-      return this.ADDRESS_TYPE
+      return this.REFERENCE_TYPE
     }
 
     switch (type.qname) {
@@ -531,21 +515,33 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     }
     return '_' + parts.join('.')
   }
+
+  generateImports() {
+    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()}"
+    `
+    return imports
+  }
 }
 
-export class AccountCodegen<NetworkType, ModuleType, StructType> {
+export class AccountCodegen<ModuleType, StructType> {
   modules: InternalMoveModule[]
-  config: Config<NetworkType>
+  config: Config
   abi: ModuleType[]
   loader: AccountRegister
-  moduleGen: AbstractCodegen<NetworkType, ModuleType, StructType>
+  moduleGen: AbstractCodegen<ModuleType, StructType>
 
   constructor(
-    moduleGen: AbstractCodegen<NetworkType, ModuleType, StructType>,
+    moduleGen: AbstractCodegen<ModuleType, StructType>,
     loader: AccountRegister,
     abi: ModuleType[],
     modules: InternalMoveModule[],
-    config: Config<NetworkType>
+    config: Config
   ) {
     // const json = fs.readFileSync(config.srcFile, 'utf-8')
     this.moduleGen = moduleGen
@@ -584,7 +580,8 @@ export class AccountCodegen<NetworkType, ModuleType, StructType> {
         if (isFrameworkAccount(account) && !isFrameworkAccount(address)) {
           // Decide where to find runtime library
           moduleImports.push(
-            `import { _${account} } from "@typemove/${this.moduleGen.PREFIX.toLowerCase()}"`
+            `import { _${account} } from "@typemove/${this.moduleGen.PREFIX.toLowerCase()}/builtin"`
+            // `import _${account} = builtin._${account} `
           )
         } else {
           moduleImports.push(
@@ -596,14 +593,11 @@ export class AccountCodegen<NetworkType, ModuleType, StructType> {
       }
     }
 
-    let loadAllTypes = `loadAllTypes(defaultMoveCoder(${
-      this.moduleGen.PREFIX
-    }Network.${this.moduleGen.generateNetworkOption(this.config.network)}))`
+    let loadAllTypes = `loadAllTypes(defaultMoveCoder())`
 
     if (this.moduleGen.SYSTEM_MODULES.has(address)) {
       loadAllTypes = `
-        loadAllTypes(defaultMoveCoder(${this.moduleGen.PREFIX}Network.MAIN_NET))
-        loadAllTypes(defaultMoveCoder(${this.moduleGen.PREFIX}Network.TEST_NET))
+        loadAllTypes(defaultMoveCoder())
       `
     }
 
@@ -617,14 +611,12 @@ export class AccountCodegen<NetworkType, ModuleType, StructType> {
 
     /* Generated modules for account ${address} */
 
-    ${this.generateImports()}
+    ${this.moduleGen.generateImports()}
 
     ${moduleImports.join('\n')}
 
     ${this.modules
-      .map((m) =>
-        this.moduleGen.generateModule(m, eventsMap, this.config.network)
-      )
+      .map((m) => this.moduleGen.generateModule(m, eventsMap))
       .join('\n')}
 
     const MODULES = JSON.parse('${JSON.stringify(this.abi)}')
@@ -646,19 +638,4 @@ export class AccountCodegen<NetworkType, ModuleType, StructType> {
       },
     ]
   }
-
-  generateImports() {
-    const imports = `
-    import { TypeDescriptor, ANY_TYPE } from "@typemove/move"
-    import {
-      MoveCoder, defaultMoveCoder, TypedEventInstance, ${
-        this.moduleGen.PREFIX
-      }Network } from "@typemove/${this.moduleGen.PREFIX.toLowerCase()}"
-    import { ${
-      this.moduleGen.ADDRESS_TYPE
-    }, ModuleClient } from "@typemove/${this.moduleGen.PREFIX.toLowerCase()}"
-    `
-
-    return imports
-  }
 }

package/src/abstract-move-coder.ts

@@ -18,15 +18,15 @@ import {
 // import { bytesToBigInt } from '../utils/index.js'
 import { ChainAdapter } from './chain-adapter.js'
 
-export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
+export abstract class AbstractMoveCoder<ModuleType, StructType> {
   protected moduleMapping = new Map<string, InternalMoveModule>()
   private typeMapping = new Map<string, InternalMoveStruct>()
   private funcMapping = new Map<string, InternalMoveFunction>()
-  network: Network
-  adapter: ChainAdapter<Network, ModuleType, StructType>
+  // network: string
+  adapter: ChainAdapter<ModuleType, StructType>
 
-  protected constructor(network: Network) {
-    this.network = network
+  protected constructor(adapter: ChainAdapter<ModuleType, StructType>) {
+    this.adapter = adapter
   }
 
   contains(account: string, name: string) {
@@ -89,11 +89,9 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     const key = account + SPLITTER + module
     let resp = this.requestMap.get(account + SPLITTER + module)
     if (!resp) {
-      resp = this.adapter
-        .fetchModule(account, module, this.network)
-        .then((m) => {
-          return this.load(m)
-        })
+      resp = this.adapter.fetchModule(account, module).then((m) => {
+        return this.load(m)
+      })
       this.requestMap.set(key, resp)
     }
     await resp
@@ -118,11 +116,9 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     const key = account + SPLITTER + module
     let resp = this.requestMap.get(account + SPLITTER + module)
     if (!resp) {
-      resp = this.adapter
-        .fetchModule(account, module, this.network)
-        .then((m) => {
-          return this.load(m)
-        })
+      resp = this.adapter.fetchModule(account, module).then((m) => {
+        return this.load(m)
+      })
       this.requestMap.set(key, resp)
     }
     await resp

package/src/chain-adapter.ts

@@ -1,17 +1,16 @@
 import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import { TypeDescriptor } from './types.js'
 
-export abstract class ChainAdapter<NetworkType, ModuleType, StructType> {
-  abstract fetchModule(
-    account: string,
-    module: string,
-    network: NetworkType
-  ): Promise<ModuleType>
+export abstract class ChainAdapter<ModuleType, StructType> {
+  endpoint: string
 
-  abstract fetchModules(
-    account: string,
-    network: NetworkType
-  ): Promise<ModuleType[]>
+  constructor(endpoint: string) {
+    this.endpoint = endpoint
+  }
+
+  abstract fetchModule(account: string, module: string): Promise<ModuleType>
+
+  abstract fetchModules(account: string): Promise<ModuleType[]>
   abstract toInternalModules(modules: ModuleType[]): InternalMoveModule[]
 
   // Get all structs that represent Events

package/src/types.ts

@@ -88,7 +88,7 @@ export class TypeDescriptor<T = any> {
       return []
     }
 
-    if (this.qname.toLowerCase() === VECTOR_STR) {
+    if (this.isVector()) {
       return this.typeArgs[0].dependedTypes()
     }
 
@@ -117,6 +117,10 @@ export class TypeDescriptor<T = any> {
 
     return Array.from(types)
   }
+
+  isVector(): boolean {
+    return this.qname.toLowerCase() === VECTOR_STR
+  }
 }
 
 export function parseMoveType(type: string): TypeDescriptor {