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

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 {

package/src/sui/sui-processor.ts

@@ -22,8 +22,14 @@ import {
 import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter, parseMoveType } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
 import { defaultMoveCoder, MoveCoder } from './move-coder.js'
+import { PromiseOrVoid } from '../core/index.js'
 // import { dynamic_field } from './builtin/0x2.js'
 
+const DEFAULT_FETCH_CONFIG: MoveFetchConfig = {
+  resourceChanges: false,
+  allEvents: true,
+}
+
 class IndexConfigure {
   address: string
   network: SuiNetwork
@@ -71,7 +77,7 @@ export class SuiBaseProcessor {
     fetchConfig?: Partial<MoveFetchConfig>
   ): SuiBaseProcessor {
     let _filters: EventFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial(fetchConfig || {})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -112,7 +118,7 @@ export class SuiBaseProcessor {
             idx
           )
 
-          const decoded = processor.coder.decodeEvent<any>(evt)
+          const decoded = await processor.coder.decodeEvent<any>(evt)
           await handler(decoded || evt, ctx)
           processResults.push(ctx.getProcessResult())
         }
@@ -131,7 +137,7 @@ export class SuiBaseProcessor {
     fetchConfig?: Partial<MoveFetchConfig>
   ): SuiBaseProcessor {
     let _filters: FunctionNameAndCallFilter[] = []
-    const _fetchConfig = MoveFetchConfig.fromPartial(fetchConfig || {})
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig })
 
     if (Array.isArray(filter)) {
       _filters = filter
@@ -171,7 +177,7 @@ export class SuiBaseProcessor {
           const programmableTx = getProgrammableTransaction(txKind)
 
           const payload = calls[0]
-          const decoded = processor.coder.decodeFunctionPayload(payload, programmableTx?.inputs || [])
+          const decoded = await processor.coder.decodeFunctionPayload(payload, programmableTx?.inputs || [])
           await handler(decoded, ctx)
         }
         return ctx.getProcessResult()
@@ -221,7 +227,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   protected abstract transformObjects(objects: SuiMoveObject[]): HandlerType[]
 
   protected onInterval(
-    handler: (resources: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (resources: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     versionInterval: HandleInterval | undefined,
     type: string | undefined
@@ -246,7 +252,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   }
 
   public onTimeInterval(
-    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
     backfillTimeIntervalInMinutes = 240,
     type?: string
@@ -263,7 +269,7 @@ abstract class SuiBaseObjectsProcessor<HandlerType> {
   }
 
   public onSlotInterval(
-    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => void,
+    handler: (objects: HandlerType[], ctx: SuiObjectsContext) => PromiseOrVoid,
     slotInterval = 100000,
     backfillSlotInterval = 400000,
     type?: string