@0xobelisk/sui-common 1.1.7 → 1.1.9

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

@@ -5,216 +5,105 @@ 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/dapp/metadata.move`;
+  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/core/metadata.move`;
   if (!existsSync(path)) {
     let code = `module ${config.name}::${config.name}_dapp_metadata {
-    use std::ascii::String;
+  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 struct DappMetadata has drop, copy, store {
+    name: String,
+    description: String,
+    cover_url: vector<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 {
+  public fun new(
+    name: String,
+    description: String,
+    cover_url: vector<String>,
+    website_url: String,
+    created_at: u64,
+    partners: vector<String>,
+  ): DappMetadata {
+    DappMetadata {
             name,
             description,
-            icon_url,
+            cover_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/dapp/schema.move`;
-  if (!existsSync(path)) {
-    let code = `module ${config.name}::${config.name}_dapp_schema {
-  use ${config.name}::${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 fun set(
+    self: &mut DappMetadata,
+    name: String,
+    description: String,
+    cover_url: vector<String>,
+    website_url: String,
+    created_at: u64,
+    partners: vector<String>,
+  ) {
+    self.name = name;
+    self.description = description;
+    self.cover_url = cover_url;
+    self.website_url = website_url;
+    self.created_at = created_at;
+    self.partners = partners;
   }
 
-  public(package) fun package_id(self: &mut Dapp): &mut StorageValue<address> {
-    storage::borrow_mut_field(&mut self.id, b"package_id")
+  public fun set_name(self: &mut DappMetadata, name: String) {
+    self.name = name;
   }
 
-  public fun borrow_version(self: &Dapp): &StorageValue<u32> {
-    storage::borrow_field(&self.id, b"version")
+  public fun set_description(self: &mut DappMetadata, description: String) {
+    self.description = description;
   }
 
-  public(package) fun version(self: &mut Dapp): &mut StorageValue<u32> {
-    storage::borrow_mut_field(&mut self.id, b"version")
+  public fun set_cover_url(self: &mut DappMetadata, cover_url: vector<String>) {
+    self.cover_url = cover_url;
   }
 
-  public fun borrow_metadata(self: &Dapp): &StorageValue<DappMetadata> {
-    storage::borrow_field(&self.id, b"metadata")
+  public fun set_website_url(self: &mut DappMetadata, website_url: String) {
+    self.website_url = website_url;
   }
 
-  public(package) fun metadata(self: &mut Dapp): &mut StorageValue<DappMetadata> {
-    storage::borrow_mut_field(&mut self.id, b"metadata")
+  public fun set_created_at(self: &mut DappMetadata, created_at: u64) {
+    self.created_at = created_at;
   }
 
-  public fun borrow_safe_mode(self: &Dapp): &StorageValue<bool> {
-    storage::borrow_field(&self.id, b"safe_mode")
+  public fun set_partners(self: &mut DappMetadata, partners: vector<String>) {
+    self.partners = partners;
   }
 
-  public(package) fun safe_mode(self: &mut Dapp): &mut StorageValue<bool> {
-    storage::borrow_mut_field(&mut self.id, b"safe_mode")
+  public fun get_name(self: &DappMetadata): String {
+    self.name
   }
-  
-  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 fun get_description(self: &DappMetadata): String {
+    self.description
   }
 
-
-  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 fun get_cover_url(self: &DappMetadata): vector<String> {
+    self.cover_url
   }
 
-  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 fun get_website_url(self: &DappMetadata): String {
+    self.website_url
   }
-  
-  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)
+  public fun get_created_at(self: &DappMetadata): u64 {
+    self.created_at
   }
 
-  #[test_only]
-
-  public fun distroy_dapp_for_testing(dapp: Dapp) {
-    let Dapp { id } = dapp;
-    id.delete();
+  public fun get_partners(self: &DappMetadata): vector<String> {
+    self.partners
   }
 }
 `;
@@ -223,94 +112,117 @@ async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
 }
 
 async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
-  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/system.move`;
+  const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/core/system.move`;
   if (!existsSync(path)) {
     let code = `module ${config.name}::${config.name}_dapp_system {
   use std::ascii::String;
   use std::ascii;
   use dubhe::type_info;
   use sui::clock::Clock;
-  use ${config.name}::${config.name}_dapp_schema;
+  use sui::transfer::public_share_object;
+  use ${config.name}::${config.name}_schema::Schema;
   use ${config.name}::${config.name}_dapp_metadata;
-  use ${config.name}::${config.name}_dapp_schema::Dapp;
+  use ${config.name}::${config.name}_dapp_metadata::DappMetadata;
+  use dubhe::storage::add_field;
+  use dubhe::storage_value;
+  use dubhe::storage_value::StorageValue;
   
   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 = ${config.name}_dapp_schema::create(ctx);
-    assert!(!dapp.borrow_metadata().contains(), 0);
-    dapp.metadata().set(
-            ${config.name}_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.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,
+    schema: &mut Schema,
     name: String,
     description: String,
-    icon_url: String,
+    cover_url: vector<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().get().get_created_at();
-    dapp.metadata().set(
+    let admin = schema.dapp__admin().try_get();
+    assert!(admin == option::some(ctx.sender()), 0);
+    let created_at = schema.dapp__metadata().get().get_created_at();
+    schema.dapp__metadata().set(
             ${config.name}_dapp_metadata::new(
                 name,
                 description,
-                icon_url,
+                cover_url,
                 website_url,
                 created_at,
                 partners
             )
         );
-  }
+    }
 
-  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 entry fun transfer_ownership(schema: &mut Schema, new_admin: address, ctx: &mut TxContext) {
+    let admin = schema.dapp__admin().try_get();
+    assert!(admin == option::some(ctx.sender()), 0);
+    schema.dapp__admin().set(new_admin);
+    }
 
-  public fun ensure_no_safe_mode(dapp: &Dapp) {
-    assert!(!dapp.borrow_safe_mode()[], 0);
-  }
+    public entry fun set_safe_mode(schema: &mut Schema, safe_mode: bool, ctx: &TxContext) {
+    let admin = schema.dapp__admin().try_get();
+    assert!(admin == option::some(ctx.sender()), 0);
+    schema.dapp__safe_mode().set(safe_mode);
+    }
 
-  public fun ensure_has_authority(dapp: &Dapp, ctx: &TxContext) {
-    assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-  }
+    public fun ensure_no_safe_mode(schema: &mut Schema) {
+    assert!(!schema.dapp__safe_mode()[], 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 fun ensure_has_authority(schema: &mut Schema, ctx: &TxContext) {
+    assert!(schema.dapp__admin().get() == ctx.sender(), 0);
+    }
+
+    public fun ensure_has_schema<S: key + store>(schema: &mut Schema, new_schema: &S) {
+    let schema_id = object::id_address(new_schema);
+    assert!(schema.dapp__authorised_schemas().get().contains(&schema_id), 0);
+    }
+
+    public(package) fun create(schema: &mut Schema, name: String, description: String, clock: &Clock, ctx: &mut TxContext){
+    add_field<StorageValue<address>>(schema.id(), b"dapp__admin", storage_value::new(b"dapp__admin", ctx));
+    add_field<StorageValue<address>>(schema.id(), b"dapp__package_id", storage_value::new(b"dapp__package_id", ctx));
+    add_field<StorageValue<u32>>(schema.id(), b"dapp__version", storage_value::new(b"dapp__version", ctx));
+    add_field<StorageValue<DappMetadata>>(schema.id(), b"dapp__metadata", storage_value::new(b"dapp__metadata", ctx));
+    add_field<StorageValue<bool>>(schema.id(), b"dapp__safe_mode", storage_value::new(b"dapp__safe_mode", ctx));
+    add_field<StorageValue<vector<address>>>(schema.id(), b"dapp__authorised_schemas", storage_value::new(b"dapp__authorised_schemas", ctx));
+    schema.dapp__metadata().set(
+            ${config.name}_dapp_metadata::new(
+                name,
+                description,
+                vector[],
+                ascii::string(b""),
+                clock.timestamp_ms(),
+                vector[]
+            )
+        );
+    let package_id = type_info::current_package_id<DappKey>();
+    schema.dapp__package_id().set(package_id);
+    schema.dapp__admin().set(ctx.sender());
+    schema.dapp__version().set(1);
+    schema.dapp__safe_mode().set(false);
+    schema.dapp__authorised_schemas().set(vector[]);
+    }
 
+    public(package) fun upgrade<DappKey: drop>(schema: &mut Schema, ctx: &TxContext) {
+    assert!(schema.dapp__metadata().contains(), 0);
+    assert!(schema.dapp__admin().get() == ctx.sender(), 0);
+    let new_package_id = type_info::current_package_id<DappKey>();
+    schema.dapp__package_id().set(new_package_id);
+    let current_version = schema.dapp__version()[];
+    schema.dapp__version().set(current_version + 1);
+    }
+
+    public(package) fun add_schema<S: key + store>(schema: &mut Schema, new_schema: S) {
+    let mut schemas = schema.dapp__authorised_schemas()[];
+    schemas.push_back(object::id_address<S>(&new_schema));
+    schema.dapp__authorised_schemas().set(schemas);
+    public_share_object(new_schema);
+    }
+}
 
 `;
     await formatAndWriteMove(code, path, 'formatAndWriteMove');

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

@@ -20,8 +20,7 @@ export async function generateSchemaError(projectName: string, errors: ErrorData
   let code = `module ${projectName}::${projectName}_errors {
 		${Object.entries(errors)
       .map(([name, message]) => {
-        console.log(`  ├─ Generating Error: ${name}`);
-        console.log(`  │  └─ Message: ${message}`);
+        console.log(`     └─ ${name}: ${message}`);
         return `#[error]
 				const ${name.toUpperCase()}: vector<u8> = b"${message}";
 				public fun ${name}_error(condition: bool) { assert!(condition, ${name.toUpperCase()})  }
@@ -35,5 +34,4 @@ export async function generateSchemaError(projectName: string, errors: ErrorData
     `${path}/contracts/${projectName}/sources/codegen/errors.move`,
     'formatAndWriteMove'
   );
-  console.log('✅ Schema Error Generation Complete\n');
 }

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

@@ -45,7 +45,7 @@ export async function generateSchemaEvent(
   for (const key of Object.keys(events)) {
     const name = key;
     const fields = events[key];
-    console.log(`     └─ Generating ${name} event: ${fields}`);
+    console.log(`     └─ ${name} event: ${JSON.stringify(fields)}`);
 
     let code = `module ${projectName}::${projectName}_${name}_event {
 						use sui::event;
@@ -95,5 +95,4 @@ use ${projectName}::${projectName}_${name}_event;
     `${path}/contracts/${projectName}/sources/codegen/events.move`,
     'formatAndWriteMove'
   );
-  console.log('✅ Schema Event Generation Complete\n');
 }

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

@@ -4,30 +4,25 @@ 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 init_test_code = `module ${config.name}::${config.name}_init_test {
-    use ${config.name}::${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) {
+    public fun deploy_dapp_for_testing(sender: address): Scenario {
         let mut scenario = test_scenario::begin(sender);
         let ctx = test_scenario::ctx(&mut scenario);
         let clock = clock::create_for_testing(ctx);
         ${config.name}::${config.name}_genesis::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)
+        scenario
     }
 }
 `;
   await formatAndWriteMove(
     init_test_code,
-    `${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/core/init_test.move`,
     'formatAndWriteMove'
   );
 
@@ -39,23 +34,21 @@ export async function generateInit(config: DubheConfig, srcPrefix: string) {
   use ${config.name}::${config.name}_dapp_system;
 
   public entry fun run(clock: &Clock, ctx: &mut TxContext) {
-    // Create a dapp.
-    let mut dapp = ${config.name}_dapp_system::create(string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
     // Create schemas
     let mut schema = ${config.name}::${config.name}_schema::create(ctx);
+    // Setup default storage
+    ${config.name}_dapp_system::create(&mut schema, string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
     // Logic that needs to be automated once the contract is deployed
     ${config.name}::${config.name}_deploy_hook::run(&mut schema, ctx);
     // Authorize schemas and public share objects
-    dapp.add_schema(schema);
-    sui::transfer::public_share_object(dapp);
+    sui::transfer::public_share_object(schema);
   }
 }
 `;
   await formatAndWriteMove(
     init_code,
-    `${srcPrefix}/contracts/${config.name}/sources/codegen/genesis.move`,
+
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/core/genesis.move`,
     'formatAndWriteMove'
   );
-
-  console.log('✅ Init Generation Complete\n');
 }

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

@@ -91,15 +91,15 @@ export async function generateSchemaData(
   for (const key of Object.keys(data)) {
     const name = key;
     const fields = data[key];
-    console.log(`     └─ Generating ${name} ${Array.isArray(fields) ? '(enum)' : '(struct)'}`);
+    console.log(
+      `     └─ ${name} ${Array.isArray(fields) ? '(enum)' : '(struct)'}: ${JSON.stringify(fields)}`
+    );
     let code = '';
 
     const enumNames = Object.keys(data)
       .filter((item) => Array.isArray(data[item]))
       .map((item) => item);
 
-    console.log(enumNames);
-
     if (Array.isArray(fields)) {
       const sortByFirstLetterFields = sortByFirstLetter(fields);
       code = `module ${projectName}::${projectName}_${convertToSnakeCase(name)} {
@@ -151,7 +151,6 @@ export async function generateSchemaData(
       'formatAndWriteMove'
     );
   }
-  console.log('✅ Schema Data Generation Complete\n');
 }
 
 function generateImport(projectName: string, data: Record<string, SchemaData> | null) {
@@ -174,8 +173,9 @@ export async function generateSchemaStructure(
   path: string
 ) {
   console.log('\n🔨 Starting Schema Structure Generation...');
-  console.log(`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schema.move`);
-  console.log(`     └─ Structure fields: ${Object.values(schemas).length}`);
+  Object.entries(schemas).forEach(([key, value]) => {
+    console.log(`     └─ ${key}: ${value}`);
+  });
   const schemaMoudle = `module ${projectName}::${projectName}_schema {
                     use std::ascii::String;
                     use std::ascii::string;
@@ -186,10 +186,64 @@ export async function generateSchemaStructure(
                     use dubhe::storage_map::{Self, StorageMap};
                     use dubhe::storage_double_map::{Self, StorageDoubleMap};
                     use sui::dynamic_field as df;
+                    use ${projectName}::${projectName}_dapp_metadata::DappMetadata;
                 
                     ${generateImport(projectName, data)}
 
                     public struct Schema has key, store { id: UID } 
+
+                      // Default storage
+                    public fun borrow_dapp__admin(self: &Schema): &StorageValue<address> {
+                      storage::borrow_field(&self.id, b"dapp__admin")
+                    }
+
+                    public fun borrow_dapp__package_id(self: &Schema): &StorageValue<address> {
+                      storage::borrow_field(&self.id, b"dapp__package_id")
+                    }
+
+                    public fun borrow_dapp__version(self: &Schema): &StorageValue<u32> {
+                      storage::borrow_field(&self.id, b"dapp__version")
+                    }
+
+                    public fun borrow_dapp__metadata(self: &Schema): &StorageValue<DappMetadata> {
+                      storage::borrow_field(&self.id, b"dapp__metadata")
+                    }
+
+                    public fun borrow_dapp__safe_mode(self: &Schema): &StorageValue<bool> {
+                      storage::borrow_field(&self.id, b"dapp__safe_mode")
+                    }
+
+                    public fun borrow_dapp__authorised_schemas(self: &Schema): &StorageValue<vector<address>> {
+                      storage::borrow_field(&self.id, b"dapp__authorised_schemas")
+                    }
+
+                    public fun borrow_dapp__schemas(self: &Schema): &StorageValue<vector<address>> {
+                      storage::borrow_field(&self.id, b"dapp__schemas")
+                    }
+
+                    public(package) fun dapp__admin(self: &mut Schema): &mut StorageValue<address> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__admin")
+                    }
+
+                    public(package) fun dapp__package_id(self: &mut Schema): &mut StorageValue<address> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__package_id")
+                    }
+
+                    public(package) fun dapp__version(self: &mut Schema): &mut StorageValue<u32> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__version")
+                    }
+
+                    public(package) fun dapp__metadata(self: &mut Schema): &mut StorageValue<DappMetadata> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__metadata")
+                    }
+
+                    public(package) fun dapp__safe_mode(self: &mut Schema): &mut StorageValue<bool> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__safe_mode")
+                    }
+
+                    public(package) fun dapp__authorised_schemas(self: &mut Schema): &mut StorageValue<vector<address>> {
+                      storage::borrow_mut_field(&mut self.id, b"dapp__authorised_schemas")
+                    }
                     
                      ${Object.entries(schemas)
                        .map(([key, value]) => {
@@ -268,8 +322,8 @@ export async function generateSchemaStructure(
 			}`;
   await formatAndWriteMove(
     schemaMoudle,
-    `${path}/contracts/${projectName}/sources/codegen/schema.move`,
+
+    `${path}/contracts/${projectName}/sources/codegen/core/schema.move`,
     'formatAndWriteMove'
   );
-  console.log('✅ Schema Structure Generation Complete\n');
 }