@typemove/aptos 1.2.4 → 1.2.5-rc.1

package/src/builtin/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as _0x1 from './0x1.js'
+export * as _0x3 from './0x3.js'

package/src/codegen/codegen.ts

@@ -0,0 +1,132 @@
+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'
+
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'aptos'),
+  endpoint: string,
+  genExample = false,
+  builtin = false
+) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+  const gen = new AptosCodegen(endpoint)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
+  console.log(chalk.green(`Generated ${numFiles} for Aptos`))
+}
+
+export class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | MoveResource> {
+  ADDRESS_TYPE = 'Address'
+  PREFIX = 'Aptos'
+  SYSTEM_PACKAGE = '@typemove/aptos'
+
+  constructor(endpoint: string) {
+    super(new AptosChainAdapter(new AptosClient(endpoint)))
+  }
+
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { AptosClient, AptosAccount, TransactionBuilderRemoteABI, Types, TxnBuilderTypes, OptionalTransactionArgs } from 'aptos'
+    `
+  }
+  protected generateExtra(module: InternalMoveModule) {
+    const funcs = module.exposedFunctions.map((f) => this.generateEntryForFunction(module, f))
+
+    const viewFuncs = module.exposedFunctions.map((f) => this.generateViewFunction(module, f))
+
+    return `
+    export namespace entry {
+      ${funcs.join('\n')}
+    }
+    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)
+    const allEmpty = func.typeParams.length === 0 && func.params.length === 0
+    const requestArg = allEmpty
+      ? ''
+      : `request: {
+      ${func.typeParams.length > 0 ? `type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}],` : ''}
+      ${func.params.length > 0 ? `arguments: [${fields.join(',')}]` : ''}},`
+
+    return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+    client: AptosClient,
+    ${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 res = await client.view(data, version?.toString())
+      const type = await coder.getMoveFunction("${module.address}::${module.name}::${func.name}")
+      return await coder.decodeArray(res, type.return) as any
+    }`
+  }
+
+  protected generateEntryForFunction(module: InternalMoveModule, func: InternalMoveFunction): string {
+    if (!func.isEntry) {
+      return ''
+    }
+    const genericString = this.generateFunctionTypeParameters(func)
+    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).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,
+      account: AptosAccount,
+      request: {
+        type_arguments: [${func.typeParams.map((_) => 'string').join(', ')}], 
+        arguments: [${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)
+    }`
+  }
+}

package/src/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/codegen/run.ts

@@ -0,0 +1,33 @@
+// #!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+import { AptosClient } from 'aptos'
+import * as path from 'path'
+import * as fs from 'fs'
+
+if (process.argv.length > 3) {
+  let abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  let endpoint: string | undefined = process.argv[4]
+  if (!endpoint || endpoint == 'mainnet') {
+    endpoint = 'https://mainnet.aptoslabs.com/'
+  }
+  if (endpoint == 'testnet') {
+    endpoint = 'https://testnet.aptoslabs.com/'
+  }
+  const aptosClient = new AptosClient(endpoint)
+  if (abisDir.startsWith('0x')) {
+    const abiAddress = abisDir
+    const abi = await aptosClient.getAccountModules(abiAddress)
+    abisDir = path.join(targetDir, '..', 'abis')
+    if (!fs.existsSync(abisDir)) {
+      fs.mkdirSync(abisDir, { recursive: true })
+    }
+    fs.writeFileSync(path.join(abisDir, abiAddress + '.json'), JSON.stringify(abi, null, 2))
+  }
+
+  await codegen(abisDir, targetDir, endpoint, true)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './models.js'
+export * from './move-types.js'
+export { MoveCoder, defaultMoveCoder } from './move-coder.js'
+export { AccountResourceClient } from './account-resource-client.js'

package/src/models.ts

@@ -0,0 +1,18 @@
+import {
+  Event,
+  MoveResource,
+  TransactionPayload_EntryFunctionPayload,
+} from './move-types.js'
+import { DecodedStruct } from '@typemove/move'
+
+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
+  }

package/src/move-coder.ts

@@ -0,0 +1,85 @@
+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'
+
+export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | MoveResource> {
+  constructor(client: AptosClient) {
+    super(new AptosChainAdapter(client))
+  }
+
+  load(module: MoveModuleBytecode): InternalMoveModule {
+    if (!module.abi) {
+      throw Error('Module without abi')
+    }
+    let m = this.moduleMapping.get(module.abi.address + '::' + module.abi.name)
+    // if (this.contains(module.abi.address, module.abi.name)) {
+    //   return
+    // }
+    if (m) {
+      return m
+    }
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
+  }
+
+  decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
+    return this.decodedStruct(event)
+  }
+  filterAndDecodeEvents<T>(type: string | TypeDescriptor<T>, resources: Event[]): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
+  }
+  decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
+    return this.decodedStruct(res)
+  }
+  filterAndDecodeResources<T>(
+    type: string | TypeDescriptor<T>,
+    resources: MoveResource[]
+  ): Promise<TypedMoveResource<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
+  }
+
+  async decodeFunctionPayload(
+    payload: TransactionPayload_EntryFunctionPayload
+  ): Promise<TransactionPayload_EntryFunctionPayload> {
+    const func = await this.getMoveFunction(payload.function)
+    const params = this.adapter.getMeaningfulFunctionParams(func.params)
+    const argumentsDecoded = await this.decodeArray(payload.arguments, params)
+
+    return {
+      ...payload,
+      arguments_decoded: argumentsDecoded
+    } as TypedFunctionPayload<any>
+  }
+}
+
+// const MOVE_CODER = new MoveCoder(AptosNetwork.MAIN_NET)
+// const TESTNET_MOVE_CODER = new MoveCoder(AptosNetwork.TEST_NET)
+//
+// export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET): MoveCoder {
+//   if (network == AptosNetwork.MAIN_NET) {
+//     return MOVE_CODER
+//   }
+//   return TESTNET_MOVE_CODER
+// }
+
+const DEFAULT_ENDPOINT = 'https://mainnet.aptoslabs.com/'
+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))
+    CODER_MAP.set(endpoint, coder)
+  }
+  return coder
+}

package/src/move-types.ts

@@ -0,0 +1,13 @@
+import { Types } from 'aptos'
+
+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