@0xobelisk/sui-common 0.5.19 → 0.5.21

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

@@ -7,7 +7,7 @@ import {
 	getStructAttrsQuery,
 } from './common';
 
-function capitalizeAndRemoveUnderscores(input: string): string {
+export function capitalizeAndRemoveUnderscores(input: string): string {
 	return input
 		.split('_')
 		.map((word, index) => {
@@ -20,34 +20,34 @@ 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');
@@ -183,128 +183,124 @@ function generateImport(
 export async function generateSchemaStructure(
 	projectName: string,
 	schemas: Record<string, SchemaType>,
-	path: string
+	path: string,
 ) {
 	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 {
                     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 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;
                     ${generateImport(projectName, schemaName, schema)}
 
                     public struct ${capitalizeAndRemoveUnderscores(
-						schemaName
-					)} has key, store {
-                        id: UID,
-                        ${getStructAttrsWithType(schema.structure)}
-                    } 
+			schemaName,
+		)} has key, store {
+                        id: UID
+											} 
                     
                      ${Object.entries(schema.structure)
-							.map(([key, value]) => {
-								return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
-									schemaName
-								)}) : &${value} {
-                        &self.${key}
+			.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} {
-                        &mut self.${key}
+					schemaName,
+				)}): &mut ${value} {
+                        storage_migrate::borrow_mut_field(&mut self.id, b"${key}")
                     }
                     `;
-							})
-							.join('')} 
+			})
+			.join('')} 
                      
            
-                    public fun register(dapps: &mut Dapps, ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(
-						schemaName
-					)} {
-                      let package_id = dapps_system::current_package_id<DappKey>();
-                      assert!(dapps.borrow_metadata().contains_key(package_id), 0);
-                      assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
-                      let schema = type_name::get<${capitalizeAndRemoveUnderscores(
-							schemaName
-						)}>().into_string();
-                      assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
-                      dapps_system::add_schema<${capitalizeAndRemoveUnderscores(
-							schemaName
-						)}>(dapps, package_id, ctx);
-                      ${capitalizeAndRemoveUnderscores(schemaName)} {
-                          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 `${key}: ${storage_type},`;
-								})
-								.join(' ')}
-                        }
+                    public(package) fun create(ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(
+			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('')}
+                      
+                      ${capitalizeAndRemoveUnderscores(schemaName)} { id }
                     }
                     
+                    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.${key}.keys()
+									self.borrow_${key}().keys()
 								}
 							
 							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[1]}> {
-									self.${key}.values()
-								}`
+									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.${key}.keys()
+									self.borrow_${key}().keys()
 								}
 							
 							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[2]}> {
-									self.${key}.values()
-								}`
+									self.borrow_${key}().values()
+								}`;
 				}
 				return `public fun get_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}, ${para_key}) : Option<${para_value}> {
-									self.${key}.${borrow_key}
+									self.borrow_${key}().${borrow_key}
 								}
 								` + extra_code;
 			})
@@ -316,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/generateSchemaHub.ts

@@ -0,0 +1,65 @@
+import { DubheConfig } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
+
+export async function generateSchemaHub(
+	config: DubheConfig,
+	srcPrefix: string
+) {
+	console.log('\n🔑 Starting DappKey Generation...');
+	console.log(
+		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`
+	);
+
+	let code = `module ${config.name}::schema_hub {
+    use sui::transfer::public_share_object;
+    use sui::dynamic_field as df;
+
+    public struct SchemaHub has key, store {
+        id: UID,
+        admin: address,
+    }
+    
+    public struct SchemaTypeWapper<phantom Schema: key + store> has copy, store, drop {}
+
+    /// Authorize an schema to access protected features of the SchemaHub.
+    public(package) fun authorize_schema<Schema: key + store>(self: &mut SchemaHub) {
+        df::add(&mut self.id, SchemaTypeWapper<Schema> {}, true);
+    }
+
+    /// Deauthorize an schema by removing its authorization key.
+    public(package) fun deauthorize_schema<Schema: key + store>(self: &mut SchemaHub) {
+        df::remove<SchemaTypeWapper<Schema>, bool>(&mut self.id, SchemaTypeWapper<Schema> {});
+    }
+
+    /// Check if an schema is authorized to access protected features of
+    /// the SchemaHub.
+    public fun is_schema_authorized<Schema: key + store>(self: &SchemaHub): bool {
+        df::exists_(&self.id, SchemaTypeWapper<Schema> {})
+    }
+
+    /// Assert that an schema is authorized to access protected features of
+    /// the SchemaHub. Aborts with \`EAppNotAuthorized\` if not.
+    public fun ensure_schema_authorized<Schema: key + store>(self: &SchemaHub) {
+        assert!(self.is_schema_authorized<Schema>(), 0);
+    }
+
+    fun init(ctx: &mut TxContext) {
+        public_share_object(SchemaHub {
+            id: object::new(ctx),
+            admin: ctx.sender(),
+        });
+    }
+
+    #[test_only]
+    public fun init_schema_hub_for_testing(ctx: &mut TxContext) {
+        init(ctx);
+    }
+}
+`;
+	await formatAndWriteMove(
+		code,
+		`${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`,
+		'formatAndWriteMove'
+	);
+	console.log('✅ DappKey Generation Complete\n');
+}

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

@@ -1,6 +1,7 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
+import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
 export async function generateDeployHook(
 	config: DubheConfig,
@@ -19,59 +20,67 @@ export async function generateDeployHook(
 		let code = `module ${config.name}::deploy_hook {
     use dubhe::dapps_schema::Dapps;
     use dubhe::dapps_system;
-    use ${config.name}::dapp_key::DappKey;
-    use std::ascii;
+    use ${config.name}::schema_hub::SchemaHub;
+    use std::ascii::string;
     use sui::clock::Clock;
+    use sui::package::UpgradeCap;
     use sui::transfer::public_share_object;
-    #[test_only]
-      use dubhe::dapps_schema;
+    ${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::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(dapps: &mut Dapps, clock: &Clock, ctx: &mut TxContext) {
+    public entry fun run(schema_hub: &mut SchemaHub, dapps: &mut Dapps, cap: &UpgradeCap, clock: &Clock, ctx: &mut TxContext) {
         // Register the dapp to dubhe.
-        dapps_system::register<DappKey>(
-            dapps,
-            ascii::string(b"${config.name}"),
-            ascii::string(b"${config.description}"),
-            clock,
-            ctx
-        );
-        ${Object.keys(config.schemas)
-			.map(schemaName => {
-				return `let ${schemaName} = ${config.name}::${schemaName}_schema::register(dapps, ctx);`;
-			})
-			.join('\n')}
+        dapps_system::register(dapps,cap,string(b"${config.name}"),string(b"${config.description}"),clock,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
-
-
-        // Share the dapp object with the public
-        ${Object.keys(config.schemas)
-			.map(schemaName => {
-				return `public_share_object(${schemaName});`;
-			})
-			.join('\n')}
+				${`\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});
+				 `;
+			}).join('\n')}
     }
 
     #[test_only]
-    public fun deploy_hook_for_testing(): (Scenario, Dapps) {
-      let mut scenario = test_scenario::begin(@0xA);
-      {
+  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 ctx = test_scenario::ctx(&mut scenario);
-      let clock = clock::create_for_testing(ctx);
-      run(&mut dapps, &clock, ctx);
-      clock::destroy_for_testing(clock);
-      test_scenario::next_tx(&mut scenario,@0xA);
-      (scenario, dapps)
+    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);
+    run(&mut schema_hub, &mut dapps, &upgrade_cap, &clock, ctx);
+
+    clock::destroy_for_testing(clock);
+    upgrade_cap.make_immutable();
+    test_scenario::next_tx(&mut scenario,@0xA);
+    (scenario, schema_hub, dapps)
   }
 }
 `;
@@ -84,33 +93,21 @@ export async function generateDeployHook(
 	console.log('✅ Deploy Hook Generation Complete\n');
 }
 
-export function generateMigrate(config: DubheConfig, srcPrefix: string) {
+export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
 	if (
 		!existsSync(
 			`${srcPrefix}/contracts/${config.name}/sources/script/migrate.move`
 		)
 	) {
 		let code = `module ${config.name}::migrate {
-    use dubhe::world::{World, AdminCap};
-
-    /// Not the right admin for this world
-    const ENotAdmin: u64 = 0;
-    const EWrongVersion: u64 = 1;
-    const ENotUpgrade: u64 = 2;
-    const VERSION: u64 = 1;
+    const ON_CHAIN_VERSION: u32 = 0;
 
-    public entry fun run(world: &mut World, admin_cap: &AdminCap) {
-        assert!(world.admin() == object::id(admin_cap), ENotAdmin);
-        assert!(world.version() < VERSION, ENotUpgrade);
-        *dubhe::world::mut_version(world, admin_cap) = VERSION;
-    }
-
-    public fun assert_version(world: &World){
-        assert!(world.version() == VERSION, EWrongVersion);
+    public fun on_chain_version(): u32 {
+        ON_CHAIN_VERSION
     }
 }
 `;
-		formatAndWriteMove(
+		await formatAndWriteMove(
 			code,
 			`${srcPrefix}/contracts/${config.name}/sources/script/migrate.move`,
 			'formatAndWriteMove'

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

@@ -1,30 +1,22 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
 export async function generateSystem(config: DubheConfig, srcPrefix: string) {
 	console.log('\n⚙️ Starting System Generation...');
-	config.systems.map(async systemName => {
-		console.log(`  ├─ Generating system: ${systemName}`);
+		console.log(`  ├─ Generating systems`);
 		console.log(
-			`     └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`
+			`     └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/systems`
 		);
 
 		if (
 			!existsSync(
-				`${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`
+				`${srcPrefix}/contracts/${config.name}/sources/systems`
 			)
 		) {
-			let code = `module ${config.name}::${systemName}_system {
-
-}
-`;
-			await formatAndWriteMove(
-				code,
-				`${srcPrefix}/contracts/${config.name}/sources/system/${systemName}.move`,
-				'formatAndWriteMove'
-			);
+			await fs.mkdir(`${srcPrefix}/contracts/${config.name}/sources/systems`, { recursive: true })
 		}
-	});
 	console.log('✅ System Generation Complete\n');
 }

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

@@ -18,7 +18,7 @@ edition = "2024.beta"
 
 [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.git", subdir = "packages/dubhe-framework", rev = "main" }
+Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "release-dubhe-v1.0.0-rc1" }
 
 [addresses]
 sui = "0x2"