@0xobelisk/sui-common 0.5.23 → 0.5.25

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

@@ -0,0 +1,327 @@
+import { DubheConfig } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
+import { existsSync } from 'fs';
+import { capitalizeAndRemoveUnderscores } from './generateSchema';
+
+export async function generateDefaultSchema(
+	config: DubheConfig,
+	srcPrefix: string
+) {
+	await generateDappSchemaMetadata(config, srcPrefix);
+	await generateDappSchema(config, srcPrefix);
+	await generateDappSystem(config, srcPrefix);
+}
+
+async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string) {
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/metadata.move`
+	if (!existsSync(path)) {
+		let code = `module ${config.name}::dapp_metadata {
+    use std::ascii::String;
+
+    public struct DappMetadata has drop, copy, store {
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        created_at: u64,
+        partners: vector<String>,
+    }
+
+    public fun new(
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        created_at: u64,
+        partners: vector<String>,
+    ): DappMetadata {
+        DappMetadata {
+            name,
+            description,
+            icon_url,
+            website_url,
+            created_at,
+            partners,
+        }
+    }
+
+    public fun set(
+        self: &mut DappMetadata,
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        created_at: u64,
+        partners: vector<String>,
+    ) {
+        self.name = name;
+        self.description = description;
+        self.icon_url = icon_url;
+        self.website_url = website_url;
+        self.created_at = created_at;
+        self.partners = partners;
+    }
+
+    public fun set_name(self: &mut DappMetadata, name: String) {
+        self.name = name;
+    }
+
+    public fun set_description(self: &mut DappMetadata, description: String) {
+        self.description = description;
+    }
+
+    public fun set_icon_url(self: &mut DappMetadata, icon_url: String) {
+        self.icon_url = icon_url;
+    }
+
+    public fun set_website_url(self: &mut DappMetadata, website_url: String) {
+        self.website_url = website_url;
+    }
+
+    public fun set_created_at(self: &mut DappMetadata, created_at: u64) {
+        self.created_at = created_at;
+    }
+
+    public fun set_partners(self: &mut DappMetadata, partners: vector<String>) {
+        self.partners = partners;
+    }
+
+    public fun get_name(self: DappMetadata): String {
+        self.name
+    }
+
+    public fun get_description(self: DappMetadata): String {
+        self.description
+    }
+
+    public fun get_icon_url(self: DappMetadata): String {
+        self.icon_url
+    }
+
+    public fun get_website_url(self: DappMetadata): String {
+        self.website_url
+    }
+
+    public fun get_created_at(self: DappMetadata): u64 {
+        self.created_at
+    }
+
+    public fun get_partners(self: DappMetadata): vector<String> {
+        self.partners
+    }
+
+}
+`;
+		await formatAndWriteMove(
+			code,
+			path,
+			'formatAndWriteMove'
+		);
+	}
+}
+
+
+async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/schema.move`
+	if (!existsSync(path)) {
+		let code = `module ${config.name}::dapp_schema {
+    use ${config.name}::dapp_metadata::DappMetadata;
+    use dubhe::storage_value;
+    use dubhe::storage_value::StorageValue;
+    use dubhe::storage_migration;
+    use sui::transfer::public_share_object;
+    use dubhe::type_info;
+
+    public struct Dapp has key, store { id: UID }
+
+    public fun borrow_admin(self: &Dapp): &StorageValue<address> {
+        storage_migration::borrow_field(&self.id, b"admin")
+    }
+
+    public(package) fun borrow_mut_admin(self: &mut Dapp): &mut StorageValue<address> {
+        storage_migration::borrow_mut_field(&mut self.id, b"admin")
+    }
+
+    public fun borrow_package_id(self: &Dapp): &StorageValue<address> {
+        storage_migration::borrow_field(&self.id, b"package_id")
+    }
+
+    public(package) fun borrow_mut_package_id(self: &mut Dapp): &mut StorageValue<address> {
+        storage_migration::borrow_mut_field(&mut self.id, b"package_id")
+    }
+
+    public fun borrow_version(self: &Dapp): &StorageValue<u32> {
+        storage_migration::borrow_field(&self.id, b"version")
+    }
+
+    public(package) fun borrow_mut_version(self: &mut Dapp): &mut StorageValue<u32> {
+        storage_migration::borrow_mut_field(&mut self.id, b"version")
+    }
+
+    public fun borrow_metadata(self: &Dapp): &StorageValue<DappMetadata> {
+        storage_migration::borrow_field(&self.id, b"metadata")
+    }
+
+    public(package) fun borrow_mut_metadata(self: &mut Dapp): &mut StorageValue<DappMetadata> {
+        storage_migration::borrow_mut_field(&mut self.id, b"metadata")
+    }
+
+    public fun borrow_schemas(self: &Dapp): &StorageValue<vector<address>> {
+        storage_migration::borrow_field(&self.id, b"schemas")
+    }
+
+    public(package) fun borrow_mut_schemas(self: &mut Dapp): &mut StorageValue<vector<address>> {
+        storage_migration::borrow_mut_field(&mut self.id, b"schemas")
+    }
+
+    public fun borrow_safe_mode(self: &Dapp): &StorageValue<bool> {
+        storage_migration::borrow_field(&self.id, b"safe_mode")
+    }
+
+    public(package) fun borrow_mut_safe_mode(self: &mut Dapp): &mut StorageValue<bool> {
+        storage_migration::borrow_mut_field(&mut self.id, b"safe_mode")
+    }
+
+    public(package) fun create(ctx: &mut TxContext): Dapp {
+        let mut id = object::new(ctx);
+        storage_migration::add_field<StorageValue<address>>(&mut id, b"admin", storage_value::new());
+        storage_migration::add_field<StorageValue<address>>(&mut id, b"package_id", storage_value::new());
+        storage_migration::add_field<StorageValue<u32>>(&mut id, b"version", storage_value::new());
+        storage_migration::add_field<StorageValue<DappMetadata>>(&mut id, b"metadata", storage_value::new());
+        storage_migration::add_field<StorageValue<vector<address>>>(&mut id, b"schemas", storage_value::new());
+        storage_migration::add_field<StorageValue<bool>>(&mut id, b"safe_mode", storage_value::new());
+        Dapp { id }
+    }
+
+    public(package) fun upgrade<DappKey: drop>(dapp: &mut Dapp, ctx: &TxContext) {
+        assert!(dapp.borrow_metadata().contains(), 0);
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+
+        let new_package_id = type_info::current_package_id<DappKey>();
+        dapp.borrow_mut_package_id().set(new_package_id);
+        dapp.borrow_mut_version().mutate!(|version| {
+        *version = *version + 1;
+        });
+    }
+
+    public(package) fun add_schema<Schema: key + store>(dapp: &mut Dapp, schema: Schema, ctx: &TxContext) {
+        assert!(dapp.borrow_metadata().contains(), 0);
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+
+        let schema_id = object::id_address(&schema);
+        dapp.borrow_mut_schemas().borrow_mut().push_back(schema_id);
+        public_share_object(schema);
+    }
+
+    #[test_only]
+    public fun create_dapp_for_testing(ctx: &mut TxContext): Dapp {
+        create(ctx)
+    }
+
+    #[test_only]
+    public fun distroy_dapp_for_testing(dapp: Dapp) {
+       let Dapp { id } = dapp;
+        id.delete();
+    }
+}
+`;
+		await formatAndWriteMove(
+			code,
+			path,
+			'formatAndWriteMove'
+		);
+	}
+}
+
+async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/system.move`
+	if (!existsSync(path)) {
+		let code = `module ${config.name}::dapp_system {
+    use std::ascii::String;
+    use std::ascii;
+    use dubhe::type_info;
+    use sui::clock::Clock;
+    use ${config.name}::dapp_schema;
+    use ${config.name}::dapp_metadata;
+    use ${config.name}::dapp_schema::Dapp;
+
+    public struct DappKey has drop {}
+
+    public(package) fun new(): DappKey {
+        DappKey {  }
+    }
+
+    public(package) fun create(name: String, description: String, clock: &Clock, ctx: &mut TxContext): Dapp {
+        let mut dapp = dapp_schema::create(ctx);
+        assert!(!dapp.borrow_metadata().contains(), 0);
+        dapp.borrow_mut_metadata().set(
+            dapp_metadata::new(
+                name,
+                description,
+                ascii::string(b""),
+                ascii::string(b""),
+                clock.timestamp_ms(),
+                vector[]
+            )
+        );
+        let package_id = type_info::current_package_id<DappKey>();
+        dapp.borrow_mut_package_id().set(package_id);
+        dapp.borrow_mut_admin().set(ctx.sender());
+        dapp.borrow_mut_version().set(1);
+        dapp.borrow_mut_safe_mode().set(false);
+        dapp.borrow_mut_schemas().set(vector[]);
+        dapp
+    }
+
+    public entry fun set_metadata(dapp: &mut Dapp, name: String, description: String, icon_url: String, website_url: String, partners: vector<String>, ctx: &TxContext) {
+        assert!(dapp.borrow_admin().contains(), 0);
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+        let created_at = dapp.borrow_mut_metadata().take().get_created_at();
+        dapp.borrow_mut_metadata().set(
+            dapp_metadata::new(
+                name,
+                description,
+                icon_url,
+                website_url,
+                created_at,
+                partners
+            )
+        );
+    }
+
+    public entry fun transfer_ownership(dapp: &mut Dapp, new_admin: address, ctx: &mut TxContext) {
+        assert!(dapp.borrow_admin().contains(), 0);
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+
+        dapp.borrow_mut_admin().set(new_admin);
+    }
+
+    public entry fun set_safe_mode(dapp: &mut Dapp, safe_mode: bool, ctx: &TxContext) {
+        assert!(dapp.borrow_admin().contains(), 0);
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+
+        dapp.borrow_mut_safe_mode().set(safe_mode);
+    }
+
+    public fun ensure_no_safe_mode(dapp: &Dapp) {
+        assert!(!dapp.borrow_safe_mode().get(), 0);
+    }
+
+    public fun ensure_has_authority(dapp: &Dapp, ctx: &TxContext) {
+        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+    }
+
+    public fun ensure_has_schema<Schema: key + store>(dapp: &Dapp, schema: &Schema) {
+        let schema_id = object::id_address(schema);
+        assert!(dapp.borrow_schemas().get().contains(&schema_id), 0);
+    }
+}
+
+`;
+		await formatAndWriteMove(
+			code,
+			path,
+			'formatAndWriteMove'
+		);
+	}
+}

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

@@ -26,12 +26,13 @@ export async function generateSchemaError(
 			console.log(`  ├─ Processing schema: ${schemaName}`);
 			for (const item of schema.errors) {
 				console.log(
-					`     └─ Generating ${item.name} code: ${item.code}`);
+					`     └─ Generating ${item.name} message: ${item.message}`);
 
 				let	code = `module ${projectName}::${schemaName}_error_${convertToSnakeCase(item.name)} {
-						const ${item.name}: u64 = ${item.code};
-						/// Get the error code.
-            public fun code(): u64 { ${item.name} }
+						#[error]
+						const ${item.name}: vector<u8> = b"${item.message}";
+						/// Get the error message.
+            public fun message(): vector<u8> { ${item.name} }
             /// Abort execution with the given error code.
             public fun emit() { abort ${item.name} }
             /// Require that the given condition is true, otherwise abort with the given error code.

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

@@ -0,0 +1,40 @@
+import { DubheConfig } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
+import { existsSync } from 'fs';
+import { capitalizeAndRemoveUnderscores } from './generateSchema';
+
+export async function generateInit(
+	config: DubheConfig,
+	srcPrefix: string
+) {
+	console.log('\n📝 Starting Init Generation...');
+	console.log(
+		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/tests/init.move`
+	);
+
+		let code = `module ${config.name}::init_test {
+    use ${config.name}::dapp_schema::Dapp;
+    use sui::clock;
+    use sui::test_scenario;
+    use sui::test_scenario::Scenario;
+    
+    public fun deploy_dapp_for_testing(sender: address): (Scenario, Dapp) {
+        let mut scenario = test_scenario::begin(sender);
+        let ctx = test_scenario::ctx(&mut scenario);
+        let clock = clock::create_for_testing(ctx);
+        ${config.name}::deploy_hook::run(&clock, ctx);
+        clock::destroy_for_testing(clock);
+        test_scenario::next_tx(&mut scenario,sender);
+        let dapp = test_scenario::take_shared<Dapp>(&scenario);
+        (scenario, dapp)
+    }
+}
+`;
+		await formatAndWriteMove(
+			code,
+			`${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
+			'formatAndWriteMove'
+		);
+
+	console.log('✅ Deploy Hook Generation Complete\n');
+}

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

@@ -201,15 +201,15 @@ export async function generateSchemaStructure(
                     use std::ascii::String;
                     use std::ascii::string;
                     use sui::package::UpgradeCap;
-                    use std::type_name;
-                    use dubhe::dapps_system;
-                    use dubhe::storage_migrate;
-                    use dubhe::dapps_schema::Dapps;
+                    use std::type_name; 
+                    use dubhe::storage_migration;
                     use dubhe::storage_value::{Self, StorageValue};
                     use dubhe::storage_map::{Self, StorageMap};
                     use dubhe::storage_double_map::{Self, StorageDoubleMap};
-                    use ${projectName}::dapp_key::DappKey;
                     use sui::dynamic_field as df;
+                    use sui::sui::SUI;
+                    use sui::coin::Coin;
+    				use sui::balance::Balance;
                     ${generateImport(projectName, schemaName, schema)}
 
                     public struct ${capitalizeAndRemoveUnderscores(
@@ -223,13 +223,13 @@ export async function generateSchemaStructure(
 				return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
 					schemaName,
 				)}) : &${value} {
-                        storage_migrate::borrow_field(&self.id, b"${key}")
+                        storage_migration::borrow_field(&self.id, b"${key}")
                     }
                     
                     public(package) fun borrow_mut_${key}(self: &mut ${capitalizeAndRemoveUnderscores(
 					schemaName,
 				)}): &mut ${value} {
-                        storage_migrate::borrow_mut_field(&mut self.id, b"${key}")
+                        storage_migration::borrow_mut_field(&mut self.id, b"${key}")
                     }
                     `;
 			})
@@ -252,7 +252,7 @@ export async function generateSchemaStructure(
 				) {
 					storage_type = `storage_double_map::new()`;
 				}
-				return `storage_migrate::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
+				return `storage_migration::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
 			})
 			.join('')}
                       
@@ -275,31 +275,35 @@ export async function generateSchemaStructure(
 				if (value.includes('StorageValue')) {
 					para_key = [];
 					para_value = `${all_types[0]}`;
-					borrow_key = 'try_get()';
+					borrow_key = 'borrow()';
 				} else if (value.includes('StorageMap')) {
 					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]}> {
+					borrow_key = 'borrow(key)';
+					if (!value.includes('Balance') && !value.includes('Coin')) {
+						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)';
-					extra_code = `public fun get_${key}_keys(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : (vector<${all_types[0]}>, vector<${all_types[1]}>) {
+					borrow_key = 'borrow(key1, key2)';
+					if (!value.includes('Balance') && !value.includes('Coin')) {
+						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}> {
+				return `public fun get_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}, ${para_key}) : &${para_value} {
 									self.borrow_${key}().${borrow_key}
 								}
 								` + extra_code;

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 ${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')}
+			// 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"