@sentio/sdk 1.27.10 → 1.29.0

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>

package/src/core/logger.ts

@@ -1,4 +1,4 @@
-import { BaseContext } from './context'
+import { BaseContext } from './base-context'
 import { DataDescriptor, LogLevel } from '../gen'
 import { DescriptorWithUsage } from './metadata'
 

package/src/core/meter.ts

@@ -1,4 +1,4 @@
-import { BaseContext } from './context'
+import { BaseContext } from './base-context'
 import { toMetricValue, Numberish } from './numberish'
 import { DescriptorWithUsage, Labels } from './metadata'
 import { DataDescriptor } from '../gen'

package/src/endpoints.ts

@@ -0,0 +1,9 @@
+import { Provider } from '@ethersproject/providers'
+
+export class Endpoints {
+  // evm providers
+  providers = new Map<number, Provider>()
+
+  chainQueryAPI = ''
+  priceFeedAPI = ''
+}

package/src/gen/google/protobuf/timestamp.ts

@@ -0,0 +1,105 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export interface Timestamp {
+  seconds: Long;
+  nanos: number;
+}
+
+function createBaseTimestamp(): Timestamp {
+  return { seconds: Long.ZERO, nanos: 0 };
+}
+
+export const Timestamp = {
+  encode(
+    message: Timestamp,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (!message.seconds.isZero()) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.seconds = reader.int64() as Long;
+          break;
+        case 2:
+          message.nanos = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Timestamp {
+    return {
+      seconds: isSet(object.seconds)
+        ? Long.fromValue(object.seconds)
+        : Long.ZERO,
+      nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Timestamp): unknown {
+    const obj: any = {};
+    message.seconds !== undefined &&
+      (obj.seconds = (message.seconds || Long.ZERO).toString());
+    message.nanos !== undefined && (obj.nanos = Math.round(message.nanos));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<Timestamp>): Timestamp {
+    const message = createBaseTimestamp();
+    message.seconds =
+      object.seconds !== undefined && object.seconds !== null
+        ? Long.fromValue(object.seconds)
+        : Long.ZERO;
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+  ? string | number | Long
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}