@0xobelisk/sui-common 0.5.22 → 0.5.24

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

@@ -3,6 +3,20 @@ import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
 import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
+import { readFileSync } from 'fs';
+
+export function extractLogicAndAuthorizationContent(filePath: string): string {
+	const fileContent = readFileSync(filePath, 'utf-8');
+	const logicAndAuthRegex = /\/\/ Logic that needs to be automated once the contract is deployed\s*\{([\s\S]*?)\}\s*;\s*\/\/ Authorize schemas and public share objects/;
+	const match = fileContent.match(logicAndAuthRegex);
+
+	if (match) {
+		return match[1].trim();
+	} else {
+		throw new Error('Logic and authorization block not found in the file.');
+	}
+}
+
 export async function generateDeployHook(
 	config: DubheConfig,
 	srcPrefix: string
@@ -12,89 +26,71 @@ export async function generateDeployHook(
 		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`
 	);
 
-	if (
-		!existsSync(
-			`${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`
-		)
-	) {
-		let code = `module ${config.name}::deploy_hook {
-    use dubhe::dapps_schema::Dapps;
-    use dubhe::dapps_system;
-    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 => {
-			return `use ${config.name}::${schemaName}_schema::${capitalizeAndRemoveUnderscores(schemaName)};`}).join('\n')
-		}
-      #[test_only]
-      use sui::clock;
-      #[test_only]
-      use sui::coin;
-      #[test_only]
-      use sui::test_scenario;
-      #[test_only]
-      use sui::package;
-      #[test_only]
-      use ${config.name}::schema_hub;      
-      #[test_only]
-      use dubhe::dapps_schema;
-      #[test_only]
-      use sui::test_scenario::Scenario;
-
-    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,coin,ctx);
-        // Create schemas
-        ${Object.keys(config.schemas).map(schemaName => {
-				return `let ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
-			}).join('\n')}
-        // Logic that needs to be automated once the contract is deployed
-				${`\n`}
-				${`\n`}
-				
-        // Authorize schemas and public share objects
-        ${Object.keys(config.schemas).map(schemaName => {
-				 return `
-				 schema_hub.authorize_schema<${capitalizeAndRemoveUnderscores(schemaName)}>();
-				 public_share_object(${schemaName});
-				 `;
+	const schemas = Object.keys(config.schemas).map(schemaName => { return `_${schemaName}: &mut ${capitalizeAndRemoveUnderscores(schemaName)}`}).join(',')
+	const importSchemas = Object.keys(config.schemas).map(schemaName => { return `use ${config.name}::${schemaName}_schema::${capitalizeAndRemoveUnderscores(schemaName)};`}).join('\n')
+	const path = `${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`;
+	let code = '';
+	if (!existsSync(path)) {
+		code = `module ${config.name}::deploy_hook {
+			use std::ascii::string;
+			use sui::clock::Clock;
+			use ${config.name}::dapp_system;
+		  ${importSchemas}
+		  public entry fun run(clock: &Clock, ctx: &mut TxContext) {
+		  // Create a dapp.
+    	  let mut dapp = dapp_system::create(string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
+    
+		 // Create schemas
+			${Object.keys(config.schemas).map(schemaName => {
+				return `let mut ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
 			}).join('\n')}
-    }
-
-    #[test_only]
-  public fun deploy_hook_for_testing(): (Scenario, SchemaHub, Dapps) {
-    let mut scenario = test_scenario::begin(@0xA);
-    {
-          let ctx = test_scenario::ctx(&mut scenario);
-          dapps_schema::init_dapps_for_testing(ctx);
-          schema_hub::init_schema_hub_for_testing(ctx);
-          test_scenario::next_tx(&mut scenario,@0xA);
-      };
-    let mut dapps = test_scenario::take_shared<Dapps>(&scenario);
-    let mut schema_hub = test_scenario::take_shared<SchemaHub>(&scenario);
-    let ctx = test_scenario::ctx(&mut scenario);
-    let clock = clock::create_for_testing(ctx);
-    let upgrade_cap = package::test_publish(@0x42.to_id(), 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();
-    test_scenario::next_tx(&mut scenario,@0xA);
-    (scenario, schema_hub, dapps)
-  }
-}
-`;
-		await formatAndWriteMove(
-			code,
-			`${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`,
-			'formatAndWriteMove'
-		);
+			// Logic that needs to be automated once the contract is deployed
+			{
+			};
+			// Authorize schemas and public share objects
+			${Object.keys(config.schemas).map(schemaName => {
+					return `
+					 dapp.add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(${schemaName}, ctx);
+					 `;
+				}).join('\n')}
+			 sui::transfer::public_share_object(dapp);
+		  }
+}` } else {
+		const content = extractLogicAndAuthorizationContent(path);
+		code = `module ${config.name}::deploy_hook {
+			use std::ascii::string;
+			use sui::clock::Clock;
+			use merak::dapp_system;
+		  ${importSchemas}
+		  public entry fun run(clock: &Clock, ctx: &mut TxContext) {
+		  // Create a dapp.
+    	  let mut dapp = dapp_system::create(string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
+    
+		 // Create schemas
+			${Object.keys(config.schemas).map(schemaName => {
+			return `let mut ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
+		}).join('\n')}
+			// Logic that needs to be automated once the contract is deployed
+			
+			{
+			${content}
+			};
+			
+			// Authorize schemas and public share objects
+			${Object.keys(config.schemas).map(schemaName => {
+			return `
+					 dapp.add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(${schemaName}, ctx);
+					 `;
+		}).join('\n')}
+			 sui::transfer::public_share_object(dapp);
+		  }
+}`
 	}
+	await formatAndWriteMove(
+		code,
+		path,
+		'formatAndWriteMove'
+	);
 	console.log('✅ Deploy Hook Generation Complete\n');
 }
 
@@ -105,7 +101,7 @@ export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
 		)
 	) {
 		let code = `module ${config.name}::migrate {
-    const ON_CHAIN_VERSION: u32 = 0;
+    const ON_CHAIN_VERSION: u32 = 1;
 
     public fun on_chain_version(): u32 {
         ON_CHAIN_VERSION

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

@@ -4,7 +4,6 @@ import { formatAndWriteMove } from '../formatAndWrite';
 export async function generateToml(
 	config: DubheConfig,
 	srcPrefix: string,
-	frameworkId: string
 ) {
 	console.log('\n📄 Starting Move.toml Generation...');
 	console.log(
@@ -18,7 +17,7 @@ edition = "2024"
 
 [dependencies]
 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" }
+Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "dubhe-testnet-v1.1.0" }
 
 [addresses]
 sui = "0x2"

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

@@ -8,25 +8,14 @@ import { generateDappKey } from './generateDappKey';
 import { generateSchemaEvent } from './generateEvent';
 import { generateSystem } from './generateSystem';
 import { generateSchemaHub } from './generateSchemaHub';
-
-function matchFrameworkId(
-    network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-): string {
-    switch (network) {
-        case 'testnet':
-            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-        case 'localnet':
-            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-        default:
-            return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
-    }
-}
+import { generateSchemaError } from './generateError';
+import {generateDefaultSchema} from "./generateDefaultSchema";
+import {generateInit} from "./generateInit";
 
 export async function schemaGen(
     config: DubheConfig,
     srcPrefix?: string,
-    network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-    frameworkId?: string,
+    network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
 ) {
     console.log('\n🚀 Starting Schema Generation Process...');
     console.log('📋 Project Configuration:');
@@ -35,16 +24,9 @@ export async function schemaGen(
         `  ├─ 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();
 
-    frameworkId = frameworkId || matchFrameworkId(network ?? 'testnet');
-
     if (existsSync(`${path}/contracts/${config.name}`)) {
         deleteFolderRecursive(
             `${path}/contracts/${config.name}/sources/codegen`,
@@ -52,7 +34,7 @@ export async function schemaGen(
     }
 
     if (!existsSync(`${path}/contracts/${config.name}/Move.toml`)) {
-        await generateToml(config, path, frameworkId);
+        await generateToml(config, path);
     }
 
     if (
@@ -66,8 +48,10 @@ export async function schemaGen(
     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 generateSchemaError(config.name, config.schemas, path);
+
+    await generateDefaultSchema(config, path);
+    await generateInit(config, path);
     await generateSystem(config, path);
     await generateMigrate(config, path);