@sentio/sdk 1.37.0-rc.2 → 1.37.0-rc.4

package/src/aptos/runtime.ts

@@ -1,13 +0,0 @@
-import { MoveStruct } from 'aptos-sdk/src/generated'
-
-export function decode<T>(struct: MoveStruct, args: any[]): T | undefined {
-  if (args.length != struct.fields.length) {
-    console.log('type mismatch actually data for', struct.name)
-    return undefined
-  }
-  const res: any = {}
-  for (const [i, field] of struct.fields.entries()) {
-    res[field.name] = args[i]
-  }
-  return res as T
-}

package/src/aptos/type-registry.ts

@@ -1,187 +0,0 @@
-import {
-  Event,
-  MoveFunction,
-  MoveModule,
-  MoveResource,
-  MoveStruct,
-  TransactionPayload_EntryFunctionPayload,
-} from 'aptos-sdk/src/generated'
-import { getMeaningfulFunctionParams, moduleQname, SPLITTER, VECTOR_STR } from './utils'
-import { parseMoveType, TypeDescriptor } from './types'
-import {
-  TypedEventInstance,
-  TypedMoveResource,
-  StructWithTag,
-  StructWithType,
-  TypedEntryFunctionPayload,
-} from './models'
-
-export class TypeRegistry {
-  moduleMapping = new Map<string, MoveModule>()
-  typeMapping = new Map<string, MoveStruct>()
-  funcMapping = new Map<string, MoveFunction>()
-
-  contains(account: string, name: string) {
-    return this.moduleMapping.has(account + '::' + name)
-  }
-
-  load(module: MoveModule) {
-    if (this.contains(module.address, module.name)) {
-      return
-    }
-    this.moduleMapping.set(moduleQname(module), module)
-
-    for (const struct of module.structs) {
-      // TODO move to util
-      const key = [module.address, module.name, struct.name].join(SPLITTER)
-      this.typeMapping.set(key, struct)
-    }
-
-    for (const func of module.exposed_functions) {
-      if (!func.is_entry) {
-        continue
-      }
-      const key = [module.address, module.name, func.name].join(SPLITTER)
-      this.funcMapping.set(key, func)
-    }
-  }
-
-  getMoveStruct(type: string): MoveStruct {
-    const struct = this.typeMapping.get(type)
-    if (!struct) {
-      throw new Error('Failed to load type' + type)
-    }
-    return struct
-  }
-
-  getMoveFunction(type: string): MoveFunction {
-    const func = this.funcMapping.get(type)
-    if (!func) {
-      throw new Error('Failed to load function' + type)
-    }
-    return func
-  }
-
-  decode(data: any, type: TypeDescriptor): any {
-    // process simple type
-    if (type.qname.startsWith('&')) {
-      return data
-    }
-    switch (type.qname) {
-      case 'signer': // TODO check this
-      case 'address':
-      case '0x1::string::String':
-      case 'bool':
-      case 'u8':
-      case 'u16':
-      case 'u32':
-        return data
-      case 'u64':
-      case 'u128':
-        return BigInt(data)
-    }
-
-    // process vector
-    if (type.qname === VECTOR_STR) {
-      // vector<u8> as hex string
-      if (type.typeArgs[0].qname === 'u8') {
-        return data
-      }
-
-      const res = []
-      for (const entry of data) {
-        res.push(this.decode(entry, type.typeArgs[0]))
-      }
-      return res
-    }
-
-    // Process complex type
-    const struct = this.getMoveStruct(type.qname)
-
-    const typeCtx = new Map<string, TypeDescriptor>()
-    for (const [idx, typeArg] of type.typeArgs.entries()) {
-      typeCtx.set('T' + idx, typeArg)
-    }
-
-    const typedData: any = {}
-
-    for (const field of struct.fields) {
-      let filedType = parseMoveType(field.type)
-      filedType = filedType.applyTypeArgs(typeCtx)
-      const value = this.decode(data[field.name], filedType)
-      typedData[field.name] = value
-    }
-    return typedData
-  }
-
-  decodeEvent<T>(event: Event): TypedEventInstance<T> | undefined {
-    return this.decodedInternal<T>(event) as TypedEventInstance<T>
-  }
-  filterAndDecodeEvents<T>(typeQname: string, resources: Event[]): TypedEventInstance<T>[] {
-    return this.filterAndDecodeInternal(typeQname, resources) as TypedEventInstance<T>[]
-  }
-  decodeResource<T>(res: MoveResource): TypedMoveResource<T> | undefined {
-    return this.decodedInternal<T>(res)
-  }
-  filterAndDecodeResources<T>(typeQname: string, resources: MoveResource[]): TypedMoveResource<T>[] {
-    return this.filterAndDecodeInternal(typeQname, resources)
-  }
-
-  private filterAndDecodeInternal<T>(typeQname: string, structs: StructWithTag[]): StructWithType<T>[] {
-    if (!structs) {
-      return []
-    }
-    const results: StructWithType<T>[] = []
-    for (const resource of structs) {
-      if (resource.type.split('<')[0] !== typeQname) {
-        continue
-      }
-      const result = this.decodedInternal(resource)
-      if (result) {
-        results.push(result as StructWithType<T>)
-      }
-    }
-    return results
-  }
-
-  private decodedInternal<T>(typeStruct: StructWithTag): StructWithType<T> | undefined {
-    const registry = TYPE_REGISTRY
-    // this.loadTypes(registry)
-    // TODO check if module is not loaded
-
-    const typeDescriptor = parseMoveType(typeStruct.type)
-    const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature())
-
-    let dataTyped = undefined
-    try {
-      dataTyped = registry.decode(typeStruct.data, typeDescriptor)
-    } catch (e) {
-      console.error('Decoding error for ', JSON.stringify(typeStruct), e)
-      return undefined
-    }
-    return { ...typeStruct, data_typed: dataTyped, type_arguments: typeArguments } as StructWithType<T>
-  }
-
-  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
-    const registry = TYPE_REGISTRY
-    // this.loadTypes(registry)
-    const argumentsTyped: any[] = []
-
-    try {
-      const func = registry.getMoveFunction(payload.function)
-      const params = getMeaningfulFunctionParams(func)
-      for (const [idx, arg] of payload.arguments.entries()) {
-        // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
-        const argType = parseMoveType(params[idx])
-        argumentsTyped.push(registry.decode(arg, argType))
-      }
-    } catch (e) {
-      console.error('Decoding error for ', JSON.stringify(payload), e)
-      return payload
-    }
-
-    return { ...payload, arguments_typed: argumentsTyped } as TypedEntryFunctionPayload<any>
-  }
-}
-
-export const TYPE_REGISTRY = new TypeRegistry()

package/src/aptos/types.ts

@@ -1,149 +0,0 @@
-import { SPLITTER, VECTOR_STR } from './utils'
-
-export class TypeDescriptor {
-  // type: string
-
-  // qualified name without type parameters
-  qname: string
-  // account?: string
-  // module?: string
-
-  typeArgs: TypeDescriptor[]
-
-  constructor(symbol: string, typeParams?: TypeDescriptor[]) {
-    this.qname = symbol
-    this.typeArgs = typeParams || []
-  }
-
-  getSignature(): string {
-    if (this.typeArgs.length > 0) {
-      return this.qname + '<' + this.typeArgs.map((t) => t.getSignature()).join(', ') + '>'
-    }
-    return this.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('&')) {
-      return []
-    }
-    switch (this.qname) {
-      case 'signer':
-      case 'address':
-      case '0x1::string::String':
-      case 'bool':
-      case 'u8':
-      case 'u16':
-      case 'u32':
-      case 'u64':
-      case 'u128':
-        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))
-    }
-
-    if (this.qname !== VECTOR_STR) {
-      types.add(this.qname)
-    }
-
-    return Array.from(types)
-  }
-}
-
-export function parseMoveType(type: string): TypeDescriptor {
-  // type = type.replace('&', '')
-
-  type = type.replaceAll('&mut ', '&')
-  type = type.replaceAll('mut ', '')
-
-  // TODO replace ' ' is not exactly safe, need to double check this
-  type = type.replaceAll(' ', '')
-
-  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 === '<') {
-      // const symbol = type.slice(symbolStart, i)
-      // symbolStart =
-      const symbol = buffer.join('')
-      buffer = []
-      stack[stack.length - 1].qname = symbol
-      stack.push(new TypeDescriptor(''))
-      continue
-    }
-    if (ch === '>') {
-      const typeParam = stack.pop()
-      if (!typeParam) {
-        throw Error('Uxpectecd stack size')
-      }
-      if (buffer.length > 0) {
-        typeParam.qname = buffer.join('')
-        buffer = []
-      }
-      stack[stack.length - 1].typeArgs.push(typeParam)
-      continue
-    }
-    if (ch === ',') {
-      const typeParam = stack.pop()
-      if (!typeParam) {
-        throw Error('Uxpectecd stack size')
-      }
-      if (buffer.length > 0) {
-        typeParam.qname = buffer.join('')
-        buffer = []
-      }
-
-      stack[stack.length - 1].typeArgs.push(typeParam)
-      // continue parse next param
-      stack.push(new TypeDescriptor(''))
-      continue
-    }
-
-    buffer.push(ch)
-  }
-
-  if (buffer.length > 0) {
-    stack[stack.length - 1].qname = buffer.join('')
-  }
-
-  const res = stack.pop()
-  if (!res || stack.length > 0) {
-    throw Error('Uxpectecd stack size')
-  }
-  return res
-}

package/src/aptos/utils.ts

@@ -1,26 +0,0 @@
-import { MoveFunction, MoveModule } from 'aptos-sdk/src/generated'
-
-export const SPLITTER = '::'
-
-export const VECTOR_STR = 'vector'
-
-export function isFrameworkAccount(account: string) {
-  return account === '0x1' || account === '0x2' || account === '0x3'
-}
-
-export function moduleQname(module: MoveModule): string {
-  return module.address.toLowerCase() + SPLITTER + module.name
-}
-
-export function moduleQnameForType(type: string): [string, string] {
-  const parts = type.split(SPLITTER).slice(0, 2)
-  return [parts[0], parts[1]]
-}
-
-export function getMeaningfulFunctionParams(func: MoveFunction): string[] {
-  let params = func.params
-  if (func.params[0] === '&signer') {
-    params = params.slice(1)
-  }
-  return params
-}