@0xobelisk/sui-cli 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -59,11 +59,12 @@
     "vitest": "0.31.4"
   },
   "scripts": {
-    "build": "pnpm run build:js",
+    "build": "pnpm run type-check && pnpm run build:js",
     "build:js": "tsup && chmod +x ./dist/dubhe.js",
     "clean": "pnpm run clean:js",
     "clean:js": "rimraf dist",
     "dev": "tsup --watch",
-    "lint": "eslint . --ext .ts"
+    "lint": "eslint . --ext .ts",
+    "type-check": "tsc --noEmit"
   }
 }

package/src/commands/test.ts

@@ -1,50 +1,51 @@
-import type { CommandModule } from "yargs";
-import { execSync } from "child_process";
-import chalk from "chalk";
+import type { CommandModule } from 'yargs';
+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/utils/callHandler.ts

@@ -5,7 +5,7 @@ import {
 	TransactionResult,
 } from '@0xobelisk/sui-client';
 import { DubheCliError } from './errors';
-import { validatePrivateKey, getOldPackageId, getObjectId } from './utils';
+import { validatePrivateKey, getOldPackageId } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';
 import { loadMetadataFromFile } from './queryStorage';
 
@@ -26,7 +26,7 @@ const BaseTxType = [
 function validateParams(params: any[]) {
 	try {
 		params.forEach(param => {
-			const [type, value] = param.split(':');
+			const [type, _] = param.split(':');
 			if (!BaseTxType.includes(type)) {
 				throw new Error(`Invalid param type: ${type}`);
 			}
@@ -162,5 +162,5 @@ in your contracts directory to use the default sui private key.`
 		params: formattedParams,
 	})) as TransactionResult;
 
-	console.log(result);
+	console.log(JSON.stringify(result, null, 2));
 }

package/src/utils/publishHandler.ts

@@ -9,7 +9,6 @@ import { execSync } from 'child_process';
 import chalk from 'chalk';
 import { DubheCliError } from './errors';
 import {
-	updateVersionInFile,
 	saveContractData,
 	validatePrivateKey,
 	schema,
@@ -282,7 +281,7 @@ async function publishContract(
 						capitalizeAndRemoveUnderscores(schemaKey) ===
 						getLastSegment(object.objectType)
 					) {
-						structure = dubheConfig.schemas[schemaKey].structure;
+						structure = dubheConfig.schemas[schemaKey];
 					}
 				}
 
@@ -427,6 +426,7 @@ export async function publishDubheFramework(
 		version,
 		schemas
 	);
+	await delay(1000);
 	console.log(chalk.green('\n✅ Dubhe Framework deployed successfully'));
 }
 

package/src/utils/startNode.ts

@@ -1,14 +1,8 @@
 import { execSync, spawn } from 'child_process';
 import chalk from 'chalk';
 import { printDubhe } from './printDubhe';
-import {
-	delay,
-	DubheCliError,
-	publishDubheFramework,
-	validatePrivateKey,
-} from '../utils';
+import { delay, DubheCliError, validatePrivateKey } from '../utils';
 import { Dubhe } from '@0xobelisk/sui-client';
-import { getFullnodeUrl, SuiClient } from '@mysten/sui/client';
 
 function isSuiStartRunning(): boolean {
 	try {

package/src/utils/storeConfig.ts

@@ -1,6 +1,5 @@
 import * as fsAsync from 'fs/promises';
 import { mkdirSync, writeFileSync } from 'fs';
-import { exit } from 'process';
 import { dirname } from 'path';
 import { DeploymentJsonType, schema } from './utils';
 import { DubheConfig } from '@0xobelisk/sui-common';

package/src/utils/upgradeHandler.ts

@@ -5,62 +5,70 @@ import { execSync } from 'child_process';
 import chalk from 'chalk';
 import { DubheCliError, UpgradeError } from './errors';
 import {
-	updateVersionInFile,
 	getOldPackageId,
 	getVersion,
 	getUpgradeCap,
 	saveContractData,
-	validatePrivateKey, getOnchainSchemas, switchEnv, delay,
+	validatePrivateKey,
+	getOnchainSchemas,
+	switchEnv,
 } from './utils';
 import * as fs from 'fs';
 import * as path from 'path';
 import { DubheConfig } from '@0xobelisk/sui-common';
 
-type ObjectContent = {
-	type: string;
-	fields: Record<string, any>;
-	hasPublicTransfer: boolean;
-	dataType: string;
-};
-
 type Field = {
 	name: string;
 	type: string;
-}
+};
 
 type Migration = {
 	schemaName: string;
 	fields: Field[];
 };
 
-function updateMigrateMethod(projectPath: string, migrations: Migration[]): void {
-	migrations.forEach((migration) => {
+function updateMigrateMethod(
+	projectPath: string,
+	migrations: Migration[]
+): void {
+	migrations.forEach(migration => {
 		let filePath = `${projectPath}/sources/codegen/schemas/${migration.schemaName}.move`;
 		const fileContent = fs.readFileSync(filePath, 'utf-8');
-		const migrateMethodRegex = new RegExp(`public fun migrate\\(_${migration.schemaName}: &mut ${capitalizeAndRemoveUnderscores(migration.schemaName)}, _cap: &UpgradeCap\\) {[^}]*}`);
+		const migrateMethodRegex = new RegExp(
+			`public fun migrate\\(_${
+				migration.schemaName
+			}: &mut ${capitalizeAndRemoveUnderscores(
+				migration.schemaName
+			)}, _cap: &UpgradeCap\\) {[^}]*}`
+		);
 		const newMigrateMethod = `
-public fun migrate(${migration.schemaName}: &mut ${capitalizeAndRemoveUnderscores(migration.schemaName)}, _cap: &UpgradeCap) {
-${migration.fields.map((field) => {
-			let storage_type = '';
-			if (field.type.includes('StorageValue')) {
-				storage_type = `storage_value::new()`;
-			} else if (field.type.includes('StorageMap')) {
-				storage_type = `storage_map::new()`;
-			} else if (
-				field.type.includes('StorageDoubleMap')
-			) {
-				storage_type = `storage_double_map::new()`;
-			}
-			return `storage_migration::add_field<${field.type}>(&mut ${migration.schemaName}.id, b"${field.name}", ${storage_type});`;
-		}).join('')}
+public fun migrate(${
+			migration.schemaName
+		}: &mut ${capitalizeAndRemoveUnderscores(
+			migration.schemaName
+		)}, _cap: &UpgradeCap) {
+${migration.fields
+	.map(field => {
+		let storage_type = '';
+		if (field.type.includes('StorageValue')) {
+			storage_type = `storage_value::new()`;
+		} else if (field.type.includes('StorageMap')) {
+			storage_type = `storage_map::new()`;
+		} else if (field.type.includes('StorageDoubleMap')) {
+			storage_type = `storage_double_map::new()`;
+		}
+		return `storage_migration::add_field<${field.type}>(&mut ${migration.schemaName}.id, b"${field.name}", ${storage_type});`;
+	})
+	.join('')}
 }
 `;
 
-		const updatedContent = fileContent.replace(migrateMethodRegex, newMigrateMethod);
+		const updatedContent = fileContent.replace(
+			migrateMethodRegex,
+			newMigrateMethod
+		);
 		fs.writeFileSync(filePath, updatedContent, 'utf-8');
 	});
-
-
 }
 
 function capitalizeAndRemoveUnderscores(input: string): string {
@@ -82,21 +90,26 @@ function getLastSegment(input: string): string {
 function replaceEnvField(
 	filePath: string,
 	networkType: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-	field: 'original-published-id' | 'latest-published-id' | 'published-version',
+	field:
+		| 'original-published-id'
+		| 'latest-published-id'
+		| 'published-version',
 	newValue: string
 ): string {
 	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}]`
+	);
 	if (networkSectionIndex === -1) {
 		console.log(`Network type [env.${networkType}] not found in the file.`);
-		return "";
+		return '';
 	}
 
 	let fieldIndex = -1;
-	let previousValue: string = "";
+	let previousValue: string = '';
 	for (let i = networkSectionIndex + 1; i < envLines.length; i++) {
 		const line = envLines[i].trim();
 		if (line.startsWith('[')) break; // End of the current network section
@@ -121,7 +134,7 @@ function replaceEnvField(
 export async function upgradeHandler(
 	config: DubheConfig,
 	name: string,
-	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
 	await switchEnv(network);
 
@@ -132,7 +145,7 @@ export async function upgradeHandler(
 		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.`,
+in your contracts directory to use the default sui private key.`
 		);
 
 	const privateKeyFormat = validatePrivateKey(privateKey);
@@ -152,24 +165,32 @@ in your contracts directory to use the default sui private key.`,
 	let oldPackageId = await getOldPackageId(projectPath, network);
 	let upgradeCap = await getUpgradeCap(projectPath, network);
 
-	const original_published_id =  replaceEnvField(`${projectPath}/Move.lock`, network, 'original-published-id', "0x0000000000000000000000000000000000000000000000000000000000000000");
+	const original_published_id = replaceEnvField(
+		`${projectPath}/Move.lock`,
+		network,
+		'original-published-id',
+		'0x0000000000000000000000000000000000000000000000000000000000000000'
+	);
 
 	let pendingMigration: Migration[] = [];
 	let schemas = await getOnchainSchemas(projectPath, network);
 	for (let schemaKey in config.schemas) {
-		schemas.forEach((schema) => {
-			if (capitalizeAndRemoveUnderscores(schemaKey) == getLastSegment(schema.name)) {
+		schemas.forEach(schema => {
+			if (
+				capitalizeAndRemoveUnderscores(schemaKey) ==
+				getLastSegment(schema.name)
+			) {
 				let migrate: Migration = { schemaName: '', fields: [] };
 				let fields: Field[] = [];
 				let isMigration = false;
-				for (const key in config.schemas[schemaKey].structure) {
+				for (const key in config.schemas[schemaKey]) {
 					if (!(key in schema.structure)) {
 						isMigration = true;
 						fields.push({
 							name: key,
-							type: config.schemas[schemaKey].structure[key],
+							type: config.schemas[schemaKey][key],
 						});
-						schema.structure[key] = config.schemas[schemaKey].structure[key];
+						schema.structure[key] = config.schemas[schemaKey][key];
 					}
 				}
 				if (isMigration) {
@@ -181,8 +202,7 @@ in your contracts directory to use the default sui private key.`,
 		});
 	}
 
-
-	pendingMigration.forEach((migration) => {
+	pendingMigration.forEach(migration => {
 		console.log(`\n🚀 Starting Migration for ${migration.schemaName}...`);
 		console.log('📋 Migration Fields:', migration.fields);
 	});
@@ -200,8 +220,8 @@ in your contracts directory to use the default sui private key.`,
 					`sui move build --dump-bytecode-as-base64 --path ${path}/contracts/${name}`,
 					{
 						encoding: 'utf-8',
-					},
-				),
+					}
+				)
 			);
 
 			modules = extractedModules;
@@ -250,21 +270,34 @@ in your contracts directory to use the default sui private key.`,
 		result.objectChanges!.map(object => {
 			if (object.type === 'published') {
 				console.log(
-					chalk.blue(`${name} PackageId: ${object.packageId}`),
-				);
-				console.log(
-					chalk.blue(`${name} Version: ${oldVersion + 1}`),
+					chalk.blue(`${name} PackageId: ${object.packageId}`)
 				);
+				console.log(chalk.blue(`${name} Version: ${oldVersion + 1}`));
 				newPackageId = object.packageId;
 			}
 		});
 
-		replaceEnvField(`${projectPath}/Move.lock`, network, 'original-published-id', original_published_id);
-		replaceEnvField(`${projectPath}/Move.lock`, network, 'latest-published-id', newPackageId);
-		replaceEnvField(`${projectPath}/Move.lock`, network, 'published-version', (oldVersion + 1) + "");
+		replaceEnvField(
+			`${projectPath}/Move.lock`,
+			network,
+			'original-published-id',
+			original_published_id
+		);
+		replaceEnvField(
+			`${projectPath}/Move.lock`,
+			network,
+			'latest-published-id',
+			newPackageId
+		);
+		replaceEnvField(
+			`${projectPath}/Move.lock`,
+			network,
+			'published-version',
+			oldVersion + 1 + ''
+		);
 
 		console.log(
-			chalk.green(`Upgrade Transaction Digest: ${result.digest}`),
+			chalk.green(`Upgrade Transaction Digest: ${result.digest}`)
 		);
 
 		saveContractData(
@@ -273,9 +306,8 @@ in your contracts directory to use the default sui private key.`,
 			newPackageId,
 			upgradeCap,
 			oldVersion + 1,
-			schemas,
+			schemas
 		);
-
 	} catch (error: any) {
 		console.log(chalk.red('Upgrade failed!'));
 		console.error(error.message);