@0xobelisk/sui-cli 1.0.7 → 1.0.9

package/src/utils/upgradeHandler.ts

@@ -5,98 +5,79 @@ import { execSync } from 'child_process';
 import chalk from 'chalk';
 import { DubheCliError, UpgradeError } from './errors';
 import {
-	updateVersionInFile,
-	getOldPackageId,
-	getVersion,
-	getUpgradeCap,
-	saveContractData,
-	validatePrivateKey, getOnchainSchemas, switchEnv, delay,
+    getOldPackageId,
+    getVersion,
+    getUpgradeCap,
+    saveContractData,
+    validatePrivateKey,
+    getOnchainSchemas,
+    switchEnv, getSchemaId,
 } 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[];
+	fields: string;
 };
 
-function updateMigrateMethod(projectPath: string, migrations: Migration[]): void {
-	migrations.forEach((migration) => {
-		let filePath = `${projectPath}/sources/codegen/schemas/${migration.schemaName}.move`;
+function updateMigrateMethod(
+	projectPath: string,
+	migrations: Migration[]
+): void {
+		let filePath = `${projectPath}/sources/codegen/schema.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\\(_schema: &mut Schema, _cap: &UpgradeCap, _ctx: &mut TxContext\\) {[^}]*}`
+		);
 		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(_schema: &mut Schema, _cap: &UpgradeCap, _ctx: &mut TxContext) {
+${migrations.map(migration => {
+		let storage_type = '';
+		if (migration.fields.includes('StorageValue')) {
+			storage_type = `storage_value::new(b"${migration.schemaName}", _ctx)`;
+		} else if (migration.fields.includes('StorageMap')) {
+			storage_type = `storage_map::new(b"${migration.schemaName}", _ctx)`;
+		} else if (migration.fields.includes('StorageDoubleMap')) {
+			storage_type = `storage_double_map::new(b"${migration.schemaName}", _ctx)`;
+		}
+		return `storage::add_field<${migration.fields}>(&mut _schema.id, b"${migration.schemaName}", ${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 {
-	return input
-		.split('_')
-		.map((word, index) => {
-			return index === 0
-				? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-				: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-		})
-		.join('');
-}
-
-function getLastSegment(input: string): string {
-	const segments = input.split('::');
-	return segments.length > 0 ? segments[segments.length - 1] : '';
 }
 
 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 +102,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 +113,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);
@@ -142,7 +123,7 @@ in your contracts directory to use the default sui private key.`,
 	const dubhe = new Dubhe({
 		secretKey: privateKeyFormat,
 	});
-	const keypair = dubhe.getKeypair();
+	const keypair = dubhe.getSigner();
 
 	const client = new SuiClient({
 		url: getFullnodeUrl(network),
@@ -151,38 +132,24 @@ in your contracts directory to use the default sui private key.`,
 	let oldVersion = Number(await getVersion(projectPath, network));
 	let oldPackageId = await getOldPackageId(projectPath, network);
 	let upgradeCap = await getUpgradeCap(projectPath, network);
+	let schemaId = await getSchemaId(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)) {
-				let migrate: Migration = { schemaName: '', fields: [] };
-				let fields: Field[] = [];
-				let isMigration = false;
-				for (const key in config.schemas[schemaKey].structure) {
-					if (!(key in schema.structure)) {
-						isMigration = true;
-						fields.push({
-							name: key,
-							type: config.schemas[schemaKey].structure[key],
-						});
-						schema.structure[key] = config.schemas[schemaKey].structure[key];
-					}
-				}
-				if (isMigration) {
-					migrate.schemaName = schemaKey;
-					migrate.fields = fields;
-					pendingMigration.push(migrate);
-				}
-			}
-		});
-	}
-
+	Object.entries(config.schemas).forEach(([key, value]) => {
+		if (!schemas.hasOwnProperty(key)) {
+			pendingMigration.push({ schemaName: key, fields: value });
+		}
+	});
 
-	pendingMigration.forEach((migration) => {
+	pendingMigration.forEach(migration => {
 		console.log(`\n🚀 Starting Migration for ${migration.schemaName}...`);
 		console.log('📋 Migration Fields:', migration.fields);
 	});
@@ -200,8 +167,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,32 +217,45 @@ 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(
 			name,
 			network,
 			newPackageId,
+            schemaId,
 			upgradeCap,
 			oldVersion + 1,
-			schemas,
+			config.schemas
 		);
-
 	} catch (error: any) {
 		console.log(chalk.red('Upgrade failed!'));
 		console.error(error.message);

package/src/utils/utils.ts

@@ -7,19 +7,14 @@ import * as fs from 'fs';
 import chalk from 'chalk';
 import { spawn } from 'child_process';
 
-export type schema = {
-	name: string;
-	objectId: string;
-	structure: Record<string, string>;
-};
-
 export type DeploymentJsonType = {
 	projectName: string;
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
 	packageId: string;
+	schemaId: string;
 	upgradeCap: string;
 	version: number;
-	schemas: schema[];
+	schemas: Record<string, string>;
 };
 
 export function validatePrivateKey(privateKey: string): false | string {
@@ -81,7 +76,7 @@ async function getDeploymentJson(projectPath: string, network: string) {
 export async function getOnchainSchemas(
 	projectPath: string,
 	network: string
-): Promise<schema[]> {
+): Promise<Record<string, string>> {
 	const deployment = await getDeploymentJson(projectPath, network);
 	return deployment.schemas;
 }
@@ -110,25 +105,12 @@ export async function getOldPackageId(
 	return deployment.packageId;
 }
 
-export async function getObjectId(
+export async function getSchemaId(
 	projectPath: string,
-	network: string,
-	schemaName: string
+	network: string
 ): Promise<string> {
 	const deployment = await getDeploymentJson(projectPath, network);
-	const schema = deployment.schemas.find(schema =>
-		schema.name
-			.toLowerCase()
-			.endsWith(`::${schemaName.toLowerCase()}_schema::${schemaName}`)
-	);
-
-	if (!schema?.objectId) {
-		throw new Error(
-			`Schema '${schemaName}' not found in deployment history`
-		);
-	}
-
-	return schema.objectId;
+	return deployment.schemaId;
 }
 
 export async function getUpgradeCap(
@@ -139,28 +121,20 @@ export async function getUpgradeCap(
 	return deployment.upgradeCap;
 }
 
-export async function getObjectIdBySchemaName(
-	projectPath: string,
-	network: string,
-	schemaName: string
-): Promise<string | undefined> {
-	const deployment = await getDeploymentJson(projectPath, network);
-	return deployment.schemas.find(schema => schema.name.includes(schemaName))
-		?.objectId;
-}
-
 export function saveContractData(
 	projectName: string,
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
 	packageId: string,
+	schemaId: string,
 	upgradeCap: string,
 	version: number,
-	schemas: schema[]
+	schemas: Record<string, string>
 ) {
 	const DeploymentData: DeploymentJsonType = {
 		projectName,
 		network,
 		packageId,
+		schemaId,
 		schemas,
 		upgradeCap,
 		version,
@@ -203,7 +177,7 @@ function getDubheDependency(
 	}
 }
 
-export function updateDubheDependency(
+export async function updateDubheDependency(
 	filePath: string,
 	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {