@0xobelisk/sui-common 1.0.3 → 1.0.5

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

@@ -13,7 +13,7 @@ export async function generateDefaultSchema(
 }
 
 async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/metadata.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/metadata.move`
 	if (!existsSync(path)) {
 		let code = `module ${config.name}::dapp_metadata {
     use std::ascii::String;
@@ -122,107 +122,108 @@ async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string
 
 
 async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/schema.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/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();
-    }
+  use ${config.name}::dapp_metadata::DappMetadata;
+  use dubhe::storage_value;
+  use dubhe::storage_value::StorageValue;
+  use dubhe::storage;
+  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::borrow_field(&self.id, b"admin")
+  }
+
+  public(package) fun admin(self: &mut Dapp): &mut StorageValue<address> {
+    storage::borrow_mut_field(&mut self.id, b"admin")
+  }
+
+  public fun borrow_package_id(self: &Dapp): &StorageValue<address> {
+    storage::borrow_field(&self.id, b"package_id")
+  }
+
+  public(package) fun package_id(self: &mut Dapp): &mut StorageValue<address> {
+    storage::borrow_mut_field(&mut self.id, b"package_id")
+  }
+
+  public fun borrow_version(self: &Dapp): &StorageValue<u32> {
+    storage::borrow_field(&self.id, b"version")
+  }
+
+  public(package) fun version(self: &mut Dapp): &mut StorageValue<u32> {
+    storage::borrow_mut_field(&mut self.id, b"version")
+  }
+
+  public fun borrow_metadata(self: &Dapp): &StorageValue<DappMetadata> {
+    storage::borrow_field(&self.id, b"metadata")
+  }
+
+  public(package) fun metadata(self: &mut Dapp): &mut StorageValue<DappMetadata> {
+    storage::borrow_mut_field(&mut self.id, b"metadata")
+  }
+
+  public fun borrow_safe_mode(self: &Dapp): &StorageValue<bool> {
+    storage::borrow_field(&self.id, b"safe_mode")
+  }
+
+  public(package) fun safe_mode(self: &mut Dapp): &mut StorageValue<bool> {
+    storage::borrow_mut_field(&mut self.id, b"safe_mode")
+  }
+  
+  public(package) fun borrow_schemas(self: &Dapp): &StorageValue<vector<address>> {
+      storage::borrow_field(&self.id, b"schemas")
+    }
+
+  public(package) fun schemas(self: &mut Dapp): &mut StorageValue<vector<address>> {
+    storage::borrow_mut_field(&mut self.id, b"schemas")
+  }
+
+
+  public(package) fun create(ctx: &mut TxContext): Dapp {
+    let mut id = object::new(ctx);
+    storage::add_field<StorageValue<address>>(&mut id, b"admin", storage_value::new(b"admin", ctx));
+    storage::add_field<StorageValue<address>>(&mut id, b"package_id", storage_value::new(b"package_id", ctx));
+    storage::add_field<StorageValue<u32>>(&mut id, b"version", storage_value::new(b"version", ctx));
+    storage::add_field<StorageValue<DappMetadata>>(&mut id, b"metadata", storage_value::new(b"metadata", ctx));
+    storage::add_field<StorageValue<bool>>(&mut id, b"safe_mode", storage_value::new(b"safe_mode", ctx));
+    storage::add_field<StorageValue<vector<address>>>(&mut id, b"schemas", storage_value::new(b"schemas", ctx));
+    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.package_id().set(new_package_id);
+    let current_version = dapp.version()[];
+    dapp.version().set(current_version + 1);
+  }
+  
+  public(package) fun add_schema<Schema: key + store>(dapp: &mut Dapp, schema: Schema) {
+    let mut schemas = dapp.schemas()[];
+    schemas.push_back(object::id_address<Schema>(&schema));
+    dapp.schemas().set(schemas);
+    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(
@@ -234,27 +235,26 @@ async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
 }
 
 async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/system.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/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(
+  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.metadata().set(
             dapp_metadata::new(
                 name,
                 description,
@@ -264,20 +264,28 @@ async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
                 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(
+    let package_id = type_info::current_package_id<DappKey>();
+    dapp.package_id().set(package_id);
+    dapp.admin().set(ctx.sender());
+    dapp.version().set(1);
+    dapp.safe_mode().set(false);
+    dapp.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,
+  ) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+    let created_at = dapp.metadata().remove().get_created_at();
+    dapp.metadata().set(
             dapp_metadata::new(
                 name,
                 description,
@@ -287,36 +295,35 @@ async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
                 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);
-    }
+  }
+
+  public entry fun transfer_ownership(dapp: &mut Dapp, new_admin: address, ctx: &mut TxContext) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+        dapp.admin().set(new_admin);
+  }
+
+  public entry fun set_safe_mode(dapp: &mut Dapp, safe_mode: bool, ctx: &TxContext) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+    dapp.safe_mode().set(safe_mode);
+  }
+
+  public fun ensure_no_safe_mode(dapp: &Dapp) {
+    assert!(!dapp.borrow_safe_mode()[], 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,

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

@@ -20,27 +20,23 @@ export async function generateSchemaError(
 	path: string
 ) {
 	console.log('\n📦 Starting Schema Error Generation...');
-	for (const key of Object.keys(errors)) {
-				const name = key
-				const message = errors[key]
-				console.log(
-					`     └─ Generating ${name} message: ${message}`);
-				let	code = `module ${projectName}::${convertToSnakeCase(name)}_error {
-						#[error]
-						const ${name}: vector<u8> = b"${message}";
-						/// Get the error message.
-            public fun message(): vector<u8> { ${name} }
-            /// Abort execution with the given error code.
-            public fun emit() { abort ${name} }
-            /// Require that the given condition is true, otherwise abort with the given error code.
-						public fun require(condition: bool) { if (!condition) { emit() }  }`
-				await formatAndWriteMove(
-					code,
-					`${path}/contracts/${projectName}/sources/codegen/errors/${convertToSnakeCase(
-						name
-					)}_error.move`,
-					'formatAndWriteMove'
-				);
-			}
+
+	let	code = `module ${projectName}::errors {
+		${Object.entries(errors).map(([name, message]) => {
+			console.log(`  ├─ Generating Error: ${name}`);
+		console.log(`  │  └─ Message: ${message}`);
+		return `#[error]
+				const ${name}: vector<u8> = b"${message}";
+				public fun ${convertToSnakeCase(name)}_error(condition: bool) { assert!(condition, ${name})  }
+		`
+	}).join('\n')}		
+            }`
+
+
+	await formatAndWriteMove(
+		code,
+		`${path}/contracts/${projectName}/sources/codegen/errors.move`,
+		'formatAndWriteMove'
+	);
 	console.log('✅ Schema Error Generation Complete\n');
 }

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

@@ -71,19 +71,40 @@ export async function generateSchemaEvent(
                                    ${getStructAttrs(fields as Record<string, string>)}
                                }
                         }
-
-                        public fun emit(${getStructAttrsWithType(fields as Record<string, string>)}) {
-                               event::emit(${name}Event {
-                                   ${getStructAttrs(fields as Record<string, string>)}
-                               });
                         }`;
 				await formatAndWriteMove(
 					code,
-					`${path}/contracts/${projectName}/sources/codegen/events/${convertToSnakeCase(
+					`${path}/contracts/${projectName}/sources/codegen/data/${convertToSnakeCase(
 						name
 					)}_event.move`,
 					'formatAndWriteMove'
 				);
 			}
+
+	let	code = `module ${projectName}::events {
+	 	use std::ascii::{String, string};
+	 	${generateImport(projectName, data)}
+		${Object.entries(events).map(([name, fields]) => {
+		return `
+use ${projectName}::${convertToSnakeCase(name)}_event::${name}Event;
+use ${projectName}::${convertToSnakeCase(name)}_event;
+			public fun ${convertToSnakeCase(name)}_event(${getStructAttrsWithType(fields as Record<string, string>)}) {
+			 dubhe::storage_event::emit_set_record<${name}Event, ${name}Event, ${name}Event>(
+				string(b"${convertToSnakeCase(name)}_event"),
+				option::none(),
+			  	option::none(),
+			  option::some(${convertToSnakeCase(name)}_event::new(${getStructAttrs(fields as Record<string, string>)}))
+			  )
+			}
+		`
+	}).join('\n')}		
+            }`
+
+
+	await formatAndWriteMove(
+		code,
+		`${path}/contracts/${projectName}/sources/codegen/events.move`,
+		'formatAndWriteMove'
+	);
 	console.log('✅ Schema Event Generation Complete\n');
 }