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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.99",
+  "version": "2.0.0",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -24,28 +24,7 @@
   "bin": {
     "dubhe": "./dist/dubhe.js"
   },
-  "scripts": {
-    "build": "pnpm run type-check && pnpm run build:js",
-    "build:js": "tsup && chmod +x ./dist/dubhe.js",
-    "clean": "pnpm run clean:js",
-    "clean:js": "rimraf dist",
-    "dev": "tsup --watch",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "lint": "eslint . --ext .ts",
-    "test": "vitest run",
-    "test:all": "pnpm test && pnpm test:integration",
-    "test:coverage": "vitest run --coverage",
-    "test:integration": "vitest run --config vitest.integration.config.ts",
-    "test:localnet": "vitest run --config vitest.integration.config.ts tests/integration/localnet.test.ts",
-    "test:testnet": "vitest run --config vitest.integration.config.ts tests/integration/testnet.test.ts",
-    "test:watch": "vitest",
-    "type-check": "tsc --noEmit",
-    "validate": "pnpm format:check && pnpm type-check"
-  },
   "dependencies": {
-    "@0xobelisk/sui-client": "workspace:*",
-    "@0xobelisk/sui-common": "workspace:*",
     "@mysten/sui": "1.35.0",
     "@types/wait-on": "^5.3.4",
     "axios": "^1.12.0",
@@ -67,7 +46,9 @@
     "wait-on": "^7.0.1",
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
-    "zod-validation-error": "^1.3.0"
+    "zod-validation-error": "^1.3.0",
+    "@0xobelisk/sui-common": "2.0.0",
+    "@0xobelisk/sui-client": "2.0.0"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.5",
@@ -89,5 +70,24 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run type-check && pnpm run build:js",
+    "build:js": "tsup && chmod +x ./dist/dubhe.js",
+    "clean": "pnpm run clean:js",
+    "clean:js": "rimraf dist",
+    "dev": "tsup --watch",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint . --ext .ts",
+    "test": "vitest run",
+    "test:all": "pnpm test && pnpm test:integration",
+    "test:coverage": "vitest run --coverage",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:localnet": "vitest run --config vitest.integration.config.ts tests/integration/localnet.test.ts",
+    "test:testnet": "vitest run --config vitest.integration.config.ts tests/integration/testnet.test.ts",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "validate": "pnpm format:check && pnpm type-check"
   }
-}
+}

package/src/commands/build.ts

@@ -4,12 +4,13 @@ import nodePath from 'path';
 import chalk from 'chalk';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 import { handlerExit } from './shell';
-import { getDefaultNetwork, switchEnv } from '../utils';
+import { getDefaultNetwork, switchEnv, lintSystemGuards, formatLintWarnings } from '../utils';
 
 type Options = {
   'config-path': string;
   network: any;
   'dump-bytecode-as-base64'?: boolean;
+  'rpc-url'?: string;
 };
 
 /**
@@ -61,6 +62,10 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'boolean',
         default: false,
         desc: 'Dump bytecode as base64'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
@@ -68,7 +73,8 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({
     'config-path': configPath,
     network,
-    'dump-bytecode-as-base64': dumpBytecodeAsBase64
+    'dump-bytecode-as-base64': dumpBytecodeAsBase64,
+    'rpc-url': rpcUrl
   }) {
     try {
       if (network == 'default') {
@@ -77,7 +83,13 @@ const commandModule: CommandModule<Options, Options> = {
       }
       console.log('🚀 Running move build');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await switchEnv(network);
+      await switchEnv(network, rpcUrl);
+
+      const projectPath = nodePath.join(process.cwd(), 'src', dubheConfig.name);
+      const lintResults = lintSystemGuards(projectPath);
+      const warnings = formatLintWarnings(lintResults);
+      if (warnings) process.stdout.write(warnings);
+
       const output = await buildHandler(dubheConfig, network, dumpBytecodeAsBase64);
       console.log(output);
       exec(`pnpm dubhe convert-json --config-path ${configPath}`);

package/src/commands/checkBalance.ts

@@ -6,26 +6,34 @@ import { getDefaultNetwork } from '../utils';
 
 type Options = {
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
   command: 'check-balance',
   describe: 'Check the balance of the account',
-  builder: {
-    network: {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
-      desc: 'Network to check balance on',
-      default: 'default'
-    }
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        desc: 'Network to check balance on',
+        default: 'default'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
+    }) as any;
   },
-  async handler({ network }) {
+  async handler({ network, 'rpc-url': rpcUrl }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
-      await checkBalanceHandler(network);
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await checkBalanceHandler(network, fullnodeUrls);
     } catch (error) {
       console.error('Error checking balance:', error);
       handlerExit(1);

package/src/commands/convertJson.ts

@@ -10,6 +10,34 @@ type Options = {
   'output-path': string;
 };
 
+const RUNTIME_FIELDS = [
+  'original_package_id',
+  'dubhe_object_id',
+  'original_dubhe_package_id',
+  'dapp_key',
+  'start_checkpoint',
+  'package_ids'
+];
+
+export function mergeConfigJsonRuntimeFields(
+  schemaJson: Record<string, unknown>,
+  existing: Record<string, unknown>
+): Record<string, unknown> {
+  const merged: Record<string, unknown> = { ...schemaJson };
+  for (const field of RUNTIME_FIELDS) {
+    if (existing[field] !== undefined) {
+      merged[field] = existing[field];
+    }
+  }
+  // If dapp_key is missing but original_package_id is present, compute it.
+  // This handles configs created before dapp_key was introduced.
+  if (!merged['dapp_key'] && merged['original_package_id']) {
+    const hex = (merged['original_package_id'] as string).replace(/^0x/i, '').padStart(64, '0');
+    merged['dapp_key'] = `${hex}::dapp_key::DappKey`;
+  }
+  return merged;
+}
+
 const commandModule: CommandModule<Options, Options> = {
   command: 'convert-json',
   describe: 'Convert JSON from Dubhe config to config.json',
@@ -18,7 +46,7 @@ const commandModule: CommandModule<Options, Options> = {
       'config-path': {
         type: 'string',
         default: 'dubhe.config.ts',
-        description: 'Options to pass to forge test'
+        description: 'Path to the Dubhe config file'
       },
       'output-path': {
         type: 'string',
@@ -34,33 +62,28 @@ const commandModule: CommandModule<Options, Options> = {
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
       const schemaJson = JSON.parse(generateConfigJson(dubheConfig));
 
-      // Preserve runtime fields written by publishHandler (package IDs, checkpoint, etc.)
-      // so that re-running convert-json after publish does not wipe deployment info.
-      const RUNTIME_FIELDS = [
-        'original_package_id',
-        'dubhe_object_id',
-        'original_dubhe_package_id',
-        'start_checkpoint'
-      ];
       let existing: Record<string, unknown> = {};
-      if (fs.existsSync(outputPath)) {
+      const isUpdate = fs.existsSync(outputPath);
+      if (isUpdate) {
         try {
           existing = JSON.parse(fs.readFileSync(outputPath, 'utf-8'));
         } catch {
           // ignore parse errors – start fresh
         }
       }
-      const merged: Record<string, unknown> = { ...schemaJson };
-      for (const field of RUNTIME_FIELDS) {
-        if (existing[field] !== undefined) {
-          merged[field] = existing[field];
-        }
+      const merged = mergeConfigJsonRuntimeFields(schemaJson, existing);
+
+      // Log which runtime fields were preserved from the existing file
+      const preserved = RUNTIME_FIELDS.filter((f) => existing[f] !== undefined);
+      if (preserved.length > 0) {
+        console.log(chalk.gray(`   preserved runtime fields: ${preserved.join(', ')}`));
       }
 
       fs.writeFileSync(outputPath, JSON.stringify(merged, null, 2));
+      console.log(chalk.green(`✅ ${isUpdate ? 'Updated' : 'Created'} ${outputPath}`));
     } catch (error: any) {
       console.error(chalk.red('Error executing convert json:'));
-      console.log(error.stdout);
+      if (error.message) console.error(error.message);
       handlerExit(1);
     }
     handlerExit();

package/src/commands/faucet.ts

@@ -7,6 +7,7 @@ import { handlerExit } from './shell';
 type Options = {
   network: any;
   recipient?: string;
+  'rpc-url'?: string;
 };
 
 const MAX_RETRIES = 60; // 60s timeout
@@ -28,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;
@@ -107,7 +113,7 @@ const commandModule: CommandModule<Options, Options> = {
     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;

package/src/commands/{schemagen.ts → generate.ts}

@@ -1,5 +1,5 @@
 import type { CommandModule } from 'yargs';
-import { schemaGen, loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+import { codegen, loadConfig, DubheConfig } from '@0xobelisk/sui-common';
 import chalk from 'chalk';
 import path from 'node:path';
 import { handlerExit } from './shell';
@@ -8,12 +8,15 @@ 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: 'schemagen',
+  command: 'generate',
+  // 'schemagen' kept as a deprecated alias for backward compatibility
+  aliases: ['schemagen'],
 
-  describe: 'Autogenerate Dubhe schemas based on the config file',
+  describe: 'Generate Move code from dubhe.config.ts',
 
   builder: {
     'config-path': {
@@ -26,10 +29,16 @@ const commandModule: CommandModule<Options, Options> = {
       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 }) {
+  async handler({ 'config-path': configPath, network, mode }) {
     try {
       if (!configPath) throw new Error('Config path is required');
       if (network == 'default') {
@@ -38,10 +47,11 @@ const commandModule: CommandModule<Options, Options> = {
       }
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
       const rootDir = path.dirname(configPath);
-      await schemaGen(rootDir, dubheConfig, network);
+      const initialMode: 0 | 1 = mode === 'dapp_subsidizes' ? 0 : 1;
+      await codegen(rootDir, dubheConfig, network, initialMode);
       handlerExit();
     } catch (error: any) {
-      console.log(chalk.red('Schemagen failed!'));
+      console.log(chalk.red('Generate failed!'));
       console.error(error.message);
       handlerExit(1);
     }

package/src/commands/index.ts

@@ -2,14 +2,14 @@ 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 test from './test';
 import build from './build';
 import hello from './hello';
 import generateKey from './generateKey';
 import checkBalance from './checkBalance';
-import configStore from './configStore';
+import storeConfig from './storeConfig';
 import watch from './watch';
 import wait from './wait';
 import switchEnv from './switchEnv';
@@ -26,14 +26,14 @@ export const commands: CommandModule<any, any>[] = [
   // call,
   // query,
   faucet,
-  schemagen,
+  generate,
   upgrade,
   test,
   build,
   hello,
   generateKey,
   checkBalance,
-  configStore,
+  storeConfig,
   watch,
   wait,
   switchEnv,

package/src/commands/info.ts

@@ -7,6 +7,7 @@ dotenv.config();
 
 type Options = {
   network: any;
+  'rpc-url'?: string;
 };
 
 const InfoCommand: CommandModule<Options, Options> = {
@@ -19,16 +20,21 @@ const InfoCommand: CommandModule<Options, Options> = {
         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 }) => {
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
-      const dubhe = initializeDubhe({ network });
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      const dubhe = initializeDubhe({ network, fullnodeUrls });
       const keypair = dubhe.getSigner();
 
       console.log(chalk.blue('Account Information:'));

package/src/commands/loadMetadata.ts

@@ -10,6 +10,7 @@ type Options = {
   network: any;
   'config-path': string;
   'package-id'?: string;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -34,18 +35,28 @@ const commandModule: CommandModule<Options, Options> = {
         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 }) {
+  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;
-      await loadMetadataHandler(dubheConfig, network, packageId);
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await loadMetadataHandler(dubheConfig, network, packageId, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/commands/publish.ts

@@ -1,8 +1,15 @@
 import type { CommandModule } from 'yargs';
 import { logError } from '../utils/errors';
-import { getDefaultNetwork, 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';
 
@@ -11,6 +18,7 @@ type Options = {
   'config-path': string;
   force: boolean;
   'gas-budget'?: number;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -38,21 +46,47 @@ const commandModule: CommandModule<Options, Options> = {
       },
       force: {
         type: 'boolean',
-        default: true,
-        desc: 'Force publish: do not update dependencies'
+        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, force }) {
+  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;
+
+      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);
+      await publishHandler(dubheConfig, network, force, gasBudget, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/commands/shell.ts

@@ -20,6 +20,7 @@ export const handlerExit = (status: number = 0) => {
 
 type Options = {
   network: any;
+  'rpc-url'?: string;
 };
 
 const parseCommandNames = () => {
@@ -38,10 +39,14 @@ const ShellCommand: CommandModule<Options, Options> = {
         choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
         default: 'default',
         desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL injected into every sub-command (overrides the default for the selected network)'
       }
     });
   },
-  handler: async ({ network }) => {
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
     if (network == 'default') {
       network = await getDefaultNetwork();
       console.log(chalk.yellow(`Use default network: [${network}]`));
@@ -60,7 +65,9 @@ const ShellCommand: CommandModule<Options, Options> = {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-      prompt: `dubhe(${chalk.green(network)}) ${chalk.bold('>')} `,
+      prompt: `dubhe(${chalk.green(network)}${
+        rpcUrl ? chalk.gray('[custom-rpc]') : ''
+      }) ${chalk.bold('>')} `,
       completer: completer,
       historySize: 200
     });
@@ -132,11 +139,14 @@ const ShellCommand: CommandModule<Options, Options> = {
             } else {
               yargsInstance.options(builder);
             }
+            const userArgs = parts.slice(1);
+            const hasNetworkFlag = userArgs.includes('--network') || userArgs.includes('-n');
+            const hasRpcUrlFlag = userArgs.includes('--rpc-url');
             const argv = yargsInstance.parseSync([
               commandName,
-              '--network',
-              network,
-              ...parts.slice(1)
+              ...(hasNetworkFlag ? [] : ['--network', network]),
+              ...(hasRpcUrlFlag || !rpcUrl ? [] : ['--rpc-url', rpcUrl]),
+              ...userArgs
             ]);
             if (handler) {
               await handler(argv);

package/src/commands/{configStore.ts → storeConfig.ts}

@@ -12,7 +12,7 @@ type Options = {
 };
 
 const commandModule: CommandModule<Options, Options> = {
-  command: 'config-store',
+  command: 'store-config',
 
   describe: 'Store configuration for the Dubhe project',
 
@@ -30,6 +30,7 @@ const commandModule: CommandModule<Options, Options> = {
     },
     'output-ts-path': {
       type: 'string',
+      default: './deployment.ts',
       desc: 'Specify the output path for the generated TypeScript configuration file (e.g., ./src/config/generated.ts)'
     }
   },

package/src/commands/switchEnv.ts

@@ -4,21 +4,28 @@ import { handlerExit } from './shell';
 
 type Options = {
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
   command: 'switch-env',
   describe: 'Switch environment',
   builder(yargs) {
-    return yargs.option('network', {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
-      default: 'localnet',
-      desc: 'Switch to node network (mainnet/testnet/devnet/localnet)'
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
+        default: 'localnet',
+        desc: 'Switch to node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
     }) as any;
   },
   async handler(argv: ArgumentsCamelCase<Options>) {
-    await switchEnv(argv.network as 'mainnet' | 'testnet' | 'devnet' | 'localnet');
+    await switchEnv(argv.network as 'mainnet' | 'testnet' | 'devnet' | 'localnet', argv['rpc-url']);
     handlerExit();
   }
 };