@sentio/sdk 1.28.0 → 1.29.0

package/src/aptos/type-registry.ts

@@ -0,0 +1,187 @@
+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,46 +1,4 @@
-import {
-  Event,
-  MoveFunction,
-  MoveModule,
-  MoveStruct,
-  TransactionPayload_EntryFunctionPayload,
-  MoveResource,
-} from 'aptos-sdk/src/generated'
-import { getMeaningfulFunctionParams, moduleQname, SPLITTER, VECTOR_STR } from './utils'
-import { parseMoveType } from '../aptos-codegen/typegen'
-
-export type EventInstance = Event & {
-  version: string
-}
-
-export type TypedEventInstance<T> = EventInstance & {
-  // Typed data converted from ABI
-  // undefined if there is converting error, usually because the ABI/data
-  // mismatch
-  data_typed: T
-
-  type_arguments: string[]
-}
-
-// Don't use intermedidate type to make IDE happier
-export type TypedEntryFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
-  arguments_typed: T
-}
-
-export type TypedMoveResource<T> = MoveResource & {
-  data_typed: T
-  type_arguments: string[]
-}
-
-interface StructWithTag {
-  type: string
-  data: any
-}
-
-interface StructWithType<T> extends StructWithTag {
-  data_typed: T
-  type_arguments: string[]
-}
+import { SPLITTER, VECTOR_STR } from './utils'
 
 export class TypeDescriptor {
   // type: string
@@ -124,172 +82,68 @@ export class TypeDescriptor {
   }
 }
 
-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
+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')
       }
-      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)
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      continue
     }
-
-    // process vector
-    if (type.qname === VECTOR_STR) {
-      // vector<u8> as hex string
-      if (type.typeArgs[0].qname === 'u8') {
-        return data
+    if (ch === ',') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
       }
-
-      const res = []
-      for (const entry of data) {
-        res.push(this.decode(entry, type.typeArgs[0]))
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
       }
-      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
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      // continue parse next param
+      stack.push(new TypeDescriptor(''))
+      continue
     }
-    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
+    buffer.push(ch)
   }
 
-  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>
+  if (buffer.length > 0) {
+    stack[stack.length - 1].qname = buffer.join('')
   }
 
-  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>
+  const res = stack.pop()
+  if (!res || stack.length > 0) {
+    throw Error('Uxpectecd stack size')
   }
+  return res
 }
-
-export const TYPE_REGISTRY = new TypeRegistry()

package/src/aptos/utils.ts

@@ -1,8 +1,5 @@
 import { MoveFunction, MoveModule } from 'aptos-sdk/src/generated'
 
-import { createChannel, createClient } from 'nice-grpc'
-import { AptosQueryClient, AptosQueryDefinition } from '../gen/chainquery/protos/chainquery'
-
 export const SPLITTER = '::'
 
 export const VECTOR_STR = 'vector'
@@ -20,12 +17,6 @@ export function moduleQnameForType(type: string): [string, string] {
   return [parts[0], parts[1]]
 }
 
-export function getChainQueryClient(address = 'chainquery-server.chain-sync:6809'): AptosQueryClient {
-  const channel = createChannel(address)
-
-  return createClient(AptosQueryDefinition, channel)
-}
-
 export function getMeaningfulFunctionParams(func: MoveFunction): string[] {
   let params = func.params
   if (func.params[0] === '&signer') {

package/src/aptos-codegen/codegen.ts

@@ -2,10 +2,11 @@ import fs from 'fs'
 import path from 'path'
 import prettier from 'prettier'
 import { MoveFunction, MoveModule, MoveModuleBytecode, MoveStruct } from 'aptos-sdk/src/generated'
-import { AccountModulesImportInfo, AccountRegister, generateType, parseMoveType } from './typegen'
+import { AccountModulesImportInfo, AccountRegister, generateType } from './typegen'
 import { getMeaningfulFunctionParams, isFrameworkAccount, moduleQname, SPLITTER } from '../aptos/utils'
 import chalk from 'chalk'
 import { AptosNetwork, getChainName, getRpcClient } from '../aptos/network'
+import { parseMoveType } from '../aptos/types'
 
 export async function generate(srcDir: string, outputDir: string) {
   await generateForNetwork(srcDir, outputDir, AptosNetwork.MAIN_NET)

package/src/aptos-codegen/typegen.ts

@@ -1,5 +1,5 @@
 import { MoveModule } from 'aptos-sdk/src/generated'
-import { TypeDescriptor } from '../aptos/types'
+import { parseMoveType, TypeDescriptor } from '../aptos/types'
 import { moduleQname, moduleQnameForType, SPLITTER, VECTOR_STR } from '../aptos/utils'
 
 function generateTypeForDescriptor(type: TypeDescriptor, currentAddress: string): string {
@@ -62,72 +62,6 @@ function generateSimpleType(type: string, currentAddress: string): string {
   return '_' + parts.join('.')
 }
 
-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
-}
-
 // TODO ctx need to have type parameters
 export function generateType(type: string, currentAddress: string): string {
   return generateTypeForDescriptor(parseMoveType(type), currentAddress)

package/src/cli/upload.ts

@@ -13,12 +13,13 @@ import { getCliVersion } from './utils'
 
 async function createProject(options: SentioProjectConfig, apiKey: string) {
   const url = new URL('/api/v1/projects', options.host)
+  const [ownerName, slug] = options.project.includes('/') ? options.project.split('/') : [undefined, options.project]
   return fetch(url, {
     method: 'POST',
     headers: {
       'api-key': apiKey,
     },
-    body: JSON.stringify({ slug: options.project, visibility: 'PRIVATE' }),
+    body: JSON.stringify({ slug, ownerName, visibility: 'PRIVATE' }),
   })
 }
 

package/src/core/base-context.ts

@@ -0,0 +1,28 @@
+import { DataDescriptor, ProcessResult, RecordMetaData } from '../gen'
+import { Logger } from './logger'
+import { Labels } from './metadata'
+import { Meter } from './meter'
+
+export abstract class BaseContext {
+  meter: Meter
+  logger: Logger
+
+  res: ProcessResult = {
+    counters: [],
+    events: [],
+    exports: [],
+    gauges: [],
+    logs: [],
+  }
+
+  protected constructor() {
+    this.meter = new Meter(this)
+    this.logger = new Logger(this)
+  }
+
+  getProcessResult(): ProcessResult {
+    return this.res
+  }
+
+  abstract getMetaData(descriptor: DataDescriptor, labels: Labels): RecordMetaData
+}

package/src/core/base-processor.ts

@@ -1,7 +1,6 @@
-import { Event } from '@ethersproject/contracts'
 import { BytesLike } from '@ethersproject/bytes'
 import { Block, Log, getNetwork } from '@ethersproject/providers'
-import { BaseContract, EventFilter } from '@ethersproject/contracts'
+import { BaseContract, Event, EventFilter } from '@ethersproject/contracts'
 import Long from 'long'
 
 import { BoundContractView, ContractContext, ContractView } from './context'

package/src/core/context.ts

@@ -1,36 +1,12 @@
 import { DataDescriptor, RecordMetaData, ProcessResult } from '../gen'
 import { BaseContract, EventFilter } from 'ethers'
 import { Block, Log } from '@ethersproject/abstract-provider'
-import { Meter, normalizeLabels } from './meter'
+import { normalizeLabels } from './meter'
 import Long from 'long'
 import { Trace } from './trace'
-import { Logger } from './logger'
 import { Labels } from './metadata'
 import { SOL_MAINMET_ID, SUI_DEVNET_ID } from '../utils/chain'
-
-export abstract class BaseContext {
-  meter: Meter
-  logger: Logger
-
-  res: ProcessResult = {
-    counters: [],
-    events: [],
-    exports: [],
-    gauges: [],
-    logs: [],
-  }
-
-  protected constructor() {
-    this.meter = new Meter(this)
-    this.logger = new Logger(this)
-  }
-
-  getProcessResult(): ProcessResult {
-    return this.res
-  }
-
-  abstract getMetaData(descriptor: DataDescriptor, labels: Labels): RecordMetaData
-}
+import { BaseContext } from './base-context'
 
 export abstract class EthContext extends BaseContext {
   chainId: number

package/src/core/event-tracker.ts

@@ -1,5 +1,5 @@
-import { BaseContext } from './context'
-import { DataDescriptor, EventTrackingResult } from '@sentio/sdk'
+import { BaseContext } from './base-context'
+import { DataDescriptor, EventTrackingResult } from '../gen'
 
 export interface Event {
   // The unique identifier of main identity associate with an event

package/src/core/exporter.ts

@@ -1,4 +1,4 @@
-import { BaseContext } from './context'
+import { BaseContext } from './base-context'
 import { DataDescriptor, ExportResult } from '@sentio/sdk'
 
 export type Export = Record<string, any>