@typemove/move 2.0.0 → 2.0.1-rc.1

package/src/types.ts

@@ -0,0 +1,362 @@
+import { accountTypeString, SPLITTER, VECTOR_STR } from './utils.js'
+
+export type DecodedStruct<B, T> = B & {
+  /**
+   * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  data_decoded: T
+  type_arguments: string[]
+}
+
+export type NestedDecodedStruct<A, B extends { data: A }, T> = B & {
+  data: DecodedStruct<A, T>
+}
+
+export class TypeDescriptor<T = any> {
+  qname: string
+  reference: boolean
+  mutable: boolean
+  typeArgs: TypeDescriptor[]
+
+  constructor(symbol: string, typeParams?: TypeDescriptor[]) {
+    this.qname = symbol
+    this.reference = false
+    this.mutable = false
+    this.typeArgs = typeParams || []
+  }
+
+  apply(...typeArgs: TypeDescriptor[]): TypeDescriptor {
+    const newObj = this.clone()
+    newObj.typeArgs = typeArgs
+    return newObj
+  }
+
+  clone(): this {
+    const newObj = new TypeDescriptor(this.qname, this.typeArgs)
+    newObj.reference = this.reference
+    newObj.mutable = this.mutable
+    return newObj as any
+  }
+
+  // compare qname without consider case for system type
+  compareQname(t: TypeDescriptor): boolean {
+    let t1 = this.qname
+    if (BUILTIN_TYPES_SET.has(this.qname.toLowerCase())) {
+      t1 = this.qname.toLowerCase()
+    }
+    let t2 = t.qname
+    if (BUILTIN_TYPES_SET.has(t.qname.toLowerCase())) {
+      t2 = t.qname
+    }
+    return t1 === t2
+  }
+
+  getSignature(): string {
+    if (this.typeArgs.length > 0) {
+      return this.qname + '<' + this.typeArgs.map((t) => t.getSignature()).join(', ') + '>'
+    }
+    return this.qname
+  }
+
+  // Make U8, U16, etc => u8, u16
+  getNormalizedSignature(): string {
+    let qname = this.qname
+    switch (qname) {
+      case 'U8':
+      case 'U16':
+      case 'U32':
+      case 'U64':
+      case 'U128':
+      case 'U256':
+      case 'Vector':
+      case 'Bool':
+      case 'Address':
+        qname = qname.toLowerCase()
+    }
+
+    if (this.typeArgs.length > 0) {
+      return qname + '<' + this.typeArgs.map((t) => t.getNormalizedSignature()).join(', ') + '>'
+    }
+    return qname
+  }
+
+  // Replace T0, T1 with more concrete type
+  applyTypeArgs(ctx: Map<string, TypeDescriptor>): TypeDescriptor {
+    const replace = ctx.get(this.qname)
+    if (replace) {
+      return replace
+    }
+    if (ctx.size === 0 || this.typeArgs.length === 0) {
+      return this
+    }
+
+    const typeArgs: TypeDescriptor[] = []
+    for (const arg of this.typeArgs) {
+      const replace = ctx.get(arg.qname)
+      if (replace) {
+        typeArgs.push(replace)
+      } else {
+        typeArgs.push(arg.applyTypeArgs(ctx))
+      }
+    }
+    return new TypeDescriptor(this.qname, typeArgs)
+  }
+
+  // all depended types including itself, not include system type
+  dependedTypes(): string[] {
+    if (this.qname.startsWith('&')) {
+      console.error('Not expected &')
+      return []
+    }
+
+    // Handle closure/lambda types: |&mut T1|T2 or |T1, T2|T3
+    if (this.qname.startsWith('|')) {
+      // Closure types are function types, not module dependencies
+      // The actual type dependencies are in the typeArgs if any
+      const types = new Set<string>()
+      for (const param of this.typeArgs) {
+        param.dependedTypes().forEach((t) => types.add(t))
+      }
+      return Array.from(types)
+    }
+
+    if (this.isVector()) {
+      return this.typeArgs[0].dependedTypes()
+    }
+
+    if (BUILTIN_TYPES_SET.has(this.qname.toLowerCase())) {
+      return []
+    }
+    switch (this.qname) {
+      case 'signer':
+      case '0x1::string::String':
+        return []
+    }
+
+    // Type parameters are not depended
+    if (this.qname.indexOf(SPLITTER) == -1) {
+      if (this.qname.startsWith('T')) {
+        return []
+      }
+    }
+
+    const types = new Set<string>()
+    for (const param of this.typeArgs) {
+      param.dependedTypes().forEach((t) => types.add(t))
+    }
+
+    types.add(this.qname)
+
+    return Array.from(types)
+  }
+
+  isVector(): boolean {
+    return this.qname.toLowerCase() === VECTOR_STR
+  }
+
+  existAnyType(): boolean {
+    if (this.qname === 'any') {
+      return true
+    }
+    for (const param of this.typeArgs) {
+      if (param.existAnyType()) {
+        return true
+      }
+    }
+    return false
+  }
+
+  name(): string {
+    const parts = this.qname.split(SPLITTER)
+    return parts[parts.length - 1]
+  }
+
+  module(): string {
+    const parts = this.qname.split(SPLITTER)
+    return parts[parts.length - 2]
+  }
+}
+
+export function parseMoveType(type: string): TypeDescriptor {
+  if (type === undefined) {
+    console.log('')
+  }
+
+  // Aptos SDK 7+ exposes Move closure / function-value types in ABIs as
+  // `|param1, param2, ...| ret`. Parse them specially — the inner params and
+  // return type are nested and recursively parsed; the descriptor's qname is
+  // the sentinel `|fn|` (other code in this file branches on qname.startsWith('|')).
+  const closure = tryParseClosure(type)
+  if (closure) {
+    return closure
+  }
+
+  const stack: TypeDescriptor[] = [new TypeDescriptor('')]
+  let buffer = []
+
+  // xxx:asdf<g1<a,<c,d>>, b, g2<a,b>, e>
+  for (let i = 0; i < type.length; i++) {
+    const ch = type[i]
+    if (ch === ' ') {
+      continue
+    }
+    if (ch === '<') {
+      // const symbol = type.slice(symbolStart, i)
+      // symbolStart =
+      const symbol = buffer.join('')
+      buffer = []
+      stack[stack.length - 1].qname = symbol
+      adjustType(stack[stack.length - 1])
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+    if (ch === '>' || ch === ',') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Unexpected stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+      adjustType(typeParam)
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      if (ch === ',') {
+        stack.push(new TypeDescriptor(''))
+      }
+      continue
+    }
+    buffer.push(ch)
+  }
+
+  if (buffer.length > 0) {
+    stack[stack.length - 1].qname = buffer.join('')
+  }
+  adjustType(stack[stack.length - 1])
+
+  const res = stack.pop()
+  if (!res || stack.length > 0) {
+    throw Error('Unexpected stack size')
+  }
+  return res
+}
+
+// Parse `|param1, param2, ...| return_type` (Aptos Move closure / function-value
+// types exposed by SDK 7+). Returns undefined if the input is not a closure.
+// Commas and the closing `|` are matched at angle-bracket depth 0.
+function tryParseClosure(type: string): TypeDescriptor | undefined {
+  let i = 0
+  while (i < type.length && type[i] === ' ') i++
+  if (type[i] !== '|') return undefined
+
+  let depth = 0
+  let close = -1
+  for (let j = i + 1; j < type.length; j++) {
+    const ch = type[j]
+    if (ch === '<') depth++
+    else if (ch === '>') depth--
+    else if (ch === '|' && depth === 0) {
+      close = j
+      break
+    }
+  }
+  if (close < 0) return undefined
+
+  const inner = type.slice(i + 1, close)
+  const ret = type.slice(close + 1).trim()
+
+  const paramTypes: TypeDescriptor[] = []
+  if (inner.trim().length > 0) {
+    let depth2 = 0
+    let start = 0
+    for (let k = 0; k <= inner.length; k++) {
+      const ch = inner[k]
+      if (k === inner.length || (ch === ',' && depth2 === 0)) {
+        const piece = inner.slice(start, k).trim()
+        if (piece.length > 0) paramTypes.push(parseMoveType(piece))
+        start = k + 1
+      } else if (ch === '<') depth2++
+      else if (ch === '>') depth2--
+    }
+  }
+
+  const typeArgs = paramTypes.slice()
+  if (ret.length > 0) typeArgs.push(parseMoveType(ret))
+
+  return new TypeDescriptor('|fn|', typeArgs)
+}
+
+function adjustType(type: TypeDescriptor) {
+  if (type.qname.startsWith('&')) {
+    type.reference = true
+    type.qname = type.qname.slice(1)
+  }
+  if (type.qname.startsWith('mut')) {
+    type.mutable = true
+    type.qname = type.qname.slice(3)
+  }
+  const parts = type.qname.split(SPLITTER)
+  if (parts.length > 1) {
+    const [account, module, name] = parts
+    type.qname = [accountTypeString(account), module, name].join(SPLITTER)
+  }
+}
+
+export const ANY_TYPE = new TypeDescriptor<any>('any')
+
+export function vectorType<T>(t: TypeDescriptor<T> = ANY_TYPE): TypeDescriptor<T[]> {
+  return BUILTIN_TYPES.VECTOR_TYPE_ANY.apply(t)
+}
+
+export const BUILTIN_TYPES = {
+  ADDRESS_TYPE: new TypeDescriptor<string>('address'),
+  // export const Address = new TypeDescriptor<string>("Address")
+
+  VECTOR_TYPE_ANY: new TypeDescriptor<any[]>('vector'),
+  VECTOR_TYPE: vectorType,
+
+  BOOL_TYPE: new TypeDescriptor<number>('bool'),
+
+  U8_TYPE: new TypeDescriptor<number>('u8'),
+  // export const U8 = new TypeDescriptor<number>("U8")
+  U16_TYPE: new TypeDescriptor<number>('u16'),
+  // export const U16 = new TypeDescriptor<number>("U16")
+  U32_TYPE: new TypeDescriptor<number>('u32'),
+  // export const U32 = new TypeDescriptor<number>("U32")
+  U64_TYPE: new TypeDescriptor<number>('u64'),
+  // export const U64 = new TypeDescriptor<number>("U64")
+  U128_TYPE: new TypeDescriptor<number>('u128'),
+  // export const U128 = new TypeDescriptor<number>("U128")
+  U256_TYPE: new TypeDescriptor<number>('u256')
+  // export const U256 = new TypeDescriptor<number>("U256")
+}
+
+const BUILTIN_TYPES_SET = new Set(
+  Object.values(BUILTIN_TYPES).flatMap((t) => {
+    if (typeof t === 'object') {
+      return [t.qname.toLowerCase()]
+    }
+    return []
+  })
+)
+
+/**
+ *
+ * @param matcher
+ * @param type
+ */
+export function matchType(matcher: TypeDescriptor, type: TypeDescriptor): boolean {
+  if (matcher.qname === 'any') {
+    return true
+  }
+  if (!matcher.compareQname(type)) {
+    return false
+  }
+  for (const [idx, matcherTarg] of matcher.typeArgs.entries()) {
+    const targ = type.typeArgs[idx]
+    if (!matchType(matcherTarg, targ)) {
+      return false
+    }
+  }
+  return true
+}

package/src/utils.ts

@@ -0,0 +1,144 @@
+import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
+import { camel as camelRadash } from 'radash'
+
+export const SPLITTER = '::'
+
+export const VECTOR_STR = 'vector'
+
+export function isFrameworkAccount(account: string) {
+  const n = parseInt(account, 16)
+  if (Number.isNaN(n)) {
+    return false
+  }
+  return n >= 0 && n < 16
+}
+
+// strip any lead 0
+export function accountTypeString(account: string): string {
+  const withoutPrefix = account.toLowerCase().replace(/^(0x)/, '')
+  return '0x' + withoutPrefix.replace(/^0*/, '')
+}
+
+const MOVE_ADDRESS_LENGTH = 32
+
+function isHex(value: string): boolean {
+  return /^(0x|0X)?[a-fA-F0-9]+$/.test(value)
+}
+
+function getHexByteLength(value: string): number {
+  return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2
+}
+
+export function isValidMoveAddress(value: string): boolean {
+  return isHex(value) && getHexByteLength(value) <= MOVE_ADDRESS_LENGTH
+}
+
+// Get full address with 32 bytes
+export function accountAddressString(account: string): string {
+  if (!isValidMoveAddress(account)) {
+    throw Error('Not valid move address')
+  }
+
+  const address = account.toLowerCase().replace(/^(0x)/, '')
+  return `0x${address.padStart(MOVE_ADDRESS_LENGTH * 2, '0')}`
+}
+
+// https://github.com/microsoft/TypeScript/issues/2536
+const KEYWORDS = new Set([
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'enum',
+  'export',
+  'extends',
+  'false',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'null',
+  'return',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'as',
+  'implements',
+  'interface',
+  'let',
+  'package',
+  'private',
+  'protected',
+  'public',
+  'static',
+  'yield',
+  'any',
+  'boolean',
+  'constructor',
+  'declare',
+  // 'get',
+  'module',
+  // 'require',
+  'number',
+  // 'set',
+  'string',
+  'symbol',
+  'type',
+  'from',
+  // 'of',
+  'async',
+  'await',
+  'bigint',
+  'object',
+  'volatile',
+  'namespace',
+  'arguments'
+])
+
+export function normalizeToJSName(name: string) {
+  if (KEYWORDS.has(name)) {
+    return name + '$'
+  }
+  return name
+}
+
+export function moduleQnameForType(type: string): [string, string] {
+  const parts = type.split(SPLITTER).slice(0, 2)
+  return [parts[0], parts[1]]
+}
+
+export function moduleQname(module: { address: string; name: string }): string {
+  return accountTypeString(module.address) + SPLITTER + module.name
+}
+
+export function structQname(module: InternalMoveModule, struct: InternalMoveStruct): string {
+  return [accountTypeString(module.address), module.name, struct.name].join(SPLITTER)
+}
+
+export function upperFirst(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export function camel(str: string): string {
+  const base = camelRadash(str)
+  return str.endsWith('_') ? base + '_' : base
+}