@0xobelisk/sui-cli 1.1.4 → 1.1.6

package/src/commands/test.ts

@@ -3,49 +3,49 @@ import { execSync } from 'child_process';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 
 type Options = {
-	'config-path': string;
-	test?: string;
-	'gas-limit'?: string;
+  'config-path': string;
+  test?: string;
+  'gas-limit'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
-	command: 'test',
+  command: 'test',
 
-	describe: 'Run tests in Dubhe contracts',
+  describe: 'Run tests in Dubhe contracts',
 
-	builder(yargs) {
-		return yargs.options({
-			'config-path': {
-				type: 'string',
-				default: 'dubhe.config.ts',
-				description: 'Options to pass to forge test',
-			},
-			test: {
-				type: 'string',
-				desc: 'Run a specific test',
-			},
-			'gas-limit': {
-				type: 'string',
-				desc: 'Set the gas limit for the test',
-			},
-		});
-	},
+  builder(yargs) {
+    return yargs.options({
+      'config-path': {
+        type: 'string',
+        default: 'dubhe.config.ts',
+        description: 'Options to pass to forge test'
+      },
+      test: {
+        type: 'string',
+        desc: 'Run a specific test'
+      },
+      'gas-limit': {
+        type: 'string',
+        desc: 'Set the gas limit for the test'
+      }
+    });
+  },
 
-	async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
-		// Start an internal anvil process if no world address is provided
-		try {
-			console.log('🚀 Running move test');
-			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-			const path = process.cwd();
-			const projectPath = `${path}/contracts/${dubheConfig.name}`;
-			const command = `sui move test --path ${projectPath} ${
-				test ? ` --test ${test}` : ''
-			} ${gasLimit ? ` --gas-limit ${gasLimit}` : ''}`;
-			execSync(command, { stdio: 'inherit', encoding: 'utf-8' });
-		} catch (error: any) {
-			process.exit(0);
-		}
-	},
+  async handler({ 'config-path': configPath, test, 'gas-limit': gasLimit }) {
+    // Start an internal anvil process if no world address is provided
+    try {
+      console.log('🚀 Running move test');
+      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+      const path = process.cwd();
+      const projectPath = `${path}/contracts/${dubheConfig.name}`;
+      const command = `sui move test --path ${projectPath} ${
+        test ? ` --test ${test}` : ''
+      } ${gasLimit ? ` --gas-limit ${gasLimit}` : ''}`;
+      execSync(command, { stdio: 'inherit', encoding: 'utf-8' });
+    } catch (error: any) {
+      process.exit(0);
+    }
+  }
 };
 
 export default commandModule;

package/src/commands/upgrade.ts

@@ -4,41 +4,41 @@ import { upgradeHandler } from '../utils/upgradeHandler';
 import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 
 type Options = {
-	network: any;
-	'config-path': string;
+  network: any;
+  'config-path': string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
-	command: 'upgrade',
+  command: 'upgrade',
 
-	describe: 'Upgrade your move contracts',
+  describe: 'Upgrade your move contracts',
 
-	builder(yargs) {
-		return yargs.options({
-			network: {
-				type: 'string',
-				choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
-				default: 'localnet',
-				desc: 'Network of the node (mainnet/testnet/devnet/localnet)',
-			},
-			'config-path': {
-				type: 'string',
-				default: 'dubhe.config.ts',
-				decs: 'Path to the config file',
-			},
-		});
-	},
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+        default: 'localnet',
+        desc: 'Network of the node (mainnet/testnet/devnet/localnet)'
+      },
+      'config-path': {
+        type: 'string',
+        default: 'dubhe.config.ts',
+        decs: 'Path to the config file'
+      }
+    });
+  },
 
-	async handler({ network, 'config-path': configPath }) {
-		try {
-			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-			await upgradeHandler(dubheConfig, dubheConfig.name, network);
-		} catch (error: any) {
-			logError(error);
-			process.exit(1);
-		}
-		process.exit(0);
-	},
+  async handler({ network, 'config-path': configPath }) {
+    try {
+      const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+      await upgradeHandler(dubheConfig, dubheConfig.name, network);
+    } catch (error: any) {
+      logError(error);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
 };
 
 export default commandModule;

package/src/commands/watch.ts

@@ -1,21 +1,21 @@
-import type { CommandModule } from "yargs";
-import chokidar from "chokidar";
-import { exec } from "child_process";
+import type { CommandModule } from 'yargs';
+import chokidar from 'chokidar';
+import { exec } from 'child_process';
 
 const commandModule: CommandModule = {
-  command: "watch",
+  command: 'watch',
 
-  describe: "Watch dubhe config",
+  describe: 'Watch dubhe config',
 
   builder(yargs) {
     return yargs;
   },
 
   async handler() {
-    const configFilePath = "dubhe.config.ts";
+    const configFilePath = 'dubhe.config.ts';
 
     const runSchemagen = () => {
-      exec("pnpm dubhe schemagen", (error, stdout, stderr) => {
+      exec('pnpm dubhe schemagen', (error, stdout, stderr) => {
         if (error) {
           console.error(`Error executing schemagen: ${error.message}`);
           return;
@@ -29,22 +29,22 @@ const commandModule: CommandModule = {
     };
 
     const watcher = chokidar.watch(configFilePath, {
-      persistent: true,
+      persistent: true
     });
 
-    watcher.on("change", (path) => {
+    watcher.on('change', (path) => {
       console.log(`${path} has been changed. Running schemagen...`);
       runSchemagen();
     });
 
     console.log(`Watching for changes in ${configFilePath}...`);
 
-    process.on("SIGINT", () => {
+    process.on('SIGINT', () => {
       watcher.close();
-      console.log("\nWatch stopped.");
+      console.log('\nWatch stopped.');
       process.exit();
     });
-  },
+  }
 };
 
 export default commandModule;

package/src/dubhe.ts

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { commands } from "./commands";
-import { logError } from "./utils/errors";
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { commands } from './commands';
+import { logError } from './utils/errors';
 
 // Load .env file into process.env
-import * as dotenv from "dotenv";
-import chalk from "chalk";
+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")
+  .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)
@@ -21,16 +21,18 @@ yargs(hideBin(process.argv))
   // Custom error handler
   .fail((msg, err) => {
     console.error(chalk.red(msg));
-    if (msg.includes("Missing required argument")) {
+    if (msg.includes('Missing required argument')) {
       console.log(
-        chalk.yellow(`Run 'pnpm dubhe ${process.argv[2]} --help' for a list of available and required arguments.`)
+        chalk.yellow(
+          `Run 'pnpm dubhe ${process.argv[2]} --help' for a list of available and required arguments.`
+        )
       );
     }
-    console.log("");
+    console.log('');
     logError(err);
-    console.log("");
+    console.log('');
 
     process.exit(1);
   })
   // Useful aliases.
-  .alias({ h: "help" }).argv;
+  .alias({ h: 'help' }).argv;

package/src/modules.d.ts

@@ -1,6 +1,6 @@
 // adding .js to minimal would break clients down the line because it probably won't get a synthetic default import
 /* eslint-disable @typescript-eslint/no-explicit-any */
-declare module "protobufjs/minimal" {
+declare module 'protobufjs/minimal' {
   export const configure: any;
   export const util: any;
   export const Reader: any;
@@ -8,4 +8,4 @@ declare module "protobufjs/minimal" {
   export const Writer: any;
   export type Writer = any;
 }
-declare module "rollup-plugin-preserve-shebang";
+declare module 'rollup-plugin-preserve-shebang';

package/src/utils/callHandler.ts

@@ -1,39 +1,34 @@
-import {
-	Dubhe,
-	loadMetadata,
-	Transaction,
-	TransactionResult,
-} from '@0xobelisk/sui-client';
+import { Dubhe, loadMetadata, Transaction, TransactionResult } from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
 import { validatePrivateKey, getOldPackageId } 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',
+  '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}`);
-	}
+  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:
@@ -48,119 +43,119 @@ function validateParams(params: any[]) {
 // 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}`);
-	}
+  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));
+  return params.map((param) => formatBCS(tx, param));
 }
 
 export async function callHandler({
-	dubheConfig,
-	moduleName,
-	funcName,
-	params,
-	network,
-	packageId,
-	metadataFilePath,
+  dubheConfig,
+  moduleName,
+  funcName,
+  params,
+  network,
+  packageId,
+  metadataFilePath
 }: {
-	dubheConfig: DubheConfig;
-	moduleName: string;
-	funcName: string;
-	params?: any[];
-	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
-	packageId?: string;
-	metadataFilePath?: string;
+  dubheConfig: DubheConfig;
+  moduleName: string;
+  funcName: string;
+  params?: any[];
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+  packageId?: string;
+  metadataFilePath?: string;
 }) {
-	const privateKey = process.env.PRIVATE_KEY;
-	if (!privateKey) {
-		throw new DubheCliError(
-			`Missing PRIVATE_KEY environment variable.
+  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 privateKeyFormat = validatePrivateKey(privateKey);
+  if (privateKeyFormat === false) {
+    throw new DubheCliError(`Please check your privateKey.`);
+  }
 
-	const path = process.cwd();
-	const projectPath = `${path}/contracts/${dubheConfig.name}`;
+  const path = process.cwd();
+  const projectPath = `${path}/contracts/${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.`
+    );
+  }
 
-	// 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]) {
+  // 	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(', ')}`
-	// 	);
-	// }
+  // 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 storageType = dubheConfig.schemas[schema].structure[struct];
 
-	const processedParams = params || [];
-	validateParams(processedParams);
-	const dubhe = new Dubhe({
-		secretKey: privateKeyFormat,
-		networkType: network,
-		packageId,
-		metadata,
-	});
-	const tx = new Transaction();
-	const formattedParams = formatBCSParams(tx, processedParams);
+  const processedParams = params || [];
+  validateParams(processedParams);
+  const dubhe = new Dubhe({
+    secretKey: privateKeyFormat,
+    networkType: 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

@@ -5,43 +5,35 @@ import { validatePrivateKey } 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.
+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 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 = new Dubhe({
+      secretKey: process.env.PRIVATE_KEY,
+      networkType: network as NetworkType
+    });
 
-		const balance = await dubhe.getBalance();
-		const balanceInSUI = Number(balance.totalBalance) / 1_000_000_000;
+    const balance = await dubhe.getBalance();
+    const balanceInSUI = Number(balance.totalBalance) / 1_000_000_000;
 
-		if (balanceInSUI === 0) {
-			throw new DubheCliError(
-				`Your account balance is 0 SUI. Please get some SUI to proceed.`
-			);
-		}
+    if (balanceInSUI === 0) {
+      throw new DubheCliError(`Your account balance is 0 SUI. Please get some SUI to proceed.`);
+    }
 
-		console.log(
-			chalk.green(
-				`Current account balance: ${balanceInSUI.toFixed(4)} SUI`
-			)
-		);
-	} catch (error) {
-		throw new DubheCliError('Failed to check balance: ' + error);
-	}
+    console.log(chalk.green(`Current account balance: ${balanceInSUI.toFixed(4)} SUI`));
+  } catch (error) {
+    throw new DubheCliError('Failed to check balance: ' + error);
+  }
 }