@typemove/sui 1.14.0-rc.1 → 2.0.0

package/src/builtin/index.ts

@@ -1,6 +0,0 @@
-/* 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

@@ -1,292 +0,0 @@
-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

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

package/src/codegen/run.ts

@@ -1,57 +0,0 @@
-#!/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

@@ -1,13 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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>