@sentio/sdk 2.4.0-rc.1 → 2.5.0-rc.1

package/src/move/account.ts

@@ -0,0 +1,96 @@
+import { parseMoveType, TypeDescriptor } from './types.js'
+import { moduleQname, moduleQnameForType } from './utils.js'
+import { NeutralMoveModule } from './neutral-models.js'
+
+export class AccountModulesImportInfo {
+  // account to module
+  imports: Map<string, Set<string>>
+  account: string
+  moduleName: string
+
+  constructor(account: string, tsModuleName: string) {
+    this.account = account
+    this.moduleName = tsModuleName
+    this.imports = new Map<string, Set<string>>()
+  }
+
+  addImport(account: string, module: string) {
+    if (account === this.account) {
+      return
+    }
+    let accountModules = this.imports.get(account)
+    if (!accountModules) {
+      accountModules = new Set<string>()
+      this.imports.set(account, accountModules)
+    }
+    accountModules.add(module)
+  }
+}
+
+export class AccountRegister {
+  accountImports = new Map<string, AccountModulesImportInfo>()
+  pendingAccounts = new Set<string>()
+
+  // loadedAccount = new Set<string>()
+  typeDescriptors = new Map<string, TypeDescriptor>()
+
+  protected loadTypeDescriptor(type: string) {
+    let descriptor = this.typeDescriptors.get(type)
+
+    // const descriptparseMoveType(type)
+    if (!descriptor) {
+      descriptor = parseMoveType(type)
+      this.typeDescriptors.set(type, descriptor)
+    }
+    return descriptor
+  }
+
+  register(module: NeutralMoveModule, tsModuleName: string): AccountModulesImportInfo {
+    const currentModuleFqn = moduleQname(module)
+
+    let accountModuleImports = this.accountImports.get(module.address)
+    if (!accountModuleImports) {
+      accountModuleImports = new AccountModulesImportInfo(module.address, tsModuleName)
+      this.accountImports.set(module.address, accountModuleImports)
+      // the account has already be processed, delete pending task
+      this.pendingAccounts.delete(module.address)
+    }
+
+    this.registerStruct(module, accountModuleImports)
+    this.registerFunctions(module, accountModuleImports)
+
+    this.accountImports.set(currentModuleFqn, accountModuleImports)
+    return accountModuleImports
+  }
+
+  registerFunctions(module: NeutralMoveModule, accountModuleImports: AccountModulesImportInfo): void {
+    for (const func of module.exposed_functions) {
+      if (!func.is_entry) {
+        continue
+      }
+      for (const param of func.params) {
+        for (const type of param.dependedTypes()) {
+          const [account, module] = moduleQnameForType(type)
+          accountModuleImports.addImport(account, module)
+          if (!this.accountImports.has(account)) {
+            this.pendingAccounts.add(account)
+          }
+        }
+      }
+    }
+  }
+
+  registerStruct(module: NeutralMoveModule, accountModuleImports: AccountModulesImportInfo): void {
+    for (const struct of module.structs) {
+      for (const field of struct.fields) {
+        for (const type of field.type.dependedTypes()) {
+          const [account, module] = moduleQnameForType(type)
+          accountModuleImports.addImport(account, module)
+          if (!this.accountImports.has(account)) {
+            this.pendingAccounts.add(account)
+          }
+        }
+      }
+    }
+  }
+}

package/src/move/filter.ts

@@ -0,0 +1,33 @@
+// TODO extends ArgumentsFilter
+import { MoveFetchConfig, ProcessResult } from '@sentio/protos'
+
+export interface EventFilter {
+  type: string
+  account?: string
+}
+
+export interface FunctionNameAndCallFilter extends CallFilter {
+  function: string
+}
+
+// TODO extends ArgumentsFilter
+export interface CallFilter {
+  includeFailed?: boolean
+  typeArguments?: string[]
+}
+
+export interface ArgumentsFilter {
+  arguments?: string[]
+}
+
+export class EventHandler<T> {
+  filters: EventFilter[]
+  handler: (event: T) => Promise<ProcessResult>
+  fetchConfig: MoveFetchConfig
+}
+
+export class CallHandler<T> {
+  filters: FunctionNameAndCallFilter[]
+  handler: (call: T) => Promise<ProcessResult>
+  fetchConfig: MoveFetchConfig
+}

package/src/move/index.ts

@@ -1,33 +1,5 @@
-// TODO extends ArgumentsFilter
-import { Data_AptCall, Data_AptEvent, MoveFetchConfig, ProcessResult } from '@sentio/protos'
-
-export interface EventFilter {
-  type: string
-  account?: string
-}
-
-export interface FunctionNameAndCallFilter extends CallFilter {
-  function: string
-}
-
-// TODO extends ArgumentsFilter
-export interface CallFilter {
-  includeFailed?: boolean
-  typeArguments?: string[]
-}
-
-export interface ArgumentsFilter {
-  arguments?: string[]
-}
-
-export class EventHandler<T> {
-  filters: EventFilter[]
-  handler: (event: T) => Promise<ProcessResult>
-  fetchConfig: MoveFetchConfig
-}
-
-export class CallHandler<T> {
-  filters: FunctionNameAndCallFilter[]
-  handler: (call: T) => Promise<ProcessResult>
-  fetchConfig: MoveFetchConfig
-}
+export * from './filter.js'
+export * from './types.js'
+export * from './ts-type.js'
+export * from './utils.js'
+export * from './account.js'

package/src/move/neutral-models.ts

@@ -0,0 +1,45 @@
+import { TypeDescriptor } from './types.js'
+
+export interface NeutralMoveModule {
+  address: string
+  name: string
+
+  exposed_functions: Array<NeutralMoveFunction>
+  structs: Array<NeutralMoveStruct>
+}
+
+export interface NeutralMoveFunction {
+  name: string
+  visibility: NeutralMoveFunctionVisibility
+  is_entry: boolean
+  generic_type_params: Array<NeutralMoveGenericTypeParam>
+  params: Array<TypeDescriptor>
+  return: Array<TypeDescriptor>
+}
+
+export interface NeutralMoveStruct {
+  name: string
+
+  is_native: boolean
+
+  abilities: Array<string>
+
+  generic_type_params: Array<NeutralMoveGenericTypeParam>
+
+  fields: Array<NeutralMoveStructField>
+}
+
+export interface NeutralMoveStructField {
+  name: string
+  type: TypeDescriptor
+}
+
+export enum NeutralMoveFunctionVisibility {
+  PRIVATE = 'private',
+  PUBLIC = 'public',
+  FRIEND = 'friend',
+}
+
+export type NeutralMoveGenericTypeParam = {
+  constraints: Array<string>
+}

package/src/move/ts-type.ts

@@ -0,0 +1,86 @@
+import { TypeDescriptor } from './types.js'
+import { normalizeToJSName, SPLITTER, VECTOR_STR } from './utils.js'
+
+export function generateTypeForDescriptor(type: TypeDescriptor, currentAddress: string, addressType: string): string {
+  // TODO &signer is defintely an address, but what if &OTHER_TYPE?
+  if (type.qname.startsWith('&')) {
+    console.error('Unexpected &')
+    return addressType
+  }
+  if (type.reference) {
+    return addressType
+  }
+
+  switch (type.qname) {
+    case 'signer': // TODO check this
+    case 'address':
+    case 'Address':
+      return addressType
+    case '0x2::object::ID':
+    case '0x2::coin::Coin':
+      return 'string'
+    case '0x1::string::String':
+      return 'string'
+    case 'bool':
+    case 'Bool':
+      return 'Boolean'
+    case 'u8':
+    case 'U8':
+    case 'u16':
+    case 'U16':
+    case 'u32':
+    case 'U32':
+      return 'number'
+    case 'u64':
+    case 'U64':
+    case 'u128':
+    case 'U128':
+      return 'bigint'
+  }
+
+  if (type.qname.toLowerCase() === VECTOR_STR) {
+    // vector<u8> as hex string
+    const elementTypeQname = type.typeArgs[0].qname
+    if (elementTypeQname === 'u8' || elementTypeQname === 'U8') {
+      return 'string'
+    }
+    if (elementTypeQname.startsWith('T') && !elementTypeQname.includes(SPLITTER)) {
+      return `${elementTypeQname}[] | string`
+    }
+    return generateTypeForDescriptor(type.typeArgs[0], currentAddress, addressType) + '[]'
+  }
+
+  const simpleName = generateSimpleType(type.qname, currentAddress)
+  if (simpleName.length === 0) {
+    console.error('unexpected error')
+  }
+  if (simpleName.toLowerCase().includes(VECTOR_STR)) {
+    console.error('unexpected vector type error')
+  }
+  if (type.typeArgs.length > 0) {
+    // return simpleName
+    return (
+      simpleName +
+      '<' +
+      type.typeArgs.map((t) => generateTypeForDescriptor(t, currentAddress, addressType)).join(',') +
+      '>'
+    )
+  }
+  return simpleName
+}
+
+function generateSimpleType(type: string, currentAddress: string): string {
+  const parts = type.split(SPLITTER)
+
+  for (let i = 0; i < parts.length; i++) {
+    parts[i] = normalizeToJSName(parts[i])
+  }
+
+  if (parts.length < 2) {
+    return parts[0]
+  }
+  if (parts[0] === currentAddress) {
+    return parts.slice(1).join('.')
+  }
+  return '_' + parts.join('.')
+}

package/src/{aptos → move}/types.ts

@@ -3,8 +3,11 @@ import { SPLITTER, VECTOR_STR } from './utils.js'
 export class TypeDescriptor {
   // type: string
 
+  // TODO add reference flag
+
   // qualified name without type parameters
   qname: string
+  reference: boolean
   // account?: string
   // module?: string
 
@@ -47,18 +50,29 @@ export class TypeDescriptor {
   // all depended types including itself, not include system type
   dependedTypes(): string[] {
     if (this.qname.startsWith('&')) {
+      console.error('Not expected &')
+      return []
+    }
+    if (this.reference) {
       return []
     }
     switch (this.qname) {
       case 'signer':
       case 'address':
+      case 'Address':
       case '0x1::string::String':
       case 'bool':
+      case 'Bool':
       case 'u8':
+      case 'U8':
       case 'u16':
+      case 'U16':
       case 'u32':
+      case 'U32':
       case 'u64':
+      case 'U64':
       case 'u128':
+      case 'U128':
         return []
     }
 
@@ -103,30 +117,33 @@ export function parseMoveType(type: string): TypeDescriptor {
       const symbol = buffer.join('')
       buffer = []
       stack[stack.length - 1].qname = symbol
+      adjustType(stack[stack.length - 1])
       stack.push(new TypeDescriptor(''))
       continue
     }
     if (ch === '>') {
       const typeParam = stack.pop()
       if (!typeParam) {
-        throw Error('Uxpectecd stack size')
+        throw Error('Unexpected stack size')
       }
       if (buffer.length > 0) {
         typeParam.qname = buffer.join('')
         buffer = []
       }
+      adjustType(typeParam)
       stack[stack.length - 1].typeArgs.push(typeParam)
       continue
     }
     if (ch === ',') {
       const typeParam = stack.pop()
       if (!typeParam) {
-        throw Error('Uxpectecd stack size')
+        throw Error('Unexpected stack size')
       }
       if (buffer.length > 0) {
         typeParam.qname = buffer.join('')
         buffer = []
       }
+      adjustType(typeParam)
 
       stack[stack.length - 1].typeArgs.push(typeParam)
       // continue parse next param
@@ -140,10 +157,18 @@ export function parseMoveType(type: string): TypeDescriptor {
   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('Uxpectecd stack size')
+    throw Error('Unexpected stack size')
   }
   return res
 }
+
+function adjustType(type: TypeDescriptor) {
+  if (type.qname.startsWith('&')) {
+    type.reference = true
+    type.qname = type.qname.slice(1)
+  }
+}

package/src/move/utils.ts

@@ -0,0 +1,25 @@
+export const SPLITTER = '::'
+
+export const VECTOR_STR = 'vector'
+
+export function isFrameworkAccount(account: string) {
+  return account === '0x1' || account === '0x2' || account === '0x3'
+}
+
+const KEYWORDS = new Set(['package', 'namespace', 'volatile', 'object', 'string', 'number', 'bigint'])
+
+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 module.address.toLowerCase() + SPLITTER + module.name
+}