@0xobelisk/sui-cli 0.5.29 → 0.5.31

package/src/commands/index.ts

@@ -4,9 +4,13 @@ import localnode from './localnode';
 import faucet from './faucet';
 import schemagen from './schemagen';
 import publish from './publish';
-import upgrade from "./upgrade";
+import upgrade from './upgrade';
 import test from './test';
+import build from './build';
 import hello from './hello';
+import generateKey from './generateKey';
+import checkBalance from './checkBalance';
+import storeConfig from './storeConfig';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -16,5 +20,9 @@ export const commands: CommandModule<any, any>[] = [
 	schemagen,
 	upgrade,
 	test,
+	build,
 	hello,
+	generateKey,
+	checkBalance,
+	storeConfig,
 ];

package/src/commands/localnode.ts

@@ -1,45 +1,18 @@
 import type { CommandModule } from 'yargs';
-import { startLocalnode, stopLocalnode, checkLocalNodeStatus } from '../utils';
+import { startLocalNode } from '../utils/startNode';
 
 const commandModule: CommandModule = {
-	command: 'localnode <action>',
+	command: 'node',
 
 	describe: 'Manage local Sui node',
 
 	builder(yargs) {
 		return yargs
-			.positional('action', {
-				describe: 'Action to perform',
-				choices: ['start', 'stop', 'status', 'restart'],
-				type: 'string',
-				demandOption: true,
-			})
-			.option('background', {
-				alias: 'b',
-				type: 'boolean',
-				description: 'Run node in background',
-				default: false,
-			});
 	},
 
-	async handler(argv) {
-		const { action, background } = argv;
-
+	async handler() {
 		try {
-			switch (action) {
-				case 'start':
-					await startLocalnode(background as boolean);
-					break;
-				case 'stop':
-					await stopLocalnode();
-					break;
-				case 'status':
-					await checkLocalNodeStatus();
-					break;
-				case 'restart':
-					await restartNode(background as boolean);
-					break;
-			}
+			await startLocalNode();
 		} catch (error) {
 			console.error('Error executing command:', error);
 			process.exit(1);
@@ -47,11 +20,4 @@ const commandModule: CommandModule = {
 	},
 };
 
-async function restartNode(background: boolean) {
-	console.log('Restarting local Sui node...');
-	await stopLocalnode();
-	await startLocalnode(background);
-	console.log('Local node has been restarted');
-}
-
 export default commandModule;

package/src/commands/storeConfig.ts

@@ -0,0 +1,44 @@
+import type { CommandModule } from 'yargs';
+import { storeConfigHandler } from '../utils/storeConfig';
+import { loadConfig, DubheConfig } from '@0xobelisk/sui-common';
+
+type Options = {
+	'config-path': string;
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	'output-path': string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+	command: 'store-config',
+
+	describe: 'Store configuration for the Dubhe project',
+
+	builder: {
+		'config-path': {
+			type: 'string',
+			default: 'dubhe.config.ts',
+			desc: 'Path to the config file',
+		},
+		network: {
+			type: 'string',
+			choices: ['mainnet', 'testnet', 'devnet', 'localnet'],
+			desc: 'Network to store config for',
+		},
+		'output-path': {
+			type: 'string',
+			desc: 'Path to output the configuration',
+		},
+	},
+	async handler({ 'config-path': configPath, network, outputPath }) {
+		try {
+			const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
+			await storeConfigHandler(dubheConfig, network, outputPath);
+		} catch (error) {
+			console.error('Error storing config:', error);
+			process.exit(1);
+		}
+		process.exit(0);
+	},
+};
+
+export default commandModule;

package/src/commands/test.ts

@@ -1,9 +1,11 @@
 import type { CommandModule } from "yargs";
 import { execSync } from "child_process";
 import chalk from "chalk";
+import { DubheConfig, loadConfig } from '@0xobelisk/sui-common';
 
 type Options = {
-  packagePath: string;
+  'config-path': string;
+  'test'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -13,20 +15,28 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      packagePath: {
+      'config-path': {
         type: "string",
-        default: ".",
+        default: "dubhe.config.ts",
         description: "Options to pass to forge test",
       },
+      test: {
+        type: 'string',
+        desc: 'Run a specific test',
+      },
     });
   },
 
-  async handler({ packagePath }) {
+  async handler({ 'config-path': configPath, test }) {
     // Start an internal anvil process if no world address is provided
     try {
-      execSync(`sui move test --path ${packagePath}`, {
-        encoding: "utf-8",
-      });
+      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}` : ''}`;
+      const output =  execSync(command, { encoding: "utf-8" });
+      console.log(output);
     } catch (error: any) {
       console.error(chalk.red("Error executing sui move test:"));
       console.log(error.stdout);

package/src/utils/checkBalance.ts

@@ -0,0 +1,55 @@
+import { Dubhe, NetworkType } from '@0xobelisk/sui-client';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import { validatePrivateKey } from './utils';
+import { DubheCliError } from './errors';
+dotenv.config();
+
+export async function checkBalanceHandler(
+	network: 'mainnet' | 'testnet' | 'devnet' | 'loclnet',
+	amount: number = 2
+) {
+	try {
+		console.log(
+			chalk.blue(
+				`Note: You need at least 2 SUI for transaction fees and staking, and registering a Dapp will reserve 1 SUI for Dubhe Dapp Staking, which can be retrieved upon unregistering.`
+			)
+		);
+
+		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 balance = await dubhe.getBalance();
+		const balanceInSUI = Number(balance.totalBalance) / 1_000_000_000;
+
+		if (balanceInSUI < amount) {
+			// console.log(chalk.yellow(`Account balance is less than 2 SUI.`));
+			throw new DubheCliError(
+				`Account balance is less than ${amount} SUI. Please get more SUI.`
+			);
+		}
+
+		console.log(
+			chalk.green(
+				`Current account balance: ${balanceInSUI.toFixed(4)} SUI`
+			)
+		);
+	} catch (error) {
+		throw new DubheCliError('Failed to check balance: ' + error);
+	}
+}

package/src/utils/errors.ts

@@ -1,46 +1,46 @@
-import chalk from "chalk";
-import { ZodError } from "zod";
-import { fromZodError, ValidationError } from "zod-validation-error";
+import chalk from 'chalk';
+import { ZodError } from 'zod';
+import { fromZodError, ValidationError } from 'zod-validation-error';
 
 export class NotInsideProjectError extends Error {
-  name = "NotInsideProjectError";
-  message = "You are not inside a Dubhe project";
+	name = 'NotInsideProjectError';
+	message = 'You are not inside a Dubhe project';
 }
 
 export class DubheCliError extends Error {
-  name = "DubheCliError";
+	name = 'DubheCliError';
 }
 
 export class UpgradeError extends Error {
-  name = "UpgradeError";
+	name = 'UpgradeError';
 }
 
 export class FsIibError extends Error {
-  name = "FsIibError";
+	name = 'FsIibError';
 }
 
 export function logError(error: unknown) {
-  if (error instanceof ValidationError) {
-    console.log(chalk.redBright(error.message));
-  } else if (error instanceof ZodError) {
-    // TODO currently this error shouldn't happen, use `fromZodErrorCustom`
-    const validationError = fromZodError(error, {
-      prefixSeparator: "\n- ",
-      issueSeparator: "\n- ",
-    });
-    console.log(chalk.redBright(validationError.message));
-  } else if (error instanceof NotInsideProjectError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    // TODO add docs to the website and update the link to the specific page
-    console.log(
-      chalk.blue(
-        `To learn more about Dubhe's configuration, please go to https://github.com/0xobelisk`
-      )
-    );
-  } else if (error instanceof DubheCliError) {
-    console.log(chalk.red(error));
-  } else {
-    console.log(error);
-  }
+	if (error instanceof ValidationError) {
+		console.log(chalk.redBright(error.message));
+	} else if (error instanceof ZodError) {
+		// TODO currently this error shouldn't happen, use `fromZodErrorCustom`
+		const validationError = fromZodError(error, {
+			prefixSeparator: '\n- ',
+			issueSeparator: '\n- ',
+		});
+		console.log(chalk.redBright(validationError.message));
+	} else if (error instanceof NotInsideProjectError) {
+		console.log(chalk.red(error.message));
+		console.log('');
+		// TODO add docs to the website and update the link to the specific page
+		console.log(
+			chalk.blue(
+				`To learn more about Dubhe's configuration, please go to https://github.com/0xobelisk`
+			)
+		);
+	} else if (error instanceof DubheCliError) {
+		console.log(chalk.red(error));
+	} else {
+		console.log(error);
+	}
 }

package/src/utils/generateAccount.ts

@@ -0,0 +1,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
+) {
+	const path = process.cwd();
+	let privateKey: string;
+
+	if (force) {
+		const dubhe = new Dubhe();
+		const keypair = dubhe.getKeypair();
+		privateKey = keypair.getSecretKey();
+
+		fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
+		console.log(chalk.green(`File created at: ${path}/.env`));
+
+		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}`));
+		}
+
+		console.log(
+			chalk.blue(`Force generate new Account: ${keypair.toSuiAddress()}`)
+		);
+		return;
+	}
+
+	// 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.getKeypair();
+
+			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}`));
+			}
+
+			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.getKeypair();
+	privateKey = keypair.getSecretKey();
+	fs.writeFileSync(`${path}/.env`, `PRIVATE_KEY=${privateKey}`);
+	console.log(chalk.green(`File created at: ${path}/.env`));
+
+	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}`));
+	}
+
+	console.log(chalk.blue(`Generate new Account: ${keypair.toSuiAddress()}`));
+}

package/src/utils/publishHandler.ts

@@ -12,7 +12,11 @@ import {
 	updateVersionInFile,
 	saveContractData,
 	validatePrivateKey,
-	schema, getSchemaHub, updateDubheDependency, switchEnv, delay,
+	schema,
+	getSchemaHub,
+	updateDubheDependency,
+	switchEnv,
+	delay,
 } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
 import * as fs from 'fs';
@@ -22,9 +26,12 @@ async function getDappsObjectId(
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
 	switch (network) {
-		case "localnet": {
+		case 'localnet': {
 			const path = process.cwd();
-			return await getSchemaHub(`${path}/contracts/dubhe-framework`, network)
+			return await getSchemaHub(
+				`${path}/contracts/dubhe-framework`,
+				network
+			);
 		}
 		case 'testnet':
 			return '0x8dbf8d28ac027ba214c9e0951b09f6842843be6cb87242b7d9a326a2677cd47a';
@@ -33,12 +40,18 @@ async function getDappsObjectId(
 	}
 }
 
-function removeEnvContent(filePath: string, networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet'): void {
+function removeEnvContent(
+	filePath: string,
+	networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+): void {
 	if (!fs.existsSync(filePath)) {
 		return;
 	}
 	const content = fs.readFileSync(filePath, 'utf-8');
-	const regex = new RegExp(`\\[env\\.${networkType}\\][\\s\\S]*?(?=\\[|$)`, 'g');
+	const regex = new RegExp(
+		`\\[env\\.${networkType}\\][\\s\\S]*?(?=\\[|$)`,
+		'g'
+	);
 	const updatedContent = content.replace(regex, '');
 	fs.writeFileSync(filePath, updatedContent, 'utf-8');
 }
@@ -56,12 +69,20 @@ const chainIds: { [key: string]: string } = {
 	mainnet: '35834a8a',
 };
 
-function updateEnvFile(filePath: string, networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet', operation: 'publish' | 'upgrade', chainId: string, publishedId: string): void {
+function updateEnvFile(
+	filePath: string,
+	networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+	operation: 'publish' | 'upgrade',
+	chainId: string,
+	publishedId: string
+): void {
 	const envFilePath = path.resolve(filePath);
 	const envContent = fs.readFileSync(envFilePath, 'utf-8');
 	const envLines = envContent.split('\n');
 
-	const networkSectionIndex = envLines.findIndex(line => line.trim() === `[env.${networkType}]`);
+	const networkSectionIndex = envLines.findIndex(
+		line => line.trim() === `[env.${networkType}]`
+	);
 	const config: EnvConfig = {
 		chainId: chainId,
 		originalPublishedId: '',
@@ -76,14 +97,18 @@ function updateEnvFile(filePath: string, networkType: 'mainnet' | 'testnet' | 'd
 			config.latestPublishedId = publishedId;
 			config.publishedVersion = 1;
 		} else {
-			throw new Error(`Network type [env.${networkType}] not found in the file and cannot upgrade.`);
+			throw new Error(
+				`Network type [env.${networkType}] not found in the file and cannot upgrade.`
+			);
 		}
 	} else {
 		for (let i = networkSectionIndex + 1; i < envLines.length; i++) {
 			const line = envLines[i].trim();
 			if (line.startsWith('[')) break; // End of the current network section
 
-			const [key, value] = line.split('=').map(part => part.trim().replace(/"/g, ''));
+			const [key, value] = line
+				.split('=')
+				.map(part => part.trim().replace(/"/g, ''));
 			switch (key) {
 				case 'original-published-id':
 					config.originalPublishedId = value;
@@ -115,9 +140,11 @@ latest-published-id = "${config.latestPublishedId}"
 published-version = "${config.publishedVersion}"
 `;
 
-	const newEnvContent = networkSectionIndex === -1
-		? envContent + updatedSection
-		: envLines.slice(0, networkSectionIndex).join('\n') + updatedSection;
+	const newEnvContent =
+		networkSectionIndex === -1
+			? envContent + updatedSection
+			: envLines.slice(0, networkSectionIndex).join('\n') +
+			  updatedSection;
 
 	fs.writeFileSync(envFilePath, newEnvContent, 'utf-8');
 }
@@ -137,7 +164,7 @@ function getLastSegment(input: string): string {
 	return segments.length > 0 ? segments[segments.length - 1] : '';
 }
 
-function buildContract(projectPath: string):  string[][] {
+function buildContract(projectPath: string): string[][] {
 	let modules: any, dependencies: any;
 	try {
 		const buildResult = JSON.parse(
@@ -145,6 +172,7 @@ function buildContract(projectPath: string):  string[][] {
 				`sui move build --dump-bytecode-as-base64 --path ${projectPath}`,
 				{
 					encoding: 'utf-8',
+					stdio: 'pipe',
 				}
 			)
 		);
@@ -167,7 +195,7 @@ async function publishContract(
 	projectPath: string
 ) {
 	const dappsObjectId = await getDappsObjectId(network);
-	console.log("dappsObjectId", dappsObjectId);
+	console.log('dappsObjectId', dappsObjectId);
 	const chainId = await client.getChainIdentifier();
 	removeEnvContent(`${projectPath}/Move.lock`, network);
 	console.log('\n🚀 Starting Contract Publication...');
@@ -226,7 +254,7 @@ async function publishContract(
 		}
 		if (
 			object.type === 'created' &&
-			object.objectType.includes("schema_hub")
+			object.objectType.includes('schema_hub')
 		) {
 			console.log(`  ├─ Schema Hub: ${object.objectId}`);
 			schemaHubId = object.objectId;
@@ -235,14 +263,20 @@ async function publishContract(
 
 	console.log(`  └─ Transaction: ${result.digest}`);
 
-	updateEnvFile(`${projectPath}/Move.lock`, network, 'publish', chainId, packageId);
+	updateEnvFile(
+		`${projectPath}/Move.lock`,
+		network,
+		'publish',
+		chainId,
+		packageId
+	);
 
 	console.log('\n⚡ Executing Deploy Hook...');
 	await delay(5000);
 
 	const deployHookTx = new Transaction();
 	deployHookTx.setGasBudget(2000000000);
-	const [txCoin] = deployHookTx.splitCoins(deployHookTx.gas, ["1000000000"]);
+	const [txCoin] = deployHookTx.splitCoins(deployHookTx.gas, ['1000000000']);
 	deployHookTx.moveCall({
 		target: `${packageId}::deploy_hook::run`,
 		arguments: [
@@ -250,7 +284,7 @@ async function publishContract(
 			deployHookTx.object(dappsObjectId),
 			deployHookTx.object(upgradeCapId),
 			deployHookTx.object('0x6'),
-			txCoin
+			txCoin,
 		],
 	});
 
@@ -275,14 +309,18 @@ async function publishContract(
 		deployHookResult.objectChanges?.map(object => {
 			if (
 				object.type === 'created' &&
-				object.objectType.includes('_schema') && !object.objectType.includes("dynamic_field")
+				object.objectType.includes('_schema') &&
+				!object.objectType.includes('dynamic_field')
 			) {
 				console.log(`  ├─ ${object.objectType}`);
 				console.log(`     └─ ID: ${object.objectId}`);
 
 				let structure: Record<string, string> = {};
 				for (let schemaKey in dubheConfig.schemas) {
-					if (capitalizeAndRemoveUnderscores(schemaKey) === getLastSegment(object.objectType)) {
+					if (
+						capitalizeAndRemoveUnderscores(schemaKey) ===
+						getLastSegment(object.objectType)
+					) {
 						structure = dubheConfig.schemas[schemaKey].structure;
 					}
 				}
@@ -302,7 +340,7 @@ async function publishContract(
 			upgradeCapId,
 			schemaHubId,
 			version,
-			schemas,
+			schemas
 		);
 		console.log('\n✅ Contract Publication Complete\n');
 	} else {
@@ -315,10 +353,10 @@ async function publishContract(
 	}
 }
 
-async function publishDubheFramework(
+export async function publishDubheFramework(
 	client: SuiClient,
 	dubhe: Dubhe,
-	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
 	const path = process.cwd();
 	const projectPath = `${path}/contracts/dubhe-framework`;
@@ -334,7 +372,6 @@ async function publishDubheFramework(
 	const keypair = dubhe.getKeypair();
 	console.log(`  └─ Account: ${keypair.toSuiAddress()}`);
 
-
 	console.log('\n📦 Building Contract...');
 	const [modules, dependencies] = buildContract(projectPath);
 
@@ -380,10 +417,7 @@ async function publishDubheFramework(
 			console.log(`  ├─ Upgrade Cap: ${object.objectId}`);
 			upgradeCapId = object.objectId;
 		}
-		if (
-			object.type === 'created' &&
-			object.objectType.includes("dapps")
-		) {
+		if (object.type === 'created' && object.objectType.includes('dapps')) {
 			console.log(`  ├─ Dapps: ${object.objectId}`);
 			schemaHubId = object.objectId;
 		}
@@ -391,23 +425,29 @@ async function publishDubheFramework(
 
 	console.log(`  └─ Transaction: ${result.digest}`);
 
-	updateEnvFile(`${projectPath}/Move.lock`, network, 'publish', chainId, packageId);
+	updateEnvFile(
+		`${projectPath}/Move.lock`,
+		network,
+		'publish',
+		chainId,
+		packageId
+	);
 
 	saveContractData(
-		"dubhe-framework",
+		'dubhe-framework',
 		network,
 		packageId,
 		upgradeCapId,
 		schemaHubId,
 		version,
-		schemas,
+		schemas
 	);
 }
 
 export async function publishHandler(
 	dubheConfig: DubheConfig,
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-	contractName?: string,
+	contractName?: string
 ) {
 	await switchEnv(network);
 
@@ -427,7 +467,7 @@ in your contracts directory to use the default sui private key.`
 	const dubhe = new Dubhe({ secretKey: privateKeyFormat });
 	const client = new SuiClient({ url: getFullnodeUrl(network) });
 
-	if (contractName == "dubhe-framework") {
+	if (contractName == 'dubhe-framework') {
 		await publishDubheFramework(client, dubhe, network);
 	} else {
 		const path = process.cwd();