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

package/src/commands/watch.ts

@@ -1,6 +1,7 @@
 import type { CommandModule } from 'yargs';
 import chokidar from 'chokidar';
 import { exec } from 'child_process';
+import { handlerExit } from './shell';
 
 const commandModule: CommandModule = {
   command: 'watch',
@@ -14,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}`);
       });
     };
 
@@ -33,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}...`);
@@ -42,7 +43,7 @@ const commandModule: CommandModule = {
     process.on('SIGINT', () => {
       watcher.close();
       console.log('\nWatch stopped.');
-      process.exit();
+      handlerExit();
     });
   }
 };

package/src/dubhe.ts

@@ -2,25 +2,30 @@
 
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import chalk from 'chalk';
 import { commands } from './commands';
 import { logError } from './utils/errors';
+import packageJson from '../package.json';
 
 // Load .env file into process.env
 import * as dotenv from 'dotenv';
-import chalk from 'chalk';
 dotenv.config();
 
 yargs(hideBin(process.argv))
   // Explicit name to display in help (by default it's the entry file, which may not be "dubhe" for e.g. ts-node)
   .scriptName('dubhe')
   // Use the commands directory to scaffold
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
+
   .command(commands as any)
+  .version(packageJson.version)
+  .demandCommand(1, 'Please provide a command')
+  .recommendCommands()
   // Enable strict mode.
   .strict()
   // Custom error handler
   .fail((msg, err) => {
     console.error(chalk.red(msg));
+
     if (msg.includes('Missing required argument')) {
       console.log(
         chalk.yellow(
@@ -29,8 +34,11 @@ yargs(hideBin(process.argv))
       );
     }
     console.log('');
-    logError(err);
-    console.log('');
+    // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
+    if (err != null) {
+      logError(err);
+      console.log('');
+    }
 
     process.exit(1);
   })

package/src/utils/axios-downloader.ts

@@ -0,0 +1,116 @@
+// Better download implementation using axios
+import chalk from 'chalk';
+import * as cliProgress from 'cli-progress';
+import * as fs from 'fs';
+import axios from 'axios';
+
+/**
+ * Download file using axios
+ */
+export async function downloadWithAxios(url: string, outputPath: string): Promise<void> {
+  try {
+    const response = await axios.get(url, {
+      responseType: 'stream',
+      timeout: 30000,
+      headers: { 'User-Agent': 'dubhe-cli' },
+      maxRedirects: 5,
+      validateStatus: (status) => status < 400 // Accept all status codes < 400
+    });
+
+    await streamToFile(response, outputPath);
+    console.log(chalk.green(`   ✓ Successfully downloaded`));
+  } catch (error: any) {
+    // Handle specific network error cases with more descriptive messages
+    if (error.code === 'ENOTFOUND') {
+      throw new Error(
+        `DNS resolution failed: ${error.message}. Please check your internet connection.`
+      );
+    } else if (error.code === 'ECONNRESET') {
+      throw new Error(`Connection reset: ${error.message}. Please check your network connection.`);
+    } else if (error.code === 'ETIMEDOUT') {
+      throw new Error(
+        `Connection timeout: ${error.message}. Please check your network connection.`
+      );
+    } else if (error.message.includes('protocol mismatch')) {
+      throw new Error(
+        `Protocol mismatch: ${error.message}. Please check your network configuration.`
+      );
+    } else if (error.response) {
+      throw new Error(`HTTP ${error.response.status}: ${error.response.statusText}`);
+    } else {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Download failed: ${errorMsg}`);
+    }
+  }
+}
+
+/**
+ * Stream response data to file with progress bar
+ */
+async function streamToFile(response: any, outputPath: string): Promise<void> {
+  const totalSize = parseInt(response.headers['content-length'] || '0');
+
+  // Create progress bar
+  const progressBar = new cliProgress.SingleBar({
+    format:
+      chalk.cyan('Download Progress') +
+      ' |{bar}| {percentage}% | {value}/{total} MB | Speed: {speed} MB/s | ETA: {eta}s',
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591',
+    hideCursor: true,
+    barsize: 30,
+    forceRedraw: true
+  });
+
+  if (totalSize > 0) {
+    progressBar.start(Math.round((totalSize / 1024 / 1024) * 100) / 100, 0, {
+      speed: '0.00'
+    });
+  } else {
+    console.log(chalk.blue('📥 Downloading... (unable to get file size)'));
+  }
+
+  const writer = fs.createWriteStream(outputPath);
+  let downloadedBytes = 0;
+  const startTime = Date.now();
+
+  return new Promise((resolve, reject) => {
+    response.data.on('data', (chunk: Buffer) => {
+      downloadedBytes += chunk.length;
+
+      if (totalSize > 0) {
+        const downloadedMB = Math.round((downloadedBytes / 1024 / 1024) * 100) / 100;
+        const elapsedTime = (Date.now() - startTime) / 1000;
+        const speed = elapsedTime > 0 ? Math.round((downloadedMB / elapsedTime) * 100) / 100 : 0;
+
+        progressBar.update(downloadedMB, {
+          speed: speed.toFixed(2)
+        });
+      }
+    });
+
+    response.data.pipe(writer);
+
+    writer.on('finish', () => {
+      if (totalSize > 0) {
+        progressBar.stop();
+      }
+
+      const totalMB = Math.round((downloadedBytes / 1024 / 1024) * 100) / 100;
+      const elapsedTime = (Date.now() - startTime) / 1000;
+      const avgSpeed = elapsedTime > 0 ? Math.round((totalMB / elapsedTime) * 100) / 100 : 0;
+
+      console.log(
+        chalk.green(`✓ Download completed! ${totalMB} MB, average speed: ${avgSpeed} MB/s`)
+      );
+      resolve();
+    });
+
+    writer.on('error', (error) => {
+      if (totalSize > 0) {
+        progressBar.stop();
+      }
+      reject(error);
+    });
+  });
+}

package/src/utils/callHandler.ts

@@ -1,129 +1,129 @@
-import { loadMetadata, Transaction, TransactionResult } from '@0xobelisk/sui-client';
-import { DubheCliError } from './errors';
-import { getOldPackageId, initializeDubhe } from './utils';
-import { DubheConfig } from '@0xobelisk/sui-common';
-import { loadMetadataFromFile } from './queryStorage';
+// import { loadMetadata, Transaction, TransactionResult } from '@0xobelisk/sui-client';
+// import { DubheCliError } from './errors';
+// import { getOldPackageId, initializeDubhe } from './utils';
+// import { DubheConfig } from '@0xobelisk/sui-common';
+// import { loadMetadataFromFile } from './queryStorage';
 
-const BaseTxType = [
-  'u8',
-  'u16',
-  'u32',
-  'u64',
-  'u128',
-  'u256',
-  'bool',
-  'id',
-  'string',
-  'address',
-  'object'
-];
+// const BaseTxType = [
+//   'u8',
+//   'u16',
+//   'u32',
+//   'u64',
+//   'u128',
+//   'u256',
+//   'bool',
+//   'id',
+//   'string',
+//   'address',
+//   'object'
+// ];
 
-function validateParams(params: any[]) {
-  try {
-    params.forEach((param) => {
-      const [type, _] = param.split(':');
-      if (!BaseTxType.includes(type)) {
-        throw new Error(`Invalid param type: ${type}`);
-      }
-    });
-  } catch (error) {
-    throw new Error(`Invalid params: ${error}`);
-  }
-}
+// function validateParams(params: any[]) {
+//   try {
+//     params.forEach((param) => {
+//       const [type, _] = param.split(':');
+//       if (!BaseTxType.includes(type)) {
+//         throw new Error(`Invalid param type: ${type}`);
+//       }
+//     });
+//   } catch (error) {
+//     throw new Error(`Invalid params: ${error}`);
+//   }
+// }
 
-// param:
-// u8:1
-// u16:1
-// u32:1
-// u64:1
-// u128:1
-// u256:1
-// object:0x1
-// address:0x1
-// bool:true
-// string:"hello"
-function formatBCS(tx: Transaction, param: string) {
-  const [type, value] = param.split(':');
-  switch (type) {
-    case 'u8':
-      return tx.pure.u8(parseInt(value));
-    case 'u16':
-      return tx.pure.u16(parseInt(value));
-    case 'u32':
-      return tx.pure.u32(parseInt(value));
-    case 'u64':
-      return tx.pure.u64(parseInt(value));
-    case 'u128':
-      return tx.pure.u128(parseInt(value));
-    case 'u256':
-      return tx.pure.u256(parseInt(value));
-    case 'object':
-      return tx.object(value);
-    case 'address':
-      return tx.pure.address(value);
-    case 'bool':
-      return tx.pure.bool(value === 'true');
-    case 'string':
-      return tx.pure.string(value);
-    default:
-      throw new Error(`Invalid param type: ${type}`);
-  }
-}
+// // param:
+// // u8:1
+// // u16:1
+// // u32:1
+// // u64:1
+// // u128:1
+// // u256:1
+// // object:0x1
+// // address:0x1
+// // bool:true
+// // string:"hello"
+// function formatBCS(tx: Transaction, param: string) {
+//   const [type, value] = param.split(':');
+//   switch (type) {
+//     case 'u8':
+//       return tx.pure.u8(parseInt(value));
+//     case 'u16':
+//       return tx.pure.u16(parseInt(value));
+//     case 'u32':
+//       return tx.pure.u32(parseInt(value));
+//     case 'u64':
+//       return tx.pure.u64(parseInt(value));
+//     case 'u128':
+//       return tx.pure.u128(parseInt(value));
+//     case 'u256':
+//       return tx.pure.u256(parseInt(value));
+//     case 'object':
+//       return tx.object(value);
+//     case 'address':
+//       return tx.pure.address(value);
+//     case 'bool':
+//       return tx.pure.bool(value === 'true');
+//     case 'string':
+//       return tx.pure.string(value);
+//     default:
+//       throw new Error(`Invalid param type: ${type}`);
+//   }
+// }
 
-function formatBCSParams(tx: Transaction, params: any[]) {
-  return params.map((param) => formatBCS(tx, param));
-}
+// function formatBCSParams(tx: Transaction, params: any[]) {
+//   return params.map((param) => formatBCS(tx, param));
+// }
 
-export async function callHandler({
-  dubheConfig,
-  moduleName,
-  funcName,
-  params,
-  network,
-  packageId,
-  metadataFilePath
-}: {
-  dubheConfig: DubheConfig;
-  moduleName: string;
-  funcName: string;
-  params?: any[];
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-  packageId?: string;
-  metadataFilePath?: string;
-}) {
-  const path = process.cwd();
-  const projectPath = `${path}/src/${dubheConfig.name}`;
+// export async function callHandler({
+//   dubheConfig,
+//   moduleName,
+//   funcName,
+//   params,
+//   network,
+//   packageId,
+//   metadataFilePath
+// }: {
+//   dubheConfig: DubheConfig;
+//   moduleName: string;
+//   funcName: string;
+//   params?: any[];
+//   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+//   packageId?: string;
+//   metadataFilePath?: string;
+// }) {
+//   const path = process.cwd();
+//   const projectPath = `${path}/src/${dubheConfig.name}`;
 
-  packageId = packageId || (await getOldPackageId(projectPath, network));
+//   packageId = packageId || (await getOldPackageId(projectPath, network));
 
-  // objectId = objectId || (await getObjectId(projectPath, network, schema));
+//   // objectId = objectId || (await getObjectId(projectPath, network, schema));
 
-  let metadata;
-  if (metadataFilePath) {
-    metadata = await loadMetadataFromFile(metadataFilePath);
-  } else {
-    metadata = await loadMetadata(network, packageId);
-  }
-  if (!metadata) {
-    throw new DubheCliError(
-      `Metadata file not found. Please provide a metadata file path or set the packageId.`
-    );
-  }
+//   let metadata;
+//   if (metadataFilePath) {
+//     metadata = await loadMetadataFromFile(metadataFilePath);
+//   } else {
+//     metadata = await loadMetadata(network, packageId);
+//   }
+//   if (!metadata) {
+//     throw new DubheCliError(
+//       `Metadata file not found. Please provide a metadata file path or set the packageId.`
+//     );
+//   }
 
-  const processedParams = params || [];
-  validateParams(processedParams);
-  const dubhe = initializeDubhe({
-    network,
-    packageId,
-    metadata
-  });
-  const tx = new Transaction();
-  const formattedParams = formatBCSParams(tx, processedParams);
+//   const processedParams = params || [];
+//   validateParams(processedParams);
+//   const dubhe = initializeDubhe({
+//     network,
+//     packageId,
+//     metadata
+//   });
+//   const tx = new Transaction();
+//   const formattedParams = formatBCSParams(tx, processedParams);
 
-  const result = (await dubhe.tx[moduleName][funcName]({
-    tx,
-    params: formattedParams
-  })) as TransactionResult;
+//   const result = (await dubhe.tx[moduleName][funcName]({
+//     tx,
+//     params: formattedParams
+//   })) as TransactionResult;
 
-  console.log(JSON.stringify(result, null, 2));
-}
+//   console.log(JSON.stringify(result, null, 2));
+// }

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

@@ -0,0 +1,9 @@
+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';
+
+// 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/generateAccount.ts

@@ -73,7 +73,7 @@ export async function generateAccountHandler(
       console.log(chalk.blue(`Using existing account: ${keypair.toSuiAddress()}`));
       return;
     }
-  } catch (error) {
+  } catch (_error) {
     // .env file doesn't exist or failed to read, continue to generate new account
   }
 

package/src/utils/index.ts

@@ -1,7 +1,8 @@
 export * from './publishHandler';
-// export * from "./upgradeHandler";
+export * from './upgradeHandler';
 export * from './errors';
 export * from './printDubhe';
 export * from './utils';
-export * from './queryStorage';
-export * from './callHandler';
+export * from './constants';
+// export * from './queryStorage';
+// export * from './callHandler';

package/src/utils/metadataHandler.ts

@@ -0,0 +1,17 @@
+import { DubheConfig } from '@0xobelisk/sui-common';
+import { getOldPackageId, saveMetadata } from './utils';
+
+export async function loadMetadataHandler(
+  dubheConfig: DubheConfig,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  packageId?: string,
+  fullnodeUrls?: string[]
+) {
+  if (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, fullnodeUrls);
+  }
+}