@0xobelisk/sui-cli 1.1.13 → 1.2.0-pre.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.1.13",
+  "version": "1.2.0-pre.1",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -33,6 +33,7 @@
   "dependencies": {
     "@mysten/sui": "^1.19.0",
     "@types/sqlite3": "^3.1.11",
+    "@types/wait-on": "^5.3.4",
     "chalk": "^5.0.1",
     "child_process": "^1.0.2",
     "chokidar": "^3.5.3",
@@ -40,28 +41,30 @@
     "ejs": "^3.1.8",
     "execa": "^7.0.0",
     "glob": "^8.0.3",
+    "ora": "^5.4.1",
     "path": "^0.12.7",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
     "typescript": "5.1.6",
+    "wait-on": "^7.0.1",
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.1.12",
-    "@0xobelisk/sui-common": "1.1.13"
+    "@0xobelisk/sui-client": "1.2.0-pre.1",
+    "@0xobelisk/sui-common": "1.2.0-pre.1"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^18.15.11",
     "@types/yargs": "^17.0.10",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "3.3.3",
     "ts-node": "^10.9.1",
     "tsup": "^6.7.0",
     "tsx": "^3.12.6",
-    "vitest": "0.31.4",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "prettier": "3.3.3"
+    "vitest": "0.31.4"
   },
   "scripts": {
     "build": "pnpm run type-check && pnpm run build:js",

package/src/commands/faucet.ts

@@ -1,14 +1,17 @@
-import { Dubhe } from '@0xobelisk/sui-client';
 import type { CommandModule } from 'yargs';
 import { requestSuiFromFaucetV0, getFaucetHost } from '@mysten/sui/faucet';
 import { SuiClient, getFullnodeUrl, GetBalanceParams } from '@mysten/sui/client';
-import { validatePrivateKey, DubheCliError } from '../utils';
+import { initializeDubhe } from '../utils';
 
 type Options = {
   network: any;
   recipient?: string;
 };
 
+const MAX_RETRIES = 60; // 60s timeout
+const RETRY_INTERVAL = 1000; // 1s retry interval
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
 const commandModule: CommandModule<Options, Options> = {
   command: 'faucet',
 
@@ -32,21 +35,7 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({ network, recipient }) {
     let faucet_address = '';
     if (recipient === undefined) {
-      const privateKey = process.env.PRIVATE_KEY;
-      if (!privateKey)
-        throw new DubheCliError(
-          `Missing PRIVATE_KEY environment variable.
-    Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
-    in your contracts directory to use the default sui private key.`
-        );
-
-      const privateKeyFormat = validatePrivateKey(privateKey);
-      if (privateKeyFormat === false) {
-        throw new DubheCliError(`Please check your PRIVATE_KEY.`);
-      }
-      const dubhe = new Dubhe({
-        secretKey: privateKeyFormat
-      });
+      const dubhe = initializeDubhe(network);
       faucet_address = dubhe.getAddress();
     } else {
       faucet_address = recipient;
@@ -63,10 +52,55 @@ const commandModule: CommandModule<Options, Options> = {
     }
 
     console.log('  ├─ Requesting funds from faucet...');
-    await requestSuiFromFaucetV0({
-      host: getFaucetHost(network),
-      recipient: faucet_address
-    });
+
+    let retryCount = 0;
+    let success = false;
+    let spinnerIndex = 0;
+    const startTime = Date.now();
+    let isInterrupted = false;
+
+    const handleInterrupt = () => {
+      isInterrupted = true;
+      process.stdout.write('\r' + ' '.repeat(50) + '\r');
+      console.log('\n  └─ Operation cancelled by user');
+      process.exit(0);
+    };
+    process.on('SIGINT', handleInterrupt);
+
+    try {
+      while (retryCount < MAX_RETRIES && !success && !isInterrupted) {
+        try {
+          await requestSuiFromFaucetV0({
+            host: getFaucetHost(network),
+            recipient: faucet_address
+          });
+          success = true;
+        } 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);
+          }
+
+          const elapsedTime = Math.floor((Date.now() - startTime) / 1000);
+          const spinner = SPINNER[spinnerIndex % SPINNER.length];
+          spinnerIndex++;
+
+          process.stdout.write(`\r  ├─ ${spinner} Retrying... (${elapsedTime}s)`);
+          await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL));
+        }
+      }
+    } finally {
+      process.removeListener('SIGINT', handleInterrupt);
+    }
+
+    if (isInterrupted) {
+      process.exit(0);
+    }
+    process.stdout.write('\r' + ' '.repeat(50) + '\r');
 
     console.log('  └─ Checking balance...');
     const client = new SuiClient({ url: getFullnodeUrl(network) });

package/src/commands/generateKey.ts

@@ -3,27 +3,27 @@ import { generateAccountHandler } from '../utils/generateAccount';
 
 type Options = {
   force?: boolean;
-  'output-ts-path'?: string;
+  'use-next-public'?: boolean;
 };
 
 const commandModule: CommandModule<Options, Options> = {
   command: 'generate-key',
-  describe:
-    'Generate a new account key pair and save it to a .env file, with an option to output to a TypeScript file.',
+  describe: 'Generate a new account keypair and save it to a .env file',
   builder: {
     force: {
       type: 'boolean',
       default: false,
-      desc: 'Force generate a new key pair'
+      desc: 'Force generate a new keypair'
     },
-    'output-ts-path': {
-      type: 'string',
-      desc: 'Specify the path to output the TypeScript file containing the key pair (e.g., ./src/config/key.ts)'
+    'use-next-public': {
+      type: 'boolean',
+      default: false,
+      desc: 'Use the NEXT_PUBLIC_ prefix for client-side usage'
     }
   },
-  async handler({ force, 'output-ts-path': outputTsPath }) {
+  async handler({ force, 'use-next-public': useNextPublic }) {
     try {
-      await generateAccountHandler(force, outputTsPath);
+      await generateAccountHandler(force, useNextPublic);
     } catch (error) {
       console.error('Error generating account:', error);
       process.exit(1);

package/src/commands/index.ts

@@ -13,8 +13,8 @@ import checkBalance from './checkBalance';
 import configStore from './configStore';
 import query from './query';
 import call from './call';
-import indexer from './indexer';
 import watch from './watch';
+import wait from './wait';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -31,6 +31,6 @@ export const commands: CommandModule<any, any>[] = [
   generateKey,
   checkBalance,
   configStore,
-  indexer,
-  watch
+  watch,
+  wait
 ];

package/src/commands/localnode.ts

@@ -7,12 +7,18 @@ const commandModule: CommandModule = {
   describe: 'Manage local Sui node',
 
   builder(yargs) {
-    return yargs;
+    return yargs
+      .option('force-regenesis', {
+        alias: 'f',
+        type: 'boolean',
+        description: 'Force regenesis the local node',
+        default: true
+      });
   },
 
-  async handler() {
+  async handler(argv) {
     try {
-      await startLocalNode();
+      await startLocalNode({ forceRegenesis: argv['force-regenesis'] as boolean });
     } catch (error) {
       console.error('Error executing command:', error);
       process.exit(1);

package/src/commands/wait.ts

@@ -0,0 +1,59 @@
+import type { CommandModule } from 'yargs';
+import waitOn from 'wait-on';
+import ora from 'ora';
+import chalk from 'chalk';
+
+interface WaitOptions {
+  url: string;
+  timeout: number;
+  interval: number;
+}
+
+const commandModule: CommandModule = {
+  command: 'wait',
+  describe: 'Wait for service to be ready',
+  builder(yargs) {
+    return yargs
+      .option('url', {
+        type: 'string',
+        description: 'URL to wait for'
+      })
+      .option('timeout', {
+        type: 'number',
+        description: 'Timeout (in milliseconds)',
+        default: 180000
+      })
+      .option('interval', {
+        type: 'number',
+        description: 'Check interval (in milliseconds)',
+        default: 1000
+      });
+  },
+  async handler(argv) {
+    const options = argv as unknown as WaitOptions;
+    const spinner = ora({
+      text: `Waiting for service to start ${chalk.cyan(options.url)}...`,
+      color: 'cyan'
+    });
+
+    spinner.start();
+
+    try {
+      await waitOn({
+        resources: [options.url],
+        timeout: options.timeout,
+        interval: options.interval,
+        validateStatus: (status: number) => status === 200
+      });
+
+      spinner.succeed(chalk.green('Service is ready!'));
+      process.exit(0);
+    } catch (error) {
+      spinner.fail(chalk.red('Timeout waiting for service'));
+      console.error(chalk.yellow('Please make sure the service is running...'));
+      process.exit(1);
+    }
+  }
+};
+
+export default commandModule;

package/src/utils/callHandler.ts

@@ -1,6 +1,6 @@
-import { Dubhe, loadMetadata, Transaction, TransactionResult } from '@0xobelisk/sui-client';
+import { loadMetadata, Transaction, TransactionResult } from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
-import { validatePrivateKey, getOldPackageId } from './utils';
+import { getOldPackageId, initializeDubhe } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
 import { loadMetadataFromFile } from './queryStorage';
 
@@ -91,19 +91,6 @@ export async function callHandler({
   packageId?: string;
   metadataFilePath?: string;
 }) {
-  const privateKey = process.env.PRIVATE_KEY;
-  if (!privateKey) {
-    throw new DubheCliError(
-      `Missing PRIVATE_KEY environment variable.
-Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
-in your contracts directory to use the default sui private key.`
-    );
-  }
-  const privateKeyFormat = validatePrivateKey(privateKey);
-  if (privateKeyFormat === false) {
-    throw new DubheCliError(`Please check your privateKey.`);
-  }
-
   const path = process.cwd();
   const projectPath = `${path}/contracts/${dubheConfig.name}`;
 
@@ -123,29 +110,10 @@ in your contracts directory to use the default sui private key.`
     );
   }
 
-  // if (!dubheConfig.schemas[schema]) {
-  // 	throw new DubheCliError(
-  // 		`Schema "${schema}" not found in dubhe config. Available schemas: ${Object.keys(
-  // 			dubheConfig.schemas
-  // 		).join(', ')}`
-  // 	);
-  // }
-
-  // if (!dubheConfig.schemas[schema].structure[struct]) {
-  // 	throw new DubheCliError(
-  // 		`Struct "${struct}" not found in schema "${schema}". Available structs: ${Object.keys(
-  // 			dubheConfig.schemas[schema].structure
-  // 		).join(', ')}`
-  // 	);
-  // }
-
-  // const storageType = dubheConfig.schemas[schema].structure[struct];
-
   const processedParams = params || [];
   validateParams(processedParams);
-  const dubhe = new Dubhe({
-    secretKey: privateKeyFormat,
-    networkType: network,
+  const dubhe = initializeDubhe({
+    network,
     packageId,
     metadata
   });

package/src/utils/checkBalance.ts

@@ -1,28 +1,13 @@
-import { Dubhe, NetworkType } from '@0xobelisk/sui-client';
 import chalk from 'chalk';
 import dotenv from 'dotenv';
-import { validatePrivateKey } from './utils';
+import { initializeDubhe } from './utils';
 import { DubheCliError } from './errors';
 dotenv.config();
 
 export async function checkBalanceHandler(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
   try {
-    const privateKey = process.env.PRIVATE_KEY;
-    if (!privateKey) {
-      throw new DubheCliError(
-        `Missing PRIVATE_KEY environment variable.
-  Run 'echo "PRIVATE_KEY=YOUR_PRIVATE_KEY" > .env'
-  in your contracts directory to use the default sui private key.`
-      );
-    }
-    const privateKeyFormat = validatePrivateKey(privateKey);
-    if (privateKeyFormat === false) {
-      throw new DubheCliError(`Please check your privateKey.`);
-    }
-
-    const dubhe = new Dubhe({
-      secretKey: process.env.PRIVATE_KEY,
-      networkType: network as NetworkType
+    const dubhe = initializeDubhe({
+      network
     });
 
     const balance = await dubhe.getBalance();

package/src/utils/generateAccount.ts

@@ -2,96 +2,100 @@ import { Dubhe } from '@0xobelisk/sui-client';
 import * as fs from 'fs';
 import chalk from 'chalk';
 
-export async function generateAccountHandler(force: boolean = false, outputTsPath?: string) {
-  if (outputTsPath) {
+export async function generateAccountHandler(
+  force: boolean = false,
+  useNextPublic: boolean = false
+) {
+  if (useNextPublic) {
     console.log(
-      chalk.blue(
-        'Note: The generated account will be stored in the .env file and the TypeScript file specified by the --output-ts-path option.'
+      chalk.gray(
+        'Note: The generated account will be stored in the .env file with NEXT_PUBLIC_ prefix for client-side usage.'
       )
     );
     console.log(
-      chalk.yellow('Warning: Do not expose the key file. It is intended for local testing only.\n')
+      chalk.yellow('Warning: Do not expose the .env file, it is intended for local testing only.\n')
     );
   }
   const path = process.cwd();
-  let privateKey: string;
+  let privateKey: string | undefined;
+  let envContent = '';
 
-  if (force) {
-    const dubhe = new Dubhe();
-    const keypair = dubhe.getSigner();
-    privateKey = keypair.getSecretKey();
-
-    fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
-    console.log(chalk.green(`File created at: ${path}/.env`));
+  // Check if .env file exists
+  try {
+    envContent = fs.readFileSync(`${path}/.env`, 'utf8');
 
-    if (outputTsPath) {
-      const dir = outputTsPath.substring(0, outputTsPath.lastIndexOf('/'));
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(
-        outputTsPath,
-        `export const PRIVATEKEY = '${privateKey}';
-export const ACCOUNT = '${keypair.toSuiAddress()}';
-`
-      );
-      console.log(chalk.green(`File created at: ${outputTsPath}\n`));
+    // privateKey = process.env.PRIVATE_KEY || process.env.NEXT_PUBLIC_PRIVATE_KEY;
+    let privateKey = process.env.PRIVATE_KEY || process.env.NEXT_PUBLIC_PRIVATE_KEY;
+    if (useNextPublic) {
+      privateKey = process.env.NEXT_PUBLIC_PRIVATE_KEY || process.env.PRIVATE_KEY;
     }
 
-    console.log(chalk.blue(`Force generate new Account: ${keypair.toSuiAddress()}`));
-    return;
-  }
+    if (privateKey) {
+      // If key exists, decide whether to update keyname based on useNextPublic
+      const newKeyName = useNextPublic ? 'NEXT_PUBLIC_PRIVATE_KEY' : 'PRIVATE_KEY';
 
-  // Check if .env file exists and has content
-  try {
-    const envContent = fs.readFileSync(`${path}/.env`, 'utf8');
-    const match = envContent.match(/PRIVATE_KEY=(.+)/);
-    if (match && match[1]) {
-      privateKey = match[1];
-      const dubhe = new Dubhe({ secretKey: privateKey });
-      const keypair = dubhe.getSigner();
+      // Find and update the last matching line based on privateKey value
+      const lines = envContent.split('\n');
+      let shouldUpdate = false;
 
-      if (outputTsPath) {
-        const dir = outputTsPath.substring(0, outputTsPath.lastIndexOf('/'));
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
+      // First check if the last matching line already has the correct keyname
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (line.endsWith(privateKey)) {
+          // If useNextPublic is true, only update if the line starts with PRIVATE_KEY=
+          // If useNextPublic is false, only update if the line starts with NEXT_PUBLIC_PRIVATE_KEY=
+          const [currentKeyName] = line.split('=');
+          if (useNextPublic) {
+            shouldUpdate = currentKeyName === 'PRIVATE_KEY';
+          } else {
+            shouldUpdate = currentKeyName === 'NEXT_PUBLIC_PRIVATE_KEY';
+          }
+          break;
         }
-        fs.writeFileSync(
-          outputTsPath,
-          `export const PRIVATEKEY = '${privateKey}';
-export const ACCOUNT = '${keypair.toSuiAddress()}';
-`
-        );
-        console.log(chalk.green(`File created at: ${outputTsPath}\n`));
       }
 
-      console.log(chalk.blue(`Using existing Account: ${keypair.toSuiAddress()}`));
+      // Only update if necessary
+      if (shouldUpdate) {
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i];
+          if (line.endsWith(privateKey)) {
+            const newLine = `${newKeyName}=${privateKey}`;
+            lines[i] = newLine;
+            envContent = lines.join('\n');
+            fs.writeFileSync(`${path}/.env`, envContent);
+            break;
+          }
+        }
+      }
+
+      const dubhe = new Dubhe({ secretKey: privateKey });
+      const keypair = dubhe.getSigner();
+      console.log(chalk.blue(`Using existing account: ${keypair.toSuiAddress()}`));
       return;
     }
   } catch (error) {
     // .env file doesn't exist or failed to read, continue to generate new account
   }
 
-  // If no existing private key, generate new account
-  const dubhe = new Dubhe();
-  const keypair = dubhe.getSigner();
-  privateKey = keypair.getSecretKey();
-  fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
-  console.log(chalk.green(`File created at: ${path}/.env`));
+  // Generate a new account if no existing key is found or force generation is requested
+  if (force || !privateKey) {
+    const dubhe = new Dubhe();
+    const keypair = dubhe.getSigner();
+    privateKey = keypair.getSecretKey();
 
-  if (outputTsPath) {
-    const dir = outputTsPath.substring(0, outputTsPath.lastIndexOf('/'));
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    const newKeyName = useNextPublic ? 'NEXT_PUBLIC_PRIVATE_KEY' : 'PRIVATE_KEY';
+    const newContent = `${newKeyName}=${privateKey}`;
+
+    // If .env file exists, append new content; otherwise create a new file
+    if (envContent) {
+      envContent = envContent.trim() + '\n' + newContent;
+    } else {
+      envContent = newContent;
     }
-    fs.writeFileSync(
-      outputTsPath,
-      `export const PRIVATEKEY = '${privateKey}';
-export const ACCOUNT = '${keypair.toSuiAddress()}';
-`
-    );
-    console.log(chalk.green(`File created at: ${outputTsPath}\n`));
-  }
 
-  console.log(chalk.blue(`Generate new Account: ${keypair.toSuiAddress()}`));
+    fs.writeFileSync(`${path}/.env`, envContent);
+    console.log(chalk.green(`File created/updated at: ${path}/.env`));
+
+    console.log(chalk.blue(`New account generated: ${keypair.toSuiAddress()}`));
+  }
 }

package/src/utils/index.ts

@@ -5,4 +5,3 @@ export * from './printDubhe';
 export * from './utils';
 export * from './queryStorage';
 export * from './callHandler';
-export * from './indexerHandler';