@typemove/aptos 1.2.9 → 1.3.0-rc.1

package/src/codegen/codegen.ts

@@ -1,10 +1,9 @@
 import * as fs from 'fs'
-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, camel, InternalMoveFunction, InternalMoveModule, normalizeToJSName } from '@typemove/move'
-import { AptosClient } from 'aptos'
+import { Aptos, AptosConfig, Event, MoveModuleBytecode, MoveResource } from '@aptos-labs/ts-sdk'
 
 export async function codegen(
   abisDir: string,
@@ -34,18 +33,18 @@ export async function codegen(
 }
 
 export class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | MoveResource> {
-  ADDRESS_TYPE = 'Address'
+  ADDRESS_TYPE = 'MoveAddressType'
   PREFIX = 'Aptos'
   SYSTEM_PACKAGE = '@typemove/aptos'
 
   constructor(endpoint: string) {
-    super(new AptosChainAdapter(new AptosClient(endpoint)))
+    super(new AptosChainAdapter(new Aptos(new AptosConfig({ fullnode: endpoint }))))
   }
 
   generateImports(): string {
     return `
       ${super.generateImports()}
-      import { AptosClient, AptosAccount, TransactionBuilderRemoteABI, Types, TxnBuilderTypes, OptionalTransactionArgs } from 'aptos'
+      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId, InputViewRequestData } from '@aptos-labs/ts-sdk'
     `
   }
   protected generateExtra(module: InternalMoveModule) {
@@ -87,20 +86,20 @@ export class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | Mo
     const requestArg = allEmpty
       ? ''
       : `request: {
-      ${func.typeParams.length > 0 ? `type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}],` : ''}
-      ${func.params.length > 0 ? `arguments: [${fields.join(',')}]` : ''}},`
+      ${func.typeParams.length > 0 ? `typeArguments: [${func.typeParams.map((_) => 'MoveStructId').join(', ')}],` : ''}
+      ${func.params.length > 0 ? `functionArguments: [${fields.join(',')}]` : ''}},`
 
     return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
-    client: AptosClient,
+    client: Aptos,
     ${requestArg}
     version?: bigint): Promise<[${returns.join(',')}]> {
-      const coder = defaultMoveCoder(client.nodeUrl)
-      const data = { 
-        type_arguments:  ${func.typeParams.length > 0 ? 'request.type_arguments' : '[]'},
-        arguments: ${func.params.length > 0 ? 'coder.encodeArray(request.arguments)' : '[]'},
-        function: "${module.address}::${module.name}::${func.name}"
+      const coder = defaultMoveCoder(client.config.fullnode)        
+      const data: InputViewRequestData = {
+        function: "${module.address}::${module.name}::${func.name}",
+        functionArguments: ${func.params.length > 0 ? 'coder.encodeArray(request.functionArguments)' : '[]'},
+        typeArguments: ${func.typeParams.length > 0 ? 'request.typeArguments' : '[]'},
       }
-      const res = await client.view(data, version?.toString())
+      const res = await client.view({payload: data, options: { ledgerVersion: version } });
       const type = await coder.getMoveFunction("${module.address}::${module.name}::${func.name}")
       return await coder.decodeArray(res, type.return) as any
     }`
@@ -124,21 +123,25 @@ export class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | Mo
     // const args = this.generateArgs(module, func)
 
     return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
-      client: AptosClient,
+      client: Aptos,
       account: AptosAccount,
       request: {
-        type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}], 
-        arguments: [${fields.join(',')}]
+        typeArguments: [${func.typeParams.map((_) => 'MoveStructId').join(', ')}], 
+        functionArguments: [${fields.join(',')}]
       },
-      extraArgs?: OptionalTransactionArgs
-    ): Promise<Types.PendingTransaction> {
-      const coder = defaultMoveCoder(client.nodeUrl)
-      const builder = new TransactionBuilderRemoteABI(client, { sender: account.address(), ...extraArgs });
-      const txn = await builder.build("${module.address}::${module.name}::${
-        func.name
-      }", request.type_arguments, coder.encodeArray(request.arguments))
-      const bcsTxn = AptosClient.generateBCSTransaction(account, txn)
-      return await client.submitSignedBCSTransaction(bcsTxn)
+      options?: InputGenerateTransactionOptions
+    ): Promise<PendingTransactionResponse> {
+      const coder = defaultMoveCoder(client.config.fullnode)  
+      const transaction = await client.build.simple({
+        sender: account.accountAddress,
+        data: {
+          function: "${module.address}::${module.name}::${func.name}",
+          functionArguments: ${func.params.length > 0 ? 'coder.encodeArray(request.functionArguments)' : '[]'},
+          typeArguments: ${func.typeParams.length > 0 ? 'request.typeArguments' : '[]'},
+        },
+        options
+      })
+      return await client.signAndSubmitTransaction({ signer: account, transaction });
     }`
   }
 }

package/src/codegen/run.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { codegen } from './codegen.js'
-import { AptosClient } from 'aptos'
+import { Aptos, AptosConfig } from '@aptos-labs/ts-sdk'
 import * as path from 'path'
 import * as fs from 'fs'
 import { Command } from 'commander'
@@ -32,17 +32,17 @@ program
   .action(async (location, options) => {
     let endpoint = options.network
     if (endpoint == 'mainnet') {
-      endpoint = 'https://mainnet.aptoslabs.com/'
+      endpoint = 'https://mainnet.aptoslabs.com/v1'
     }
     if (endpoint == 'testnet') {
-      endpoint = 'https://testnet.aptoslabs.com/'
+      endpoint = 'https://testnet.aptoslabs.com/v1'
     }
-    const aptosClient = new AptosClient(endpoint)
+    const aptosClient = new Aptos(new AptosConfig({ fullnode: endpoint }))
 
     let abisDir = location
     if (location.startsWith('0x')) {
       const abiAddress = abisDir
-      const abi = await aptosClient.getAccountModules(abiAddress)
+      const abi = await aptosClient.getAccountModules({ accountAddress: abiAddress })
       abisDir = options.abiDir
       if (!fs.existsSync(abisDir)) {
         fs.mkdirSync(abisDir, { recursive: true })

package/src/models.ts

@@ -1,18 +1,13 @@
-import {
-  Event,
-  MoveResource,
-  TransactionPayload_EntryFunctionPayload,
-} from './move-types.js'
 import { DecodedStruct } from '@typemove/move'
+import { EntryFunctionPayloadResponse, MoveResource, Event } from '@aptos-labs/ts-sdk'
 
 export type TypedEventInstance<T> = DecodedStruct<Event, T>
 export type TypedMoveResource<T> = DecodedStruct<MoveResource, T>
 
 // Don't use intermediate type to make IDE happier
-export type TypedFunctionPayload<T extends Array<any>> =
-  TransactionPayload_EntryFunctionPayload & {
-    /**
-     * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-     */
-    arguments_decoded: T
-  }
+export type TypedFunctionPayload<T extends Array<any>> = EntryFunctionPayloadResponse & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}

package/src/move-coder.ts

@@ -1,12 +1,18 @@
 import { AbstractMoveCoder, InternalMoveModule, parseMoveType, TypeDescriptor } from '@typemove/move'
-import { Event, MoveModuleBytecode, MoveResource, TransactionPayload_EntryFunctionPayload } from './move-types.js'
 import { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './models.js'
 import { AptosChainAdapter } from './aptos-chain-adapter.js'
 import { toInternalModule } from './to-internal.js'
-import { AptosClient } from 'aptos'
+import {
+  Aptos,
+  AptosConfig,
+  EntryFunctionPayloadResponse,
+  Event,
+  MoveModuleBytecode,
+  MoveResource
+} from '@aptos-labs/ts-sdk'
 
 export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | MoveResource> {
-  constructor(client: AptosClient) {
+  constructor(client: Aptos) {
     super(new AptosChainAdapter(client))
   }
 
@@ -27,12 +33,14 @@ export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | Mov
   }
 
   decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
+    // TODO fix type
     return this.decodedStruct(event)
   }
   filterAndDecodeEvents<T>(type: string | TypeDescriptor<T>, resources: Event[]): Promise<TypedEventInstance<T>[]> {
     if (typeof type === 'string') {
       type = parseMoveType(type)
     }
+    // TODO fix type
     return this.filterAndDecodeStruct(type, resources)
   }
   decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
@@ -48,9 +56,9 @@ export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | Mov
     return this.filterAndDecodeStruct(type, resources)
   }
 
-  async decodeFunctionPayload(
-    payload: TransactionPayload_EntryFunctionPayload
-  ): Promise<TransactionPayload_EntryFunctionPayload> {
+  async decodeFunctionPayload<T extends Array<any>>(
+    payload: EntryFunctionPayloadResponse
+  ): Promise<TypedFunctionPayload<T>> {
     const func = await this.getMoveFunction(payload.function)
     const params = this.adapter.getMeaningfulFunctionParams(func.params)
     const argumentsDecoded = await this.decodeArray(payload.arguments, params)
@@ -58,7 +66,7 @@ export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | Mov
     return {
       ...payload,
       arguments_decoded: argumentsDecoded
-    } as TypedFunctionPayload<any>
+    } as TypedFunctionPayload<T>
   }
 }
 
@@ -72,13 +80,14 @@ export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | Mov
 //   return TESTNET_MOVE_CODER
 // }
 
-const DEFAULT_ENDPOINT = 'https://mainnet.aptoslabs.com/'
+const DEFAULT_ENDPOINT = 'https://mainnet.aptoslabs.com/v1'
 const CODER_MAP = new Map<string, MoveCoder>()
 
 export function defaultMoveCoder(endpoint: string = DEFAULT_ENDPOINT): MoveCoder {
   let coder = CODER_MAP.get(endpoint)
   if (!coder) {
-    coder = new MoveCoder(new AptosClient(endpoint))
+    const config = new AptosConfig({ fullnode: endpoint })
+    coder = new MoveCoder(new Aptos(config))
     CODER_MAP.set(endpoint, coder)
   }
   return coder

package/src/move-types.ts

@@ -1,13 +1,14 @@
-import { Types } from 'aptos'
+// import {  MoveModule } from '@aptos-labs/ts-sdk'
 
-export type Address = Types.Address
-export type Event = Types.Event
-export type MoveFunction = Types.MoveFunction
-export type MoveModule = Types.MoveModule
-export type MoveResource = Types.MoveResource
-export type MoveStruct = Types.MoveStruct
-export type MoveStructField = Types.MoveStructField
-export type MoveModuleBytecode = Types.MoveModuleBytecode
-export type TransactionPayload_EntryFunctionPayload =
-  Types.TransactionPayload_EntryFunctionPayload
-export type Transaction_UserTransaction = Types.Transaction_UserTransaction
+export type Address = string
+
+// export type {
+//   MoveAddressType,
+//   Event,
+//   MoveFunction,
+//   MoveModule,
+//   MoveResource,
+//   MoveStruct,
+//   MoveStructField,
+//   MoveModuleBytecode
+// } from '@aptos-labs/ts-sdk'