@typemove/aptos 1.0.0-rc.13 → 1.0.0-rc.15

package/src/codegen/codegen.ts

@@ -3,7 +3,7 @@ import { Event, MoveModuleBytecode, MoveResource } from '../move-types.js'
 import chalk from 'chalk'
 import { join } from 'path'
 import { AptosChainAdapter } from '../aptos-chain-adapter.js'
-import { AbstractCodegen } from '@typemove/move'
+import { AbstractCodegen, camel, InternalMoveFunction, InternalMoveModule, normalizeToJSName } from '@typemove/move'
 
 export async function codegen(
   abisDir: string,
@@ -20,10 +20,7 @@ export async function codegen(
   console.log(chalk.green(`Generated ${numFiles} for Aptos`))
 }
 
-class AptosCodegen extends AbstractCodegen<
-  MoveModuleBytecode,
-  Event | MoveResource
-> {
+class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | MoveResource> {
   ADDRESS_TYPE = 'Address'
   REFERENCE_TYPE = 'Address'
   PREFIX = 'Aptos'
@@ -33,10 +30,62 @@ class AptosCodegen extends AbstractCodegen<
     super(new AptosChainAdapter(endpoint))
   }
 
-  // generateImports(): string {
-  //   return `
-  //     ${super.generateImports()}
-  //     import { Address } from '@typemove/aptos'
-  //   `
-  // }
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { AptosClient } from 'aptos'
+    `
+  }
+  protected generateExtra(module: InternalMoveModule) {
+    // const funcs = module.exposedFunctions.map((f) =>
+    //     this.generateBuilderForFunction(module, f)
+    // )
+
+    const viewFuncs = module.exposedFunctions.map((f) => this.generateViewFunction(module, f))
+
+    // export namespace builder {
+    //   ${funcs.join('\n')}
+    // }
+
+    return `
+    export namespace view {
+      ${viewFuncs.join('\n')}
+    }
+    `
+  }
+
+  protected generateViewFunction(module: InternalMoveModule, func: InternalMoveFunction): string {
+    if (!func.isView) {
+      return ''
+    }
+    const genericString = this.generateFunctionTypeParameters(func)
+    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
+      return this.generateTypeForDescriptor(param, module.address)
+    })
+
+    const returns = func.return.map((param) => {
+      return this.generateTypeForDescriptor(param, module.address)
+    })
+
+    const typeParamArg = func.typeParams
+      .map((v, idx) => {
+        return `TypeDescriptor<T${idx}> | string`
+      })
+      .join(',')
+
+    // const args = this.generateArgs(module, func)
+
+    return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+    client: AptosClient,
+    request: {
+      type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}], 
+      arguments: [${fields.join(',')}]},
+    version?: bigint): Promise<[${returns.join(',')}]> {
+      const data = { ...request, function: "${module.address}::${module.name}::${func.name}", }
+      const res = await client.view(data, version?.toString())
+      const coder = defaultMoveCoder(client.nodeUrl)
+      const type = await coder.getMoveFunction("${module.address}::${module.name}::${func.name}")
+      return await coder.decodeArray(res, type.return) as any
+    }`
+  }
 }

package/src/to-internal.ts

@@ -7,16 +7,9 @@ import {
   parseMoveType,
 } from '@typemove/move'
 import { Types } from 'aptos'
-import {
-  MoveFunction,
-  MoveModuleBytecode,
-  MoveStruct,
-  MoveStructField,
-} from './move-types'
+import { MoveFunction, MoveModuleBytecode, MoveStruct, MoveStructField } from './move-types'
 
-export function toInternalModule(
-  module: MoveModuleBytecode
-): InternalMoveModule {
+export function toInternalModule(module: MoveModuleBytecode): InternalMoveModule {
   if (!module.abi) {
     throw Error('module with no ABI found')
   }
@@ -45,6 +38,7 @@ export function toInternalFunction(func: MoveFunction): InternalMoveFunction {
   return {
     typeParams: func.generic_type_params,
     isEntry: func.is_entry,
+    isView: func.is_view,
     name: func.name,
     params: func.params.map(parseMoveType),
     return: func.return.map(parseMoveType),
@@ -62,9 +56,7 @@ export function toInternalStruct(struct: MoveStruct): InternalMoveStruct {
   }
 }
 
-export function toInternalField(
-  module: MoveStructField
-): InternalMoveStructField {
+export function toInternalField(module: MoveStructField): InternalMoveStructField {
   return {
     name: module.name,
     type: parseMoveType(module.type),