@sentio/sdk 2.13.0-rc.1 → 2.13.0-rc.11

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
@@ -228,3 +241,19 @@ export interface TraceResult {
 //       "transactionPosition": 22,
 //       "type": "create"
 //     }
+
+export function isNullAddress(address: string) {
+  try {
+    // Normalize the input address
+    const normalizedAddress = getAddress(address)
+    // Check if the normalized address is equal to the null address (all zeros)
+    return normalizedAddress === '0x0000000000000000000000000000000000000000'
+  } catch (error) {
+    return false
+  }
+}
+
+export function validateAndNormalizeAddress(address: string): string {
+  const normalizedAddress = getAddress(address)
+  return normalizedAddress.toLowerCase()
+}

package/src/move/abstract-codegen.ts

@@ -12,6 +12,7 @@ import { format } from 'prettier'
 import { isFrameworkAccount, moduleQname, normalizeToJSName, SPLITTER, VECTOR_STR } from './utils.js'
 import { camelCase, upperFirst } from 'lodash-es'
 import { TypeDescriptor } from './types.js'
+import { ChainAdapter } from './chain-adapter.js'
 
 interface OutputFile {
   fileName: string
@@ -24,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
@@ -33,30 +34,30 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   GENERATE_CLIENT = false
   GENERATE_ON_ENTRY = true
   PAYLOAD_OPTIONAL = false
+  SYSTEM_MODULES = new Set(['0x1', '0x2', '0x3'])
 
-  abstract fetchModules(account: string, network: NetworkType): Promise<ModuleTypes>
-  abstract toInternalModules(modules: ModuleTypes): InternalMoveModule[]
-  // Get the structs that represent Events
-  abstract getEventStructs(module: InternalMoveModule): Map<string, InternalMoveStruct>
-  // 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[]
+  chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>
+
+  protected constructor(chainAdapter: ChainAdapter<NetworkType, ModuleTypes, StructType>) {
+    this.chainAdapter = chainAdapter
+  }
 
   readModulesFile(fullPath: string) {
     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
     }
@@ -70,9 +71,9 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     const loader = new AccountRegister()
 
     // when generating user code, don't need to generate framework account
-    loader.accountImports.set('0x1', new AccountModulesImportInfo('0x1', '0x1'))
-    loader.accountImports.set('0x2', new AccountModulesImportInfo('0x2', '0x2'))
-    loader.accountImports.set('0x3', new AccountModulesImportInfo('0x3', '0x3'))
+    for (const sysModule of this.SYSTEM_MODULES) {
+      loader.accountImports.set(sysModule, new AccountModulesImportInfo(sysModule, sysModule))
+    }
     // const client = getRpcClient(network)
 
     for (const file of files) {
@@ -81,7 +82,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
       }
       const fullPath = path.resolve(srcDir, file)
       const abi = this.readModulesFile(fullPath)
-      const modules = this.toInternalModules(abi)
+      const modules = this.chainAdapter.toInternalModules(abi)
 
       for (const module of modules) {
         loader.register(module, path.basename(file, '.json'))
@@ -100,8 +101,8 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
         console.log(`download dependent module for account ${account} at ${network}`)
 
         try {
-          const rawModules = await this.fetchModules(account, network)
-          const modules = this.toInternalModules(rawModules)
+          const rawModules = await this.chainAdapter.fetchModules(account, network)
+          const modules = this.chainAdapter.toInternalModules(rawModules)
 
           fs.writeFileSync(path.resolve(srcDir, account + '.json'), JSON.stringify(rawModules, null, '\t'))
           for (const module of modules) {
@@ -133,18 +134,19 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     }
 
     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
   }
 
@@ -163,7 +165,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     const clientFunctions = this.GENERATE_CLIENT
       ? module.exposedFunctions.map((f) => this.generateClientFunctions(module, f)).filter((s) => s !== '')
       : []
-    const eventStructs = this.getEventStructs(module)
+    const eventStructs = this.chainAdapter.getEventStructs(module)
     const eventTypes = new Set(eventStructs.keys())
     const events = Array.from(eventStructs.values())
       .map((e) => this.generateOnEvents(module, e))
@@ -219,6 +221,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   }
 
   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<ModuleTypes, NetworkType> {
     `
     }
 
+    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}
   `
@@ -282,7 +308,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
       return
     }
 
-    const fields = this.getMeaningfulFunctionParams(func.params).map((param) => {
+    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
       return this.generateTypeForDescriptor(param, module.address) + (this.PAYLOAD_OPTIONAL ? ' | undefined' : '')
     })
 
@@ -307,7 +333,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     }
     // const moduleName = normalizeToJSName(module.name)
     const funcName = camelCase(func.name)
-    const fields = this.getMeaningfulFunctionParams(func.params).map((param) => {
+    const fields = this.chainAdapter.getMeaningfulFunctionParams(func.params).map((param) => {
       return this.generateTypeForDescriptor(param, module.address)
     })
     const genericString = this.generateFunctionTypeParameters(func)
@@ -359,7 +385,7 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
     const source = `
   onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
       this.PREFIX
-    }Context) => void, fetchConfig?: MoveFetchConfig): ${moduleName} {
+    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
     this.onMoveEvent(func, {
       type: '${module.name}::${struct.name}'
     },
@@ -447,17 +473,17 @@ export abstract class AbstractCodegen<ModuleTypes, NetworkType> {
   }
 }
 
-export class AccountCodegen<ModuleType, NetworkType> {
+export class AccountCodegen<NetworkType, ModuleType, StructType> {
   modules: InternalMoveModule[]
   config: Config<NetworkType>
-  abi: ModuleType
+  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,
+    abi: ModuleType[],
     modules: InternalMoveModule[],
     config: Config<NetworkType>
   ) {
@@ -484,7 +510,7 @@ export class AccountCodegen<ModuleType, NetworkType> {
     }
 
     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,
@@ -514,6 +540,17 @@ export class AccountCodegen<ModuleType, NetworkType> {
       }
     }
 
+    let loadAllTypes = `loadAllTypes(defaultMoveCoder(${
+      this.moduleGen.PREFIX
+    }Network.${this.moduleGen.generateNetworkOption(this.config.network)}))`
+
+    if (this.moduleGen.SYSTEM_MODULES.has(address)) {
+      loadAllTypes = `
+        loadAllTypes(defaultMoveCoder(${this.moduleGen.PREFIX}Network.MAIN_NET))
+        loadAllTypes(defaultMoveCoder(${this.moduleGen.PREFIX}Network.TEST_NET))
+      `
+    }
+
     const source = `
     /* Autogenerated file. Do not edit manually. */
     /* tslint:disable */
@@ -536,7 +573,7 @@ export class AccountCodegen<ModuleType, NetworkType> {
       }
     }
 
-    loadAllTypes(defaultMoveCoder())
+    ${loadAllTypes}
     ` // source
 
     return [

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

@@ -1,32 +1,25 @@
 import { moduleQname, SPLITTER, VECTOR_STR } from './utils.js'
-import { 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 StructWithTag<Base> = {
-  type: string
-  data: Base
-}
-
-export type DecodedStructWithTag<B, T> = StructWithTag<B> & {
-  data_decoded: T
-  type_arguments: string[]
-}
-
-export abstract class AbstractMoveCoder<StructType> {
-  private moduleMapping = new Map<string, InternalMoveModule>()
+export abstract class AbstractMoveCoder<Network, ModuleType, StructType> {
+  protected moduleMapping = new Map<string, InternalMoveModule>()
   private typeMapping = new Map<string, InternalMoveStruct>()
   private funcMapping = new Map<string, InternalMoveFunction>()
+  network: Network
+  adapter: ChainAdapter<Network, ModuleType, StructType>
+
+  protected constructor(network: Network) {
+    this.network = network
+  }
 
   contains(account: string, name: string) {
     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)) {
@@ -63,23 +56,53 @@ export abstract class AbstractMoveCoder<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)
+    }
+    await resp
+    func = this.funcMapping.get(type)
+    if (func) {
+      return 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
@@ -114,13 +137,13 @@ export abstract class AbstractMoveCoder<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()) {
@@ -132,13 +155,14 @@ export abstract class AbstractMoveCoder<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
@@ -183,7 +207,7 @@ export abstract class AbstractMoveCoder<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()) {
@@ -195,19 +219,19 @@ export abstract class AbstractMoveCoder<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
@@ -216,13 +240,13 @@ export abstract class AbstractMoveCoder<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())
       }
@@ -230,61 +254,49 @@ export abstract class AbstractMoveCoder<StructType> {
     return entries
   }
 
-  encodeCallArgs(args: any[], func: string): any[] {
-    const f = this.getMoveFunction(func)
-    return this.encodeArray(args, this.getMeaningfulFunctionParams(f.params))
+  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: TypeDescriptor<T>,
+    structsWithTags: StructType[]
+  ): Promise<DecodedStruct<StructType, T>[]> {
     if (!structsWithTags) {
-      return []
+      return [] as any
     }
-    const results: DecodedStructWithTag<StructType, T>[] = []
+    // const typeMatcherDescriptor = parseMoveType(typeMatcher)
+    const results: DecodedStruct<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(typeMatcher, resourceTypeDescriptor)) {
         continue
       }
-      const result = this.decodedStructWithTag(resource)
+
+      const result = await this.decodedStruct<T>(resource)
       if (result) {
-        results.push(result as DecodedStructWithTag<StructType, T>)
+        results.push(result)
+      } else {
+        console.error('decoding error')
       }
     }
     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<DecodedStruct<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
@@ -293,6 +305,6 @@ export abstract class AbstractMoveCoder<StructType> {
       ...typeStruct,
       data_decoded: dataTyped,
       type_arguments: typeArguments,
-    } as DecodedStructWithTag<StructType, T>
+    } as DecodedStruct<StructType, T>
   }
 }

package/src/move/chain-adapter.ts

@@ -0,0 +1,17 @@
+import { InternalMoveModule, InternalMoveStruct } from './internal-models.js'
+import { TypeDescriptor } from './types.js'
+
+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[]>
+  abstract toInternalModules(modules: ModuleType[]): InternalMoveModule[]
+  // Get the structs that represent Events
+  abstract getEventStructs(module: InternalMoveModule): Map<string, InternalMoveStruct>
+  // 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/index.ts

@@ -2,3 +2,4 @@ export * from './filter.js'
 export * from './types.js'
 export * from './utils.js'
 export * from './account.js'
+export * from './chain-adapter.js'