@sentio/sdk 1.20.1 → 1.21.0

package/src/aptos/aptos-processor.ts

@@ -5,13 +5,15 @@ import {
   AptosNetwork,
   Transaction_UserTransaction,
   TransactionPayload_EntryFunctionPayload,
+  TypedEntryFunctionPayload,
+  TypedEventInstance,
+  TypeRegistry,
 } from '.'
-import type { Event as OldEvent } from 'aptos/src/generated'
 
 import Long from 'long'
 import { APTOS_MAINNET_ID, APTOS_TESTNET_ID } from '../utils/chain'
-
-export type Event = OldEvent & { version: string }
+import { EventInstance, GLOBAL_TYPE_REGISTRY } from './types'
+import { parseMoveType } from '../aptos-codegen/typegen'
 
 type IndexConfigure = {
   address: string
@@ -20,18 +22,25 @@ type IndexConfigure = {
   // endSeqNumber?: Long
 }
 
-export interface EventFilter {
+export interface EventFilter extends ArgumentsFilter {
   type: string
 }
 
-export interface CallFilter {
+export interface CallFilter extends CallArgumentsFilter {
   function: string
+}
+
+export interface CallArgumentsFilter extends ArgumentsFilter {
   typeArguments?: string[]
 }
 
+export interface ArgumentsFilter {
+  arguments?: string[]
+}
+
 class EventHandler {
   filters: EventFilter[]
-  handler: (event: Event) => Promise<ProcessResult>
+  handler: (event: EventInstance) => Promise<ProcessResult>
 }
 
 class CallHandler {
@@ -40,28 +49,29 @@ class CallHandler {
 }
 
 export class AptosBaseProcessor {
-  name: string
+  readonly moduleName: string
   config: IndexConfigure
   eventHandlers: EventHandler[] = []
   callHandlers: CallHandler[] = []
 
-  constructor(options: AptosBindOptions) {
-    this.name = options.name || options.address
+  constructor(moduleName: string, options: AptosBindOptions) {
+    this.moduleName = moduleName
     this.configure(options)
     global.PROCESSOR_STATE.aptosProcessors.push(this)
   }
 
-  static bind(options: AptosBindOptions): AptosBaseProcessor {
-    return new AptosBaseProcessor(options)
-  }
+  // getABI(): MoveModule | undefined {
+  //   return undefined
+  // }
 
   public onTransaction(
     handler: (transaction: Transaction_UserTransaction, ctx: AptosContext) => void
   ): AptosBaseProcessor {
     const address = this.config.address
+    const moduleName = this.moduleName
     this.callHandlers.push({
       handler: async function (tx) {
-        const ctx = new AptosContext(address, Long.fromString(tx.version), tx)
+        const ctx = new AptosContext(moduleName, address, Long.fromString(tx.version), tx)
         if (tx) {
           handler(tx, ctx)
         }
@@ -77,7 +87,7 @@ export class AptosBaseProcessor {
   }
 
   public onEvent(
-    handler: (event: Event, ctx: AptosContext) => void,
+    handler: (event: EventInstance, ctx: AptosContext) => void,
     filter: EventFilter | EventFilter[]
   ): AptosBaseProcessor {
     let _filters: EventFilter[] = []
@@ -88,13 +98,18 @@ export class AptosBaseProcessor {
       _filters.push(filter)
     }
 
-    const address = this.config.address
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
 
     this.eventHandlers.push({
       handler: async function (event) {
-        const ctx = new AptosContext(address, Long.fromString(event.version))
+        const ctx = new AptosContext(processor.moduleName, processor.config.address, Long.fromString(event.version))
         if (event) {
-          handler(event, ctx)
+          const decoded = processor.decodeEvent(event)
+          handler(decoded, ctx)
         }
         return {
           gauges: ctx.gauges,
@@ -119,14 +134,18 @@ export class AptosBaseProcessor {
       _filters.push(filter)
     }
 
-    const address = this.config.address
+    // const address = this.config.address
+    // const moduleName = this.moduleName
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
 
     this.callHandlers.push({
       handler: async function (tx) {
-        const ctx = new AptosContext(address, Long.fromString(tx.version), tx)
+        const ctx = new AptosContext(processor.moduleName, processor.config.address, Long.fromString(tx.version), tx)
         if (tx) {
           const payload = tx.payload as TransactionPayload_EntryFunctionPayload
-          handler(payload, ctx)
+          const decoded = processor.decodeFunctionPayload(payload)
+          handler(decoded, ctx)
         }
         return {
           gauges: ctx.gauges,
@@ -160,4 +179,53 @@ export class AptosBaseProcessor {
         return APTOS_MAINNET_ID
     }
   }
+
+  loadTypes(registry: TypeRegistry) {
+    if (registry.contains(this.config.address, this.moduleName)) {
+      return
+    }
+    this.loadTypesInternal(registry)
+  }
+
+  protected loadTypesInternal(registry: TypeRegistry) {
+    // should be override by subclass
+  }
+
+  private decodeEvent(event: EventInstance): EventInstance {
+    const registry = GLOBAL_TYPE_REGISTRY
+    this.loadTypes(registry)
+    // TODO check if module is not loaded
+
+    let dataTyped = undefined
+    try {
+      dataTyped = registry.decode(event.data, parseMoveType(event.type))
+    } catch (e) {
+      console.warn('Decoding error for ', event.type)
+      return event
+    }
+
+    return { ...event, data_typed: dataTyped } as TypedEventInstance<any>
+  }
+
+  private decodeFunctionPayload(
+    payload: TransactionPayload_EntryFunctionPayload
+  ): TransactionPayload_EntryFunctionPayload {
+    const registry = GLOBAL_TYPE_REGISTRY
+    this.loadTypes(registry)
+    const argumentsTyped: any[] = []
+
+    try {
+      const func = registry.getMoveFunction(payload.function)
+      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(func.params[idx + 1])
+        argumentsTyped.push(registry.decode(arg, argType))
+      }
+    } catch (e) {
+      console.warn('Decoding error for ', payload.function)
+      return payload
+    }
+
+    return { ...payload, arguments_typed: argumentsTyped } as TypedEntryFunctionPayload<any>
+  }
 }

package/src/aptos/bind-options.ts

@@ -9,13 +9,6 @@ export enum AptosNetwork {
 export class AptosBindOptions {
   address: string
   network?: AptosNetwork = AptosNetwork.TEST_NET
-  name?: string
   startVersion?: Long | number
   // endBlock?: Long | number
 }
-
-export class NamedAptosBindOptions {
-  address: string
-  network?: AptosNetwork = AptosNetwork.TEST_NET
-  startVersion?: Long | number
-}

package/src/aptos/context.ts

@@ -1,5 +1,5 @@
 import Long from 'long'
-import { MetricDescriptor, RecordMetaData } from '../gen'
+import { DataDescriptor, RecordMetaData } from '../gen'
 import { Labels } from '../core/metadata'
 import { APTOS_TESTNET_ID } from '../utils/chain'
 import { normalizeLabels } from '../core/meter'
@@ -8,27 +8,30 @@ import { Transaction_UserTransaction } from './'
 
 export class AptosContext extends BaseContext {
   address: string
-  blockNumber: Long
+  moduleName: string
+  version: Long
   transaction: Transaction_UserTransaction
 
-  constructor(address: string, slot: Long, transaction?: Transaction_UserTransaction) {
+  constructor(moduleName: string, address: string, version: Long, transaction?: Transaction_UserTransaction) {
     super()
     this.address = address
-    this.blockNumber = slot
+    this.moduleName = moduleName
+    this.version = version
     if (transaction) {
       this.transaction = transaction
     }
   }
 
-  getMetaData(descriptor: MetricDescriptor | undefined, labels: Labels): RecordMetaData {
+  getMetaData(descriptor: DataDescriptor | undefined, labels: Labels): RecordMetaData {
     return {
-      contractAddress: this.address,
-      blockNumber: this.blockNumber,
+      address: this.address,
+      contractName: this.moduleName,
+      blockNumber: this.version,
       transactionIndex: 0,
       transactionHash: this.transaction?.hash || '', // TODO
       logIndex: 0,
       chainId: APTOS_TESTNET_ID, // TODO set in context
-      descriptor: descriptor,
+      dataDescriptor: descriptor,
       labels: normalizeLabels(labels),
     }
   }

package/src/aptos/index.ts

@@ -1,5 +1,6 @@
 export type { Transaction_UserTransaction, TransactionPayload_EntryFunctionPayload } from 'aptos/src/generated'
-export type { Event, CallFilter, EventFilter } from './aptos-processor'
+export type { EventInstance, TypedEventInstance, TypeRegistry, TypedEntryFunctionPayload } from './types'
+export type { CallFilter, EventFilter } from './aptos-processor'
 export { AptosBaseProcessor } from './aptos-processor'
 export { AptosContext } from './context'
-export { AptosBindOptions, NamedAptosBindOptions, AptosNetwork } from './bind-options'
+export { AptosBindOptions, AptosNetwork } from './bind-options'

package/src/aptos/runtime.ts

@@ -0,0 +1,13 @@
+import { MoveStruct } from 'aptos/src/generated/models/MoveStruct'
+
+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/types.ts

@@ -0,0 +1,203 @@
+import {
+  Event,
+  MoveFunction,
+  MoveModule,
+  MoveStruct,
+  TransactionPayload_EntryFunctionPayload,
+} from 'aptos/src/generated'
+import { 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
+}
+
+// Don't use intermedidate type to make IDE happier
+export type TypedEntryFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
+  arguments_typed: T
+}
+
+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 || []
+  }
+
+  // Replace T0, T1 with more concrete type
+  applyArgs(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.applyArgs(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 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.applyArgs(typeCtx)
+      const value = this.decode(data[field.name], filedType)
+      typedData[field.name] = value
+    }
+    return typedData
+  }
+
+  // private decodeInternal(data: any, type: TypeDescriptor, typeArgs: )
+}
+
+export const GLOBAL_TYPE_REGISTRY = new TypeRegistry()

package/src/aptos/utils.ts

@@ -0,0 +1,18 @@
+import { MoveModule } from 'aptos/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]]
+}