@sentio/sdk 2.23.0 → 2.24.0-rc.2

package/src/move/types.ts

@@ -1,241 +0,0 @@
-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 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
-  }
-
-  // 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 []
-    }
-
-    if (this.qname.toLowerCase() === VECTOR_STR) {
-      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)
-  }
-}
-
-export function parseMoveType(type: string): TypeDescriptor {
-  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
-}
-
-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/move/utils.ts

@@ -1,69 +0,0 @@
-import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
-
-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')}`
-}
-
-const KEYWORDS = new Set(['package', 'namespace', 'volatile', 'object', 'string', 'number', 'bigint', 'any'])
-
-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)
-}

package/src/sui/module-client.ts

@@ -1,7 +0,0 @@
-// import { JsonRpcProvider } from "@mysten/sui.js";
-
-export class ModuleClient {
-  public async viewDecoded(func: string, typeArguments: string[], args: any[], ledger_version?: bigint) {
-    throw Error('not implemented')
-  }
-}

package/src/sui/move-types.ts

@@ -1,108 +0,0 @@
-import type {
-  SuiMoveNormalizedField,
-  SuiMoveNormalizedFunction,
-  SuiMoveNormalizedModule,
-  SuiMoveNormalizedStruct,
-  SuiMoveNormalizedType,
-} from '@mysten/sui.js'
-import {
-  InternalMoveFunction,
-  InternalMoveFunctionVisibility,
-  InternalMoveModule,
-  InternalMoveStruct,
-  InternalMoveStructField,
-} from '../move/internal-models.js'
-import { SPLITTER, TypeDescriptor } from '../move/index.js'
-
-export function toInternalModule(module: SuiMoveNormalizedModule): InternalMoveModule {
-  return {
-    address: module.address,
-    exposedFunctions: Object.entries(module.exposedFunctions).map(([n, f]) => toInternalFunction(n, f)),
-    name: module.name,
-    structs: Object.entries(module.structs).map(([n, s]) => toInternalStruct(n, s)),
-  }
-}
-
-export function toInternalFunction(name: string, func: SuiMoveNormalizedFunction): InternalMoveFunction {
-  let visibility
-  switch (func.visibility) {
-    case 'Private':
-      visibility = InternalMoveFunctionVisibility.PRIVATE
-      break
-    case 'Public':
-      visibility = InternalMoveFunctionVisibility.PUBLIC
-      break
-    case 'Friend':
-      visibility = InternalMoveFunctionVisibility.FRIEND
-      break
-    default:
-      throw Error('No visibility for function' + name)
-  }
-  return {
-    typeParams: func.typeParameters.map((p: any) => {
-      return { constraints: p.abilities }
-    }),
-    isEntry: func.isEntry,
-    name: name,
-    params: func.parameters.map(toTypeDescriptor),
-    return: func.return.map(toTypeDescriptor),
-    visibility: visibility,
-  }
-}
-
-export function toInternalStruct(name: string, struct: SuiMoveNormalizedStruct): InternalMoveStruct {
-  return {
-    abilities: struct.abilities.abilities,
-    fields: struct.fields.map(toInternalField),
-    typeParams: struct.typeParameters.map((p: any) => {
-      return { constraints: p.constraints.abilities }
-    }),
-    isNative: false,
-    name: name,
-  }
-}
-
-export function toInternalField(module: SuiMoveNormalizedField): InternalMoveStructField {
-  return {
-    name: module.name,
-    type: toTypeDescriptor(module.type),
-  }
-}
-
-export function toTypeDescriptor(normalizedType: SuiMoveNormalizedType): TypeDescriptor {
-  if (typeof normalizedType === 'string') {
-    return new TypeDescriptor(normalizedType)
-  }
-
-  if ('Struct' in normalizedType) {
-    const qname = [normalizedType.Struct.address, normalizedType.Struct.module, normalizedType.Struct.name].join(
-      SPLITTER
-    )
-
-    const args = normalizedType.Struct.typeArguments.map(toTypeDescriptor)
-
-    return new TypeDescriptor(qname, args)
-  }
-
-  if ('Vector' in normalizedType) {
-    return new TypeDescriptor('Vector', [toTypeDescriptor(normalizedType.Vector)])
-  }
-  if ('TypeParameter' in normalizedType) {
-    return new TypeDescriptor('T' + normalizedType.TypeParameter)
-  }
-
-  if ('Reference' in normalizedType) {
-    const res = toTypeDescriptor(normalizedType.Reference)
-    res.reference = true
-    return res
-  }
-
-  if ('MutableReference' in normalizedType) {
-    const res = toTypeDescriptor(normalizedType.MutableReference)
-    res.reference = true
-    res.mutable = true
-    return res
-  }
-
-  throw new Error('Unexpected sui type')
-}

package/src/sui/sui-chain-adapter.ts

@@ -1,93 +0,0 @@
-import { ChainAdapter, moduleQname, SPLITTER, TypeDescriptor } from '../move/index.js'
-import { toInternalModule } from './move-types.js'
-import { SuiNetwork } from './network.js'
-import { InternalMoveModule, InternalMoveStruct } from '../move/internal-models.js'
-import {
-  Connection,
-  JsonRpcProvider,
-  SuiMoveNormalizedModule,
-  SuiEvent,
-  SuiMoveObject,
-  SuiParsedData,
-} from '@mysten/sui.js'
-
-export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
-  static INSTANCE = new SuiChainAdapter()
-
-  async fetchModule(account: string, module: string, network: SuiNetwork): Promise<SuiMoveNormalizedModule> {
-    const client = getRpcClient(network)
-    return await client.getNormalizedMoveModule({ package: account, module })
-  }
-
-  async fetchModules(account: string, network: SuiNetwork): Promise<SuiMoveNormalizedModule[]> {
-    const client = getRpcClient(network)
-    const modules = await client.getNormalizedMoveModulesByPackage({ package: account })
-    return Object.values(modules)
-  }
-
-  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
-    return params
-    // if (params.length === 0) {
-    //   return params
-    // }
-    // return params.slice(0, params.length - 1)
-  }
-
-  toInternalModules(modules: SuiMoveNormalizedModule[]): InternalMoveModule[] {
-    return Object.values(modules).map(toInternalModule)
-  }
-
-  getAllEventStructs(modules: InternalMoveModule[]): Map<string, InternalMoveStruct> {
-    const eventMap = new Map<string, InternalMoveStruct>()
-
-    for (const module of modules) {
-      const qname = moduleQname(module)
-
-      for (const struct of module.structs) {
-        const abilities = new Set(struct.abilities)
-        if (abilities.has('Drop') && abilities.has('Copy')) {
-          eventMap.set(qname + SPLITTER + struct.name, struct)
-        }
-      }
-    }
-    return eventMap
-  }
-
-  getType(base: SuiEvent | SuiMoveObject): string {
-    return base.type
-  }
-
-  getData(val: SuiEvent | SuiMoveObject) {
-    if (SuiEvent.is(val)) {
-      return val.parsedJson as any
-    }
-    if (SuiParsedData.is(val)) {
-      return val.fields as any
-    }
-    // if (SuiMoveObject.is(val)) {
-    //   return val.fields as any
-    // }
-    // This may not be perfect, just think everything has
-    if ('fields' in val) {
-      if ('type' in val && Object.keys(val).length === 2) {
-        return val.fields as any
-      }
-    }
-    return val as any
-  }
-  // validateAndNormalizeAddress(address: string) {
-  //   return validateAndNormalizeAddress(address)
-  // }
-}
-
-function getRpcEndpoint(network: SuiNetwork): string {
-  switch (network) {
-    case SuiNetwork.TEST_NET:
-      return 'https://fullnode.testnet.sui.io/'
-  }
-  return 'https://fullnode.mainnet.sui.io/'
-}
-
-function getRpcClient(network: SuiNetwork): JsonRpcProvider {
-  return new JsonRpcProvider(new Connection({ fullnode: getRpcEndpoint(network) }))
-}