create-dubhe 0.0.4 → 0.0.5

package/template/nextjs/sui-template/contracts/counter/sources/codegen/schema_hub.move

@@ -0,0 +1,60 @@
+  // Copyright (c) Obelisk Labs, Inc.
+  // SPDX-License-Identifier: MIT
+  #[allow(unused_use)]
+  
+  /* Autogenerated file. Do not edit manually. */
+  
+  module counter::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);
+  }
+}

package/template/nextjs/sui-template/contracts/counter/sources/codegen/schemas/counter.move

@@ -8,10 +8,16 @@
 
   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};
@@ -22,36 +28,32 @@
 
   use counter::dapp_key::DappKey;
 
+  use sui::dynamic_field as df;
+
   public struct Counter has key, store {
     id: UID,
-    value: StorageValue<u32>,
   }
 
   public fun borrow_value(self: &Counter): &StorageValue<u32> {
-    &self.value
+    storage_migrate::borrow_field(&self.id, b"value")
   }
 
   public(package) fun borrow_mut_value(self: &mut Counter): &mut StorageValue<u32> {
-    &mut self.value
+    storage_migrate::borrow_mut_field(&mut self.id, b"value")
   }
 
-  public fun register(dapps: &mut Dapps, ctx: &mut TxContext): Counter {
-    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<Counter>().into_string();
-    assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
-    dapps_system::add_schema<Counter>(dapps, package_id, ctx);
-    Counter {
-                          id: object::new(ctx),
-                          value: storage_value::new(),
-                        }
+  public(package) fun create(ctx: &mut TxContext): Counter {
+    let mut id = object::new(ctx);
+    storage_migrate::add_field<StorageValue<u32>>(&mut id, b"value", storage_value::new());
+    Counter { id }
   }
 
+  public fun migrate(_counter: &mut Counter, _cap: &UpgradeCap) {}
+
   // ======================================== View Functions ========================================
 
   public fun get_value(self: &Counter): Option<u32> {
-    self.value.try_get()
+    self.borrow_value().try_get()
   }
 
   // =========================================================================================================

package/template/nextjs/sui-template/contracts/counter/sources/script/deploy_hook.move

@@ -6,17 +6,17 @@
 
   use dubhe::dapps_system;
 
-  use counter::dapp_key::DappKey;
+  use counter::schema_hub::SchemaHub;
 
-  use std::ascii;
+  use std::ascii::string;
 
   use sui::clock::Clock;
 
-  use sui::transfer::public_share_object;
+  use sui::package::UpgradeCap;
 
-  #[test_only]
+  use sui::transfer::public_share_object;
 
-  use dubhe::dapps_schema;
+  use counter::counter_schema::Counter;
 
   #[test_only]
 
@@ -28,40 +28,58 @@
 
   #[test_only]
 
+  use sui::package;
+
+  #[test_only]
+
+  use counter::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"counter"),
-            ascii::string(b"counter"),
-            clock,
-            ctx
-        );
-    let mut counter = counter::counter_schema::register(dapps, ctx);
+    dapps_system::register(dapps,cap,string(b"counter"),string(b"counter"),clock,ctx);
+    // Create schemas
+    let mut counter = counter::counter_schema::create(ctx);
     // Logic that needs to be automated once the contract is deployed
-      counter.borrow_mut_value().set(0);
 
-    // Share the dapp object with the public
+    counter.borrow_mut_value().set(0);
+    // Authorize schemas and public share objects
+    schema_hub.authorize_schema<Counter>();
     public_share_object(counter);
   }
 
   #[test_only]
 
-  public fun deploy_hook_for_testing(): (Scenario, Dapps) {
+  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);
-    run(&mut dapps, &clock, 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, dapps)
+    (scenario, schema_hub, dapps)
   }
 }

package/template/nextjs/sui-template/contracts/counter/sources/script/migrate.move

@@ -0,0 +1,8 @@
+module counter::migrate {
+
+  const ON_CHAIN_VERSION: u32 = 0;
+
+  public fun on_chain_version(): u32 {
+    ON_CHAIN_VERSION
+  }
+}

package/template/nextjs/sui-template/contracts/counter/sources/systems/counter.move

@@ -0,0 +1,11 @@
+module counter::counter_system {
+    use counter::counter_schema::Counter;
+
+    public entry fun inc(counter: &mut Counter) {
+        counter.borrow_mut_value().mutate!(|value| *value = *value + 1);
+    }
+
+    public fun get(counter: &Counter): u32 {
+        counter.borrow_value().get()
+    }
+}

package/template/nextjs/sui-template/dubhe.config.ts

@@ -7,8 +7,8 @@ export const dubheConfig = {
   schemas: {
     counter: {
       structure: {
-        value: "StorageValue<u32>"
-      }
+        value: 'StorageValue<u32>',
+      },
     },
   },
 } as DubheConfig;

package/template/nextjs/sui-template/localnet/dubhe-framework/Move.toml

@@ -1,26 +1,16 @@
 [package]
 name = "Dubhe"
-edition = "2024.alpha" # edition = "legacy" to use legacy (pre-2024) Move
-published-at = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
-# license = ""           # e.g., "MIT", "GPL", "Apache 2.0"
-# authors = ["..."]      # e.g., ["Joe Smith (joesmith@noemail.com)", "John Snow (johnsnow@noemail.com)"]
+edition = "2024.alpha"
+version = "1.0.0"
+published-at = "0xbaa3c172e1409fbbd8cd5da701166f8df4db725ee791de21d7b45f330b8b2568"
+license = "MIT"
+authors = ["Obelisk Labs"]
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.36.2" }
 
-# For remote import, use the `{ git = "...", subdir = "...", rev = "..." }`.
-# Revision can be a branch, a tag, and a commit hash.
-# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }
-
-# For local dependencies use `local = path`. Path is relative to the package root
-# Local = { local = "../path/to" }
-
-# To resolve a version conflict and force a specific version for dependency
-# override use `override = true`
-# Override = { local = "../conflicting/version", override = true }
-
 [addresses]
-dubhe = "0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28"
+dubhe = "0xbaa3c172e1409fbbd8cd5da701166f8df4db725ee791de21d7b45f330b8b2568"
 #dubhe = "0x0"
 
 # Named addresses will be accessible in Move as `@name`. They're also exported:

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/dapps/metadata.move

@@ -0,0 +1,96 @@
+module dubhe::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
+    }
+
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/dapps/schema.move

@@ -0,0 +1,83 @@
+module dubhe::dapps_schema {
+    use std::ascii::String;
+    use dubhe::storage_map;
+    use sui::transfer::public_share_object;
+    use dubhe::dapp_metadata::DappMetadata;
+    use dubhe::storage_map::StorageMap;
+
+    public struct Dapps has key, store {
+        id: UID,
+        admin: StorageMap<address, address>,
+        version: StorageMap<address, u32>,
+        metadata: StorageMap<address, DappMetadata>,
+        schemas: StorageMap<address, vector<String>>,
+        safe_mode: StorageMap<address, bool>,
+        verified: StorageMap<address, bool>
+    }
+
+
+    public(package) fun borrow_mut_version(self: &mut Dapps): &mut StorageMap<address, u32> {
+        &mut self.version
+    }
+
+    public(package) fun borrow_mut_admin(self: &mut Dapps): &mut StorageMap<address, address> {
+        &mut self.admin
+    }
+
+    public(package) fun borrow_mut_metadata(self: &mut Dapps): &mut StorageMap<address, DappMetadata> {
+        &mut self.metadata
+    }
+
+    public(package) fun borrow_mut_schemas(self: &mut Dapps): &mut StorageMap<address, vector<String>> {
+        &mut self.schemas
+    }
+
+    public(package) fun borrow_mut_safe_mode(self: &mut Dapps): &mut StorageMap<address, bool> {
+        &mut self.safe_mode
+    }
+
+    public(package) fun borrow_mut_verified(self: &mut Dapps): &mut StorageMap<address, bool> {
+        &mut self.verified
+    }
+
+    public fun borrow_admin(self: &Dapps): &StorageMap<address, address> {
+        &self.admin
+    }
+
+    public fun borrow_version(self: &Dapps): &StorageMap<address, u32> {
+        &self.version
+    }
+
+    public fun borrow_metadata(self: &Dapps): &StorageMap<address, DappMetadata> {
+        &self.metadata
+    }
+
+    public fun borrow_schemas(self: &Dapps): &StorageMap<address, vector<String>> {
+        &self.schemas
+    }
+
+    public fun borrow_safe_mode(self: &Dapps): &StorageMap<address, bool> {
+        &self.safe_mode
+    }
+
+    public fun borrow_verified(self: &mut Dapps): &StorageMap<address, bool> {
+        &self.verified
+    }
+
+    fun init(ctx: &mut TxContext) {
+        public_share_object(Dapps {
+            id: object::new(ctx),
+            admin: storage_map::new(),
+            version: storage_map::new(),
+            metadata: storage_map::new(),
+            schemas: storage_map::new(),
+            safe_mode: storage_map::new(),
+            verified: storage_map::new(),
+        });
+    }
+
+    #[test_only]
+    public fun init_dapps_for_testing(ctx: &mut TxContext){
+        init(ctx)
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/dapps/system.move

@@ -0,0 +1,75 @@
+module dubhe::dapps_system {
+    use std::ascii::String;
+    use std::ascii;
+    use dubhe::root_schema::Root;
+    use dubhe::dapp_metadata;
+    use sui::clock::Clock;
+    use dubhe::dapps_schema::Dapps;
+    use dubhe::root_system;
+
+    public entry fun register<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        name: String,
+        description: String,
+        clock: &Clock,
+        ctx: &mut TxContext
+    ) {
+        
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(!dapps.borrow_metadata().contains_key(dapp_id), 0);
+
+        dapps.borrow_mut_metadata().set(
+            dapp_id,
+            dapp_metadata::new(
+                name,
+                description,
+                ascii::string(b""),
+                ascii::string(b""),
+                clock.timestamp_ms(),
+                vector[]
+            )
+        );
+        dapps.borrow_mut_admin().set(dapp_id, ctx.sender());
+        dapps.borrow_mut_version().set(dapp_id, 0);
+        dapps.borrow_mut_safe_mode().set(dapp_id, false);
+    }
+
+    public entry fun set_metadata<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        name: String,
+        description: String,
+        icon_url: String,
+        website_url: String,
+        partners: vector<String>
+    ) {
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        let created_at = dapps.borrow_mut_metadata().take(dapp_id).get_created_at();
+        dapps.borrow_mut_metadata().set(dapp_id, dapp_metadata::new(name, description, icon_url, website_url, created_at, partners));
+    }
+
+    public entry fun transfer_ownership<UpgradeCap: key>(
+        dapps: &mut Dapps,
+        upgrade_cap: &UpgradeCap,
+        new_admin: address,
+        ctx: &mut TxContext
+    ) {
+        let dapp_id = object::id_address<UpgradeCap>(upgrade_cap);
+        assert!(dapps.borrow_admin().get(dapp_id) == ctx.sender(), 0);
+        dapps.borrow_mut_admin().set(dapp_id, new_admin);
+    }
+
+    public entry fun add_verification(dapps: &mut Dapps, root: &Root, dapp_id: address, ctx: &mut TxContext) {
+        root_system::ensure_root(root, ctx);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        dapps.borrow_mut_verified().set(dapp_id, true);
+    }
+
+    public entry fun remove_verification(dapps: &mut Dapps, root: &Root, dapp_id: address, ctx: &mut TxContext) {
+        root_system::ensure_root(root, ctx);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id), 0);
+        dapps.borrow_mut_verified().remove(dapp_id);
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/dapps/tests.move

@@ -0,0 +1,52 @@
+#[test_only]
+module dubhe::dapps_tests {
+    use dubhe::dapps_schema::Dapps;
+    use dubhe::dapps_schema;
+    use dubhe::dapps_system;
+    use std::ascii::string;
+    use std::debug;
+    use sui::clock;
+    use sui::test_scenario;
+    use sui::package;
+    use sui::package::UpgradeCap;
+
+    public struct DappKey has drop {}
+
+    #[test]
+    public fun dapps_register() {
+        let mut scenario = test_scenario::begin(@0xA);
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            dapps_schema::init_dapps_for_testing(ctx);
+            test_scenario::next_tx(&mut scenario,@0xA);
+        };
+
+        let mut dapps = test_scenario::take_shared<Dapps>(&scenario);
+
+        let upgrade_cap = package::test_publish(@0x42.to_id(), scenario.ctx());
+        debug::print(&object::id_address<UpgradeCap>(&upgrade_cap));
+
+        let clock = clock::create_for_testing(test_scenario::ctx(&mut scenario));
+        dapps_system::register<UpgradeCap>(
+            &mut dapps,
+            &upgrade_cap,
+            string(b"DappKey"),
+            string(b"DappKey"),
+            &clock,
+            test_scenario::ctx(&mut scenario)
+        );
+
+        test_scenario::next_tx(&mut scenario,@0xA);
+
+        let dapp_id = object::id_address<UpgradeCap>(&upgrade_cap);
+        assert!(dapps.borrow_version().get(dapp_id) == 0, 0);
+        assert!(dapps.borrow_metadata().contains_key(dapp_id));
+        assert!(dapps.borrow_admin().get(dapp_id) == test_scenario::ctx(&mut scenario).sender(), 0);
+        assert!(dapps.borrow_safe_mode().get(dapp_id) == false, 0);
+
+        clock::destroy_for_testing(clock);
+        test_scenario::return_shared<Dapps>(dapps);
+        upgrade_cap.make_immutable();
+        scenario.end();
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/root/schema.move

@@ -0,0 +1,33 @@
+module dubhe::root_schema {
+    use dubhe::storage_value;
+    use dubhe::storage_value::StorageValue;
+    use sui::transfer::public_share_object;
+
+    public struct Root has key, store {
+        id: UID,
+        key: StorageValue<address>,
+    }
+
+
+    public(package) fun borrow_mut_key(self: &mut Root): &mut StorageValue<address> {
+        &mut self.key
+    }
+
+    public fun borrow_key(self: &Root): &StorageValue<address> {
+        &self.key
+    }
+
+    fun init(ctx: &mut TxContext) {
+        let mut key = storage_value::new();
+        key.set(ctx.sender());
+        public_share_object(Root {
+            id: object::new(ctx),
+            key,
+        });
+    }
+
+    #[test_only]
+    public fun init_root_for_testing(ctx: &mut TxContext){
+        init(ctx)
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/core/root/system.move

@@ -0,0 +1,24 @@
+module dubhe::root_system {
+    use dubhe::root_schema::Root;
+
+    public entry fun set_key(
+        root: &mut Root,
+        key: address,
+        ctx: &mut TxContext
+    ) {
+        ensure_root(root, ctx);
+        root.borrow_mut_key().set(key);
+    }
+
+    public entry fun remove_key(
+        root: &mut Root,
+        ctx: &mut TxContext
+    ) {
+        ensure_root(root, ctx);
+        root.borrow_mut_key().remove();
+    }
+
+    public fun ensure_root(root: &Root, ctx: &TxContext) {
+        assert!(root.borrow_key().get() == ctx.sender(), 0);
+    }
+}