@typemove/aptos 1.0.0-rc.13

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,42 @@
+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 } from '@typemove/move'
+
+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`))
+}
+
+class AptosCodegen extends AbstractCodegen<
+  MoveModuleBytecode,
+  Event | MoveResource
+> {
+  ADDRESS_TYPE = 'Address'
+  REFERENCE_TYPE = 'Address'
+  PREFIX = 'Aptos'
+  SYSTEM_PACKAGE = '@typemove/aptos'
+
+  constructor(endpoint: string) {
+    super(new AptosChainAdapter(endpoint))
+  }
+
+  // generateImports(): string {
+  //   return `
+  //     ${super.generateImports()}
+  //     import { Address } from '@typemove/aptos'
+  //   `
+  // }
+}

package/src/codegen/index.ts

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

package/src/codegen/run.ts

@@ -0,0 +1,20 @@
+// #!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+
+if (process.argv.length > 3) {
+  const 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/'
+  }
+
+  await codegen(abisDir, targetDir, endpoint, true)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './models.js'
+export * from './move-types.js'
+export { MoveCoder, defaultMoveCoder } from './move-coder.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,84 @@
+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'
+
+export class MoveCoder extends AbstractMoveCoder<MoveModuleBytecode, Event | MoveResource> {
+  constructor(network: string) {
+    super(new AptosChainAdapter(network))
+  }
+
+  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(DEFAULT_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

package/src/to-internal.ts

@@ -0,0 +1,72 @@
+import {
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  InternalMoveModule,
+  InternalMoveStruct,
+  InternalMoveStructField,
+  parseMoveType,
+} from '@typemove/move'
+import { Types } from 'aptos'
+import {
+  MoveFunction,
+  MoveModuleBytecode,
+  MoveStruct,
+  MoveStructField,
+} from './move-types'
+
+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),
+  }
+}
+
+export function toInternalFunction(func: MoveFunction): InternalMoveFunction {
+  let visibility
+  switch (func.visibility) {
+    case Types.MoveFunctionVisibility.PRIVATE:
+      visibility = InternalMoveFunctionVisibility.PRIVATE
+      break
+    case Types.MoveFunctionVisibility.PUBLIC:
+      visibility = InternalMoveFunctionVisibility.PUBLIC
+      break
+    case Types.MoveFunctionVisibility.FRIEND:
+      visibility = InternalMoveFunctionVisibility.FRIEND
+      break
+  }
+  return {
+    typeParams: func.generic_type_params,
+    isEntry: func.is_entry,
+    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,
+    name: struct.name,
+  }
+}
+
+export function toInternalField(
+  module: MoveStructField
+): InternalMoveStructField {
+  return {
+    name: module.name,
+    type: parseMoveType(module.type),
+  }
+}