@sentio/sdk 2.4.0 → 2.5.0-rc.2

package/src/sui/builtin/index.ts

@@ -0,0 +1,5 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as _0x1 from './0x1.js'
+export * as _0x2 from './0x2.js'

package/src/sui/codegen/codegen.ts

@@ -0,0 +1,71 @@
+import { SuiNetwork } from '../network.js'
+import * as fs from 'fs'
+import chalk from 'chalk'
+import { NeutralMoveModule, NeutralMoveStruct } from '../../move/neutral-models.js'
+import { AbstractCodegen } from '../../move/abstract-codegen.js'
+import { JsonRpcProvider, SuiMoveNormalizedModules } from '@mysten/sui.js'
+import { toNeutralModule } from '../move-types.js'
+import { moduleQname, SPLITTER, TypeDescriptor } from '../../move/index.js'
+
+export async function codegen(abisDir: string, outDir = 'src/types/sui') {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+  console.log(chalk.green('Generated Types for Sui'))
+  const gen = new SuiCodeGen()
+  await gen.generate(abisDir, outDir)
+}
+
+function getRpcEndpoint(network: SuiNetwork): string {
+  switch (network) {
+    case SuiNetwork.TEST_NET:
+      return 'https://fullnode.testnet.sui.io/'
+  }
+  return 'https://fullnode.mainnet.sui.io/'
+}
+
+function getRpcClient(network: SuiNetwork): JsonRpcProvider {
+  return new JsonRpcProvider(getRpcEndpoint(network))
+}
+
+class SuiCodeGen extends AbstractCodegen<SuiMoveNormalizedModules, SuiNetwork> {
+  ADDRESS_TYPE = 'SuiAddress'
+  MAIN_NET = SuiNetwork.MAIN_NET
+  TEST_NET = SuiNetwork.TEST_NET
+  PREFIX = 'Sui'
+  STRUCT_FIELD_NAME = 'fields'
+
+  async fetchModules(account: string, network: SuiNetwork): Promise<SuiMoveNormalizedModules> {
+    const client = getRpcClient(network)
+    return await client.getNormalizedMoveModulesByPackage(account)
+  }
+
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    return params.slice(0, params.length - 1)
+  }
+
+  toNeutral(modules: SuiMoveNormalizedModules): NeutralMoveModule[] {
+    return Object.values(modules).map(toNeutralModule)
+  }
+
+  getEventStructs(module: NeutralMoveModule) {
+    const qname = moduleQname(module)
+    const eventMap = new Map<string, NeutralMoveStruct>()
+
+    for (const struct of module.structs) {
+      const abilities = new Set(struct.abilities)
+      if (abilities.has('Drop') && abilities.has('Copy')) {
+        eventMap.set(qname + SPLITTER + struct.name, struct)
+      }
+    }
+    return eventMap
+  }
+
+  readModulesFile(fullPath: string) {
+    const res = super.readModulesFile(fullPath)
+    if (res.result) {
+      return res.result
+    }
+    return res
+  }
+}

package/src/sui/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/sui/codegen/run.ts

@@ -0,0 +1,13 @@
+// #!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+
+  await codegen(abisDir, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/sui/index.ts

@@ -4,4 +4,8 @@ export * from './network.js'
 export * from './context.js'
 export * from './models.js'
 
+export type { SuiAddress } from './move-types.js'
+
+export * from './move-coder.js'
+
 export { SuiPlugin } from './sui-plugin.js'

package/src/sui/models.ts

@@ -1,9 +1,5 @@
-import { MoveEvent } from '@mysten/sui.js'
+import { MoveEvent, MoveCall } from '@mysten/sui.js'
 
-// export type MoveEvent = MoveEvent & {
-// }
-
-//
 export type TypedEventInstance<T> = MoveEvent & {
   /**
    * decoded data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
@@ -13,26 +9,9 @@ export type TypedEventInstance<T> = MoveEvent & {
   type_arguments: string[]
 }
 
-//
-// // Don't use intermediate type to make IDE happier
-// export type TypedEntryFunctionPayload<T extends Array<any>> = TransactionPayload_EntryFunctionPayload & {
-//   /**
-//    * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
-//    */
-//   arguments_decoded: T
-// }
-//
-// export type TypedMoveResource<T> = MoveResource & {
-//   data_decoded: T
-//   type_arguments: string[]
-// }
-//
-// export interface StructWithTag {
-//   type: string
-//   data: any
-// }
-//
-// export interface StructWithType<T> extends StructWithTag {
-//   data_decoded: T
-//   type_arguments: string[]
-// }
+export type TypedEntryFunctionPayload<T extends Array<any>> = MoveCall & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}

package/src/sui/move-coder.ts

@@ -0,0 +1,63 @@
+import { TypedEventInstance, TypedEntryFunctionPayload } from './models.js'
+import { AbstractMoveCoder } from '../move/abstract-move-coder.js'
+import { MoveCall, MoveEvent, SuiMoveNormalizedModule } from '@mysten/sui.js'
+import { toNeutralModule } from './move-types.js'
+import { SPLITTER } from '../move/index.js'
+
+export class MoveCoder extends AbstractMoveCoder<MoveEvent> {
+  load(module: SuiMoveNormalizedModule) {
+    if (this.contains(module.address, module.name)) {
+      return
+    }
+    this.loadNeutral(toNeutralModule(module))
+  }
+
+  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 || [] }
+  }
+  filterAndDecodeEvents<T>(typeQname: string, resources: MoveEvent[]): TypedEventInstance<T>[] {
+    const resp = this.filterAndDecodeInternal(
+      typeQname,
+      resources.map((event) => {
+        return { ...event, data: event.fields, 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 || [] }
+    })
+  }
+
+  decodeFunctionPayload(payload: MoveCall): MoveCall {
+    // this.loadTypes(registry)
+    const argumentsTyped: any[] = []
+
+    try {
+      const functionType = [payload.package.objectId, payload.module, payload.function].join(SPLITTER)
+      const func = this.getMoveFunction(functionType)
+      const params = func.params.slice(0, func.params.length - 1)
+      const args = payload.arguments || []
+      for (const [idx, arg] of args.entries()) {
+        // TODO consider apply payload.type_arguments, but this might be hard since we don't code gen for them
+        const argType = params[idx]
+        argumentsTyped.push(this.decode(arg, argType))
+      }
+    } catch (e) {
+      console.error('Decoding error for ', JSON.stringify(payload), e)
+      return payload
+    }
+
+    return {
+      ...payload,
+      arguments_decoded: argumentsTyped,
+    } as TypedEntryFunctionPayload<any>
+  }
+}
+
+export const MOVE_CODER = new MoveCoder()
+
+export function defaultMoveCoder(): MoveCoder {
+  return MOVE_CODER
+}

package/src/sui/move-types.ts

@@ -0,0 +1,109 @@
+import {
+  SuiMoveNormalizedField,
+  SuiMoveNormalizedFunction,
+  SuiMoveNormalizedModule,
+  SuiMoveNormalizedStruct,
+  SuiMoveNormalizedType,
+} from '@mysten/sui.js'
+import {
+  NeutralMoveFunction,
+  NeutralMoveFunctionVisibility,
+  NeutralMoveModule,
+  NeutralMoveStruct,
+  NeutralMoveStructField,
+} from '../move/neutral-models.js'
+import { SPLITTER, TypeDescriptor } from '../move/index.js'
+
+export type { SuiAddress } from '@mysten/sui.js'
+
+export function toNeutralModule(module: SuiMoveNormalizedModule): NeutralMoveModule {
+  return {
+    address: module.address,
+    exposed_functions: Object.entries(module.exposed_functions).map(([n, f]) => toNeutralFunction(n, f)),
+    name: module.name,
+    structs: Object.entries(module.structs).map(([n, s]) => toNeutralStruct(n, s)),
+  }
+}
+
+export function toNeutralFunction(name: string, func: SuiMoveNormalizedFunction): NeutralMoveFunction {
+  let visibility
+  switch (func.visibility) {
+    case 'Private':
+      visibility = NeutralMoveFunctionVisibility.PRIVATE
+      break
+    case 'Public':
+      visibility = NeutralMoveFunctionVisibility.PUBLIC
+      break
+    case 'Friend':
+      visibility = NeutralMoveFunctionVisibility.FRIEND
+      break
+  }
+  return {
+    generic_type_params: func.type_parameters.map((p) => {
+      return { constraints: p.abilities }
+    }),
+    is_entry: func.is_entry,
+    name: name,
+    params: func.parameters.map(convertToTypeDescriptor),
+    return: func.return_.map(convertToTypeDescriptor),
+    visibility: visibility,
+  }
+}
+
+export function toNeutralStruct(name: string, struct: SuiMoveNormalizedStruct): NeutralMoveStruct {
+  return {
+    abilities: struct.abilities.abilities,
+    fields: struct.fields.map(toNeutralField),
+    generic_type_params: struct.type_parameters.map((p) => {
+      return { constraints: p.constraints.abilities }
+    }),
+    is_native: false,
+    name: name,
+  }
+}
+
+export function toNeutralField(module: SuiMoveNormalizedField): NeutralMoveStructField {
+  return {
+    name: module.name,
+    type: convertToTypeDescriptor(module.type_),
+  }
+}
+
+export function convertToTypeDescriptor(normalizedType: SuiMoveNormalizedType): TypeDescriptor {
+  if (typeof normalizedType === 'string') {
+    return new TypeDescriptor(normalizedType)
+  }
+
+  if ('Struct' in normalizedType) {
+    // normalizedType.Struct.
+    // return normalizedType;
+    const qname = [normalizedType.Struct.address, normalizedType.Struct.module, normalizedType.Struct.name].join(
+      SPLITTER
+    )
+
+    const args = normalizedType.Struct.type_arguments.map(convertToTypeDescriptor)
+
+    return new TypeDescriptor(qname, args)
+  }
+
+  if ('Vector' in normalizedType) {
+    return new TypeDescriptor('vector', [convertToTypeDescriptor(normalizedType.Vector)])
+  }
+  if ('TypeParameter' in normalizedType) {
+    return new TypeDescriptor('T' + normalizedType.TypeParameter)
+  }
+
+  if ('Reference' in normalizedType) {
+    const res = convertToTypeDescriptor(normalizedType.Reference)
+    res.reference = true
+    return res
+  }
+
+  if ('MutableReference' in normalizedType) {
+    const res = convertToTypeDescriptor(normalizedType.MutableReference)
+    res.reference = true
+    return res
+  }
+
+  throw new Error('Unexpected sui type')
+}

package/src/sui/sui-processor.ts

@@ -6,6 +6,7 @@ import { SuiContext } from './context.js'
 import { MoveEvent, SuiTransactionResponse, getMoveCallTransaction, MoveCall } from '@mysten/sui.js'
 import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
+import { defaultMoveCoder } from './move-coder.js'
 
 class IndexConfigure {
   address: string
@@ -82,8 +83,7 @@ export class SuiBaseProcessor {
         for (const evt of events) {
           if ('moveEvent' in evt) {
             const eventInstance = evt.moveEvent as MoveEvent
-            const decoded = eventInstance // TODO
-            // const decoded = MOVE_CODER.decodeEvent<any>(eventInstance)
+            const decoded = defaultMoveCoder().decodeEvent<any>(eventInstance)
             await handler(decoded || eventInstance, ctx)
           }
         }
@@ -135,7 +135,7 @@ export class SuiBaseProcessor {
             throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected number of call transactions ' + calls.length)
           }
           const payload = calls[0]
-          const decoded = payload // MOVE_CODER.decodeFunctionPayload(payload)
+          const decoded = defaultMoveCoder().decodeFunctionPayload(payload)
           await handler(decoded, ctx)
         }
         return ctx.getProcessResult()