@0xobelisk/sui-cli 0.5.17 → 0.5.19

package/src/commands/schemagen.ts

@@ -1,36 +1,47 @@
-import type { CommandModule } from "yargs";
-import { worldgen, loadConfig, ObeliskConfig } from "@0xobelisk/sui-common";
-import chalk from "chalk";
+import type { CommandModule } from 'yargs';
+import { schemaGen, loadConfig, ObeliskConfig } from '@0xobelisk/sui-common';
+import chalk from 'chalk';
 
 type Options = {
-  configPath?: string;
+	configPath?: string;
+	network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
+	frameworkId?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
-  command: "schemagen",
+	command: 'schemagen',
 
-  describe: "Autogenerate Obelisk schemas based on the config file",
+	describe: 'Autogenerate Obelisk schemas based on the config file',
 
-  builder(yargs) {
-    return yargs.options({
-      configPath: {
-        type: "string",
-        default: "obelisk.config.ts",
-        desc: "Path to the config file"
-      },
-    });
-  },
+	builder: {
+		configPath: {
+			type: 'string',
+			default: 'obelisk.config.ts',
+			desc: 'Path to the config file',
+		},
+		network: {
+			type: 'string',
+			choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
+			desc: 'Node network (mainnet/testnet/devnet/localnet)',
+		},
+		frameworkId: {
+			type: 'string',
+			desc: 'Framework Package ID',
+		},
+	},
 
-  async handler({ configPath }) {
-    try {
-      const obeliskConfig = (await loadConfig(configPath)) as ObeliskConfig;
-      await worldgen(obeliskConfig);
-      process.exit(0);
-    } catch (error: any) {
-      console.log(chalk.red("Schemagen failed!"));
-      console.error(error.message);
-    }
-  },
+	async handler({ configPath, network, frameworkId }) {
+		try {
+			const obeliskConfig = (await loadConfig(
+				configPath
+			)) as ObeliskConfig;
+			await schemaGen(obeliskConfig, undefined, network, frameworkId);
+			process.exit(0);
+		} catch (error: any) {
+			console.log(chalk.red('Schemagen failed!'));
+			console.error(error.message);
+		}
+	},
 };
 
 export default commandModule;

package/src/commands/upgrade.ts

@@ -1,53 +1,53 @@
-import type { CommandModule } from "yargs";
-import { logError } from "../utils/errors";
-import { upgradeHandler } from "../utils";
-import { ObeliskConfig, loadConfig, ValueType } from "@0xobelisk/sui-common";
-
-type Options = {
-  network: any;
-  configPath: string;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "upgrade",
-
-  describe: "Upgrade your move contracts",
-
-  builder(yargs) {
-    return yargs.options({
-      network: {
-        type: "string",
-        choices: ["mainnet", "testnet", "devnet", "localnet"],
-        desc: "Network of the node (mainnet/testnet/devnet/localnet)",
-      },
-      configPath: {
-        type: "string",
-        default: "obelisk.config.ts",
-        decs: "Path to the config file",
-      },
-    });
-  },
-
-  async handler({ network, configPath }) {
-    try {
-      const obeliskConfig = (await loadConfig(configPath)) as ObeliskConfig;
-
-      let schemaNames = Object.keys(obeliskConfig.schemas).filter(
-        (key) =>
-          !(
-            typeof obeliskConfig.schemas === "object" &&
-            "ephemeral" in obeliskConfig.schemas &&
-            (obeliskConfig.schemas[key] as ValueType).ephemeral
-          )
-      );
-
-      await upgradeHandler(obeliskConfig.name, network, schemaNames);
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  },
-};
-
-export default commandModule;
+// import type { CommandModule } from "yargs";
+// import { logError } from "../utils/errors";
+// import { upgradeHandler } from "../utils";
+// import { ObeliskConfig, loadConfig, ValueType } from "@0xobelisk/sui-common";
+
+// type Options = {
+//   network: any;
+//   configPath: string;
+// };
+
+// const commandModule: CommandModule<Options, Options> = {
+//   command: "upgrade",
+
+//   describe: "Upgrade your move contracts",
+
+//   builder(yargs) {
+//     return yargs.options({
+//       network: {
+//         type: "string",
+//         choices: ["mainnet", "testnet", "devnet", "localnet"],
+//         desc: "Network of the node (mainnet/testnet/devnet/localnet)",
+//       },
+//       configPath: {
+//         type: "string",
+//         default: "obelisk.config.ts",
+//         decs: "Path to the config file",
+//       },
+//     });
+//   },
+
+//   async handler({ network, configPath }) {
+//     try {
+//       const obeliskConfig = (await loadConfig(configPath)) as ObeliskConfig;
+
+//       let schemaNames = Object.keys(obeliskConfig.schemas).filter(
+//         (key) =>
+//           !(
+//             typeof obeliskConfig.schemas === "object" &&
+//             "ephemeral" in obeliskConfig.schemas &&
+//             (obeliskConfig.schemas[key] as ValueType).ephemeral
+//           )
+//       );
+
+//       await upgradeHandler(obeliskConfig.name, network, schemaNames);
+//     } catch (error: any) {
+//       logError(error);
+//       process.exit(1);
+//     }
+//     process.exit(0);
+//   },
+// };
+
+// export default commandModule;

package/src/utils/index.ts

@@ -1,5 +1,5 @@
-export * from "./publishHandler";
-export * from "./upgradeHandler";
-export * from "./errors";
-export * from "./printObelisk";
-export * from "./utils";
+export * from './publishHandler';
+// export * from "./upgradeHandler";
+export * from './errors';
+export * from './printObelisk';
+export * from './utils';

package/src/utils/localnode/index.ts

@@ -0,0 +1,3 @@
+export { startLocalnode } from './start';
+export { checkLocalNodeStatus } from './status';
+export { stopLocalnode } from './stop';

package/src/utils/localnode/start.ts

@@ -0,0 +1,87 @@
+import { execSync, spawn } from 'child_process';
+import chalk from 'chalk';
+
+function isSuiStartRunning(): boolean {
+	try {
+		const cmd =
+			process.platform === 'win32'
+				? `tasklist /FI "IMAGENAME eq sui.exe" /FO CSV /NH`
+				: 'pgrep -f "sui start"';
+
+		const result = execSync(cmd).toString().trim();
+		return process.platform === 'win32'
+			? result.toLowerCase().includes('sui.exe')
+			: result.length > 0;
+	} catch (error) {
+		return false;
+	}
+}
+
+export async function startLocalnode(background: boolean = false) {
+	console.log('\n🔍 Checking Local Node Status...');
+	console.log('  ├─ Scanning running processes');
+
+	if (isSuiStartRunning()) {
+		console.log(chalk.yellow('\n⚠️  Warning: Local Node Already Running'));
+		console.log(chalk.yellow('  ├─ Cannot start a new instance'));
+		console.log(
+			chalk.yellow('  └─ Please stop the existing process first')
+		);
+		return;
+	}
+
+	console.log('\n🚀 Starting Local Node...');
+	console.log('  ├─ Mode: ' + (background ? 'Background' : 'Foreground'));
+	console.log('  ├─ Faucet: Enabled');
+	console.log('  └─ Force Regenesis: Yes');
+
+	try {
+		const suiProcess = spawn(
+			'sui',
+			['start', '--with-faucet', '--force-regenesis'],
+			{
+				env: { ...process.env, RUST_LOG: 'off,sui_node=info' },
+				stdio: background ? 'ignore' : 'inherit',
+				detached: background,
+			}
+		);
+
+		suiProcess.on('error', error => {
+			console.error(chalk.red('\n❌ Failed to Start Local Node'));
+			console.error(chalk.red(`  └─ Error: ${error.message}`));
+		});
+
+		if (!background) {
+			suiProcess.on('exit', code => {
+				if (code === 0) {
+					console.log(chalk.green('\n✅ Local Node Stopped'));
+					console.log(chalk.green('  └─ Exit Status: Normal'));
+				} else {
+					console.error(chalk.red('\n❌ Local Node Crashed'));
+					console.error(chalk.red(`  └─ Exit Code: ${code}`));
+				}
+			});
+
+			console.log(chalk.cyan('\n📡 Local Node Running'));
+			console.log(chalk.cyan('  └─ Press Ctrl+C to stop'));
+
+			await new Promise(() => {});
+		} else {
+			suiProcess.unref();
+			console.log(chalk.green('\n✅ Local Node Started in Background'));
+
+			if (process.platform === 'win32') {
+				console.log('\n💡 Helpful Commands:');
+				console.log('  ├─ Check Process: tasklist | findstr sui.exe');
+				console.log('  └─ Stop Node: taskkill /PID <process_id> /F');
+			} else {
+				console.log('\n💡 Helpful Commands:');
+				console.log("  ├─ Check Process: pgrep -f 'sui start'");
+				console.log('  └─ Stop Node: kill <process_id>');
+			}
+		}
+	} catch (error: any) {
+		console.error(chalk.red('\n❌ Failed to Start Local Node'));
+		console.error(chalk.red(`  └─ Error: ${error.message}`));
+	}
+}

package/src/utils/localnode/status.ts

@@ -0,0 +1,38 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+export async function checkLocalNodeStatus() {
+	console.log('\n🔍 Checking Local Node Status...');
+
+	try {
+		const cmd =
+			process.platform === 'win32'
+				? `tasklist /FI "IMAGENAME eq sui.exe" /FO CSV /NH`
+				: "ps aux | grep '[s]ui start --with-faucet --force-regenesis'";
+
+		const output = execSync(cmd, {
+			encoding: 'utf8',
+		});
+
+		const isRunning =
+			process.platform === 'win32'
+				? output.toLowerCase().includes('sui.exe')
+				: output.split('\n').filter(Boolean).length > 0;
+
+		if (isRunning) {
+			console.log(chalk.green('\n✅ Node Status: Running'));
+			console.log(chalk.gray('\n📊 Process Details:'));
+			console.log(chalk.gray(`  └─ ${output.trim()}`));
+		} else {
+			console.log(chalk.red('\n❌ Node Status: Not Running'));
+			console.log(chalk.yellow('\n💡 Quick Start:'));
+			console.log(chalk.yellow('  └─ Run `obelisk localnode start`'));
+		}
+	} catch (error) {
+		console.log(chalk.red('\n❌ Node Status: Not Running'));
+		console.log(chalk.yellow('\n💡 Quick Start:'));
+		console.log(chalk.yellow('  └─ Run `obelisk localnode start`'));
+	}
+}
+
+// checkLocalNodeStatus();

package/src/utils/localnode/stop.ts

@@ -0,0 +1,58 @@
+import { execSync } from 'child_process';
+
+export async function stopLocalnode() {
+	console.log('Stopping local node...');
+
+	try {
+		// Choose different commands based on the operating system
+		const cmd =
+			process.platform === 'win32'
+				? `tasklist /FI "IMAGENAME eq sui.exe" /FO CSV /NH`
+				: "ps aux | grep '[s]ui start --with-faucet --force-regenesis'";
+
+		const output = execSync(cmd, {
+			encoding: 'utf8',
+		});
+
+		if (!output) {
+			console.log('No running local node process found');
+			return;
+		}
+
+		// Parse process ID based on the operating system
+		let pid;
+		if (process.platform === 'win32') {
+			// Windows output format: "sui.exe","1234",... (CSV format)
+			const match = output.match(/"sui\.exe",["']?(\d+)/i);
+			pid = match ? match[1] : null;
+		} else {
+			// Unix system output format: user pid %cpu ...
+			pid = output.toString().split(/\s+/)[1];
+		}
+
+		if (!pid) {
+			console.log('No running local node process found');
+			return;
+		}
+
+		// Choose the command to terminate the process based on the operating system
+		if (process.platform === 'win32') {
+			execSync(`taskkill /PID ${pid} /F`);
+		} else {
+			process.kill(Number(pid));
+		}
+
+		console.log('✅ Local node stopped successfully');
+	} catch (error: any) {
+		if (
+			error.code === 'ESRCH' ||
+			error.message.includes('no running tasks')
+		) {
+			console.log('No running local node process found');
+		} else {
+			console.error('❌ Error stopping local node:', error.message);
+		}
+	}
+}
+
+// stopLocalnode();

package/src/utils/publishHandler.ts

@@ -11,44 +11,59 @@ import { ObeliskCliError } from './errors';
 import {
 	updateVersionInFile,
 	saveContractData,
-	validatePrivateKey, schema,
+	validatePrivateKey,
+	schema,
 } from './utils';
-import {log} from "node:util";
+
+async function getDappsObjectId(
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+) {
+	switch (network) {
+		case 'testnet':
+			return '0xa66942c08d9fc318a70ab9d0cfd7e75f1a2dd1ac31aff12fde008d25bfa9604b';
+		default:
+			return '0xa66942c08d9fc318a70ab9d0cfd7e75f1a2dd1ac31aff12fde008d25bfa9604b';
+	}
+}
 
 export async function publishHandler(
 	name: string,
-	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+	dappsObjectId?: string
 ) {
+	console.log('\n🚀 Starting Contract Publication...');
+	console.log(`  ├─ Project: ${name}`);
+	console.log(`  ├─ Network: ${network}`);
+
 	const path = process.cwd();
 	const projectPath = `${path}/contracts/${name}`;
+	dappsObjectId = dappsObjectId || (await getDappsObjectId(network));
 
+	console.log('  ├─ Validating Environment...');
 	const privateKey = process.env.PRIVATE_KEY;
-	if (!privateKey)
+	if (!privateKey) {
 		throw new ObeliskCliError(
 			`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 ObeliskCliError(`Please check your privateKey.`);
 	}
-	const obelisk = new Obelisk({
-		secretKey: privateKeyFormat,
-	});
+
+	const obelisk = new Obelisk({ secretKey: privateKeyFormat });
 	const keypair = obelisk.getKeypair();
+	console.log(`  └─ Account: ${keypair.toSuiAddress()}`);
 
-	const client = new SuiClient({
-		url: getFullnodeUrl(network),
-	});
+	const client = new SuiClient({ url: getFullnodeUrl(network) });
 
+	console.log('\n📦 Building Contract...');
 	let modules: any, dependencies: any;
 	try {
-		const {
-			modules: extractedModules,
-			dependencies: extractedDependencies,
-		} = JSON.parse(
+		const buildResult = JSON.parse(
 			execSync(
 				`sui move build --dump-bytecode-as-base64 --path ${projectPath}`,
 				{
@@ -56,78 +71,69 @@ in your contracts directory to use the default sui private key.`
 				}
 			)
 		);
-		modules = extractedModules;
-		dependencies = extractedDependencies;
+		modules = buildResult.modules;
+		dependencies = buildResult.dependencies;
+		console.log('  └─ Build successful');
 	} catch (error: any) {
-		console.error(chalk.red('Error executing sui move build:'));
+		console.error(chalk.red('  └─ Build failed'));
 		console.error(error.stdout);
-		process.exit(1); // You might want to exit with a non-zero status code to indicate an error
+		process.exit(1);
 	}
 
-	console.log(chalk.blue(`Account: ${keypair.toSuiAddress()}`));
-
+	console.log('\n🔄 Publishing Contract...');
 	const tx = new Transaction();
-	const [upgradeCap] = tx.publish({
-		modules,
-		dependencies,
-	});
-	tx.transferObjects(
-		[upgradeCap],
-		keypair.toSuiAddress()
-	);
+	const [upgradeCap] = tx.publish({ modules, dependencies });
+	tx.transferObjects([upgradeCap], keypair.toSuiAddress());
 
 	let result: SuiTransactionBlockResponse;
 	try {
 		result = await client.signAndExecuteTransaction({
 			signer: keypair,
 			transaction: tx,
-			options: {
-				showObjectChanges: true,
-			},
+			options: { showObjectChanges: true },
 		});
 	} catch (error: any) {
-		console.error(chalk.red(`Failed to execute publish, please republish`));
+		console.error(chalk.red('  └─ Publication failed'));
 		console.error(error.message);
 		process.exit(1);
 	}
 
 	if (result.effects?.status.status === 'failure') {
-		console.log(chalk.red(`Failed to execute publish, please republish`));
+		console.log(chalk.red('  └─ Publication failed'));
 		process.exit(1);
 	}
 
+	console.log('  ├─ Processing publication results...');
 	let version = 1;
 	let packageId = '';
 	let schemas: schema[] = [];
 	let upgradeCapId = '';
+
 	result.objectChanges!.map(object => {
 		if (object.type === 'published') {
-			console.log(chalk.blue(`${name} PackageId: ${object.packageId}`));
+			console.log(`  ├─ Package ID: ${object.packageId}`);
 			packageId = object.packageId;
 		}
 		if (
 			object.type === 'created' &&
 			object.objectType === '0x2::package::UpgradeCap'
 		) {
-			console.log(chalk.blue(`${name} UpgradeCap: ${object.objectId}`));
+			console.log(`  ├─ Upgrade Cap: ${object.objectId}`);
 			upgradeCapId = object.objectId;
 		}
 	});
 
-	console.log(chalk.green(`Publish transaction digest: ${result.digest}`));
+	console.log(`  └─ Transaction: ${result.digest}`);
 
-	console.log('Executing the deployHook: ');
-	const delay = (ms: number) =>
-		new Promise(resolve => setTimeout(resolve, ms));
-	await delay(5000);
+	console.log('\n⚡ Executing Deploy Hook...');
+	await new Promise(resolve => setTimeout(resolve, 5000));
 
 	const deployHookTx = new Transaction();
-
 	deployHookTx.moveCall({
 		target: `${packageId}::deploy_hook::run`,
 		arguments: [
-			deployHookTx.object("0xa66942c08d9fc318a70ab9d0cfd7e75f1a2dd1ac31aff12fde008d25bfa9604b"),
-			deployHookTx.object("0x6"),
+			deployHookTx.object(dappsObjectId),
+			deployHookTx.object('0x6'),
 		],
 	});
 
@@ -136,39 +142,33 @@ in your contracts directory to use the default sui private key.`
 		deployHookResult = await client.signAndExecuteTransaction({
 			signer: keypair,
 			transaction: deployHookTx,
-			options: {
-				showEffects: true,
-				showObjectChanges: true
-			},
+			options: { showEffects: true, showObjectChanges: true },
 		});
 	} catch (error: any) {
-		console.error(
-			chalk.red(
-				`Failed to execute deployHook, please republish or manually call deploy_hook::run`
-			)
-		);
+		console.error(chalk.red('  └─ Deploy hook execution failed'));
 		console.error(error.message);
 		process.exit(1);
 	}
 
 	if (deployHookResult.effects?.status.status === 'success') {
-		console.log(
-			chalk.green(
-				`Successful auto-execution of deployHook, please check the transaction digest: ${deployHookResult.digest}`
-			)
-		);
+		console.log('  ├─ Hook execution successful');
+		console.log(`  ├─ Transaction: ${deployHookResult.digest}`);
+
+		console.log('\n📋 Created Schemas:');
 		deployHookResult.objectChanges?.map(object => {
 			if (
-				object.type === 'created' && object.objectType.includes("schema")
+				object.type === 'created' &&
+				object.objectType.includes('schema')
 			) {
-				console.log(chalk.blue(`${name} Schema Object id: ${object.objectId}`));
-				console.log(chalk.blue(`${name} Schema Object type: ${object.objectType}`));
+				console.log(`  ├─ ${object.objectType}`);
+				console.log(`     └─ ID: ${object.objectId}`);
 				schemas.push({
 					name: object.objectType,
 					objectId: object.objectId,
 				});
 			}
 		});
+
 		saveContractData(
 			name,
 			network,
@@ -177,10 +177,12 @@ in your contracts directory to use the default sui private key.`
 			upgradeCapId,
 			version
 		);
+		console.log('\n✅ Contract Publication Complete\n');
 	} else {
+		console.log(chalk.yellow('  └─ Deploy hook execution failed'));
 		console.log(
 			chalk.yellow(
-				`Failed to execute deployHook, please republish or manually call deploy_hook::run`
+				'     Please republish or manually call deploy_hook::run'
 			)
 		);
 	}