@sentio/sdk 2.13.0-rc.7 → 2.13.0-rc.9

package/src/aptos/codegen/codegen.ts

@@ -6,12 +6,17 @@ import { join } from 'path'
 import { AptosChainAdapter } from '../aptos-chain-adapter.js'
 import { AbstractCodegen } from '../../move/abstract-codegen.js'
 
-export async function codegen(abisDir: string, outDir = join('src', 'types', 'aptos'), genExample = false) {
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'aptos'),
+  genExample = false,
+  builtin = false
+) {
   if (!fs.existsSync(abisDir)) {
     return
   }
   const gen = new AptosCodegen()
-  const numFiles = await gen.generate(abisDir, outDir)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
   console.log(chalk.green(`Generated ${numFiles} for Aptos`))
 }
 

package/src/aptos/codegen/run.ts

@@ -6,7 +6,7 @@ if (process.argv.length > 3) {
   const abisDir = process.argv[2]
   const targetDir = process.argv[3]
 
-  await codegen(abisDir, targetDir)
+  await codegen(abisDir, targetDir, false, true)
 } else {
   console.error('Not enough argument')
   process.exit(1)

package/src/aptos/ext/aptos-dex.ts

@@ -2,12 +2,13 @@ import { Gauge } from '@sentio/sdk'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { calculateValueInUsd, getCoinInfo, whitelistCoins, whiteListed } from './coin.js'
 import { AptosResourcesContext, TypedMoveResource, MoveResource, AptosContext } from '@sentio/sdk/aptos'
+import { TypeDescriptor } from '../../move/index.js'
 
 export interface PoolAdaptor<T> {
   getXReserve(pool: T): bigint
   getYReserve(pool: T): bigint
   getExtraPoolTags(pool: TypedMoveResource<T>): any
-  poolTypeName: string
+  poolType: TypeDescriptor<T>
 }
 
 export class AptosDex<T> {
@@ -98,10 +99,7 @@ export class AptosDex<T> {
     ctx: AptosResourcesContext,
     poolsHandler?: (pools: TypedMoveResource<T>[]) => Promise<void> | void
   ) {
-    const pools: TypedMoveResource<T>[] = await ctx.coder.filterAndDecodeResources(
-      this.poolAdaptor.poolTypeName,
-      resources
-    )
+    const pools = await ctx.coder.filterAndDecodeResources(this.poolAdaptor.poolType, resources)
 
     const volumeByCoin = new Map<string, BigDecimal>()
     const timestamp = ctx.timestampInMicros

package/src/aptos/index.ts

@@ -8,3 +8,5 @@ export * from './api.js'
 export { ModuleClient } from './module-client.js'
 
 export { AptosPlugin } from './aptos-plugin.js'
+
+export { BUILTIN_TYPES } from '../move/types.js'

package/src/aptos/models.ts

@@ -1,17 +1,12 @@
 import { Event, MoveResource, TransactionPayload_EntryFunctionPayload } from './move-types.js'
+import { DecodedStruct } 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[]
-}
+export type TypedEventInstance<T> = DecodedStruct<EventInstance, T>
+export type TypedMoveResource<T> = DecodedStruct<MoveResource, T>
 
 // Don't use intermediate type to make IDE happier
 export type TypedFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
@@ -20,8 +15,3 @@ export type TypedFunctionPayload<T extends Array<any>> = TransactionPayload_Entr
    */
   arguments_decoded: T
 }
-
-export type TypedMoveResource<T> = MoveResource & {
-  data_decoded: T
-  type_arguments: string[]
-}

package/src/aptos/move-coder.ts

@@ -10,6 +10,7 @@ import { TypedEventInstance, TypedFunctionPayload, TypedMoveResource } from './m
 import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
 import { AptosNetwork } from './network.js'
 import { AptosChainAdapter } from './aptos-chain-adapter.js'
+import { parseMoveType, TypeDescriptor } from '../move/index.js'
 
 export class MoveCoder extends AbstractMoveCoder<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   constructor(network: AptosNetwork) {
@@ -36,14 +37,23 @@ export class MoveCoder extends AbstractMoveCoder<AptosNetwork, MoveModuleBytecod
   decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
     return this.decodedStruct<T>(event) as any
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: Event[]): Promise<TypedEventInstance<T>[]> {
-    return this.filterAndDecodeStruct(typeQname, resources) as any
+  filterAndDecodeEvents<T>(type: string | TypeDescriptor<T>, resources: Event[]): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources) as any
   }
   decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
     return this.decodedStruct<T>(res)
   }
-  filterAndDecodeResources<T>(typeQname: string, resources: MoveResource[]): Promise<TypedMoveResource<T>[]> {
-    return this.filterAndDecodeStruct(typeQname, resources) as any
+  filterAndDecodeResources<T>(
+    type: string | TypeDescriptor<T>,
+    resources: MoveResource[]
+  ): Promise<TypedMoveResource<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
   }
 
   async decodeFunctionPayload(

package/src/move/abstract-codegen.ts

@@ -46,17 +46,18 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     return JSON.parse(fs.readFileSync(fullPath, 'utf-8'))
   }
 
-  async generate(srcDir: string, outputDir: string): Promise<number> {
-    const num1 = await this.generateForNetwork(srcDir, outputDir, this.MAIN_NET)
+  async generate(srcDir: string, outputDir: string, builtin = false): Promise<number> {
+    const num1 = await this.generateForNetwork(srcDir, outputDir, this.MAIN_NET, builtin)
     const num2 = await this.generateForNetwork(
       path.join(srcDir, 'testnet'),
       path.join(outputDir, 'testnet'),
-      this.TEST_NET
+      this.TEST_NET,
+      builtin
     )
     return num1 + num2
   }
 
-  async generateForNetwork(srcDir: string, outputDir: string, network: NetworkType) {
+  async generateForNetwork(srcDir: string, outputDir: string, network: NetworkType, builtin = false) {
     if (!fs.existsSync(srcDir)) {
       return 0
     }
@@ -133,18 +134,19 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     }
 
     const rootFile = path.join(outputDir, 'index.ts')
-    fs.writeFileSync(
-      rootFile,
-      `/* Autogenerated file. Do not edit manually. */
+    let rootFileContent = `/* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
 `
-    )
     for (const output of outputs) {
       const parsed = path.parse(output.fileName)
-      const content = `export * as _${parsed.name.replaceAll('-', '_')} from './${parsed.name}.js'\n`
-      fs.appendFileSync(rootFile, content)
+      rootFileContent += `export * as _${parsed.name.replaceAll('-', '_')} from './${parsed.name}.js'\n`
     }
+    // if (builtin) {
+    //   rootFileContent += `export { BUILTIN_TYPES } from '@sentio/sdk/move'`
+    // }
+    fs.writeFileSync(rootFile, rootFileContent)
+
     return outputs.length + 1
   }
 
@@ -219,6 +221,7 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   }
 
   generateStructs(module: InternalMoveModule, struct: InternalMoveStruct, events: Set<string>) {
+    const typeParams = struct.typeParams || []
     const genericString = this.generateStructTypeParameters(struct)
     const genericStringAny = this.generateStructTypeParameters(struct, true)
 
@@ -240,11 +243,34 @@ export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
     `
     }
 
+    const typeParamApplyArg = typeParams
+      .map((v, idx) => {
+        return `arg${idx}: TypeDescriptor<T${idx}> = ANY_TYPE`
+      })
+      .join(',')
+    const typeParamApply = typeParams
+      .map((v, idx) => {
+        return `arg${idx}`
+      })
+      .join(',')
+
+    const typeWithArg = `
+  export function type${genericString}(${typeParamApplyArg}): TypeDescriptor<${structName}${genericString}> {
+    return TYPE.apply(${typeParamApply})
+  }`
+
     return `
-  export class ${structName}${genericString} {
-    static TYPE_QNAME = '${module.address}::${module.name}::${struct.name}'
+  export interface ${structName}${genericString} {
     ${fields.join('\n')}
   }
+  
+  export namespace ${structName}{
+    export const TYPE_QNAME = '${module.address}::${module.name}::${struct.name}'
+    
+    const TYPE = new TypeDescriptor<${structName}${genericStringAny}>(${structName}.TYPE_QNAME)
+
+    ${typeWithArg}
+  }
 
   ${eventPayload}
   `
@@ -484,7 +510,7 @@ export class AccountCodegen<NetworkType, ModuleType, StructType> {
     }
 
     const imports = `
-    import { CallFilter } from "@sentio/sdk/move"
+    import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move"
     import {
       MoveCoder, defaultMoveCoder, ${this.moduleGen.PREFIX}BindOptions, ${this.moduleGen.PREFIX}BaseProcessor,
       TypedEventInstance, ${this.moduleGen.PREFIX}Network, TypedFunctionPayload,

package/src/move/abstract-move-coder.ts

@@ -1,14 +1,9 @@
 import { moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
-import { matchType, parseMoveType, TypeDescriptor } from './types.js'
+import { DecodedStruct, matchType, parseMoveType, TypeDescriptor } from './types.js'
 import { InternalMoveFunction, InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import { bytesToBigInt } from '../utils/index.js'
 import { ChainAdapter } from './chain-adapter.js'
 
-export type DecodedStructWithTag<B, T> = B & {
-  data_decoded: T
-  type_arguments: string[]
-}
-
 export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
   protected moduleMapping = new Map<string, InternalMoveModule>()
   private typeMapping = new Map<string, InternalMoveStruct>()
@@ -270,32 +265,32 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
   }
 
   protected async filterAndDecodeStruct<T>(
-    typeMatcher: string,
+    typeMatcher: TypeDescriptor<T>,
     structsWithTags: StructType[]
-  ): Promise<DecodedStructWithTag<StructType, T>[]> {
+  ): Promise<DecodedStruct<StructType, T>[]> {
     if (!structsWithTags) {
       return [] as any
     }
-    const typeMatcherDescriptor = parseMoveType(typeMatcher)
-    const results: DecodedStructWithTag<StructType, T>[] = []
+    // const typeMatcherDescriptor = parseMoveType(typeMatcher)
+    const results: DecodedStruct<StructType, T>[] = []
     for (const resource of structsWithTags) {
       const resourceType = this.adapter.getType(resource)
       const resourceTypeDescriptor = parseMoveType(resourceType)
-      if (!matchType(typeMatcherDescriptor, resourceTypeDescriptor)) {
+      if (!matchType(typeMatcher, resourceTypeDescriptor)) {
         continue
       }
 
-      const result = await this.decodedStruct(resource)
+      const result = await this.decodedStruct<T>(resource)
       if (result) {
-        results.push(result as DecodedStructWithTag<StructType, T>)
+        results.push(result)
       } else {
-        console.log('')
+        console.error('decoding error')
       }
     }
     return results
   }
 
-  protected async decodedStruct<T>(typeStruct: StructType): Promise<DecodedStructWithTag<StructType, T> | undefined> {
+  protected async decodedStruct<T>(typeStruct: StructType): Promise<DecodedStruct<StructType, T> | undefined> {
     const typeDescriptor = parseMoveType(this.adapter.getType(typeStruct))
     const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature())
 
@@ -310,6 +305,6 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
       ...typeStruct,
       data_decoded: dataTyped,
       type_arguments: typeArguments,
-    } as DecodedStructWithTag<StructType, T>
+    } as DecodedStruct<StructType, T>
   }
 }

package/src/move/types.ts

@@ -1,6 +1,14 @@
 import { SPLITTER, VECTOR_STR } from './utils.js'
 
-export class TypeDescriptor {
+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
@@ -13,6 +21,32 @@ export class TypeDescriptor {
     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(', ') + '>'
@@ -51,25 +85,12 @@ export class TypeDescriptor {
     if (this.reference) {
       return []
     }
+    if (BUILTIN_TYPES_SET.has(this.qname.toLowerCase())) {
+      return []
+    }
     switch (this.qname) {
       case 'signer':
-      case 'address':
-      case 'Address':
       case '0x1::string::String':
-      case 'bool':
-      case 'Bool':
-      case 'u8':
-      case 'U8':
-      case 'u16':
-      case 'U16':
-      case 'u32':
-      case 'U32':
-      case 'u64':
-      case 'U64':
-      case 'u128':
-      case 'U128':
-      case 'u256':
-      case 'U256':
         return []
     }
 
@@ -155,6 +176,30 @@ function adjustType(type: TypeDescriptor) {
   }
 }
 
+export const ANY_TYPE = new TypeDescriptor<any>('any')
+
+export const BUILTIN_TYPES = {
+  ADDRESS_TYPE: new TypeDescriptor<string>('address'),
+  // export const Address = new TypeDescriptor<string>("Address")
+
+  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).map((t) => t.qname.toLowerCase()))
+
 /**
  *
  * @param matcher
@@ -164,7 +209,7 @@ export function matchType(matcher: TypeDescriptor, type: TypeDescriptor): boolea
   if (matcher.qname === 'any') {
     return true
   }
-  if (matcher.qname !== type.qname) {
+  if (!matcher.compareQname(type)) {
     return false
   }
   for (const [idx, matcherTarg] of matcher.typeArgs.entries()) {

package/src/sui/builtin/0x1.ts

@@ -4,7 +4,7 @@
 
 /* Generated modules for account 0x1 */
 
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move";
 import {
   MoveCoder,
   defaultMoveCoder,
@@ -63,21 +63,39 @@ export class ascii extends SuiBaseProcessor {
 }
 
 export namespace ascii {
-  export class Char {
-    static TYPE_QNAME = "0x1::ascii::Char";
+  export interface Char {
     byte: number;
   }
 
+  export namespace Char {
+    export const TYPE_QNAME = "0x1::ascii::Char";
+
+    const TYPE = new TypeDescriptor<Char>(Char.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Char> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CharInstance extends TypedEventInstance<Char> {
     data_decoded: Char;
     type_arguments: [];
   }
 
-  export class String {
-    static TYPE_QNAME = "0x1::ascii::String";
+  export interface String {
     bytes: number[];
   }
 
+  export namespace String {
+    export const TYPE_QNAME = "0x1::ascii::String";
+
+    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<String> {
+      return TYPE.apply();
+    }
+  }
+
   export interface StringInstance extends TypedEventInstance<String> {
     data_decoded: String;
     type_arguments: [];
@@ -115,12 +133,21 @@ export class bit_vector extends SuiBaseProcessor {
 }
 
 export namespace bit_vector {
-  export class BitVector {
-    static TYPE_QNAME = "0x1::bit_vector::BitVector";
+  export interface BitVector {
     length: bigint;
     bit_field: Boolean[];
   }
 
+  export namespace BitVector {
+    export const TYPE_QNAME = "0x1::bit_vector::BitVector";
+
+    const TYPE = new TypeDescriptor<BitVector>(BitVector.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<BitVector> {
+      return TYPE.apply();
+    }
+  }
+
   export interface BitVectorInstance extends TypedEventInstance<BitVector> {
     data_decoded: BitVector;
     type_arguments: [];
@@ -158,11 +185,20 @@ export class fixed_point32 extends SuiBaseProcessor {
 }
 
 export namespace fixed_point32 {
-  export class FixedPoint32 {
-    static TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+  export interface FixedPoint32 {
     value: bigint;
   }
 
+  export namespace FixedPoint32 {
+    export const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+
+    const TYPE = new TypeDescriptor<FixedPoint32>(FixedPoint32.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<FixedPoint32> {
+      return TYPE.apply();
+    }
+  }
+
   export interface FixedPoint32Instance
     extends TypedEventInstance<FixedPoint32> {
     data_decoded: FixedPoint32;
@@ -205,11 +241,20 @@ export class string_ extends SuiBaseProcessor {
 }
 
 export namespace string_ {
-  export class String {
-    static TYPE_QNAME = "0x1::string::String";
+  export interface String {
     bytes: number[];
   }
 
+  export namespace String {
+    export const TYPE_QNAME = "0x1::string::String";
+
+    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<String> {
+      return TYPE.apply();
+    }
+  }
+
   export interface StringInstance extends TypedEventInstance<String> {
     data_decoded: String;
     type_arguments: [];
@@ -245,11 +290,20 @@ export class type_name extends SuiBaseProcessor {
 }
 
 export namespace type_name {
-  export class TypeName {
-    static TYPE_QNAME = "0x1::type_name::TypeName";
+  export interface TypeName {
     name: ascii.String;
   }
 
+  export namespace TypeName {
+    export const TYPE_QNAME = "0x1::type_name::TypeName";
+
+    const TYPE = new TypeDescriptor<TypeName>(TypeName.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TypeName> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TypeNameInstance extends TypedEventInstance<TypeName> {
     data_decoded: TypeName;
     type_arguments: [];