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

package/src/aptos/aptos-processor.ts

@@ -15,6 +15,12 @@ import {
 } from '@sentio/protos'
 import { ServerError, Status } from 'nice-grpc'
 import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter, parseMoveType } from '../move/index.js'
+import { PromiseOrVoid } from '../core/index.js'
+
+const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
+  resourceChanges: false,
+  allEvents: true,
+}
 
 type IndexConfigure = {
   address: string
@@ -54,11 +60,11 @@ export class AptosBaseProcessor {
   // }
 
   public onTransaction(
-    handler: (transaction: Transaction_UserTransaction, ctx: AptosContext) => void,
+    handler: (transaction: Transaction_UserTransaction, ctx: AptosContext) => PromiseOrVoid,
     includedFailed = false,
     fetchConfig?: Partial<MoveFetchConfig>
   ): this {
-    const _fetchConfig = MoveFetchConfig.fromPartial(fetchConfig || {})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     // const address = this.config.address
     // const moduleName = this.moduleName
@@ -92,7 +98,7 @@ export class AptosBaseProcessor {
     fetchConfig?: Partial<MoveFetchConfig>
   ): this {
     let _filters: EventFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial(fetchConfig || {})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -131,7 +137,7 @@ export class AptosBaseProcessor {
             idx
           )
           const eventInstance = evt as EventInstance
-          const decoded = processor.coder.decodeEvent<any>(eventInstance)
+          const decoded = await processor.coder.decodeEvent<any>(eventInstance)
           await handler(decoded || eventInstance, ctx)
           processResults.push(ctx.getProcessResult())
         }
@@ -145,12 +151,12 @@ export class AptosBaseProcessor {
   }
 
   public onEntryFunctionCall(
-    handler: (call: TransactionPayload_EntryFunctionPayload, ctx: AptosContext) => void,
+    handler: (call: TransactionPayload_EntryFunctionPayload, ctx: AptosContext) => PromiseOrVoid,
     filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
     fetchConfig?: Partial<MoveFetchConfig>
   ): this {
     let _filters: FunctionNameAndCallFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial(fetchConfig || {})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -179,7 +185,7 @@ export class AptosBaseProcessor {
         )
         if (tx) {
           const payload = tx.payload as TransactionPayload_EntryFunctionPayload
-          const decoded = processor.coder.decodeFunctionPayload(payload)
+          const decoded = await processor.coder.decodeFunctionPayload(payload)
           await handler(decoded, ctx)
         }
         return ctx.getProcessResult()
@@ -230,7 +236,7 @@ export class AptosResourcesProcessor {
   }
 
   private onInterval(
-    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => void,
+    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     versionInterval: HandleInterval | undefined,
     type: string | undefined
@@ -260,7 +266,7 @@ export class AptosResourcesProcessor {
   }
 
   public onTimeInterval(
-    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => void,
+    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string
@@ -277,7 +283,7 @@ export class AptosResourcesProcessor {
   }
 
   public onVersionInterval(
-    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => void,
+    handler: (resources: MoveResource[], ctx: AptosResourcesContext) => PromiseOrVoid,
     versionInterval = 100000,
     backfillVersionInterval = 400000,
     typePrefix?: string

package/src/aptos/codegen/codegen.ts

@@ -1,5 +1,5 @@
 import * as fs from 'fs'
-import { MoveModuleBytecode } from '../move-types.js'
+import { Event, MoveModuleBytecode, MoveResource } from '../move-types.js'
 import chalk from 'chalk'
 import { AptosNetwork } from '../network.js'
 import { join } from 'path'
@@ -15,7 +15,7 @@ export async function codegen(abisDir: string, outDir = join('src', 'types', 'ap
   console.log(chalk.green(`Generated ${numFiles} for Aptos`))
 }
 
-class AptosCodegen extends AbstractCodegen<MoveModuleBytecode, AptosNetwork> {
+class AptosCodegen extends AbstractCodegen<AptosNetwork, MoveModuleBytecode, Event | MoveResource> {
   ADDRESS_TYPE = 'Address'
   MAIN_NET = AptosNetwork.MAIN_NET
   TEST_NET = AptosNetwork.TEST_NET

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

@@ -98,7 +98,10 @@ export class AptosDex<T> {
     ctx: AptosResourcesContext,
     poolsHandler?: (pools: TypedMoveResource<T>[]) => Promise<void> | void
   ) {
-    const pools: TypedMoveResource<T>[] = ctx.coder.filterAndDecodeResources(this.poolAdaptor.poolTypeName, resources)
+    const pools: TypedMoveResource<T>[] = await ctx.coder.filterAndDecodeResources(
+      this.poolAdaptor.poolTypeName,
+      resources
+    )
 
     const volumeByCoin = new Map<string, BigDecimal>()
     const timestamp = ctx.timestampInMicros

package/src/aptos/module-client.ts

@@ -17,7 +17,7 @@ export class ModuleClient {
     ledger_version?: bigint
   ): Promise<any[]> {
     const coder = defaultMoveCoder()
-    const encodedArgs = coder.encodeCallArgs(args, func)
+    const encodedArgs = await coder.encodeCallArgs(args, func)
 
     const request: Types.ViewRequest = {
       function: func,

package/src/aptos/move-coder.ts

@@ -21,29 +21,37 @@ export class MoveCoder extends AbstractMoveCoder<AptosNetwork, MoveModuleBytecod
     if (!module.abi) {
       throw Error('Module without abi')
     }
-    if (this.contains(module.abi.address, module.abi.name)) {
-      return
+    let m = this.moduleMapping.get(module.abi.address + '::' + module.abi.name)
+    // if (this.contains(module.abi.address, module.abi.name)) {
+    //   return
+    // }
+    if (m) {
+      return m
     }
-    this.loadInternal(toInternalModule(module))
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
   }
 
-  decodeEvent<T>(event: Event): TypedEventInstance<T> | undefined {
-    return this.decodedStruct<T>(event) as TypedEventInstance<T>
+  decodeEvent<T>(event: Event): Promise<TypedEventInstance<T> | undefined> {
+    return this.decodedStruct<T>(event) as any
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: Event[]): TypedEventInstance<T>[] {
-    return this.filterAndDecodeStruct(typeQname, resources) as TypedEventInstance<T>[]
+  filterAndDecodeEvents<T>(typeQname: string, resources: Event[]): Promise<TypedEventInstance<T>[]> {
+    return this.filterAndDecodeStruct(typeQname, resources) as any
   }
-  decodeResource<T>(res: MoveResource): TypedMoveResource<T> | undefined {
+  decodeResource<T>(res: MoveResource): Promise<TypedMoveResource<T> | undefined> {
     return this.decodedStruct<T>(res)
   }
-  filterAndDecodeResources<T>(typeQname: string, resources: MoveResource[]): TypedMoveResource<T>[] {
+  filterAndDecodeResources<T>(typeQname: string, resources: MoveResource[]): Promise<TypedMoveResource<T>[]> {
     return this.filterAndDecodeStruct(typeQname, resources) as any
   }
 
-  decodeFunctionPayload(payload: TransactionPayload_EntryFunctionPayload): TransactionPayload_EntryFunctionPayload {
-    const func = this.getMoveFunction(payload.function)
+  async decodeFunctionPayload(
+    payload: TransactionPayload_EntryFunctionPayload
+  ): Promise<TransactionPayload_EntryFunctionPayload> {
+    const func = await this.getMoveFunction(payload.function)
     const params = this.adapter.getMeaningfulFunctionParams(func.params)
-    const argumentsDecoded = this.decodeArray(payload.arguments, params)
+    const argumentsDecoded = await this.decodeArray(payload.arguments, params)
 
     return {
       ...payload,

package/src/eth/base-processor.ts

@@ -1,5 +1,5 @@
 import { BaseContract, DeferredTopicFilter, TransactionResponseParams } from 'ethers'
-import { BlockParams, Network } from 'ethers/providers'
+import { Network } from 'ethers/providers'
 
 import { BoundContractView, ContractContext, ContractView, GlobalContext } from './context.js'
 import {
@@ -15,8 +15,7 @@ import {
 import { BindOptions } from './bind-options.js'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ServerError, Status } from 'nice-grpc'
-import { fixEmptyKey, TypedEvent, TypedCallTrace, formatEthData } from './eth.js'
-import * as console from 'console'
+import { fixEmptyKey, TypedEvent, TypedCallTrace, formatEthData, RichBlock } from './eth.js'
 import { getNetworkFromCtxOrNetworkish } from './provider.js'
 import sha3 from 'js-sha3'
 import { ListStateStorage } from '@sentio/runtime'
@@ -88,7 +87,7 @@ export class GlobalProcessor {
   }
 
   public onBlockInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     blockInterval = 250,
     backfillBlockInterval = 1000
   ): this {
@@ -99,7 +98,7 @@ export class GlobalProcessor {
   }
 
   public onTimeInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240
   ): this {
@@ -115,7 +114,7 @@ export class GlobalProcessor {
   }
 
   public onInterval(
-    handler: (block: BlockParams, ctx: GlobalContext) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: GlobalContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined
   ): this {
@@ -245,7 +244,7 @@ export abstract class BaseProcessor<
   }
 
   public onBlockInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     blockInterval = 250,
     backfillBlockInterval = 1000
   ): this {
@@ -256,7 +255,7 @@ export abstract class BaseProcessor<
   }
 
   public onTimeInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240
   ): this {
@@ -268,7 +267,7 @@ export abstract class BaseProcessor<
   }
 
   public onInterval(
-    handler: (block: BlockParams, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    handler: (block: RichBlock, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined
   ): this {

package/src/eth/eth.ts

@@ -11,7 +11,7 @@ import {
   object,
   formatData,
 } from 'ethers/providers'
-import { CallExceptionError, LogDescription, Result, DeferredTopicFilter } from 'ethers'
+import { CallExceptionError, LogDescription, Result, DeferredTopicFilter, BlockParams } from 'ethers'
 import { ContractContext } from './context.js'
 import { getAddress } from 'ethers/address'
 import { getBigInt, getNumber, hexlify } from 'ethers/utils'
@@ -34,6 +34,11 @@ export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = a
 
 export type TypedEventFilter<_TEvent extends TypedEvent> = DeferredTopicFilter
 
+export interface RichBlock extends BlockParams {
+  traces?: Trace[]
+  transactionReceipts?: TransactionReceiptParams[]
+}
+
 export class SimpleEthersError extends Error {
   e: Error
 
@@ -132,7 +137,7 @@ export function formatEthData(data: {
   if (data.block && !data.block.transactions) {
     data.block.transactions = []
   }
-  const block = data.block ? formatBlock(data.block) : undefined
+  const block = data.block ? formatRichBlock(data.block) : undefined
   const trace = data.trace ? (data.trace as Trace) : undefined
   const transaction = data.transaction ? formatTransactionResponse(data.transaction) : undefined
   const transactionReceipt = data.transactionReceipt ? formatTransactionReceipt(data.transactionReceipt) : undefined
@@ -145,6 +150,14 @@ export function formatEthData(data: {
   }
 }
 
+export function formatRichBlock(block: RichBlock): RichBlock {
+  formatBlock(block)
+  if (block.transactionReceipts) {
+    block.transactionReceipts = block.transactionReceipts.map((t) => formatTransactionReceipt(t))
+  }
+  return block
+}
+
 export interface TypedCallTrace<TArgsArray extends Array<any> = any, TArgsObject = any> extends Trace {
   args: TArgsObject & IResult
   name: string

package/src/move/abstract-codegen.ts

@@ -25,7 +25,7 @@ interface Config<NetworkType> {
   network: NetworkType
 }
 
-export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
+export abstract class AbstractCodegen<NetworkType, ModuleTypes, StructType> {
   TEST_NET: NetworkType
   MAIN_NET: NetworkType
   ADDRESS_TYPE: string
@@ -36,9 +36,9 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   PAYLOAD_OPTIONAL = false
   SYSTEM_MODULES = new Set(['0x1', '0x2', '0x3'])
 
-  chainAdapter: ChainAdapter<NetworkType, ModuleTypes>
+  chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>
 
-  protected constructor(chainAdapter: ChainAdapter<NetworkType, ModuleTypes>) {
+  protected constructor(chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>) {
     this.chainAdapter = chainAdapter
   }
 
@@ -447,15 +447,15 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   }
 }
 
-export class AccountCodegen<ModuleType, NetworkType> {
+export class AccountCodegen<NetworkType, ModuleType, StructType> {
   modules: InternalMoveModule[]
   config: Config<NetworkType>
   abi: ModuleType[]
   loader: AccountRegister
-  moduleGen: AbstractCodegen<ModuleType, NetworkType>
+  moduleGen: AbstractCodegen<NetworkType, ModuleType, StructType>
 
   constructor(
-    moduleGen: AbstractCodegen<ModuleType, NetworkType>,
+    moduleGen: AbstractCodegen<NetworkType, ModuleType, StructType>,
     loader: AccountRegister,
     abi: ModuleType[],
     modules: InternalMoveModule[],

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

@@ -1,25 +1,20 @@
 import { moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
-import { parseMoveType, TypeDescriptor } from './types.js'
+import { 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 StructWithTag<Base> = {
-  type: string
-  data: Base
-}
-
-export type DecodedStructWithTag<B, T> = StructWithTag<B> & {
+export type DecodedStructWithTag<B, T> = B & {
   data_decoded: T
   type_arguments: string[]
 }
 
 export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
-  private moduleMapping = new Map<string, InternalMoveModule>()
+  protected moduleMapping = new Map<string, InternalMoveModule>()
   private typeMapping = new Map<string, InternalMoveStruct>()
   private funcMapping = new Map<string, InternalMoveFunction>()
   network: Network
-  adapter: ChainAdapter<Network, ModuleType>
+  adapter: ChainAdapter<Network, ModuleType, StructType>
 
   protected constructor(network: Network) {
     this.network = network
@@ -29,11 +24,7 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     return this.moduleMapping.has(account + '::' + name)
   }
 
-  // protected abstract getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[]
-
-  protected toStructWithTag(val: StructType): StructWithTag<StructType> {
-    return val as any
-  }
+  abstract load(module: ModuleType): InternalMoveModule
 
   protected loadInternal(module: InternalMoveModule) {
     if (this.contains(module.address, module.name)) {
@@ -70,23 +61,53 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     return '0x' + data.toString(16)
   }
 
-  getMoveStruct(type: string): InternalMoveStruct {
-    const struct = this.typeMapping.get(type)
-    if (!struct) {
-      throw new Error('Failed to load type' + type + ' type are not imported anywhere')
+  private requestMap = new Map<string, Promise<InternalMoveModule>>()
+
+  async getMoveStruct(type: string): Promise<InternalMoveStruct> {
+    let struct = this.typeMapping.get(type)
+    if (struct) {
+      return struct
+    }
+    const [account, module, typeName] = type.split(SPLITTER)
+    const key = account + SPLITTER + module
+    let resp = this.requestMap.get(account + SPLITTER + module)
+    if (!resp) {
+      resp = this.adapter.fetchModule(account, module, this.network).then((m) => {
+        return this.load(m)
+      })
+      this.requestMap.set(key, resp)
     }
-    return struct
+    await resp
+    struct = this.typeMapping.get(type)
+    if (struct) {
+      return struct
+    }
+    throw new Error('Failed to load function ' + type + ' type are not imported anywhere')
   }
 
-  getMoveFunction(type: string): InternalMoveFunction {
-    const func = this.funcMapping.get(type)
-    if (!func) {
-      throw new Error('Failed to load function ' + type + ' type are not imported anywhere')
+  async getMoveFunction(type: string): Promise<InternalMoveFunction> {
+    let func = this.funcMapping.get(type)
+    if (func) {
+      return func
+    }
+    const [account, module, typeName] = type.split(SPLITTER)
+    const key = account + SPLITTER + module
+    let resp = this.requestMap.get(account + SPLITTER + module)
+    if (!resp) {
+      resp = this.adapter.fetchModule(account, module, this.network).then((m) => {
+        return this.load(m)
+      })
+      this.requestMap.set(key, resp)
     }
-    return func
+    await resp
+    func = this.funcMapping.get(type)
+    if (func) {
+      return func
+    }
+    throw new Error('Failed to load function ' + type + ' type are not imported anywhere')
   }
 
-  decode(data: any, type: TypeDescriptor): any {
+  async decode(data: any, type: TypeDescriptor): Promise<any> {
     // process simple type
     if (type.reference) {
       return data
@@ -121,13 +142,13 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
 
       const res = []
       for (const entry of data) {
-        res.push(this.decode(entry, type.typeArgs[0]))
+        res.push(await this.decode(entry, type.typeArgs[0]))
       }
       return res
     }
 
     // Process complex type
-    const struct = this.getMoveStruct(type.qname)
+    const struct = await this.getMoveStruct(type.qname)
 
     const typeCtx = new Map<string, TypeDescriptor>()
     for (const [idx, typeArg] of type.typeArgs.entries()) {
@@ -139,13 +160,14 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     for (const field of struct.fields) {
       let filedType = field.type
       filedType = filedType.applyTypeArgs(typeCtx)
-      const value = this.decode(data[field.name], filedType)
+      const fieldValue = this.adapter.getData(data)[field.name]
+      const value = await this.decode(fieldValue, filedType)
       typedData[field.name] = value
     }
     return typedData
   }
 
-  encode(data: any, type: TypeDescriptor): any {
+  async encode(data: any, type: TypeDescriptor): Promise<any> {
     // process simple type
     if (type.reference) {
       return data
@@ -190,7 +212,7 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     }
 
     // Process complex type
-    const struct = this.getMoveStruct(type.qname)
+    const struct = await this.getMoveStruct(type.qname)
 
     const typeCtx = new Map<string, TypeDescriptor>()
     for (const [idx, typeArg] of type.typeArgs.entries()) {
@@ -202,19 +224,19 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     for (const field of struct.fields) {
       let filedType = field.type
       filedType = filedType.applyTypeArgs(typeCtx)
-      const value = this.encode(data[field.name], filedType)
+      const value = await this.encode(data[field.name], filedType)
       typedData[field.name] = value
     }
     return typedData
   }
 
-  decodeArray(entries: any[], types: TypeDescriptor[]): any[] {
+  async decodeArray(entries: any[], types: TypeDescriptor[]): Promise<any[]> {
     const entriesDecoded: any[] = []
     for (const [idx, arg] of entries.entries()) {
       // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
       const argType = types[idx]
       try {
-        entriesDecoded.push(this.decode(arg, argType))
+        entriesDecoded.push(await this.decode(arg, argType))
       } catch (e) {
         console.error(e, 'Decoding error for ', JSON.stringify(arg), 'using type', argType)
         return entries
@@ -223,13 +245,13 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     return entriesDecoded
   }
 
-  encodeArray(entriesDecoded: any[], types: TypeDescriptor[]): any[] {
+  async encodeArray(entriesDecoded: any[], types: TypeDescriptor[]): Promise<any[]> {
     const entries: any[] = []
     for (const [idx, arg] of entriesDecoded.entries()) {
       // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
       const argType = types[idx]
       try {
-        entries.push(this.encode(arg, argType))
+        entries.push(await this.encode(arg, argType))
       } catch (e) {
         throw Error('Decoding error for ' + JSON.stringify(arg) + 'using type' + argType + e.toString())
       }
@@ -237,61 +259,49 @@ export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
     return entries
   }
 
-  encodeCallArgs(args: any[], func: string): any[] {
-    const f = this.getMoveFunction(func)
+  async encodeCallArgs(args: any[], func: string): Promise<any[]> {
+    const f = await this.getMoveFunction(func)
     return this.encodeArray(args, this.adapter.getMeaningfulFunctionParams(f.params))
   }
 
-  decodeCallResult(res: any[], func: string): any[] {
-    const f = this.getMoveFunction(func)
+  async decodeCallResult(res: any[], func: string): Promise<any[]> {
+    const f = await this.getMoveFunction(func)
     return this.decodeArray(res, f.return)
   }
 
-  protected filterAndDecodeStruct(typeQname: string, structs: StructType[]): any {
-    if (!structs) {
-      return []
-    }
-    const withTags = structs.map((s) => this.toStructWithTag(s))
-    return this.filterAndDecodeStructWithTags(typeQname, withTags)
-  }
-
-  private filterAndDecodeStructWithTags<T>(
-    typeQname: string,
-    structsWithTags: StructWithTag<StructType>[]
-  ): DecodedStructWithTag<StructType, T>[] {
+  protected async filterAndDecodeStruct<T>(
+    typeMatcher: string,
+    structsWithTags: StructType[]
+  ): Promise<DecodedStructWithTag<StructType, T>[]> {
     if (!structsWithTags) {
-      return []
+      return [] as any
     }
+    const typeMatcherDescriptor = parseMoveType(typeMatcher)
     const results: DecodedStructWithTag<StructType, T>[] = []
     for (const resource of structsWithTags) {
-      if (typeQname.includes('<')) {
-        if (resource.type !== typeQname) {
-          continue
-        }
-      } else if (resource.type.split('<')[0] !== typeQname) {
+      const resourceType = this.adapter.getType(resource)
+      const resourceTypeDescriptor = parseMoveType(resourceType)
+      if (!matchType(typeMatcherDescriptor, resourceTypeDescriptor)) {
         continue
       }
-      const result = this.decodedStructWithTag(resource)
+
+      const result = await this.decodedStruct(resource)
       if (result) {
         results.push(result as DecodedStructWithTag<StructType, T>)
+      } else {
+        console.log('')
       }
     }
     return results
   }
 
-  protected decodedStruct<T>(typeStruct: StructType): DecodedStructWithTag<StructType, T> | undefined {
-    return this.decodedStructWithTag(this.toStructWithTag(typeStruct)) as any
-  }
-
-  private decodedStructWithTag<T>(
-    typeStruct: StructWithTag<StructType>
-  ): DecodedStructWithTag<StructType, T> | undefined {
-    const typeDescriptor = parseMoveType(typeStruct.type)
+  protected async decodedStruct<T>(typeStruct: StructType): Promise<DecodedStructWithTag<StructType, T> | undefined> {
+    const typeDescriptor = parseMoveType(this.adapter.getType(typeStruct))
     const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature())
 
     let dataTyped = undefined
     try {
-      dataTyped = this.decode(this.toStructWithTag(typeStruct.data), typeDescriptor)
+      dataTyped = await this.decode(typeStruct, typeDescriptor)
     } catch (e) {
       console.error('Decoding error for ', JSON.stringify(typeStruct), e)
       return undefined

package/src/move/chain-adapter.ts

@@ -1,7 +1,7 @@
 import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
 import { TypeDescriptor } from './types.js'
 
-export abstract class ChainAdapter<NetworkType, ModuleType> {
+export abstract class ChainAdapter<NetworkType, ModuleType, StructType> {
   abstract fetchModule(account: string, module: string, network: NetworkType): Promise<ModuleType>
 
   abstract fetchModules(account: string, network: NetworkType): Promise<ModuleType[]>
@@ -11,4 +11,7 @@ export abstract class ChainAdapter<NetworkType, ModuleType> {
   // Get the parameters that actually have arguments in runtime
   // Aptos first signer and Sui's last TxContext are no use
   abstract getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[]
+
+  abstract getType(base: StructType): string
+  abstract getData<T>(base: StructType): any
 }

package/src/move/types.ts

@@ -154,3 +154,24 @@ function adjustType(type: TypeDescriptor) {
     type.qname = type.qname.slice(3)
   }
 }
+
+/**
+ *
+ * @param matcher
+ * @param type
+ */
+export function matchType(matcher: TypeDescriptor, type: TypeDescriptor): boolean {
+  if (matcher.qname === 'any') {
+    return true
+  }
+  if (matcher.qname !== type.qname) {
+    return false
+  }
+  for (const [idx, matcherTarg] of matcher.typeArgs.entries()) {
+    const targ = type.typeArgs[idx]
+    if (!matchType(matcherTarg, targ)) {
+      return false
+    }
+  }
+  return true
+}

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

@@ -31,10 +31,7 @@ export namespace bag {
 }
 
 export namespace balance {
-  export class Balance<T0> {
-    static TYPE_QNAME = "0x2::balance::Balance";
-    value: bigint;
-  }
+  export type Balance<T> = string;
 
   export class Supply<T0> {
     static TYPE_QNAME = "0x2::balance::Supply";