@sentio/sdk 2.10.2 → 2.11.0-rc.1

package/src/sui/builtin/index.ts

@@ -3,3 +3,4 @@
 /* eslint-disable */
 export * as _0x1 from './0x1.js'
 export * as _0x2 from './0x2.js'
+export * as _0x3 from './0x3.js'

package/src/sui/codegen/codegen.ts

@@ -1,9 +1,10 @@
+import { Connection, JsonRpcProvider, SuiMoveNormalizedModules } from '@mysten/sui.js'
+
 import { SuiNetwork } from '../network.js'
 import * as fs from 'fs'
 import chalk from 'chalk'
 import { InternalMoveModule, InternalMoveStruct } from '../../move/internal-models.js'
 import { AbstractCodegen } from '../../move/abstract-codegen.js'
-import { JsonRpcProvider, SuiMoveNormalizedModules } from '@mysten/sui.js'
 import { toInternalModule } from '../move-types.js'
 import { moduleQname, SPLITTER, structQname, TypeDescriptor } from '../../move/index.js'
 import { getMeaningfulFunctionParams } from '../utils.js'
@@ -26,7 +27,7 @@ function getRpcEndpoint(network: SuiNetwork): string {
 }
 
 function getRpcClient(network: SuiNetwork): JsonRpcProvider {
-  return new JsonRpcProvider(getRpcEndpoint(network))
+  return new JsonRpcProvider(new Connection({ fullnode: getRpcEndpoint(network) }))
 }
 
 class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
@@ -35,10 +36,11 @@ class SuiCodegen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
   TEST_NET = SuiNetwork.TEST_NET
   PREFIX = 'Sui'
   STRUCT_FIELD_NAME = 'fields'
+  GENERATE_ON_ENTRY = true
 
   async fetchModules(account: string, network: SuiNetwork): Promise<SuiMoveNormalizedModules> {
     const client = getRpcClient(network)
-    return await client.getNormalizedMoveModulesByPackage(account)
+    return await client.getNormalizedMoveModulesByPackage({ package: account })
   }
 
   getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {

package/src/sui/context.ts

@@ -1,7 +1,7 @@
 import { RecordMetaData } from '@sentio/protos'
 import { type Labels, BaseContext, normalizeLabels } from '../index.js'
 import { SuiNetwork, getChainId } from './network.js'
-import { SuiTransactionResponse } from '@mysten/sui.js'
+import { SuiTransactionBlockResponse } from '@mysten/sui.js'
 
 export class SuiContext extends BaseContext {
   address: string
@@ -9,7 +9,7 @@ export class SuiContext extends BaseContext {
   moduleName: string
   timestamp: Date
   slot: bigint
-  transaction: SuiTransactionResponse
+  transaction: SuiTransactionBlockResponse
 
   constructor(
     moduleName: string,
@@ -17,7 +17,7 @@ export class SuiContext extends BaseContext {
     address: string,
     timestamp: Date,
     slot: bigint,
-    transaction?: SuiTransactionResponse
+    transaction?: SuiTransactionBlockResponse
   ) {
     super()
     this.address = address.toLowerCase()
@@ -40,7 +40,7 @@ export class SuiContext extends BaseContext {
       contractName: this.moduleName,
       blockNumber: this.slot,
       transactionIndex: 0,
-      transactionHash: this.transaction?.certificate.transactionDigest || '', // TODO
+      transactionHash: this.transaction?.digest || '', // TODO
       logIndex: 0,
       chainId: this.getChainId(),
       name: name,

package/src/sui/models.ts

@@ -1,15 +1,15 @@
-import { MoveEvent, MoveCall } from '@mysten/sui.js'
+import { SuiEvent, MoveCallSuiTransaction } from '@mysten/sui.js'
 
-export type TypedEventInstance<T> = MoveEvent & {
+export type TypedEventInstance<T> = SuiEvent & {
   /**
    * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
    */
-  fields_decoded: T
+  data_decoded: T
 
   type_arguments: string[]
 }
 
-export type TypedFunctionPayload<T extends Array<any>> = MoveCall & {
+export type TypedFunctionPayload<T extends Array<any>> = MoveCallSuiTransaction & {
   /**
    * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
    */

package/src/sui/move-coder.ts

@@ -1,11 +1,11 @@
 import { TypedEventInstance, TypedFunctionPayload } from './models.js'
 import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
-import { MoveCall, MoveEvent, SuiMoveNormalizedModule } from '@mysten/sui.js'
+import { MoveCallSuiTransaction, SuiEvent, SuiMoveNormalizedModule, SuiCallArg } from '@mysten/sui.js'
 import { toInternalModule } from './move-types.js'
 import { SPLITTER, TypeDescriptor } from '../move/index.js'
 import { getMeaningfulFunctionParams } from './utils.js'
 
-export class MoveCoder extends AbstractMoveCoder<MoveEvent> {
+export class MoveCoder extends AbstractMoveCoder<SuiEvent> {
   load(module: SuiMoveNormalizedModule) {
     if (this.contains(module.address, module.name)) {
       return
@@ -25,32 +25,44 @@ export class MoveCoder extends AbstractMoveCoder<MoveEvent> {
     }
   }
 
-  decodeEvent<T>(event: MoveEvent): TypedEventInstance<T> | undefined {
-    const res = this.decodedInternal<T>({ ...event, data: event.fields })
-    return { ...event, fields_decoded: res?.data_decoded as T, type_arguments: res?.type_arguments || [] }
+  decodeEvent<T>(event: SuiEvent): TypedEventInstance<T> | undefined {
+    const res = this.decodedInternal<T>({ ...event, data: event.parsedJson })
+    return { ...event, data_decoded: res?.data_decoded as T, type_arguments: res?.type_arguments || [] }
   }
-  filterAndDecodeEvents<T>(typeQname: string, resources: MoveEvent[]): TypedEventInstance<T>[] {
+  filterAndDecodeEvents<T>(typeQname: string, resources: SuiEvent[]): TypedEventInstance<T>[] {
     const resp = this.filterAndDecodeInternal(
       typeQname,
       resources.map((event) => {
-        return { ...event, data: event.fields, type: event.type }
+        return { ...event, data: event.parsedJson, type: event.type }
       })
     )
     return resp.map((res) => {
       delete res.data_decoded
-      const event = res as MoveEvent
-      return { ...event, fields_decoded: res?.data_decoded as T, type_arguments: res?.type_arguments || [] }
+      const event = res as SuiEvent
+      return { ...event, data_decoded: res?.data_decoded as T, type_arguments: res?.type_arguments || [] }
     })
   }
   getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
     return getMeaningfulFunctionParams(params)
   }
 
-  decodeFunctionPayload(payload: MoveCall): MoveCall {
-    const functionType = [payload.package.objectId, payload.module, payload.function].join(SPLITTER)
+  decodeFunctionPayload(payload: MoveCallSuiTransaction, inputs: SuiCallArg[]): MoveCallSuiTransaction {
+    const functionType = [payload.package, payload.module, payload.function].join(SPLITTER)
     const func = this.getMoveFunction(functionType)
     const params = getMeaningfulFunctionParams(func.params)
-    const argumentsTyped = this.decodeArray(payload.arguments || [], params)
+    const args = []
+    for (const value of payload.arguments || []) {
+      const argValue = value as any
+      if ('Input' in (argValue as any)) {
+        const idx = argValue.Input
+        const arg = inputs[idx]
+        args.push(arg) // TODO check why ts not work using arg.push(arg)
+      } else {
+        args.push(undefined)
+      }
+    }
+
+    const argumentsTyped = this.decodeArray(args, params)
     return {
       ...payload,
       arguments_decoded: argumentsTyped,

package/src/sui/move-types.ts

@@ -19,7 +19,7 @@ export type { SuiAddress } from '@mysten/sui.js'
 export function toInternalModule(module: SuiMoveNormalizedModule): InternalMoveModule {
   return {
     address: module.address,
-    exposedFunctions: Object.entries(module.exposed_functions).map(([n, f]) => toInternalFunction(n, f)),
+    exposedFunctions: Object.entries(module.exposedFunctions).map(([n, f]) => toInternalFunction(n, f)),
     name: module.name,
     structs: Object.entries(module.structs).map(([n, s]) => toInternalStruct(n, s)),
   }
@@ -41,13 +41,13 @@ export function toInternalFunction(name: string, func: SuiMoveNormalizedFunction
       throw Error('No visibility for function' + name)
   }
   return {
-    typeParams: func.type_parameters.map((p: any) => {
+    typeParams: func.typeParameters.map((p: any) => {
       return { constraints: p.abilities }
     }),
-    isEntry: func.is_entry,
+    isEntry: func.isEntry,
     name: name,
     params: func.parameters.map(toTypeDescriptor),
-    return: func.return_.map(toTypeDescriptor),
+    return: func.return.map(toTypeDescriptor),
     visibility: visibility,
   }
 }
@@ -56,7 +56,7 @@ export function toInternalStruct(name: string, struct: SuiMoveNormalizedStruct):
   return {
     abilities: struct.abilities.abilities,
     fields: struct.fields.map(toInternalField),
-    typeParams: struct.type_parameters.map((p: any) => {
+    typeParams: struct.typeParameters.map((p: any) => {
       return { constraints: p.constraints.abilities }
     }),
     isNative: false,
@@ -67,7 +67,7 @@ export function toInternalStruct(name: string, struct: SuiMoveNormalizedStruct):
 export function toInternalField(module: SuiMoveNormalizedField): InternalMoveStructField {
   return {
     name: module.name,
-    type: toTypeDescriptor(module.type_),
+    type: toTypeDescriptor(module.type),
   }
 }
 
@@ -81,7 +81,7 @@ export function toTypeDescriptor(normalizedType: SuiMoveNormalizedType): TypeDes
       SPLITTER
     )
 
-    const args = normalizedType.Struct.type_arguments.map(toTypeDescriptor)
+    const args = normalizedType.Struct.typeArguments.map(toTypeDescriptor)
 
     return new TypeDescriptor(qname, args)
   }

package/src/sui/sui-processor.ts

@@ -11,7 +11,14 @@ import { ListStateStorage } from '@sentio/runtime'
 import { SuiNetwork, getChainId } from './network.js'
 import { ServerError, Status } from 'nice-grpc'
 import { SuiContext, SuiObjectsContext } from './context.js'
-import { MoveEvent, SuiTransactionResponse, MoveCall, SuiMoveObject } from '@mysten/sui.js'
+import {
+  MoveCallSuiTransaction,
+  SuiEvent,
+  SuiMoveObject,
+  SuiTransactionBlockResponse,
+  getTransactionKind,
+  getProgrammableTransaction,
+} from '@mysten/sui.js'
 import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
 import { defaultMoveCoder } from './move-coder.js'
@@ -50,7 +57,7 @@ export class SuiBaseProcessor {
   }
 
   public onMoveEvent(
-    handler: (event: MoveEvent, ctx: SuiContext) => void,
+    handler: (event: SuiEvent, ctx: SuiContext) => void,
     filter: EventFilter | EventFilter[],
     fetchConfig?: MoveFetchConfig
   ): SuiBaseProcessor {
@@ -73,8 +80,8 @@ export class SuiBaseProcessor {
         if (!data.transaction) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'event is null')
         }
-        const txn = data.transaction as SuiTransactionResponse
-        if (!txn.effects.events || !txn.effects.events.length) {
+        const txn = data.transaction as SuiTransactionBlockResponse
+        if (!txn.events || !txn.events.length) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'no event in the transactions')
         }
 
@@ -87,14 +94,14 @@ export class SuiBaseProcessor {
           txn
         )
 
-        const events = txn.effects.events
-        txn.effects.events = []
+        const events = txn.events
+        txn.events = []
         for (const evt of events) {
-          if ('moveEvent' in evt) {
-            const eventInstance = evt.moveEvent as MoveEvent
-            const decoded = defaultMoveCoder().decodeEvent<any>(eventInstance)
-            await handler(decoded || eventInstance, ctx)
-          }
+          // if ('moveEvent' in evt) {
+          //   const eventInstance = evt.moveEvent as SuiEvent
+          const decoded = defaultMoveCoder().decodeEvent<any>(evt)
+          await handler(decoded || evt, ctx)
+          // }
         }
 
         return ctx.getProcessResult()
@@ -106,7 +113,7 @@ export class SuiBaseProcessor {
   }
 
   public onEntryFunctionCall(
-    handler: (call: MoveCall, ctx: SuiContext) => void,
+    handler: (call: MoveCallSuiTransaction, ctx: SuiContext) => void,
     filter: FunctionNameAndCallFilter | FunctionNameAndCallFilter[],
     fetchConfig?: MoveFetchConfig
   ): SuiBaseProcessor {
@@ -128,7 +135,7 @@ export class SuiBaseProcessor {
         if (!data.transaction) {
           throw new ServerError(Status.INVALID_ARGUMENT, 'call is null')
         }
-        const tx = data.transaction as SuiTransactionResponse
+        const tx = data.transaction as SuiTransactionBlockResponse
 
         const ctx = new SuiContext(
           processor.moduleName,
@@ -139,12 +146,18 @@ export class SuiBaseProcessor {
           tx
         )
         if (tx) {
-          const calls: MoveCall[] = getMoveCalls(tx)
+          const calls: MoveCallSuiTransaction[] = getMoveCalls(tx)
           if (calls.length !== 1) {
             throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected number of call transactions ' + calls.length)
           }
+          const txKind = getTransactionKind(tx)
+          if (!txKind) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected getTransactionKind get empty')
+          }
+          const programmableTx = getProgrammableTransaction(txKind)
+
           const payload = calls[0]
-          const decoded = defaultMoveCoder().decodeFunctionPayload(payload)
+          const decoded = defaultMoveCoder().decodeFunctionPayload(payload, programmableTx?.inputs || [])
           await handler(decoded, ctx)
         }
         return ctx.getProcessResult()

package/src/sui/utils.ts

@@ -1,10 +1,26 @@
-import { SuiTransactionResponse, getMoveCallTransaction, SuiTransactionKind } from '@mysten/sui.js'
+import {
+  SuiTransactionBlockResponse,
+  MoveCallSuiTransaction,
+  getTransactionKind,
+  getProgrammableTransaction,
+  ProgrammableTransaction,
+  SuiTransaction,
+} from '@mysten/sui.js'
 import { TypeDescriptor } from '../move/index.js'
 
-export function getMoveCalls(tx: SuiTransactionResponse) {
-  return tx.certificate.data.transactions.flatMap((tx: SuiTransactionKind) => {
-    const call = getMoveCallTransaction(tx)
-    if (call) {
+export function getMoveCalls(txBlock: SuiTransactionBlockResponse) {
+  const txKind = getTransactionKind(txBlock)
+  if (!txKind) {
+    return []
+  }
+  const programmableTx: ProgrammableTransaction | undefined = getProgrammableTransaction(txKind)
+  if (!programmableTx) {
+    return []
+  }
+
+  return programmableTx.transactions.flatMap((tx: SuiTransaction) => {
+    if ('MoveCall' in tx) {
+      const call = tx.MoveCall as MoveCallSuiTransaction
       return [call]
     }
     return []

package/src/testing/sui-facet.ts

@@ -1,9 +1,9 @@
+import { SuiEvent, SuiTransactionBlockResponse, MoveCallSuiTransaction } from '@mysten/sui.js'
 import { DataBinding, HandlerType } from '@sentio/protos'
 import { getChainId } from '../sui/network.js'
 import { TestProcessorServer } from './test-processor-server.js'
 import { parseMoveType } from '../move/types.js'
 import { SuiNetwork } from '../sui/index.js'
-import { MoveEvent, SuiTransactionResponse, MoveCall } from '@mysten/sui.js'
 import { getMoveCalls } from '../sui/utils.js'
 import { SPLITTER } from '../move/index.js'
 
@@ -13,11 +13,11 @@ export class SuiFacet {
     this.server = server
   }
 
-  testEntryFunctionCall(transaction: SuiTransactionResponse, network: SuiNetwork = SuiNetwork.MAIN_NET) {
+  testEntryFunctionCall(transaction: SuiTransactionBlockResponse, network: SuiNetwork = SuiNetwork.MAIN_NET) {
     return this.testEntryFunctionCalls([transaction], network)
   }
 
-  testEntryFunctionCalls(transactions: SuiTransactionResponse[], network: SuiNetwork = SuiNetwork.MAIN_NET) {
+  testEntryFunctionCalls(transactions: SuiTransactionBlockResponse[], network: SuiNetwork = SuiNetwork.MAIN_NET) {
     const bindings = []
     for (const trans of transactions) {
       const binding = this.buildEntryFunctionCallBinding(trans, network)
@@ -32,14 +32,14 @@ export class SuiFacet {
   }
 
   private buildEntryFunctionCallBinding(
-    transaction: SuiTransactionResponse,
+    transaction: SuiTransactionBlockResponse,
     network: SuiNetwork = SuiNetwork.MAIN_NET
   ): DataBinding | undefined {
-    const calls: MoveCall[] = getMoveCalls(transaction)
+    const calls: MoveCallSuiTransaction[] = getMoveCalls(transaction)
     if (calls.length !== 1) {
       throw Error('Transaction has more than one calls')
     }
-    const functionType = [calls[0].package.objectId, calls[0].module, calls[0].function].join(SPLITTER)
+    const functionType = [calls[0].package, calls[0].module, calls[0].function].join(SPLITTER)
 
     for (const config of this.server.contractConfigs) {
       if (config.contract?.chainId !== getChainId(network)) {
@@ -66,12 +66,16 @@ export class SuiFacet {
     return undefined
   }
 
-  testEvent(transaction: SuiTransactionResponse, event: number | MoveEvent, network: SuiNetwork = SuiNetwork.MAIN_NET) {
+  testEvent(
+    transaction: SuiTransactionBlockResponse,
+    event: number | SuiEvent,
+    network: SuiNetwork = SuiNetwork.MAIN_NET
+  ) {
     if (typeof event !== 'number') {
-      const transaction2: SuiTransactionResponse = {} as any
+      const transaction2: SuiTransactionBlockResponse = {} as any
       Object.assign(transaction2, transaction)
       transaction = transaction2
-      transaction.effects.events = [event]
+      transaction.events = [event]
       event = 0
     }
     const binding = this.buildEventBinding(transaction, event, network)
@@ -82,13 +86,13 @@ export class SuiFacet {
   }
 
   private buildEventBinding(
-    transaction: SuiTransactionResponse,
+    transaction: SuiTransactionBlockResponse,
     eventIdx: number,
     network: SuiNetwork = SuiNetwork.MAIN_NET
   ): DataBinding | undefined {
     // const allEvents = new Set(transaction.events.map(e => e.type))
-    const event = transaction.effects.events?.[eventIdx]
-    if (!event || !event.moveEvent) {
+    const event = transaction.events?.[eventIdx]
+    if (!event) {
       throw Error('Invaild test transaction, no event located')
     }
 
@@ -98,13 +102,13 @@ export class SuiFacet {
       }
       for (const eventConfig of config.moveEventConfigs) {
         for (const eventFilter of eventConfig.filters) {
-          if (config.contract.address + '::' + eventFilter.type === parseMoveType(event.moveEvent.type).qname) {
-            transaction.effects.events = [event]
+          if (config.contract.address + '::' + eventFilter.type === parseMoveType(event.type).qname) {
+            transaction.events = [event]
             return {
               data: {
                 suiEvent: {
                   transaction,
-                  timestamp: new Date(transaction.timestamp_ms || 0),
+                  timestamp: new Date(transaction.timestampMs || 0),
                   slot: 10000n,
                 },
               },

package/src/eth/codegen/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": "../..",
-    "outDir": "../../../lib"
-  },
-  "extends": "../../../tsconfig.json",
-  "include": ["./"]
-}