@sentio/sdk 2.0.0-rc.2 → 2.0.0-rc.21

package/src/aptos/context.ts

@@ -0,0 +1,72 @@
+import { RecordMetaData } from '@sentio/protos'
+import { type Labels, BaseContext, normalizeLabels } from '@sentio/sdk'
+import { Transaction_UserTransaction } from './move-types.js'
+import { AptosNetwork, getChainId } from './network.js'
+
+export class AptosContext extends BaseContext {
+  address: string
+  network: AptosNetwork
+  moduleName: string
+  version: bigint
+  transaction: Transaction_UserTransaction
+
+  constructor(
+    moduleName: string,
+    network: AptosNetwork,
+    address: string,
+    version: bigint,
+    transaction?: Transaction_UserTransaction
+  ) {
+    super()
+    this.address = address
+    this.network = network
+    this.moduleName = moduleName
+    this.version = version
+    if (transaction) {
+      this.transaction = transaction
+    }
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: this.moduleName,
+      blockNumber: this.version,
+      transactionIndex: 0,
+      transactionHash: this.transaction?.hash || '', // TODO
+      logIndex: 0,
+      chainId: getChainId(this.network),
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}
+
+export class AptosResourceContext extends BaseContext {
+  address: string
+  network: AptosNetwork
+  version: bigint
+  timestampInMicros: number
+
+  constructor(network: AptosNetwork, address: string, version: bigint, timestampInMicros: number) {
+    super()
+    this.address = address
+    this.network = network
+    this.version = version
+    this.timestampInMicros = timestampInMicros
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: 'resources',
+      blockNumber: this.version,
+      transactionIndex: 0,
+      transactionHash: '',
+      logIndex: 0,
+      chainId: getChainId(this.network),
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/aptos/index.ts

@@ -0,0 +1,10 @@
+export * from './move-types.js'
+export type { EventInstance, TypedEventInstance, TypedEntryFunctionPayload, TypedMoveResource } from './models.js'
+export { defaultMoveCoder, MoveCoder } from './move-coder.js'
+export type { FunctionNameAndCallFilter, EventFilter, CallFilter, ArgumentsFilter } from './aptos-processor.js'
+export { AptosBaseProcessor, AptosAccountProcessor } from './aptos-processor.js'
+export { AptosContext, AptosResourceContext } from './context.js'
+export { AptosBindOptions, AptosNetwork } from './network.js'
+export * from './api.js'
+
+export { AptosPlugin } from './aptos-plugin.js'

package/src/aptos/models.ts

@@ -0,0 +1,35 @@
+import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from './move-types.js'
+
+export type EventInstance = Event & {
+  version: string
+}
+
+export type TypedEventInstance<T> = EventInstance & {
+  /**
+   * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  data_decoded: T
+
+  type_arguments: string[]
+}
+
+// Don't use intermediate type to make IDE happier
+export type TypedEntryFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}
+
+export type TypedMoveResource<T> = MoveResource & {
+  type_arguments: string[]
+}
+
+export interface StructWithTag {
+  type: string
+  data: any
+}
+
+export interface StructWithType<T> extends StructWithTag {
+  type_arguments: string[]
+}

package/src/aptos/move-coder.ts

@@ -0,0 +1,199 @@
+import {
+  Event,
+  MoveFunction,
+  MoveModule,
+  MoveResource,
+  MoveStruct,
+  TransactionPayload_EntryFunctionPayload,
+} from './move-types.js'
+
+import { getMeaningfulFunctionParams, moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
+import { parseMoveType, TypeDescriptor } from './types.js'
+import {
+  TypedEventInstance,
+  TypedMoveResource,
+  StructWithTag,
+  StructWithType,
+  TypedEntryFunctionPayload,
+} from './models.js'
+
+export class MoveCoder {
+  private moduleMapping = new Map<string, MoveModule>()
+  private typeMapping = new Map<string, MoveStruct>()
+  private 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 = MOVE_CODER
+    // 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_decoded: dataTyped,
+      type_arguments: typeArguments,
+    } as StructWithType<T>
+  }
+
+  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
+    const registry = MOVE_CODER
+    // 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_decoded: argumentsTyped,
+    } as TypedEntryFunctionPayload<any>
+  }
+}
+
+export const MOVE_CODER = new MoveCoder()
+
+export function defaultMoveCoder(): MoveCoder {
+  return MOVE_CODER
+}

package/src/aptos/move-types.ts

@@ -0,0 +1,11 @@
+import { Types } from 'aptos-sdk'
+
+export type Address = Types.Address
+export type Event = Types.Event
+export type MoveFunction = Types.MoveFunction
+export type MoveModule = Types.MoveModule
+export type MoveResource = Types.MoveResource
+export type MoveStruct = Types.MoveStruct
+export type MoveModuleBytecode = Types.MoveModuleBytecode
+export type TransactionPayload_EntryFunctionPayload = Types.TransactionPayload_EntryFunctionPayload
+export type Transaction_UserTransaction = Types.Transaction_UserTransaction

package/src/aptos/network.ts

@@ -0,0 +1,29 @@
+import { CHAIN_IDS, getChainName } from '../core/chain.js'
+
+export enum AptosNetwork {
+  MAIN_NET = 1,
+  TEST_NET = 2,
+  // DEV_NET,
+}
+
+export function getChainId(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return CHAIN_IDS.APTOS_TESTNET
+  }
+  return CHAIN_IDS.APTOS_MAINNET
+}
+
+export function getAptosChainName(network: AptosNetwork): string {
+  switch (network) {
+    case AptosNetwork.TEST_NET:
+      return getChainName(CHAIN_IDS.APTOS_TESTNET)
+  }
+  return getChainName(CHAIN_IDS.APTOS_MAINNET)
+}
+
+export class AptosBindOptions {
+  address: string
+  network?: AptosNetwork = AptosNetwork.MAIN_NET
+  startVersion?: bigint | number
+}

package/src/aptos/run-codegen.ts

@@ -0,0 +1,13 @@
+// #!/usr/bin/env node
+
+import { codegen } from './codegen/codegen.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+
+  await codegen(abisDir, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}