@0xobelisk/sui-cli 1.2.0-pre.98 → 2.0.0

package/src/commands/test.ts

@@ -1,7 +1,8 @@
 import type { CommandModule } from 'yargs';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 import { handlerExit } from './shell';
+import { lintSystemGuards, formatLintWarnings } from '../utils';
 
 /**
  * Returns the active Sui client environment (e.g. "localnet", "testnet").
@@ -15,12 +16,56 @@ function getActiveSuiEnv(): string {
   }
 }
 
-type Options = {
+export type RunMoveTestOptions = {
+  /** Substring matched against each test's fully qualified name (`addr::module::fun`). */
+  filter?: string;
+  'gas-limit'?: string;
+  /** Same as `gas-limit` (programmatic API). */
+  gasLimit?: string;
+  buildEnv?: string;
+  /** When true, passes `-l` to list tests instead of running them. */
+  list?: boolean;
+};
+
+type CliOptions = {
   'config-path': string;
+  /** Positional from `test [filter]` */
+  filter?: string;
   test?: string;
-  'gas-limit'?: string;
+  'gas-limit': string;
+  list?: boolean;
 };
 
+/**
+ * Builds argv for `sui move test` (argument array — no shell interpolation).
+ *
+ * Sui expects an optional filter as a **positional** argument at the end of the command.
+ * The `--test` flag on `sui move test` is unrelated (it enables compiling the `tests/` tree).
+ *
+ * @see `sui move test --help`
+ */
+export function buildSuiMoveTestArgv(options: {
+  projectPath: string;
+  gasLimit: string;
+  buildEnv?: string;
+  filter?: string;
+  list?: boolean;
+}): string[] {
+  const args = ['move', 'test'];
+  if (options.buildEnv) {
+    args.push('--build-env', options.buildEnv);
+  }
+  args.push('--path', options.projectPath);
+  if (options.list) {
+    args.push('-l');
+  }
+  args.push('--gas-limit', options.gasLimit);
+  if (options.filter && !options.list) {
+    args.push(options.filter);
+  }
+  return args;
+}
+
 /**
  * Core Move test runner for Dubhe contracts.
  * Runs `sui move test` against the package at `src/<dubheConfig.name>`.
@@ -29,58 +74,82 @@ type Options = {
  */
 export async function testHandler(
   dubheConfig: DubheConfig,
-  test?: string,
-  gasLimit: string = '100000000',
-  buildEnv?: string
+  options: RunMoveTestOptions = {}
 ): Promise<string> {
+  const gasLimit = options['gas-limit'] ?? options.gasLimit ?? '100000000';
   const cwd = process.cwd();
   const projectPath = `${cwd}/src/${dubheConfig.name}`;
-  // --build-env overrides the active Sui client environment for dependency resolution.
-  // Required for localnet (which is not in Move.toml [environments]) when the
-  // active client env has been set to localnet from a previous run.
-  const buildEnvFlag = buildEnv ? `--build-env ${buildEnv}` : '';
-  const command = `sui move test ${buildEnvFlag} --path ${projectPath} ${
-    test ? `--test ${test}` : ''
-  } --gas-limit ${gasLimit}`;
-  return execSync(command, { stdio: 'pipe', encoding: 'utf-8' });
+  const argv = buildSuiMoveTestArgv({
+    projectPath,
+    gasLimit,
+    buildEnv: options.buildEnv,
+    filter: options.filter,
+    list: options.list
+  });
+  return execFileSync('sui', argv, { stdio: 'pipe', encoding: 'utf-8' });
+}
+
+function resolveTestFilter(argv: { filter?: string; test?: string }): string | undefined {
+  return argv.filter ?? argv.test;
 }
 
-const commandModule: CommandModule<Options, Options> = {
-  command: 'test',
+const commandModule: CommandModule<CliOptions, CliOptions> = {
+  command: 'test [filter]',
 
   describe: 'Run Move unit tests in Dubhe contracts',
 
   builder(yargs) {
-    return yargs.options({
-      'config-path': {
+    return yargs
+      .positional('filter', {
         type: 'string',
-        default: 'dubhe.config.ts',
-        description: 'Path to the Dubhe config file'
-      },
-      test: {
-        type: 'string',
-        desc: 'Run a specific test by name'
-      },
-      'gas-limit': {
-        type: 'string',
-        desc: 'Set the gas limit for the test',
-        default: '100000000'
-      }
-    });
+        describe:
+          'Substring of fully qualified test name (see `sui move test --help`); optional when using --list'
+      })
+      .options({
+        'config-path': {
+          type: 'string',
+          default: 'dubhe.config.ts',
+          description: 'Path to the Dubhe config file'
+        },
+        test: {
+          type: 'string',
+          describe: 'Same as positional [filter] (kept for backward compatibility)'
+        },
+        'gas-limit': {
+          type: 'string',
+          desc: 'Set the gas limit for the test',
+          default: '100000000'
+        },
+        list: {
+          type: 'boolean',
+          default: false,
+          describe: 'List all Move unit tests (`sui move test -l`)'
+        }
+      });
   },
 
-  async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
+  async handler(argv) {
+    const { 'config-path': configPath, 'gas-limit': gasLimit, list } = argv;
+    const filter = resolveTestFilter(argv);
+
     try {
-      console.log('🚀 Running move test');
+      console.log(list ? '🚀 Listing Move unit tests' : '🚀 Running move test');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
 
-      // Ephemeral networks (localnet/devnet) are not defined in Move.toml [environments].
-      // Use --build-env testnet for dependency resolution so `sui move test` can resolve
-      // git dependencies without requiring a localnet env entry.
+      const projectPath = `${process.cwd()}/src/${dubheConfig.name}`;
+      const lintResults = lintSystemGuards(projectPath);
+      const warnings = formatLintWarnings(lintResults);
+      if (warnings) process.stdout.write(warnings);
+
       const activeEnv = getActiveSuiEnv();
       const buildEnv = activeEnv === 'localnet' || activeEnv === 'devnet' ? 'testnet' : undefined;
 
-      const output = await testHandler(dubheConfig, test, gasLimit, buildEnv);
+      const output = await testHandler(dubheConfig, {
+        filter,
+        'gas-limit': gasLimit,
+        buildEnv,
+        list
+      });
       if (output) process.stdout.write(output);
     } catch (error: any) {
       if (error.stdout) process.stdout.write(error.stdout);

package/src/commands/upgrade.ts

@@ -3,12 +3,15 @@ import { logError } from '../utils/errors';
 import { upgradeHandler } from '../utils/upgradeHandler';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 import { handlerExit } from './shell';
-import { getDefaultNetwork } from '../utils';
+import { getDefaultNetwork, lintSystemGuards, formatLintWarnings, confirm } from '../utils';
+import { join as pathJoin } from 'path';
 import chalk from 'chalk';
 
 type Options = {
   network: any;
   'config-path': string;
+  'bump-version': boolean;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -28,18 +31,48 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'string',
         default: 'dubhe.config.ts',
         decs: 'Path to the config file'
+      },
+      'bump-version': {
+        type: 'boolean',
+        default: false,
+        desc: 'Force a version bump even when no new resources were added (use for breaking logic changes or security fixes that must invalidate old clients)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'bump-version': bumpVersion,
+    'rpc-url': rpcUrl
+  }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await upgradeHandler(dubheConfig, dubheConfig.name, network);
+
+      const projectPath = pathJoin(process.cwd(), 'src', dubheConfig.name);
+      const lintResults = lintSystemGuards(projectPath);
+      if (lintResults.length > 0) {
+        process.stdout.write(formatLintWarnings(lintResults));
+        const proceed = await confirm(
+          'Some entry functions are missing ensure_latest_version. Proceed with upgrade anyway?'
+        );
+        if (!proceed) {
+          console.log(chalk.red('Upgrade cancelled.'));
+          handlerExit(1);
+          return;
+        }
+      }
+
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await upgradeHandler(dubheConfig, dubheConfig.name, network, bumpVersion, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/commands/watch.ts

@@ -15,17 +15,17 @@ const commandModule: CommandModule = {
   async handler() {
     const configFilePath = 'dubhe.config.ts';
 
-    const runSchemagen = () => {
-      exec('pnpm dubhe schemagen', (error, stdout, stderr) => {
+    const runGenerate = () => {
+      exec('pnpm dubhe generate', (error, stdout, stderr) => {
         if (error) {
-          console.error(`Error executing schemagen: ${error.message}`);
+          console.error(`Error executing generate: ${error.message}`);
           return;
         }
         if (stderr) {
-          console.error(`schemagen stderr: ${stderr}`);
+          console.error(`generate stderr: ${stderr}`);
           return;
         }
-        console.log(`schemagen stdout: ${stdout}`);
+        console.log(`generate stdout: ${stdout}`);
       });
     };
 
@@ -34,8 +34,8 @@ const commandModule: CommandModule = {
     });
 
     watcher.on('change', (path) => {
-      console.log(`${path} has been changed. Running schemagen...`);
-      runSchemagen();
+      console.log(`${path} has been changed. Running generate...`);
+      runGenerate();
     });
 
     console.log(`Watching for changes in ${configFilePath}...`);

package/src/utils/checkBalance.ts

@@ -4,10 +4,14 @@ import { initializeDubhe } from './utils';
 import { DubheCliError } from './errors';
 dotenv.config();
 
-export async function checkBalanceHandler(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
+export async function checkBalanceHandler(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  fullnodeUrls?: string[]
+) {
   try {
     const dubhe = initializeDubhe({
-      network
+      network,
+      fullnodeUrls
     });
 
     const balance = await dubhe.getBalance();

package/src/utils/constants.ts

@@ -1,5 +1,9 @@
-export const TESTNET_DUBHE_HUB_OBJECT_ID =
-  '0xfef203de9d3a2980429e91df535a0503ccf8d3c05aa3815936984243dc96f19f';
+export {
+  TESTNET_DUBHE_HUB_OBJECT_ID,
+  TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID,
+  MAINNET_DUBHE_HUB_OBJECT_ID,
+  MAINNET_DUBHE_FRAMEWORK_PACKAGE_ID
+} from '@0xobelisk/sui-client';
 
-export const TESTNET_ORIGINAL_DUBHE_PACKAGE_ID =
-  '0x8817b4976b6c607da01cea49d728f71d09274c82e9b163fa20c2382586f8aefc';
+// Keep legacy alias for backwards compatibility within this package
+export { TESTNET_DUBHE_FRAMEWORK_PACKAGE_ID as TESTNET_ORIGINAL_DUBHE_PACKAGE_ID } from '@0xobelisk/sui-client';

package/src/utils/metadataHandler.ts

@@ -4,13 +4,14 @@ import { getOldPackageId, saveMetadata } from './utils';
 export async function loadMetadataHandler(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  packageId?: string
+  packageId?: string,
+  fullnodeUrls?: string[]
 ) {
   if (packageId) {
-    await saveMetadata(dubheConfig.name, network, packageId);
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
   } else {
     const projectPath = `${process.cwd()}/src/${dubheConfig.name}`;
     const packageId = await getOldPackageId(projectPath, network);
-    await saveMetadata(dubheConfig.name, network, packageId);
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
   }
 }