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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.12",
+  "version": "1.2.0-pre.120",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -8,8 +8,6 @@
     "move",
     "blockchain"
   ],
-  "type": "module",
-  "author": "team@obelisk.build",
   "homepage": "https://github.com/0xobelisk/dubhe/tree/main/packages/sui-cli#readme",
   "bugs": "https://github.com/0xobelisk/dubhe/issues",
   "repository": {
@@ -17,12 +15,8 @@
     "url": "https://github.com/0xobelisk/dubhe.git"
   },
   "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=18"
-  },
+  "author": "team@obelisk.build",
+  "type": "module",
   "exports": {
     ".": "./dist/index.js"
   },
@@ -31,34 +25,39 @@
     "dubhe": "./dist/dubhe.js"
   },
   "dependencies": {
-    "@mysten/sui": "^1.19.0",
-    "@types/sqlite3": "^3.1.11",
+    "@mysten/sui": "1.35.0",
     "@types/wait-on": "^5.3.4",
+    "axios": "^1.12.0",
     "chalk": "^5.0.1",
     "child_process": "^1.0.2",
     "chokidar": "^3.5.3",
+    "cli-progress": "^3.12.0",
+    "cli-table3": "^0.6.5",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.8",
     "execa": "^7.0.0",
     "glob": "^8.0.3",
+    "http-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7.0.6",
+    "inquirer": "^9.2.15",
     "ora": "^5.4.1",
     "path": "^0.12.7",
-    "sqlite": "^5.1.1",
-    "sqlite3": "^5.1.7",
-    "typescript": "5.1.6",
+    "typescript": "^5.8.3",
     "wait-on": "^7.0.1",
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.2.0-pre.12",
-    "@0xobelisk/sui-common": "1.2.0-pre.12"
+    "@0xobelisk/sui-client": "1.2.0-pre.120",
+    "@0xobelisk/sui-common": "1.2.0-pre.120"
   },
   "devDependencies": {
+    "@types/cli-progress": "^3.11.5",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
-    "@types/node": "^18.15.11",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.16.0",
     "@types/yargs": "^17.0.10",
-    "eslint": "^8.56.0",
+    "eslint": "^9.0.0",
     "eslint-config-prettier": "^9.1.0",
     "prettier": "3.3.3",
     "ts-node": "^10.9.1",
@@ -66,15 +65,28 @@
     "tsx": "^3.12.6",
     "vitest": "0.31.4"
   },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "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",
-    "lint": "eslint . --ext .ts",
     "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

@@ -1,35 +1,71 @@
 import type { CommandModule } from 'yargs';
-import { execSync } from 'child_process';
+import { execSync, exec } from 'child_process';
+import nodePath from 'path';
 import chalk from 'chalk';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
-import { switchEnv, updateDubheDependency } from '../utils';
+import { handlerExit } from './shell';
+import { getDefaultNetwork, switchEnv, lintSystemGuards, formatLintWarnings } from '../utils';
 
 type Options = {
   'config-path': string;
   network: any;
   'dump-bytecode-as-base64'?: boolean;
+  'rpc-url'?: string;
 };
 
+/**
+ * Core build logic for Dubhe contracts.
+ *
+ * - localnet: uses --build-env testnet + --pubfile-path Pub.localnet.toml so that
+ *   dependency addresses are resolved through the ephemeral publication file created
+ *   by publishHandler. Counter can only be built after dubhe is published on localnet.
+ * - Other networks: uses -e <network> (standard Sui CLI environment flag).
+ */
+export async function buildHandler(
+  dubheConfig: DubheConfig,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  dumpBytecodeAsBase64: boolean = false
+): Promise<string> {
+  const cwd = process.cwd();
+  const projectPath = nodePath.join(cwd, 'src', dubheConfig.name);
+
+  let command: string;
+  if (network === 'localnet') {
+    const pubfilePath = nodePath.join(cwd, 'Pub.localnet.toml');
+    command = `sui move build --build-env testnet --pubfile-path ${pubfilePath} --path ${projectPath}`;
+  } else {
+    command = `sui move build -e ${network} --path ${projectPath}`;
+  }
+
+  if (dumpBytecodeAsBase64) command += ' --dump-bytecode-as-base64';
+
+  return execSync(command, { encoding: 'utf-8' });
+}
+
 const commandModule: CommandModule<Options, Options> = {
   command: 'build',
-  describe: 'Run tests in Dubhe contracts',
+  describe: 'Build Dubhe contracts',
   builder(yargs) {
     return yargs.options({
       'config-path': {
         type: 'string',
         default: 'dubhe.config.ts',
-        description: 'Options to pass to forge test'
+        description: 'Path to the Dubhe config file'
       },
       network: {
         type: 'string',
-        default: 'localnet',
-        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+        default: 'default',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
         desc: 'Node network (mainnet/testnet/devnet/localnet)'
       },
       'dump-bytecode-as-base64': {
         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)'
       }
     });
   },
@@ -37,25 +73,32 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({
     'config-path': configPath,
     network,
-    'dump-bytecode-as-base64': dumpBytecodeAsBase64
+    'dump-bytecode-as-base64': dumpBytecodeAsBase64,
+    'rpc-url': rpcUrl
   }) {
-    // Start an internal anvil process if no world address is provided
     try {
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
       console.log('🚀 Running move build');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      const path = process.cwd();
-      const projectPath = `${path}/src/${dubheConfig.name}`;
-      await switchEnv(network);
-      await updateDubheDependency(projectPath + '/Move.toml', network);
-      const command = `sui move build --path ${projectPath} ${
-        dumpBytecodeAsBase64 ? ` --dump-bytecode-as-base64` : ''
-      }`;
-      const output = execSync(command, { encoding: 'utf-8' });
+      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}`);
     } catch (error: any) {
       console.error(chalk.red('Error executing sui move build:'));
-      console.log(error.stdout);
-      process.exit(0);
+      if (error.stdout) process.stdout.write(error.stdout);
+      if (error.stderr) process.stderr.write(error.stderr);
+      if (!error.stdout && !error.stderr && error.message) process.stderr.write(error.message);
+      handlerExit(1);
     }
   }
 };

package/src/commands/call.ts

@@ -1,90 +1,90 @@
-import type { CommandModule } from 'yargs';
-import { logError } from '../utils/errors';
-import { callHandler } from '../utils';
-import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+// import type { CommandModule } from 'yargs';
+// import { logError } from '../utils/errors';
+// import { callHandler } from '../utils';
+// import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
 
-type Options = {
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-  module: string;
-  function: string;
-  'config-path'?: string;
-  'package-id'?: string;
-  'metadata-path'?: string;
-  params?: any[];
-};
+// type Options = {
+//   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+//   module: string;
+//   function: string;
+//   'config-path'?: string;
+//   'package-id'?: string;
+//   'metadata-path'?: string;
+//   params?: any[];
+// };
 
-/**
- * CLI command for calling a function in a module
- */
-const commandModule: CommandModule<Options, Options> = {
-  command: 'call',
+// /**
+//  * CLI command for calling a function in a module
+//  */
+// const commandModule: CommandModule<Options, Options> = {
+//   command: 'call',
 
-  describe: 'Call a function in a module',
+//   describe: 'Call a function in a module',
 
-  builder: {
-    network: {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-      desc: 'Node network (mainnet/testnet/devnet/localnet)',
-      default: 'localnet'
-    },
-    module: {
-      type: 'string',
-      desc: 'Module name',
-      demandOption: true
-    },
-    function: {
-      type: 'string',
-      desc: 'Function name',
-      demandOption: true
-    },
-    'config-path': {
-      type: 'string',
-      default: 'dubhe.config.ts',
-      desc: 'Configuration file path'
-    },
-    'package-id': {
-      type: 'string',
-      desc: 'Package ID (optional)'
-    },
-    'metadata-path': {
-      type: 'string',
-      desc: 'Path to metadata JSON file (optional)'
-    },
-    params: {
-      type: 'array',
-      desc: 'Params for the function',
-      string: true
-    }
-  },
+//   builder: {
+//     network: {
+//       type: 'string',
+//       choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+//       desc: 'Node network (mainnet/testnet/devnet/localnet)',
+//       default: 'localnet'
+//     },
+//     module: {
+//       type: 'string',
+//       desc: 'Module name',
+//       demandOption: true
+//     },
+//     function: {
+//       type: 'string',
+//       desc: 'Function name',
+//       demandOption: true
+//     },
+//     'config-path': {
+//       type: 'string',
+//       default: 'dubhe.config.ts',
+//       desc: 'Configuration file path'
+//     },
+//     'package-id': {
+//       type: 'string',
+//       desc: 'Package ID (optional)'
+//     },
+//     'metadata-path': {
+//       type: 'string',
+//       desc: 'Path to metadata JSON file (optional)'
+//     },
+//     params: {
+//       type: 'array',
+//       desc: 'Params for the function',
+//       string: true
+//     }
+//   },
 
-  async handler({
-    network,
-    'config-path': configPath,
-    module: moduleName,
-    function: funcName,
-    'package-id': packageId,
-    'metadata-path': metadataPath,
-    params
-  }) {
-    try {
-      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+//   async handler({
+//     network,
+//     'config-path': configPath,
+//     module: moduleName,
+//     function: funcName,
+//     'package-id': packageId,
+//     'metadata-path': metadataPath,
+//     params
+//   }) {
+//     try {
+//       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
 
-      await callHandler({
-        dubheConfig,
-        moduleName,
-        funcName,
-        network,
-        packageId,
-        metadataFilePath: metadataPath,
-        params
-      });
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-};
+//       await callHandler({
+//         dubheConfig,
+//         moduleName,
+//         funcName,
+//         network,
+//         packageId,
+//         metadataFilePath: metadataPath,
+//         params
+//       });
+//     } catch (error: any) {
+//       logError(error);
+//       process.exit(1);
+//     }
+//     process.exit(0);
+//   }
+// };
 
-export default commandModule;
+// export default commandModule;

package/src/commands/checkBalance.ts

@@ -1,29 +1,44 @@
 import type { CommandModule } from 'yargs';
 import { checkBalanceHandler } from '../utils/checkBalance';
+import { handlerExit } from './shell';
+import chalk from 'chalk';
+import { getDefaultNetwork } from '../utils';
 
 type Options = {
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  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'],
-      desc: 'Network to check balance on',
-      default: 'localnet'
-    }
+  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 {
-      await checkBalanceHandler(network);
+      if (network == 'default') {
+        network = await getDefaultNetwork();
+        console.log(chalk.yellow(`Use default network: [${network}]`));
+      }
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await checkBalanceHandler(network, fullnodeUrls);
     } catch (error) {
       console.error('Error checking balance:', error);
-      process.exit(1);
+      handlerExit(1);
     }
-    process.exit(0);
+    handlerExit();
   }
 };
 

package/src/commands/convertJson.ts

@@ -0,0 +1,84 @@
+import type { CommandModule } from 'yargs';
+import chalk from 'chalk';
+import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
+import { generateConfigJson } from '../utils';
+import fs from 'fs';
+import { handlerExit } from './shell';
+
+type Options = {
+  'config-path': string;
+  'output-path': string;
+};
+
+const RUNTIME_FIELDS = [
+  'original_package_id',
+  'dubhe_object_id',
+  'original_dubhe_package_id',
+  'dapp_key',
+  'start_checkpoint'
+];
+
+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',
+  builder(yargs) {
+    return yargs.options({
+      'config-path': {
+        type: 'string',
+        default: 'dubhe.config.ts',
+        description: 'Options to pass to forge test'
+      },
+      'output-path': {
+        type: 'string',
+        default: 'dubhe.config.json',
+        description: 'Output path for the config.json file'
+      }
+    });
+  },
+
+  async handler({ 'config-path': configPath, 'output-path': outputPath }) {
+    try {
+      console.log('🚀 Running convert json');
+      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+      const schemaJson = JSON.parse(generateConfigJson(dubheConfig));
+
+      let existing: Record<string, unknown> = {};
+      if (fs.existsSync(outputPath)) {
+        try {
+          existing = JSON.parse(fs.readFileSync(outputPath, 'utf-8'));
+        } catch {
+          // ignore parse errors – start fresh
+        }
+      }
+      const merged = mergeConfigJsonRuntimeFields(schemaJson, existing);
+
+      fs.writeFileSync(outputPath, JSON.stringify(merged, null, 2));
+    } catch (error: any) {
+      console.error(chalk.red('Error executing convert json:'));
+      console.log(error.stdout);
+      handlerExit(1);
+    }
+    handlerExit();
+  }
+};
+
+export default commandModule;