@typemove/sui 2.0.0 → 2.0.1

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,292 @@
+import * as fs from 'fs'
+import chalk from 'chalk'
+import {
+  InternalMoveModule,
+  InternalMoveStruct,
+  structQname,
+  InternalMoveFunction,
+  InternalMoveFunctionVisibility,
+  normalizeToJSName,
+  camel
+} from '@typemove/move'
+import { AbstractCodegen } from '@typemove/move/codegen'
+import { join } from 'path'
+import {
+  SuiChainAdapter,
+  ModuleWithAddress,
+  getGrpcClient,
+  SuiEventInput,
+  SuiMoveObjectInput
+} 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)) {
+    console.error(chalk.red(`ABIs directory ${abisDir} does not exist`))
+    return 0
+  }
+  try {
+    const gen = new SuiCodegen(endpoint)
+    const numFiles = await gen.generate(abisDir, outDir, builtin)
+    if (numFiles > 0) {
+      console.log(chalk.green(`Generated for ${numFiles} accounts for Sui to ${outDir}`))
+    } else {
+      console.error(chalk.red(`No account found`))
+    }
+    return numFiles
+  } catch (e) {
+    console.error(chalk.red(`Failed to generate for ${abisDir}, please check if ABI json files are valid`))
+    console.log(e)
+    return 0
+  }
+}
+
+export class SuiCodegen extends AbstractCodegen<ModuleWithAddress, SuiEventInput | SuiMoveObjectInput> {
+  ADDRESS_TYPE = 'string'
+  SYSTEM_PACKAGE = '@typemove/sui'
+  PREFIX = 'Sui'
+  PAYLOAD_OPTIONAL = true
+
+  constructor(endpoint: string) {
+    super(new SuiChainAdapter(getGrpcClient(endpoint)))
+  }
+
+  readModulesFile(fullPath: string) {
+    // Cached ABI is now an array of { address, module } produced by
+    // SuiChainAdapter.fetchModules / codegen run.ts. Just pass it through.
+    return super.readModulesFile(fullPath)
+  }
+
+  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 generateExtra(address: string | undefined, module: InternalMoveModule): string {
+    const funcs = module.exposedFunctions.map((f) =>
+      this.generateBuilderForFunction(address || module.address, 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, isView: boolean) {
+    const args = []
+    const argsLen = func.params.length
+    for (const [idx, arg] of func.params.entries()) {
+      if (idx === argsLen - 1 && arg.qname === '0x2::tx_context::TxContext') {
+        // no op
+      } else if (arg.reference) {
+        args.push({
+          paramType: isView ? this.ADDRESS_TYPE : `${this.ADDRESS_TYPE} | TransactionObjectArgument`,
+          callValue: `_args.push(transactionArgumentOrObject(args[${idx}], tx))`
+        })
+      } else if (arg.isVector()) {
+        // TODO fix pure vector
+        args.push({
+          paramType: isView
+            ? `${this.ADDRESS_TYPE}[]`
+            : `(${this.ADDRESS_TYPE} | TransactionObjectArgument)[] | TransactionArgument`,
+          callValue: `_args.push(transactionArgumentOrVec(args[${idx}], tx))`
+        })
+      } else {
+        // Handle pure type
+        let pureFunction = ''
+        const paramType = isView
+          ? this.generateTypeForDescriptor(arg, module.address)
+          : `${this.generateTypeForDescriptor(arg, module.address)} | TransactionArgument`
+
+        switch (arg.qname.toLowerCase()) {
+          case 'u8':
+            pureFunction = `transactionArgumentOrPureU8`
+            break
+          case 'u16':
+            pureFunction = `transactionArgumentOrPureU16`
+            break
+          case 'u32':
+            pureFunction = `transactionArgumentOrPureU32`
+            break
+          case 'u64':
+            pureFunction = `transactionArgumentOrPureU64`
+            break
+          case 'u128':
+            pureFunction = `transactionArgumentOrPureU128`
+            break
+          case 'u256':
+            pureFunction = `transactionArgumentOrPureU256`
+            break
+          case 'bool':
+            pureFunction = `transactionArgumentOrPureBool`
+            break
+          case 'string':
+            pureFunction = `transactionArgumentOrPureString`
+            break
+          case 'address':
+            pureFunction = `transactionArgumentOrPureAddress`
+            break
+          // case 'vector':
+          // case 'option':
+          default:
+            pureFunction = `transactionArgumentOrPure`
+          //   paramType = 'TransactionArgument'
+        }
+        const callValue = pureFunction ? `_args.push(${pureFunction}(args[${idx}], tx))` : `_args.push(args[${idx}])`
+
+        args.push({
+          paramType,
+          callValue
+        })
+      }
+    }
+    return args
+  }
+
+  protected generateViewFunction(module: InternalMoveModule, func: InternalMoveFunction): string {
+    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE) {
+      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, true)
+    const returnType = `${this.generateFunctionReturnTypeParameters(func, module.address)}`
+
+    // gRPC simulateTransaction's CommandOutput only carries BCS bytes (no type
+    // string the way devInspectTransactionBlock did), so we capture the
+    // declared Move return-type signatures at codegen time and pass them
+    // through to the decoder at runtime.
+    const returnSignaturesLiteral = JSON.stringify(func.return.map((t) => t.getSignature()))
+
+    return `export async function ${camel(normalizeToJSName(func.name))}${genericString}(
+      client: SuiGrpcClient,
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${
+        typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``
+      } ): Promise<TypedSimulateResults<${returnType}>> {
+      const tx = new Transaction()
+      builder.${camel(normalizeToJSName(func.name))}(tx, args ${typeParamArg.length > 0 ? `, typeArguments` : ''})
+      // checksEnabled: false matches the old devInspectTransactionBlock
+      // semantics — allow simulating view calls without validating object
+      // ownership or signer, which view callers obviously can't satisfy.
+      const simulateRes = await client.simulateTransaction({
+        transaction: tx,
+        sender: ZERO_ADDRESS,
+        include: { commandResults: true },
+        checksEnabled: false
+      } as any)
+
+      return (await getMoveCoder(client)).decodeSimulateResult<${returnType}>(simulateRes, ${returnSignaturesLiteral}${typeParamArg.length > 0 ? `, typeArguments` : ''})
+    }`
+  }
+
+  protected generateBuilderForFunction(
+    address: string,
+    module: InternalMoveModule,
+    func: InternalMoveFunction
+  ): string {
+    if (func.visibility === InternalMoveFunctionVisibility.PRIVATE && func.isEntry !== true) {
+      return ''
+    }
+
+    const args = this.generateArgs(module, func, false)
+
+    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: Transaction,
+      args: [${args.map((a) => a.paramType).join(',')}],
+      ${typeParamArg.length > 0 ? `typeArguments: [${typeParamArg}]` : ``} ):
+       TransactionArgument & [ ${'TransactionArgument,'.repeat(args.length)} ] {
+      const _args: any[] = []
+      ${args.map((a) => a.callValue).join('\n')}
+
+      // @ts-ignore
+      return tx.moveCall({
+        target: "${address}::${module.name}::${func.name}",
+        arguments: _args,
+        ${typeParamArg.length > 0 ? `typeArguments: [${typeParamToString}]` : ``}
+      })
+    }`
+  }
+
+  generateImports(): string {
+    return `
+      ${super.generateImports()}
+      import { ZERO_ADDRESS, TypedSimulateResults, getMoveCoder } from '@typemove/sui'
+      import { Transaction, TransactionArgument, TransactionObjectArgument } from '@mysten/sui/transactions'
+      import { SuiGrpcClient } from '@mysten/sui/grpc'
+      import {  transactionArgumentOrObject, 
+                transactionArgumentOrVec,
+                transactionArgumentOrPure,
+                transactionArgumentOrPureU8,
+                transactionArgumentOrPureU16,
+                transactionArgumentOrPureU32,
+                transactionArgumentOrPureU64,
+                transactionArgumentOrPureU128,
+                transactionArgumentOrPureU256,
+                transactionArgumentOrPureBool,
+                transactionArgumentOrPureString,
+                transactionArgumentOrPureAddress,
+      } from '@typemove/sui'
+    `
+  }
+}

package/src/codegen/index.ts

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

package/src/codegen/run.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { codegen } from './codegen.js'
+import { Command } from 'commander'
+import { createRequire } from 'module'
+import fs from 'fs'
+import path from 'path'
+import { getGrpcClient, getGrpcFullnodeUrl, SuiChainAdapter } from '../sui-chain-adapter.js'
+const require = createRequire(import.meta.url)
+let pkg = undefined
+try {
+  pkg = require('../../package.json')
+} catch (e) {
+  pkg = require('../../../package.json')
+}
+
+const program = new Command()
+program
+  .name('typemove-sui')
+  .description('CLI to generate typescript types from SUI ABIs')
+  .showHelpAfterError()
+  .version(pkg.version)
+  .argument('<location>', 'Directory of ABI json files or address of account to generate types for')
+  .option('-a, --abi-dir <dir>', 'Directory to store downloaded ABI. Only useful if <location> is address', './abis')
+  .option('-t, --target-dir <dir>', 'Directory to output generated files', './types')
+  .option(
+    '-n, --network <mainnet|testnet|$url>',
+    'Network to use, could be either "mainnet", "testnet" or any node URL',
+    'mainnet'
+  )
+  .action(async (location, options) => {
+    let endpoint = options.network
+    if (endpoint === 'mainnet' || endpoint === 'testnet' || endpoint === 'devnet' || endpoint === 'localnet') {
+      endpoint = getGrpcFullnodeUrl(endpoint)
+    }
+
+    const suiClient = getGrpcClient(endpoint)
+
+    let abisDir = location
+    if (location.startsWith('0x')) {
+      const abiAddress = abisDir
+      // Fetch via adapter so the on-disk shape matches what codegen reads back.
+      // ABI is serialized as { address, module }[] — the address is included
+      // because the proto Module doesn't carry the package id per entry.
+      const abi = await new SuiChainAdapter(suiClient).fetchModules(abiAddress)
+      abisDir = options.abiDir
+      if (!fs.existsSync(abisDir)) {
+        fs.mkdirSync(abisDir, { recursive: true })
+      }
+      fs.writeFileSync(path.join(abisDir, abiAddress + '.json'), JSON.stringify(abi, null, 2))
+    }
+
+    const num = await codegen(abisDir, options.targetDir, endpoint, true)
+    process.exit(num == 0 ? 1 : 0)
+  })
+
+program.parse()

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from './models.js'
+export * from './transaction.js'
+
+export { MoveCoder, defaultMoveCoder, getMoveCoder } from './move-coder.js'
+export {
+  SuiChainAdapter,
+  type ModuleWithAddress,
+  type SuiEventInput,
+  type SuiMoveObjectInput,
+  inferNetworkFromUrl,
+  getGrpcClient,
+  getGrpcFullnodeUrl
+} from './sui-chain-adapter.js'

package/src/models.ts

@@ -0,0 +1,32 @@
+import type { SuiClientTypes } from '@mysten/sui/client'
+import type { GrpcTypes } from '@mysten/sui/grpc'
+import { DecodedStruct } from '@typemove/move'
+
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000'
+
+// Decoder input/output types are now keyed on @mysten/sui/client's unified
+// SuiClientTypes shapes (which both jsonRpc and gRPC clients implement) plus
+// gRPC proto types for the transaction-side shapes that don't have a
+// transport-agnostic equivalent. No `@mysten/sui/jsonRpc` import remains.
+export type TypedEventInstance<T> = DecodedStruct<SuiClientTypes.Event, T>
+export type TypedSuiMoveObject<T> = DecodedStruct<SuiClientTypes.Object<{ json: true }>, T>
+
+export type TypedFunctionPayload<T extends Array<any>> = GrpcTypes.MoveCall & {
+  /**
+   * decoded argument data using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  arguments_decoded: T
+}
+
+// Result wrapper for SuiGrpcClient.simulateTransaction return values. Replaces
+// the old TypedDevInspectResults that was tied to JSON-RPC's DevInspectResults.
+// The raw simulate response shape is intentionally widened to `any` here
+// because the underlying SDK types are heavily generic and we only need the
+// `commandResults` slice; we pass the original result through unchanged plus a
+// `results_decoded` field populated by `MoveCoder.decodeSimulateResult`.
+export type TypedSimulateResults<T extends Array<any>> = {
+  /**
+   * Decoded return values using ABI, undefined if there is decoding error, usually because the ABI/data mismatch
+   */
+  results_decoded?: T
+} & Record<string, any>