@typemove/aptos 1.13.5-rc.2 → 2.0.0-rc.1

package/src/builtin/index.ts

@@ -1,6 +0,0 @@
-/* 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

@@ -1,190 +0,0 @@
-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

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

package/src/codegen/run.ts

@@ -1,70 +0,0 @@
-#!/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 aptosClient.getAccountModules({ accountAddress: abiAddress })
-      abisDir = options.abiDir
-      if (!fs.existsSync(abisDir)) {
-        fs.mkdirSync(abisDir, { recursive: true })
-      }
-      fs.writeFileSync(
-        path.join(abisDir, abiAddress + '.json'),
-        JSON.stringify(new AptosChainAdapter(aptosClient).toPersistableModules(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

@@ -1,15 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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
-}