@0xobelisk/sui-common 0.5.18 → 0.5.20

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"

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

@@ -1,22 +1,24 @@
 import { SchemaType, DubheConfig } from '../../types';
 import { rmdirSync, existsSync } from 'fs';
 import { deleteFolderRecursive } from './common';
-import { generateSystem } from './generateSystem';
 import { generateToml } from './generateToml';
 import { generateSchemaData, generateSchemaStructure } from './generateSchema';
 import { generateDeployHook, generateMigrate } from './generateScript';
 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 '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
 		case 'localnet':
-			return '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
 		default:
-			return '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+			return '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
 	}
 }
 
@@ -61,9 +63,14 @@ export async function schemaGen(
 		await generateDeployHook(config, path);
 	}
 
-	await generateSystem(config, path);
 	await generateSchemaData(config.name, config.schemas, path);
-	await generateSchemaStructure(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');
 }