@0xobelisk/sui-common 0.5.20 → 0.5.22

package/src/codegen/utils/renderMove/generateSchema.ts

@@ -20,34 +20,34 @@ export function capitalizeAndRemoveUnderscores(input: string): string {
 
 export function renderSetAttrsFunc(
 	schemaName: string,
-	fields: BaseType | Record<string, BaseType>
+	fields: BaseType | Record<string, BaseType>,
 ): string {
 	return Object.entries(fields)
 		.map(
 			([key, type]) =>
 				`public(package) fun set_${key}(self: &mut ${schemaName}, ${key}: ${type}) {
                         self.${key} = ${key};
-                    }`
+                    }`,
 		)
 		.join('\n');
 }
 
 export function renderSetFunc(
 	schemaName: string,
-	fields: Record<string, string>
+	fields: Record<string, string>,
 ): string {
 	return `public(package) fun set(self: &mut ${schemaName}, ${getStructAttrsWithType(
-		fields
+		fields,
 	)}) {
             ${Object.entries(fields)
-				.map(([fieldName]) => `self.${fieldName} = ${fieldName};`)
-				.join('\n')}
+		.map(([fieldName]) => `self.${fieldName} = ${fieldName};`)
+		.join('\n')}
             }`;
 }
 
 export function renderGetAllFunc(
 	schemaName: string,
-	fields: Record<string, string>
+	fields: Record<string, string>,
 ): string {
 	return `public fun get(self: &${schemaName}): ${getStructTypes(fields)} {
         (${getStructAttrsQuery(fields)})
@@ -56,16 +56,16 @@ export function renderGetAllFunc(
 
 export function renderGetAttrsFunc(
 	schemaName: string,
-	fields: BaseType | Record<string, BaseType>
+	fields: BaseType | Record<string, BaseType>,
 ): string {
 	return Object.entries(fields)
 		.map(
 			([
-				key,
-				type,
-			]) => `public fun get_${key}(self: &${schemaName}): ${type} {
+				 key,
+				 type,
+			 ]) => `public fun get_${key}(self: &${schemaName}): ${type} {
                                     self.${key}
-                                }`
+                                }`,
 		)
 		.join('\n');
 }
@@ -80,7 +80,7 @@ function convertToSnakeCase(input: string): string {
 export async function generateSchemaData(
 	projectName: string,
 	schemas: Record<string, SchemaType>,
-	path: string
+	path: string,
 ) {
 	console.log('\n📦 Starting Schema Data Generation...');
 	for (const schemaName in schemas) {
@@ -91,7 +91,7 @@ export async function generateSchemaData(
 				console.log(
 					`     └─ Generating ${item.name} ${
 						Array.isArray(item.fields) ? '(enum)' : '(struct)'
-					}`
+					}`,
 				);
 				let code = '';
 
@@ -101,42 +101,42 @@ export async function generateSchemaData(
 
 				if (Array.isArray(item.fields)) {
 					code = `module ${projectName}::${schemaName}_${convertToSnakeCase(
-						item.name
+						item.name,
 					)} {
                         public enum ${item.name} has copy, drop , store {
                                 ${item.fields}
                         }
                         
                         ${item.fields
-							.map((field: string) => {
-								return `public fun new_${convertToSnakeCase(
-									field
-								)}(): ${item.name} {
+						.map((field: string) => {
+							return `public fun new_${convertToSnakeCase(
+								field,
+							)}(): ${item.name} {
                                 ${item.name}::${field}
                             }`;
-							})
-							.join('')}`;
+						})
+						.join('')}`;
 				} else {
 					code = `module ${projectName}::${schemaName}_${convertToSnakeCase(
-						item.name
+						item.name,
 					)} {
                             use std::ascii::String;
                             ${enumNames
-								.map(
-									name =>
-										`use ${projectName}::${schemaName}_${convertToSnakeCase(
-											name
-										)}::${name};`
-								)
-								.join('\n')}
+						.map(
+							name =>
+								`use ${projectName}::${schemaName}_${convertToSnakeCase(
+									name,
+								)}::${name};`,
+						)
+						.join('\n')}
 
                            public struct ${item.name} has copy, drop , store {
                                 ${getStructAttrsWithType(item.fields)}
                            }
                         
                            public fun new(${getStructAttrsWithType(
-								item.fields
-							)}): ${item.name} {
+						item.fields,
+					)}): ${item.name} {
                                ${item.name} {
                                    ${getStructAttrs(item.fields)}
                                }
@@ -152,9 +152,9 @@ export async function generateSchemaData(
 				await formatAndWriteMove(
 					code,
 					`${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}_${convertToSnakeCase(
-						item.name
+						item.name,
 					)}.move`,
-					'formatAndWriteMove'
+					'formatAndWriteMove',
 				);
 			}
 		}
@@ -165,13 +165,13 @@ export async function generateSchemaData(
 function generateImport(
 	projectName: string,
 	schemaName: string,
-	schema: SchemaType
+	schema: SchemaType,
 ) {
 	if (schema.data) {
 		return schema.data
 			.map(item => {
 				return `use ${projectName}::${schemaName}_${convertToSnakeCase(
-					item.name
+					item.name,
 				)}::${item.name};`;
 			})
 			.join('\n');
@@ -184,18 +184,17 @@ export async function generateSchemaStructure(
 	projectName: string,
 	schemas: Record<string, SchemaType>,
 	path: string,
-	migration_enabled: boolean
 ) {
 	console.log('\n🔨 Starting Schema Structure Generation...');
 	for (const schemaName in schemas) {
 		console.log(`  ├─ Generating schema: ${schemaName}`);
 		console.log(
-			`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`
+			`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
 		);
 		console.log(
 			`     └─ Structure fields: ${
 				Object.keys(schemas[schemaName].structure).length
-			}`
+			}`,
 		);
 		const schema = schemas[schemaName];
 		const schemaMoudle = `module ${projectName}::${schemaName}_schema {
@@ -214,92 +213,91 @@ export async function generateSchemaStructure(
                     ${generateImport(projectName, schemaName, schema)}
 
                     public struct ${capitalizeAndRemoveUnderscores(
-						schemaName
-					)} has key, store {
+			schemaName,
+		)} has key, store {
                         id: UID
 											} 
                     
                      ${Object.entries(schema.structure)
-							.map(([key, value]) => {
-								return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
-									schemaName
-								)}) : &${value} {
+			.map(([key, value]) => {
+				return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
+					schemaName,
+				)}) : &${value} {
                         storage_migrate::borrow_field(&self.id, b"${key}")
                     }
                     
                     public(package) fun borrow_mut_${key}(self: &mut ${capitalizeAndRemoveUnderscores(
-						schemaName
-					)}): &mut ${value} {
+					schemaName,
+				)}): &mut ${value} {
                         storage_migrate::borrow_mut_field(&mut self.id, b"${key}")
                     }
                     `;
-							})
-							.join('')} 
+			})
+			.join('')} 
                      
            
                     public(package) fun create(ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(
-						schemaName
-					)} {
+			schemaName,
+		)} {
                       let mut id = object::new(ctx);
                       ${Object.entries(schema.structure)
-											.map(([key, value]) => {
-												let storage_type = '';
-												if (value.includes('StorageValue')) {
-													storage_type = `storage_value::new()`;
-												} else if (value.includes('StorageMap')) {
-													storage_type = `storage_map::new()`;
-												} else if (
-													value.includes('StorageDoubleMap')
-												) {
-													storage_type = `storage_double_map::new()`;
-												}
-												return `storage_migrate::add_field<${value}>(&mut id, b"${key}", ${storage_type});`
-											})
-											.join('')}
+			.map(([key, value]) => {
+				let storage_type = '';
+				if (value.includes('StorageValue')) {
+					storage_type = `storage_value::new()`;
+				} else if (value.includes('StorageMap')) {
+					storage_type = `storage_map::new()`;
+				} else if (
+					value.includes('StorageDoubleMap')
+				) {
+					storage_type = `storage_double_map::new()`;
+				}
+				return `storage_migrate::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
+			})
+			.join('')}
                       
                       ${capitalizeAndRemoveUnderscores(schemaName)} { id }
                     }
                     
-                    ${ migration_enabled ? `public fun migrate(_${schemaName}: &mut ${capitalizeAndRemoveUnderscores(schemaName)}, _cap: &UpgradeCap) {  }`
-					                : ""
-										}
+                    public fun migrate(_${schemaName}: &mut ${capitalizeAndRemoveUnderscores(schemaName)}, _cap: &UpgradeCap) {  }
+
                     
               
                  // ======================================== View Functions ========================================
                     ${Object.entries(schema.structure)
 			.map(([key, value]) => {
 				// @ts-ignore
-				let all_types = value.match(/<(.+)>/)[1].split(',').map(type => type.trim())
-				let para_key: string[] = []
-				let para_value = ""
-				let borrow_key = ""
-				let extra_code = ""
+				let all_types = value.match(/<(.+)>/)[1].split(',').map(type => type.trim());
+				let para_key: string[] = [];
+				let para_value = '';
+				let borrow_key = '';
+				let extra_code = '';
 				if (value.includes('StorageValue')) {
-					para_key = []
-					para_value = `${all_types[0]}`
-					borrow_key = 'try_get()'
+					para_key = [];
+					para_value = `${all_types[0]}`;
+					borrow_key = 'try_get()';
 				} else if (value.includes('StorageMap')) {
-					para_key = [`key: ${all_types[0]}`]
-					para_value = `${all_types[1]}`
-					borrow_key = 'try_get(key)'
+					para_key = [`key: ${all_types[0]}`];
+					para_value = `${all_types[1]}`;
+					borrow_key = 'try_get(key)';
 					extra_code = `public fun get_${key}_keys(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[0]}> {
 									self.borrow_${key}().keys()
 								}
 							
 							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[1]}> {
 									self.borrow_${key}().values()
-								}`
+								}`;
 				} else if (value.includes('StorageDoubleMap')) {
-					para_key = [`key1: ${all_types[0]}`, `key2: ${all_types[1]}`]
-					para_value = `${all_types[2]}`
-					borrow_key = 'try_get(key1, key2)'
+					para_key = [`key1: ${all_types[0]}`, `key2: ${all_types[1]}`];
+					para_value = `${all_types[2]}`;
+					borrow_key = 'try_get(key1, key2)';
 					extra_code = `public fun get_${key}_keys(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : (vector<${all_types[0]}>, vector<${all_types[1]}>) {
 									self.borrow_${key}().keys()
 								}
 							
 							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[2]}> {
 									self.borrow_${key}().values()
-								}`
+								}`;
 				}
 				return `public fun get_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}, ${para_key}) : Option<${para_value}> {
 									self.borrow_${key}().${borrow_key}
@@ -314,7 +312,7 @@ export async function generateSchemaStructure(
 		await formatAndWriteMove(
 			schemaMoudle,
 			`${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
-			'formatAndWriteMove'
+			'formatAndWriteMove',
 		);
 	}
 	console.log('✅ Schema Structure Generation Complete\n');

package/src/codegen/utils/renderMove/generateScript.ts

@@ -9,12 +9,12 @@ export async function generateDeployHook(
 ) {
 	console.log('\n📝 Starting Deploy Hook Generation...');
 	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`
+		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`
 	);
 
 	if (
 		!existsSync(
-			`${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`
+			`${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`
 		)
 	) {
 		let code = `module ${config.name}::deploy_hook {
@@ -23,6 +23,8 @@ export async function generateDeployHook(
     use ${config.name}::schema_hub::SchemaHub;
     use std::ascii::string;
     use sui::clock::Clock;
+    use sui::sui::SUI;
+    use sui::coin::Coin;
     use sui::package::UpgradeCap;
     use sui::transfer::public_share_object;
     ${Object.keys(config.schemas).map(schemaName => {
@@ -31,6 +33,8 @@ export async function generateDeployHook(
       #[test_only]
       use sui::clock;
       #[test_only]
+      use sui::coin;
+      #[test_only]
       use sui::test_scenario;
       #[test_only]
       use sui::package;
@@ -41,9 +45,9 @@ export async function generateDeployHook(
       #[test_only]
       use sui::test_scenario::Scenario;
 
-    public entry fun run(schema_hub: &mut SchemaHub, dapps: &mut Dapps, cap: &UpgradeCap, clock: &Clock, ctx: &mut TxContext) {
+    public entry fun run(schema_hub: &mut SchemaHub, dapps: &mut Dapps, cap: &UpgradeCap, clock: &Clock, coin: Coin<SUI>, ctx: &mut TxContext) {
         // Register the dapp to dubhe.
-        dapps_system::register(dapps,cap,string(b"${config.name}"),string(b"${config.description}"),clock,ctx);
+        dapps_system::register(dapps,cap,string(b"${config.name}"),string(b"${config.description}"),clock,coin,ctx);
         // Create schemas
         ${Object.keys(config.schemas).map(schemaName => {
 				return `let ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
@@ -75,7 +79,8 @@ export async function generateDeployHook(
     let ctx = test_scenario::ctx(&mut scenario);
     let clock = clock::create_for_testing(ctx);
     let upgrade_cap = package::test_publish(@0x42.to_id(), ctx);
-    run(&mut schema_hub, &mut dapps, &upgrade_cap, &clock, ctx);
+    let coin  = coin::mint_for_testing<SUI>(1_000_000_000, ctx);
+    run(&mut schema_hub, &mut dapps, &upgrade_cap, &clock, coin, ctx);
 
     clock::destroy_for_testing(clock);
     upgrade_cap.make_immutable();
@@ -86,7 +91,7 @@ export async function generateDeployHook(
 `;
 		await formatAndWriteMove(
 			code,
-			`${srcPrefix}/contracts/${config.name}/sources/script/deploy_hook.move`,
+			`${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`,
 			'formatAndWriteMove'
 		);
 	}
@@ -96,7 +101,7 @@ export async function generateDeployHook(
 export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
 	if (
 		!existsSync(
-			`${srcPrefix}/contracts/${config.name}/sources/script/migrate.move`
+			`${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`
 		)
 	) {
 		let code = `module ${config.name}::migrate {
@@ -109,7 +114,7 @@ export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
 `;
 		await formatAndWriteMove(
 			code,
-			`${srcPrefix}/contracts/${config.name}/sources/script/migrate.move`,
+			`${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`,
 			'formatAndWriteMove'
 		);
 	}

package/src/codegen/utils/renderMove/generateToml.ts

@@ -13,16 +13,15 @@ export async function generateToml(
 
 	let code = `[package]
 name = "${config.name}"
-version = "0.0.1"
-edition = "2024.beta"
+version = "1.0.0"
+edition = "2024"
 
 [dependencies]
-Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.36.2" }
-Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "release-dubhe-v1.0.0-rc1" }
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.38.3" }
+Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "dubhe-testnet-v1.0.0" }
 
 [addresses]
 sui = "0x2"
-dubhe = "${frameworkId}"
 ${config.name} = "0x0"
 `;
 	await formatAndWriteMove(

package/src/codegen/utils/renderMove/schemaGen.ts

@@ -5,72 +5,71 @@ import { generateToml } from './generateToml';
 import { generateSchemaData, generateSchemaStructure } from './generateSchema';
 import { generateDeployHook, generateMigrate } from './generateScript';
 import { generateDappKey } from './generateDappKey';
-import {generateSchemaEvent} from "./generateEvent";
+import { generateSchemaEvent } from './generateEvent';
 import { generateSystem } from './generateSystem';
 import { generateSchemaHub } from './generateSchemaHub';
 
 function matchFrameworkId(
-	network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+    network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
 ): string {
-	switch (network) {
-		case 'testnet':
-			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-		case 'localnet':
-			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-		default:
-			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-	}
+    switch (network) {
+        case 'testnet':
+            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
+        case 'localnet':
+            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
+        default:
+            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
+    }
 }
 
 export async function schemaGen(
-	config: DubheConfig,
-	srcPrefix?: string,
-	network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-	frameworkId?: string
+    config: DubheConfig,
+    srcPrefix?: string,
+    network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+    frameworkId?: string,
 ) {
-	console.log('\n🚀 Starting Schema Generation Process...');
-	console.log('📋 Project Configuration:');
-	console.log(`  ├─ Name: ${config.name}`);
-	console.log(
-		`  ├─ Description: ${config.description || 'No description provided'}`
-	);
-	console.log(`  ├─ Network: ${network || 'testnet'}`);
-	console.log(
-		`  └─ Framework ID: ${
-			frameworkId || matchFrameworkId(network ?? 'testnet')
-		}\n`
-	);
+    console.log('\n🚀 Starting Schema Generation Process...');
+    console.log('📋 Project Configuration:');
+    console.log(`  ├─ Name: ${config.name}`);
+    console.log(
+        `  ├─ Description: ${config.description || 'No description provided'}`,
+    );
+    console.log(`  ├─ Network: ${network || 'testnet'}`);
+    console.log(
+        `  └─ Framework ID: ${
+            frameworkId || matchFrameworkId(network ?? 'testnet')
+        }\n`,
+    );
 
-	const path = srcPrefix ?? process.cwd();
+    const path = srcPrefix ?? process.cwd();
 
-	frameworkId = frameworkId || matchFrameworkId(network ?? 'testnet');
+    frameworkId = frameworkId || matchFrameworkId(network ?? 'testnet');
 
-	if (existsSync(`${path}/contracts/${config.name}`)) {
-		deleteFolderRecursive(
-			`${path}/contracts/${config.name}/sources/codegen`
-		);
-	}
+    if (existsSync(`${path}/contracts/${config.name}`)) {
+        deleteFolderRecursive(
+            `${path}/contracts/${config.name}/sources/codegen`,
+        );
+    }
 
-	if (!existsSync(`${path}/contracts/${config.name}/Move.toml`)) {
-		await generateToml(config, path, frameworkId);
-	}
+    if (!existsSync(`${path}/contracts/${config.name}/Move.toml`)) {
+        await generateToml(config, path, frameworkId);
+    }
 
-	if (
-		!existsSync(
-			`${path}/contracts/${config.name}/sources/script/deploy_hook.move`
-		)
-	) {
-		await generateDeployHook(config, path);
-	}
+    if (
+        !existsSync(
+            `${path}/contracts/${config.name}/sources/script/deploy_hook.move`,
+        )
+    ) {
+        await generateDeployHook(config, path);
+    }
 
-	await generateSchemaData(config.name, config.schemas, path);
-	await generateSchemaStructure(config.name, config.schemas, path, config.migration_enabled);
-	await generateSchemaEvent(config.name, config.schemas, path);
-	await generateDappKey(config, path);
-	await generateSchemaHub(config, path);
-	await generateSystem(config, path);
-	if (config.migration_enabled) {
-		await generateMigrate(config, path);
-	}
-	console.log('✅ Schema Generation Process Complete!\n');
+    await generateSchemaData(config.name, config.schemas, path);
+    await generateSchemaStructure(config.name, config.schemas, path);
+    await generateSchemaEvent(config.name, config.schemas, path);
+    await generateDappKey(config, path);
+    await generateSchemaHub(config, path);
+    await generateSystem(config, path);
+    await generateMigrate(config, path);
+
+    console.log('✅ Schema Generation Process Complete!\n');
 }