@typemove/aptos 2.0.0 → 2.0.1

package/src/builtin/index.ts

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

package/src/codegen/codegen.ts

@@ -0,0 +1,190 @@
+import * as fs from 'fs'
+import chalk from 'chalk'
+import { join } from 'path'
+import { AptosChainAdapter } from '../aptos-chain-adapter.js'
+import {
+  camel,
+  InternalMoveFunction,
+  InternalMoveModule,
+  InternalMoveStruct,
+  normalizeToJSName,
+  structQname
+} from '@typemove/move'
+import { AbstractCodegen } from '@typemove/move/codegen'
+import { Aptos, AptosConfig, Event, MoveModuleBytecode, MoveResource } from '@aptos-labs/ts-sdk'
+
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'aptos'),
+  config: AptosConfig,
+  genExample = false,
+  builtin = false
+) {
+  if (!fs.existsSync(abisDir)) {
+    console.error(chalk.red(`ABIs directory ${abisDir} does not exist`))
+    return 0
+  }
+  const gen = new AptosCodegen(config)
+  try {
+    const numFiles = await gen.generate(abisDir, outDir, builtin)
+    if (numFiles > 0) {
+      console.log(chalk.green(`Generated for ${numFiles} accounts for Aptos to ${outDir}`))
+    } else {
+      console.error(chalk.red(`No account found`))
+    }
+    return numFiles
+  } catch (e) {
+    console.error(chalk.red(`Failed to generate for ${abisDir}, please check if ABI json files are valid`))
+    console.log(e)
+    return 0
+  }
+}
+
+export class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, Event | MoveResource> {
+  ADDRESS_TYPE = 'MoveAddressType'
+  PREFIX = 'Aptos'
+  SYSTEM_PACKAGE = '@typemove/aptos'
+
+  constructor(
+    config: AptosConfig,
+    readonly useViewJson = false
+  ) {
+    super(new AptosChainAdapter(new Aptos(config)))
+  }
+
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId, InputViewFunctionData, InputViewFunctionJsonData } from '@aptos-labs/ts-sdk'
+    `
+  }
+
+  protected generateExtra(address: string | undefined, 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')}
+    }
+    `
+  }
+
+  generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>): string {
+    let content = ''
+    switch (structQname(module, struct)) {
+      case '0x1::object::Object':
+        content += `export type ${struct.name}<T> = MoveAddressType`
+        break
+    }
+    return content + super.generateStructs(module, struct, events, content !== '')
+  }
+
+  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 ? `typeArguments: [${func.typeParams.map((_) => 'MoveStructId').join(', ')}],` : ''}
+      ${func.params.length > 0 ? `functionArguments: [${fields.join(',')}]` : ''}},`
+
+    if (this.useViewJson) {
+      return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+    client: Aptos,
+    ${requestArg}
+    version?: bigint): Promise<[${returns.join(',')}]> {
+      const coder = ${this.getGetDefaultCoder()}        
+      const data: InputViewFunctionJsonData = {
+        function: "${module.address}::${module.name}::${func.name}",
+        functionArguments: ${func.params.length > 0 ? 'request.functionArguments.map(coder.toMoveValue)' : '[]'},
+        typeArguments: ${func.typeParams.length > 0 ? 'request.typeArguments' : '[]'},
+      }
+      const res = await client.viewJson({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
+    }`
+    }
+
+    return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+    client: Aptos,
+    ${requestArg}
+    version?: bigint): Promise<[${returns.join(',')}]> {
+      const coder = ${this.getGetDefaultCoder()}        
+      const data: InputViewFunctionData = {
+        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({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
+    }`
+  }
+
+  protected getGetDefaultCoder() {
+    return `defaultMoveCoder(client.config)`
+  }
+
+  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: Aptos,
+      account: AptosAccount,
+      request: {
+        typeArguments: [${func.typeParams.map((_) => 'MoveStructId').join(', ')}], 
+        functionArguments: [${fields.join(',')}]
+      },
+      options?: InputGenerateTransactionOptions
+    ): Promise<PendingTransactionResponse> {
+      const coder = ${this.getGetDefaultCoder()}
+      const transaction = await client.transaction.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/index.ts

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

package/src/codegen/run.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+import { AptosChainAdapter } from '../aptos-chain-adapter.js'
+import { Aptos, AptosConfig, Network } from '@aptos-labs/ts-sdk'
+import * as path from 'path'
+import * as fs from 'fs'
+import { Command } from 'commander'
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+let pkg = undefined
+try {
+  pkg = require('../../package.json')
+} catch (e) {
+  pkg = require('../../../package.json')
+}
+
+const program = new Command()
+
+program
+  .name('typemove-aptos')
+  .description('CLI to generate typescript types from Aptos ABIs')
+  .showHelpAfterError()
+  .version(pkg.version)
+  .argument('<location>', 'Directory of ABI json files or address of account to generate types for')
+  .option('-a, --abi-dir <dir>', 'Directory to store downloaded ABI. Only useful if <location> is address', './abis')
+  .option('-t, --target-dir <dir>', 'Directory to output generated files', './types')
+  .option(
+    '-n, --network <mainnet|testnet|$url>',
+    'Network to use, could be either "mainnet", "testnet" or any node URL',
+    'mainnet'
+  )
+  .action(async (location, options) => {
+    const endpoint = options.network
+    let config: AptosConfig
+    if (endpoint == 'mainnet') {
+      config = new AptosConfig({
+        network: Network.MAINNET
+      })
+    } else if (endpoint == 'testnet') {
+      config = new AptosConfig({
+        network: Network.TESTNET
+      })
+    } else {
+      config = new AptosConfig({
+        network: Network.CUSTOM,
+        fullnode: endpoint
+      })
+    }
+    const aptosClient = new Aptos(config)
+
+    let abisDir = location
+    if (location.startsWith('0x')) {
+      const abiAddress = abisDir
+      const abi = await new AptosChainAdapter(aptosClient).fetchModules(abiAddress)
+      abisDir = options.abiDir
+      if (!fs.existsSync(abisDir)) {
+        fs.mkdirSync(abisDir, { recursive: true })
+      }
+      fs.writeFileSync(path.join(abisDir, abiAddress + '.json'), JSON.stringify(abi, null, 2))
+    }
+
+    const num = await codegen(abisDir, options.targetDir, config, true)
+    process.exit(num == 0 ? 1 : 0)
+  })
+
+program.parse()

package/src/coder-helpers.ts

@@ -0,0 +1,15 @@
+import { ResourceChange } from './models.js'
+import { MoveCoder } from './move-coder.js'
+
+export async function decodeResourceChange<T>(
+  resources: {
+    [key: string]: any
+  }[],
+  coder: MoveCoder
+): Promise<ResourceChange<T>[]> {
+  const promises = resources.map(async (r) => {
+    r.data = await coder.decodeResource<T>(r.data)
+    return r as ResourceChange<T>
+  })
+  return await Promise.all(promises)
+}

package/src/index.ts

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

package/src/models.ts

@@ -0,0 +1,23 @@
+import { DecodedStruct, NestedDecodedStruct } from '@typemove/move'
+import {
+  EntryFunctionPayloadResponse,
+  MoveResource,
+  Event,
+  WriteSetChangeWriteResource,
+  WriteSetChangeDeleteResource
+} 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>> = EntryFunctionPayloadResponse & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}
+
+export type ResourceChange<T> =
+  | NestedDecodedStruct<MoveResource, WriteSetChangeWriteResource, T>
+  | WriteSetChangeDeleteResource

package/src/move-coder.ts

@@ -0,0 +1,124 @@
+import { AbstractMoveCoder, InternalMoveModule, parseMoveType, TypeDescriptor } from '@typemove/move'
+import { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './models.js'
+import { AptosChainAdapter } from './aptos-chain-adapter.js'
+import { toInternalModule } from './to-internal.js'
+import {
+  Aptos,
+  AptosConfig,
+  EntryFunctionPayloadResponse,
+  Event,
+  MoveModuleBytecode,
+  MoveResource,
+  MoveValue,
+  Network
+} from '@aptos-labs/ts-sdk'
+
+export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | MoveResource> {
+  constructor(
+    client: Aptos,
+    readonly ignoreObjectInnerField: boolean = false
+  ) {
+    super(new AptosChainAdapter(client))
+  }
+
+  load(module: MoveModuleBytecode, address: string): 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
+    }
+    this.accounts.add(module.abi.address)
+    m = toInternalModule(module)
+    this.loadInternal(m, address)
+    return m
+  }
+
+  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> {
+    return this.decodedStruct(res)
+  }
+
+  protected async decode(data: any, type: TypeDescriptor): Promise<any> {
+    switch (type.qname) {
+      case '0x1::object::Object':
+        if (this.ignoreObjectInnerField && typeof data === 'string') {
+          return data
+        }
+        if (typeof data === 'object' && data?.inner !== undefined && typeof data?.inner === 'string') {
+          return data.inner
+        }
+    }
+    return super.decode(data, type)
+  }
+
+  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<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)
+
+    return {
+      ...payload,
+      arguments_decoded: argumentsDecoded
+    } as TypedFunctionPayload<T>
+  }
+
+  toMoveValue(value: any): MoveValue {
+    switch (typeof value) {
+      case 'boolean':
+        return value
+      case 'number':
+        return value
+      case 'bigint':
+        return value.toString()
+      case 'object':
+        if (Array.isArray(value)) {
+          return value.map(this.toMoveValue)
+        }
+        return value
+      default:
+        return value.toString()
+    }
+  }
+}
+
+const DEFAULT_CONFIG = new AptosConfig({ network: Network.MAINNET })
+
+const CODER_MAP = new Map<string, MoveCoder>()
+
+export function defaultMoveCoder(config = DEFAULT_CONFIG): MoveCoder {
+  const configKey = config.fullnode ? config.fullnode : config.network
+
+  let coder = CODER_MAP.get(configKey)
+  if (!coder) {
+    coder = new MoveCoder(new Aptos(config))
+    CODER_MAP.set(configKey, coder)
+  }
+  return coder
+}

package/src/to-internal.ts

@@ -0,0 +1,71 @@
+import {
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  InternalMoveModule,
+  InternalMoveStruct,
+  InternalMoveStructField,
+  parseMoveType
+} from '@typemove/move'
+import {
+  MoveFunctionVisibility,
+  MoveFunction,
+  MoveModuleBytecode,
+  MoveStruct,
+  MoveStructField
+} from '@aptos-labs/ts-sdk'
+
+export function toInternalModule(module: MoveModuleBytecode): InternalMoveModule {
+  if (!module.abi) {
+    throw Error('module with no ABI found')
+  }
+  const abi = module.abi
+  return {
+    address: abi.address,
+    exposedFunctions: abi.exposed_functions.map(toInternalFunction),
+    name: abi.name,
+    structs: abi.structs.map(toInternalStruct),
+    enums: []
+  }
+}
+
+export function toInternalFunction(func: MoveFunction): InternalMoveFunction {
+  let visibility
+  switch (func.visibility) {
+    case MoveFunctionVisibility.PRIVATE:
+      visibility = InternalMoveFunctionVisibility.PRIVATE
+      break
+    case MoveFunctionVisibility.PUBLIC:
+      visibility = InternalMoveFunctionVisibility.PUBLIC
+      break
+    case MoveFunctionVisibility.FRIEND:
+      visibility = InternalMoveFunctionVisibility.FRIEND
+      break
+  }
+  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),
+    visibility: visibility
+  }
+}
+
+export function toInternalStruct(struct: MoveStruct): InternalMoveStruct {
+  return {
+    abilities: struct.abilities,
+    fields: struct.fields.map(toInternalField),
+    typeParams: struct.generic_type_params,
+    isNative: struct.is_native,
+    isEvent: struct.is_event,
+    name: struct.name
+  }
+}
+
+export function toInternalField(module: MoveStructField): InternalMoveStructField {
+  return {
+    name: module.name,
+    type: parseMoveType(module.type)
+  }
+}