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

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/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";

package/src/sui/codegen/codegen.ts

@@ -1,4 +1,4 @@
-import { SuiMoveNormalizedModule } from '@mysten/sui.js'
+import { SuiMoveNormalizedModule, SuiEvent, SuiMoveObject } from '@mysten/sui.js'
 
 import { SuiNetwork } from '../network.js'
 import * as fs from 'fs'
@@ -18,7 +18,7 @@ export async function codegen(abisDir: string, outDir = join('src', 'types', 'su
   console.log(chalk.green(`Generated ${numFiles} for Sui`))
 }
 
-class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModule, SuiNetwork> {
+class SuiCodegen extends AbstractCodegen<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   ADDRESS_TYPE = 'SuiAddress'
   MAIN_NET = SuiNetwork.MAIN_NET
   TEST_NET = SuiNetwork.TEST_NET
@@ -45,6 +45,8 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModule, SuiNetwork> {
         return `export type ${struct.name} = string`
       case '0x2::coin::Coin':
         return `export type ${struct.name}<T> = string`
+      case '0x2::balance::Balance':
+        return `export type ${struct.name}<T> = string`
       case '0x1::option::Option':
         return `export type Option<T> = T | undefined`
     }
@@ -56,6 +58,7 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModule, SuiNetwork> {
       case '0x2::object::ID':
       case '0x2::coin::Coin':
       case '0x1::option::Option':
+      case '0x2::balance::Balance':
         return ''
     }
     return super.generateOnEvents(module, struct)

package/src/sui/context.ts

@@ -60,6 +60,7 @@ export class SuiObjectsContext extends BaseContext {
   network: SuiNetwork
   slot: bigint
   timestamp: Date
+  coder: MoveCoder
 
   constructor(network: SuiNetwork, address: string, slot: bigint, timestamp: Date) {
     super()
@@ -67,6 +68,7 @@ export class SuiObjectsContext extends BaseContext {
     this.network = network
     this.slot = slot
     this.timestamp = timestamp
+    this.coder = defaultMoveCoder(network)
   }
 
   getChainId(): string {

package/src/sui/move-coder.ts

@@ -1,18 +1,12 @@
-import { TypedEventInstance, TypedFunctionPayload, TypedSuiMoveObject } from './models.js'
-import { AbstractMoveCoder, StructWithTag } from '../move/abstract-move-coder.js'
-import {
-  MoveCallSuiTransaction,
-  SuiCallArg,
-  SuiEvent,
-  SuiMoveNormalizedModule,
-  SuiMoveObject,
-  SuiRawData,
-} from '@mysten/sui.js'
+import { TypedEventInstance, TypedFunctionPayload } from './models.js'
+import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
+import { MoveCallSuiTransaction, SuiCallArg, SuiEvent, SuiMoveNormalizedModule, SuiMoveObject } from '@mysten/sui.js'
 import { toInternalModule } from './move-types.js'
 import { SPLITTER, TypeDescriptor } from '../move/index.js'
 import { dynamic_field } from './builtin/0x2.js'
 import { SuiNetwork } from './network.js'
 import { SuiChainAdapter } from './sui-chain-adapter.js'
+import { InternalMoveModule } from '../move/internal-models.js'
 
 export class MoveCoder extends AbstractMoveCoder<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   constructor(network: SuiNetwork) {
@@ -20,60 +14,58 @@ export class MoveCoder extends AbstractMoveCoder<SuiNetwork, SuiMoveNormalizedMo
     this.adapter = new SuiChainAdapter()
   }
 
-  load(module: SuiMoveNormalizedModule) {
-    if (this.contains(module.address, module.name)) {
-      return
+  load(module: SuiMoveNormalizedModule): InternalMoveModule {
+    let m = this.moduleMapping.get(module.address + '::' + module.name)
+    if (m) {
+      return m
     }
-    this.loadInternal(toInternalModule(module))
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
   }
 
   decode(data: any, type: TypeDescriptor): any {
     switch (type.qname) {
       case '0x2::object::ID':
       case '0x2::coin::Coin':
+      case '0x2::balance::Balance':
         return data
       case '0x1::option::Option':
-        // return this.decode(data, type.typeArgs[0])
-        return data
+        if (data === null) {
+          return data
+        }
+        return this.decode(data, type.typeArgs[0])
       default:
         return super.decode(data, type)
     }
   }
 
-  toStructWithTag(val: SuiEvent | SuiMoveObject): StructWithTag<SuiEvent> {
-    if (SuiEvent.is(val)) {
-      return {
-        ...val,
-        data: val.parsedJson as any,
-      }
-    }
-    if (SuiRawData.is(val)) {
-      return {
-        ...val,
-        data: val.fields as any,
-      }
-    }
-    return val as any
-  }
-
-  decodeEvent<T>(event: SuiEvent): TypedEventInstance<T> | undefined {
+  decodeEvent<T>(event: SuiEvent): Promise<TypedEventInstance<T> | undefined> {
     return this.decodedStruct<T>(event) as any
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: SuiEvent[]): TypedEventInstance<T>[] {
-    return this.filterAndDecodeStruct(typeQname, resources)
+  filterAndDecodeEvents<T>(typeQname: string, resources: SuiEvent[]): Promise<TypedEventInstance<T>[]> {
+    return this.filterAndDecodeStruct(typeQname, resources) as any
   }
 
-  getObjectsFromDynamicFields<Name, Value>(objects: SuiMoveObject[]): dynamic_field.Field<Name, Value>[] {
-    return this.filterAndDecodeObjects(`0x2::dynamic_field::Field`, objects).map((o) => o.data_decoded) as any
+  async getDynamicFields(
+    objects: SuiMoveObject[],
+    keyTypeMatcher: string = 'any',
+    valueTypeMatcher: string = 'any'
+  ): Promise<dynamic_field.Field<any, any>[]> {
+    const res = (await this.filterAndDecodeObjects(
+      `0x2::dynamic_field::Field<${keyTypeMatcher}, ${valueTypeMatcher}>`,
+      objects
+    )) as any[]
+    return res.map((o) => o.data_decoded) as any
   }
 
-  filterAndDecodeObjects<T>(typeQname: string, objects: SuiMoveObject[]): TypedSuiMoveObject<T>[] {
-    return this.filterAndDecodeStruct(typeQname, objects)
+  filterAndDecodeObjects(typeMatcher: string, objects: SuiMoveObject[]): Promise<any[]> {
+    return this.filterAndDecodeStruct(typeMatcher, objects) as any
   }
 
-  decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): MoveCallSuiTransaction {
+  async decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): Promise<MoveCallSuiTransaction> {
     const functionType = [payload.package, payload.module, payload.function].join(SPLITTER)
-    const func = this.getMoveFunction(functionType)
+    const func = await this.getMoveFunction(functionType)
     const params = this.adapter.getMeaningfulFunctionParams(func.params)
     const args = []
     for (const value of payload.arguments || []) {
@@ -95,7 +87,7 @@ export class MoveCoder extends AbstractMoveCoder<SuiNetwork, SuiMoveNormalizedMo
       }
     }
 
-    const argumentsTyped = this.decodeArray(args, params)
+    const argumentsTyped = await this.decodeArray(args, params)
     return {
       ...payload,
       arguments_decoded: argumentsTyped,

package/src/sui/sui-chain-adapter.ts

@@ -2,9 +2,16 @@ import { ChainAdapter, moduleQname, SPLITTER, TypeDescriptor } from '../move/ind
 import { toInternalModule } from './move-types.js'
 import { SuiNetwork } from './network.js'
 import { InternalMoveModule, InternalMoveStruct } from '../move/internal-models.js'
-import { Connection, JsonRpcProvider, SuiMoveNormalizedModule } from '@mysten/sui.js'
+import {
+  Connection,
+  JsonRpcProvider,
+  SuiMoveNormalizedModule,
+  SuiEvent,
+  SuiMoveObject,
+  SuiParsedData,
+} from '@mysten/sui.js'
 
-export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedModule> {
+export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedModule, SuiEvent | SuiMoveObject> {
   static INSTANCE = new SuiChainAdapter()
 
   async fetchModule(account: string, module: string, network: SuiNetwork): Promise<SuiMoveNormalizedModule> {
@@ -41,6 +48,29 @@ export class SuiChainAdapter extends ChainAdapter<SuiNetwork, SuiMoveNormalizedM
     }
     return eventMap
   }
+
+  getType(base: SuiEvent | SuiMoveObject): string {
+    return base.type
+  }
+
+  getData(val: SuiEvent | SuiMoveObject) {
+    if (SuiEvent.is(val)) {
+      return val.parsedJson as any
+    }
+    if (SuiParsedData.is(val)) {
+      return val.fields as any
+    }
+    // if (SuiMoveObject.is(val)) {
+    //   return val.fields as any
+    // }
+    // This may not be perfect, just think everything has
+    if ('fields' in val) {
+      if ('type' in val && Object.keys(val).length === 2) {
+        return val.fields as any
+      }
+    }
+    return val as any
+  }
 }
 
 function getRpcEndpoint(network: SuiNetwork): string {