@0xobelisk/sui-cli 1.2.0-pre.12 → 1.2.0-pre.120

package/src/commands/faucet.ts

@@ -1,11 +1,13 @@
 import type { CommandModule } from 'yargs';
-import { requestSuiFromFaucetV0, getFaucetHost } from '@mysten/sui/faucet';
+import { requestSuiFromFaucetV2, getFaucetHost } from '@mysten/sui/faucet';
 import { SuiClient, getFullnodeUrl, GetBalanceParams } from '@mysten/sui/client';
 import { initializeDubhe } from '../utils';
+import { handlerExit } from './shell';
 
 type Options = {
   network: any;
   recipient?: string;
+  'rpc-url'?: string;
 };
 
 const MAX_RETRIES = 60; // 60s timeout
@@ -27,15 +29,20 @@ const commandModule: CommandModule<Options, Options> = {
       },
       recipient: {
         type: 'string',
+        alias: 'r',
         desc: 'Sui address to fund'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL for balance check (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, recipient }) {
+  async handler({ network, recipient, 'rpc-url': rpcUrl }) {
     let faucet_address = '';
     if (recipient === undefined) {
-      const dubhe = initializeDubhe(network);
+      const dubhe = initializeDubhe({ network });
       faucet_address = dubhe.getAddress();
     } else {
       faucet_address = recipient;
@@ -63,26 +70,29 @@ const commandModule: CommandModule<Options, Options> = {
       isInterrupted = true;
       process.stdout.write('\r' + ' '.repeat(50) + '\r');
       console.log('\n  └─ Operation cancelled by user');
-      process.exit(0);
+      handlerExit(1);
     };
     process.on('SIGINT', handleInterrupt);
 
     try {
       while (retryCount < MAX_RETRIES && !success && !isInterrupted) {
         try {
-          await requestSuiFromFaucetV0({
+          await requestSuiFromFaucetV2({
             host: getFaucetHost(network),
             recipient: faucet_address
           });
           success = true;
-        } catch (error) {
+        } catch (_error) {
           if (isInterrupted) break;
 
           retryCount++;
           if (retryCount === MAX_RETRIES) {
             console.log(`  └─ Failed to request funds after ${MAX_RETRIES} attempts.`);
             console.log('  └─ Please check your network connection and try again later.');
-            process.exit(1);
+            console.log(
+              '  └─ You can visit https://faucet.testnet.sui.io/ to request funds manually.'
+            );
+            handlerExit(1);
           }
 
           const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
@@ -98,12 +108,12 @@ const commandModule: CommandModule<Options, Options> = {
     }
 
     if (isInterrupted) {
-      process.exit(0);
+      handlerExit(1);
     }
     process.stdout.write('\r' + ' '.repeat(50) + '\r');
 
     console.log('  └─ Checking balance...');
-    const client = new SuiClient({ url: getFullnodeUrl(network) });
+    const client = new SuiClient({ url: rpcUrl || getFullnodeUrl(network) });
     let params = {
       owner: faucet_address
     } as GetBalanceParams;
@@ -115,7 +125,7 @@ const commandModule: CommandModule<Options, Options> = {
     console.log(`  └─ Balance: ${(Number(balance.totalBalance) / 1_000_000_000).toFixed(4)} SUI`);
 
     console.log('\n✅ Faucet Operation Complete\n');
-    process.exit(0);
+    handlerExit();
   }
 };
 

package/src/commands/generate.ts

@@ -0,0 +1,61 @@
+import type { CommandModule } from 'yargs';
+import { codegen, loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+import chalk from 'chalk';
+import path from 'node:path';
+import { handlerExit } from './shell';
+import { getDefaultNetwork } from '../utils';
+
+type Options = {
+  'config-path'?: string;
+  network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+  mode?: 'user_pays' | 'dapp_subsidizes';
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: 'generate',
+  // 'schemagen' kept as a deprecated alias for backward compatibility
+  aliases: ['schemagen'],
+
+  describe: 'Generate Move code from dubhe.config.ts',
+
+  builder: {
+    'config-path': {
+      type: 'string',
+      default: 'dubhe.config.ts',
+      desc: 'Path to the config file'
+    },
+    network: {
+      type: 'string',
+      choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'] as const,
+      default: 'default',
+      desc: 'Node network (mainnet/testnet/devnet/localnet)'
+    },
+    mode: {
+      type: 'string',
+      choices: ['user_pays', 'dapp_subsidizes'] as const,
+      default: 'user_pays',
+      desc: 'Initial settlement mode for this DApp (only applies on first generate)'
+    }
+  },
+
+  async handler({ 'config-path': configPath, network, mode }) {
+    try {
+      if (!configPath) throw new Error('Config path is required');
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
+      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+      const rootDir = path.dirname(configPath);
+      const initialMode: 0 | 1 = mode === 'dapp_subsidizes' ? 0 : 1;
+      await codegen(rootDir, dubheConfig, network, initialMode);
+      handlerExit();
+    } catch (error: any) {
+      console.log(chalk.red('Generate failed!'));
+      console.error(error.message);
+      handlerExit(1);
+    }
+  }
+};
+
+export default commandModule;

package/src/commands/generateKey.ts

@@ -1,5 +1,6 @@
 import type { CommandModule } from 'yargs';
 import { generateAccountHandler } from '../utils/generateAccount';
+import { handlerExit } from './shell';
 
 type Options = {
   force?: boolean;
@@ -26,9 +27,9 @@ const commandModule: CommandModule<Options, Options> = {
       await generateAccountHandler(force, useNextPublic);
     } catch (error) {
       console.error('Error generating account:', error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };
 

package/src/commands/index.ts

@@ -2,35 +2,44 @@ import { CommandModule } from 'yargs';
 
 import localnode from './localnode';
 import faucet from './faucet';
-import schemagen from './schemagen';
+import generate from './generate';
 import publish from './publish';
-import upgrade from './upgrade';
 import test from './test';
 import build from './build';
 import hello from './hello';
 import generateKey from './generateKey';
 import checkBalance from './checkBalance';
-import configStore from './configStore';
-import query from './query';
-import call from './call';
+import storeConfig from './storeConfig';
 import watch from './watch';
 import wait from './wait';
+import switchEnv from './switchEnv';
+import info from './info';
+import loadMetadata from './loadMetadata';
+import doctor from './doctor';
+import convertJson from './convertJson';
+import upgrade from './upgrade';
+import shell from './shell';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
   localnode,
   publish,
-  call,
-  query,
+  // call,
+  // query,
   faucet,
-  schemagen,
+  generate,
   upgrade,
   test,
   build,
   hello,
   generateKey,
   checkBalance,
-  configStore,
+  storeConfig,
   watch,
-  wait
+  wait,
+  switchEnv,
+  info,
+  loadMetadata,
+  doctor,
+  convertJson,
+  shell
 ];

package/src/commands/info.ts

@@ -0,0 +1,61 @@
+import { CommandModule } from 'yargs';
+import { logError, initializeDubhe, getDefaultNetwork } from '../utils';
+import dotenv from 'dotenv';
+import chalk from 'chalk';
+import { handlerExit } from './shell';
+dotenv.config();
+
+type Options = {
+  network: any;
+  'rpc-url'?: string;
+};
+
+const InfoCommand: CommandModule<Options, Options> = {
+  command: 'info',
+  describe: 'Get information about the current Sui node',
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        default: 'default',
+        desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
+    });
+  },
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
+    try {
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      const dubhe = initializeDubhe({ network, fullnodeUrls });
+      const keypair = dubhe.getSigner();
+
+      console.log(chalk.blue('Account Information:'));
+      console.log(`  Network: ${chalk.green(network)}`);
+      console.log(`  Address: ${chalk.green(keypair.toSuiAddress())}`);
+
+      try {
+        const balance = await dubhe.getBalance('0x2::sui::SUI');
+        const suiBalance = (Number(balance.totalBalance) / 10 ** 9).toFixed(4);
+        console.log(`  Balance: ${chalk.green(suiBalance)} SUI`);
+      } catch (_error) {
+        console.log(
+          `  Balance: ${chalk.red('Failed to fetch balance')} ${chalk.gray('(Network error)')}`
+        );
+      }
+      handlerExit();
+    } catch (error) {
+      logError(error);
+      handlerExit(1);
+    }
+  }
+};
+
+export default InfoCommand;

package/src/commands/loadMetadata.ts

@@ -0,0 +1,68 @@
+import type { CommandModule } from 'yargs';
+import { logError } from '../utils/errors';
+import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+import { loadMetadataHandler } from '../utils/metadataHandler';
+import { handlerExit } from './shell';
+import { getDefaultNetwork } from '../utils';
+import chalk from 'chalk';
+
+type Options = {
+  network: any;
+  'config-path': string;
+  'package-id'?: string;
+  'rpc-url'?: string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: 'load-metadata',
+
+  describe: 'Load metadata for a package',
+
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        default: 'default',
+        desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      },
+      'config-path': {
+        type: 'string',
+        desc: 'Configuration file path',
+        default: 'dubhe.config.ts'
+      },
+      'package-id': {
+        type: 'string',
+        desc: 'Package ID to load metadata for',
+        optional: true
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
+    });
+  },
+
+  async handler({
+    network,
+    'config-path': configPath,
+    'package-id': packageId,
+    '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;
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await loadMetadataHandler(dubheConfig, network, packageId, fullnodeUrls);
+    } catch (error: any) {
+      logError(error);
+      handlerExit(1);
+    }
+    handlerExit();
+  }
+};
+
+export default commandModule;

package/src/commands/localnode.ts

@@ -1,22 +1,38 @@
 import type { CommandModule } from 'yargs';
 import { startLocalNode } from '../utils/startNode';
+import { handlerExit } from './shell';
 
-const commandModule: CommandModule = {
+type Options = {
+  'data-dir': string;
+  force: boolean;
+};
+
+const commandModule: CommandModule<Options, Options> = {
   command: 'node',
 
   describe: 'Manage local Sui node',
 
-  builder(yargs) {
-    return yargs
+  builder: {
+    'data-dir': {
+      type: 'string',
+      default: '.chk',
+      desc: 'Path to the data directory'
+    },
+    force: {
+      type: 'boolean',
+      default: false,
+      desc: 'Force restart: stop existing node and remove data directory'
+    }
   },
 
-  async handler() {
+  async handler({ 'data-dir': data_dir, force }) {
     try {
-      await startLocalNode();
+      await startLocalNode(data_dir, force);
     } catch (error) {
       console.error('Error executing command:', error);
-      process.exit(1);
+      handlerExit(1);
     }
+    handlerExit();
   }
 };
 

package/src/commands/publish.ts

@@ -1,12 +1,24 @@
 import type { CommandModule } from 'yargs';
 import { logError } from '../utils/errors';
-import { publishHandler } from '../utils';
+import {
+  getDefaultNetwork,
+  publishHandler,
+  lintSystemGuards,
+  formatLintWarnings,
+  confirm
+} from '../utils';
 import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+import { execSync } from 'child_process';
+import { join as pathJoin } from 'path';
+import { handlerExit } from './shell';
+import chalk from 'chalk';
 
 type Options = {
   network: any;
   'config-path': string;
+  force: boolean;
   'gas-budget'?: number;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -18,8 +30,8 @@ const commandModule: CommandModule<Options, Options> = {
     return yargs.options({
       network: {
         type: 'string',
-        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-        default: 'localnet',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        default: 'default',
         desc: 'Node network (mainnet/testnet/devnet/localnet)'
       },
       'config-path': {
@@ -31,19 +43,55 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'number',
         desc: 'Optional gas budget for the transaction',
         optional: true
+      },
+      force: {
+        type: 'boolean',
+        default: false,
+        desc: 'Clear existing published state for this network before build (use when re-publishing or to fix PublishErrorNonZeroAddress)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath, 'gas-budget': gasBudget }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'gas-budget': gasBudget,
+    force,
+    '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 publishHandler(dubheConfig, network, gasBudget);
+
+      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 publish anyway?'
+        );
+        if (!proceed) {
+          console.log(chalk.red('Publish cancelled.'));
+          handlerExit(1);
+          return;
+        }
+      }
+
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      execSync(`pnpm dubhe convert-json --config-path ${configPath}`, { encoding: 'utf-8' });
+      await publishHandler(dubheConfig, network, force, gasBudget, fullnodeUrls);
     } catch (error: any) {
       logError(error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };