@typemove/sui 1.0.0-rc.10

package/src/builtin/index.ts

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

package/src/codegen/codegen.ts

@@ -0,0 +1,244 @@
+import {
+  SuiMoveNormalizedModule,
+  SuiEvent,
+  SuiMoveObject,
+} from '@mysten/sui.js'
+
+import * as fs from 'fs'
+import chalk from 'chalk'
+import {
+  InternalMoveModule,
+  InternalMoveStruct,
+  AbstractCodegen,
+  structQname,
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  normalizeToJSName,
+  camel,
+} from '@typemove/move'
+import { join } from 'path'
+import { SuiChainAdapter } from '../sui-chain-adapter.js'
+
+export async function codegen(
+  abisDir: string,
+  outDir = join('src', 'types', 'sui'),
+  endpoint: string,
+  genExample = false,
+  builtin = false
+) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+  const gen = new SuiCodegen(endpoint)
+  const numFiles = await gen.generate(abisDir, outDir, builtin)
+  console.log(chalk.green(`Generated ${numFiles} for Sui`))
+}
+
+class SuiCodegen extends AbstractCodegen<
+  // SuiNetwork,
+  SuiMoveNormalizedModule,
+  SuiEvent | SuiMoveObject
+> {
+  ADDRESS_TYPE = 'SuiAddress'
+  REFERENCE_TYPE = 'ObjectId'
+  SYSTEM_PACKAGE = '@mysten/sui.js'
+  // ADDRESS_TYPE = 'string'
+  // MAIN_NET = SuiNetwork.MAIN_NET
+  // TEST_NET = SuiNetwork.TEST_NET
+  PREFIX = 'Sui'
+  // STRUCT_FIELD_NAME = 'fields'
+  // GENERATE_ON_ENTRY = true
+  PAYLOAD_OPTIONAL = true
+
+  constructor(endpoint: string) {
+    super(new SuiChainAdapter(endpoint))
+  }
+
+  readModulesFile(fullPath: string) {
+    const res = super.readModulesFile(fullPath)
+    if (res.result) {
+      return res.result
+    }
+    return res
+  }
+
+  generateStructs(
+    module: InternalMoveModule,
+    struct: InternalMoveStruct,
+    events: Set<string>
+  ): string {
+    let content = ''
+    switch (structQname(module, struct)) {
+      // TODO they should still have module code generated
+      case '0x1::ascii::Char':
+      case '0x1::ascii::String':
+      case '0x2::object::ID':
+        content += `export type ${struct.name} = string`
+        break
+      case '0x2::coin::Coin':
+        content += `export type ${struct.name}<T> = string`
+        break
+      case '0x2::balance::Balance':
+        content += `export type ${struct.name}<T> = bigint`
+        break
+      case '0x1::option::Option':
+        content += `export type Option<T> = T | undefined`
+        break
+    }
+    return (
+      content + super.generateStructs(module, struct, events, content !== '')
+    )
+  }
+
+  generateForEvents(
+    module: InternalMoveModule,
+    struct: InternalMoveStruct
+  ): string {
+    switch (structQname(module, struct)) {
+      case '0x1::ascii::Char':
+      case '0x1::ascii::String':
+      case '0x2::object::ID':
+      case '0x2::coin::Coin':
+      case '0x1::option::Option':
+      case '0x2::balance::Balance':
+        return ''
+    }
+    return super.generateForEvents(module, struct)
+  }
+
+  protected generateBuilder(module: InternalMoveModule): string {
+    const funcs = module.exposedFunctions.map((f) =>
+      this.generateBuilderForFunction(module, f)
+    )
+
+    const viewFuncs = module.exposedFunctions.map((f) =>
+      this.generateViewFunction(module, f)
+    )
+
+    return `
+    export namespace builder {
+      ${funcs.join('\n')}
+    }
+    export namespace view {
+      ${viewFuncs.join('\n')}
+    }
+    `
+  }
+
+  private generateArgs(module: InternalMoveModule, func: InternalMoveFunction) {
+    const args = []
+    for (const [idx, arg] of func.params.entries()) {
+      if (arg.reference) {
+        args.push({
+          paramType: 'ObjectId | ObjectCallArg | TransactionArgument',
+          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.object(args[${idx}]))`,
+        })
+      } else if (arg.isVector()) {
+        args.push({
+          paramType: '(ObjectId | ObjectCallArg)[] | TransactionArgument',
+          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.makeMoveVec({
+            objects: args[${idx}].map((a: any) => tx.object(a))
+            // type: TODO
+          }))`,
+        })
+      } else {
+        args.push({
+          paramType: `${this.generateTypeForDescriptor(
+            arg,
+            module.address
+          )} | TransactionArgument`,
+          callValue: `_args.push(TransactionArgument.is(args[${idx}]) ? args[${idx}] : tx.pure(args[${idx}]))`,
+        })
+      }
+    }
+    return args
+  }
+
+  protected generateViewFunction(
+    module: InternalMoveModule,
+    func: InternalMoveFunction
+  ): string {
+    if (func.visibility !== InternalMoveFunctionVisibility.PUBLIC) {
+      return ''
+    }
+    const genericString = this.generateFunctionTypeParameters(func)
+
+    const typeParamArg = func.typeParams
+      .map((v, idx) => {
+        return `TypeDescriptor<T${idx}> | string`
+      })
+      .join(',')
+
+    const args = this.generateArgs(module, func)
+
+    return `export async function ${camel(
+      normalizeToJSName(func.name)
+    )}${genericString}(
+      provider: JsonRpcProvider,
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ) {
+      const tx = new TransactionBlock()
+      builder.${camel(normalizeToJSName(func.name))}(tx, args ${
+      typeParamArg.length > 0 ? `, typeArguments` : ''
+    })
+      const res = await provider.devInspectTransactionBlock({
+        transactionBlock: tx,
+        sender: ZERO_ADDRESS
+      })
+      return res
+    }`
+  }
+
+  protected generateBuilderForFunction(
+    module: InternalMoveModule,
+    func: InternalMoveFunction
+  ): string {
+    if (func.visibility !== InternalMoveFunctionVisibility.PUBLIC) {
+      return ''
+    }
+
+    const args = this.generateArgs(module, func)
+
+    const genericString = this.generateFunctionTypeParameters(func)
+
+    const typeParamArg = func.typeParams
+      .map((v, idx) => {
+        return `TypeDescriptor<T${idx}> | string`
+      })
+      .join(',')
+    const typeParamToString = func.typeParams
+      .map((v, idx) => {
+        return `typeof typeArguments[${idx}] === 'string' ? typeArguments[${idx}] : typeArguments[${idx}].getSignature()`
+      })
+      .join(',')
+
+    return `export function ${camel(
+      normalizeToJSName(func.name)
+    )}${genericString}(tx: TransactionBlock, 
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ):
+       TransactionArgument & [ ${'TransactionArgument,'.repeat(
+         func.params.length
+       )} ] {
+      const _args: any[] = []
+      ${args.map((a) => a.callValue).join('\n')}
+      
+      // @ts-ignore
+      return tx.moveCall({
+        target: "${module.address}::${module.name}::${func.name}",
+        arguments: _args,
+        ${
+          typeParamArg.length > 0 ? `typeArguments: [${typeParamToString}]` : ``
+        }
+      })
+    }`
+  }
+
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { ZERO_ADDRESS } from '@typemove/sui'
+      import { TransactionBlock, TransactionArgument, ObjectCallArg, JsonRpcProvider } from '@mysten/sui.js'
+    `
+  }
+}

package/src/codegen/index.ts

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

package/src/codegen/run.ts

@@ -0,0 +1,20 @@
+// #!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  let endpoint: string | undefined = process.argv[4]
+  if (!endpoint || endpoint == 'mainnet') {
+    endpoint = 'https://fullnode.mainnet.sui.io/'
+  }
+  if (endpoint == 'testnet') {
+    endpoint = 'https://fullnode.testnet.sui.io/'
+  }
+
+  await codegen(abisDir, targetDir, endpoint, false, true)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './models.js'
+
+export type { SuiAddress, ObjectId } from '@mysten/sui.js'
+// export * as builtin from './builtin/index.js'
+
+export { MoveCoder, defaultMoveCoder } from './move-coder.js'
+
+export { ModuleClient } from './module-client.js'

package/src/models.ts

@@ -0,0 +1,24 @@
+import type {
+  SuiEvent,
+  MoveCallSuiTransaction,
+  SuiMoveObject,
+} from '@mysten/sui.js'
+import { DecodedStruct } from '@typemove/move'
+
+export const ZERO_ADDRESS =
+  '0x0000000000000000000000000000000000000000000000000000000000000000'
+
+export type TypedEventInstance<T> = DecodedStruct<SuiEvent, T>
+export type TypedSuiMoveObject<T> = DecodedStruct<SuiMoveObject, T>
+
+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
+     */
+    arguments_decoded: T
+  }
+
+// export interface TypedExecutionResultType<T> extends ExecutionResultType {
+//
+// }

package/src/module-client.ts

@@ -0,0 +1,23 @@
+import { JsonRpcProvider } from '@mysten/sui.js'
+
+export class ModuleClient {
+  public async viewDecoded(
+    func: string,
+    typeArguments: string[],
+    args: any[],
+    ledger_version?: bigint
+  ) {
+    throw Error('not implemented')
+  }
+}
+
+// const provider: JsonRpcProvider
+
+//
+// provider.
+
+export class TypedJsonRpcProvider extends JsonRpcProvider {
+  public xxx() {
+    this.connection.fullnode
+  }
+}

package/src/move-coder.ts

@@ -0,0 +1,147 @@
+import { TypedEventInstance, TypedFunctionPayload } from './models.js'
+import {
+  AbstractMoveCoder,
+  ANY_TYPE,
+  DecodedStruct,
+  parseMoveType,
+  SPLITTER,
+  TypeDescriptor,
+  InternalMoveModule,
+} from '@typemove/move'
+import {
+  MoveCallSuiTransaction,
+  SuiCallArg,
+  SuiEvent,
+  SuiMoveNormalizedModule,
+  SuiMoveObject,
+} from '@mysten/sui.js'
+import { toInternalModule } from './to-internal.js'
+import { SuiChainAdapter } from './sui-chain-adapter.js'
+import { dynamic_field } from './builtin/0x2.js'
+
+export class MoveCoder extends AbstractMoveCoder<
+  // SuiNetwork,
+  SuiMoveNormalizedModule,
+  SuiEvent | SuiMoveObject
+> {
+  constructor(network: string) {
+    super(new SuiChainAdapter(network))
+  }
+
+  load(module: SuiMoveNormalizedModule): InternalMoveModule {
+    let m = this.moduleMapping.get(module.address + '::' + module.name)
+    if (m) {
+      return m
+    }
+    m = toInternalModule(module)
+    this.loadInternal(m)
+    return m
+  }
+
+  protected decode(data: any, type: TypeDescriptor): any {
+    switch (type.qname) {
+      case '0x1::ascii::Char':
+      case '0x1::ascii::String':
+      case '0x2::object::ID':
+      case '0x2::coin::Coin':
+        return data
+      case '0x2::balance::Balance':
+        return BigInt(data)
+      case '0x1::option::Option':
+        if (data === null) {
+          return data
+        }
+        return this.decode(data, type.typeArgs[0])
+      default:
+        return super.decode(data, type)
+    }
+  }
+
+  decodeEvent<T>(event: SuiEvent): Promise<TypedEventInstance<T> | undefined> {
+    return this.decodedStruct(event)
+  }
+  filterAndDecodeEvents<T>(
+    type: TypeDescriptor<T> | string,
+    resources: SuiEvent[]
+  ): Promise<TypedEventInstance<T>[]> {
+    if (typeof type === 'string') {
+      type = parseMoveType(type)
+    }
+    return this.filterAndDecodeStruct(type, resources)
+  }
+
+  async getDynamicFields<T1, T2>(
+    objects: SuiMoveObject[],
+    keyType: TypeDescriptor<T1> = ANY_TYPE,
+    valueType: TypeDescriptor<T2> = ANY_TYPE
+  ): Promise<dynamic_field.Field<T1, T2>[]> {
+    // const type = dynamic_field.Field.TYPE
+    // Not using the code above to avoid cycle initialize failed
+    const type = new TypeDescriptor<dynamic_field.Field<T1, T2>>(
+      '0x2::dynamic_field::Field'
+    )
+    type.typeArgs = [keyType, valueType]
+    const res = await this.filterAndDecodeObjects(type, objects)
+    return res.map((o) => o.data_decoded)
+  }
+
+  filterAndDecodeObjects<T>(
+    type: TypeDescriptor<T>,
+    objects: SuiMoveObject[]
+  ): Promise<DecodedStruct<SuiMoveObject, T>[]> {
+    return this.filterAndDecodeStruct(type, objects)
+  }
+
+  async decodeFunctionPayload(
+    payload: MoveCallSuiTransaction,
+    inputs: SuiCallArg[]
+  ): Promise<MoveCallSuiTransaction> {
+    const functionType = [
+      payload.package,
+      payload.module,
+      payload.function,
+    ].join(SPLITTER)
+    const func = await this.getMoveFunction(functionType)
+    const params = this.adapter.getMeaningfulFunctionParams(func.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]
+        if (arg.type === 'pure') {
+          args.push(arg.value)
+        } else if (arg.type === 'object') {
+          // object is not there
+          args.push(undefined)
+        } else {
+          console.error('unexpected function arg value')
+          args.push(undefined)
+        }
+        // args.push(arg) // TODO check why ts not work using arg.push(arg)
+      } else {
+        args.push(undefined)
+      }
+    }
+
+    const argumentsTyped = await this.decodeArray(args, params, false)
+    return {
+      ...payload,
+      arguments_decoded: argumentsTyped,
+    } as TypedFunctionPayload<any>
+  }
+}
+
+const DEFAULT_ENDPOINT = 'https://fullnode.mainnet.sui.io/'
+const CODER_MAP = new Map<string, MoveCoder>()
+
+export function defaultMoveCoder(
+  endpoint: string = DEFAULT_ENDPOINT
+): MoveCoder {
+  let coder = CODER_MAP.get(endpoint)
+  if (!coder) {
+    coder = new MoveCoder(DEFAULT_ENDPOINT)
+    CODER_MAP.set(endpoint, coder)
+  }
+  return coder
+}

package/src/sui-chain-adapter.ts

@@ -0,0 +1,113 @@
+import { toInternalModule } from './to-internal.js'
+import {
+  InternalMoveModule,
+  InternalMoveStruct,
+  ChainAdapter,
+  moduleQname,
+  SPLITTER,
+  TypeDescriptor,
+} from '@typemove/move'
+import {
+  Connection,
+  JsonRpcProvider,
+  SuiMoveNormalizedModule,
+  SuiEvent,
+  SuiMoveObject,
+  SuiParsedData,
+} from '@mysten/sui.js'
+
+export class SuiChainAdapter extends ChainAdapter<
+  // SuiNetwork,
+  SuiMoveNormalizedModule,
+  SuiEvent | SuiMoveObject
+> {
+  // static INSTANCE = new SuiChainAdapter()
+
+  async fetchModule(
+    account: string,
+    module: string
+    // network: SuiNetwork
+  ): Promise<SuiMoveNormalizedModule> {
+    const client = getRpcClient(this.endpoint)
+    return await client.getNormalizedMoveModule({ package: account, module })
+  }
+
+  async fetchModules(
+    account: string
+    // network: SuiNetwork
+  ): Promise<SuiMoveNormalizedModule[]> {
+    const client = getRpcClient(this.endpoint)
+    const modules = await client.getNormalizedMoveModulesByPackage({
+      package: account,
+    })
+    return Object.values(modules)
+  }
+
+  getMeaningfulFunctionParams(params: TypeDescriptor[]): TypeDescriptor[] {
+    return params
+    // if (params.length === 0) {
+    //   return params
+    // }
+    // return params.slice(0, params.length - 1)
+  }
+
+  toInternalModules(modules: SuiMoveNormalizedModule[]): InternalMoveModule[] {
+    return Object.values(modules).map(toInternalModule)
+  }
+
+  getAllEventStructs(
+    modules: InternalMoveModule[]
+  ): Map<string, InternalMoveStruct> {
+    const eventMap = new Map<string, InternalMoveStruct>()
+
+    for (const module of modules) {
+      const qname = moduleQname(module)
+
+      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
+  }
+
+  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
+  }
+  // validateAndNormalizeAddress(address: string) {
+  //   return validateAndNormalizeAddress(address)
+  // }
+}
+
+// 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(endpoint: string): JsonRpcProvider {
+  return new JsonRpcProvider(new Connection({ fullnode: endpoint }))
+}