create-dubhe 0.0.4 → 0.0.5

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

@@ -0,0 +1,39 @@
+#[test_only]
+module dubhe::root_tests {
+    use dubhe::root_schema::Root;
+    use dubhe::root_schema;
+    use dubhe::root_system;
+    use sui::test_scenario;
+
+    public struct USDT has drop {}
+
+    #[test]
+    public fun root_key() {
+        let mut scenario = test_scenario::begin(@0xA);
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_schema::init_root_for_testing(ctx);
+            test_scenario::next_tx(&mut scenario,@0xA);
+        };
+
+        let mut root = test_scenario::take_shared<Root>(&scenario);
+        assert!(root.borrow_key().get() == @0xA, 0);
+
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_system::set_key(&mut root, @0xB, ctx);
+            test_scenario::next_tx(&mut scenario,@0xB);
+        };
+        assert!(root.borrow_key().get() == @0xB, 0);
+
+        {
+            let ctx = test_scenario::ctx(&mut scenario);
+            root_system::remove_key(&mut root, ctx);
+            test_scenario::next_tx(&mut scenario,@0xC);
+        };
+        assert!(root.borrow_key().try_get() == option::none<address>(), 0);
+
+        test_scenario::return_shared<Root>(root);
+        scenario.end();
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/frames/utils/type_info.move

@@ -0,0 +1,29 @@
+module dubhe::type_info {
+    use std::ascii::String;
+    use std::ascii::string;
+    use sui::address;
+    use std::type_name::TypeName;
+
+    public fun parse_type_name(type_name: TypeName): (address, String, String, String) {
+        let pending_parse_str = type_name.into_string();
+        let delimiter = string(b"::");
+
+        // TBD: this can probably be hard-coded as all hex addrs are 64 bytes
+        let package_delimiter_index = pending_parse_str.index_of(&delimiter);
+        let package_addr = pending_parse_str.substring(0, package_delimiter_index);
+        let package_id = address::from_ascii_bytes(package_addr.as_bytes());
+
+        let tail = pending_parse_str.substring(package_delimiter_index + 2, pending_parse_str.length());
+
+        let module_delimiter_index = tail.index_of(&delimiter);
+        let module_name = tail.substring(0, module_delimiter_index);
+
+        let struct_name_with_type = tail.substring(module_delimiter_index + 2, tail.length());
+
+        let delimiter = string(b"<");
+        let struct_name_delimiter_index = struct_name_with_type.index_of(&delimiter);
+        let struct_name = struct_name_with_type.substring(0, struct_name_delimiter_index);
+
+        (package_id, module_name, struct_name, struct_name_with_type)
+    }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/double_map.move

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 #[allow(unused_variable)]
 module dubhe::storage_double_map {
 

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/map.move

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 #[allow(unused_variable)]
 module dubhe::storage_map {
 

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/migrate.move

@@ -0,0 +1,19 @@
+module dubhe::storage_migrate {
+    use sui::dynamic_field as df;
+
+    public fun add_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>, storagr_type: StorageType) {
+        df::add(uid, field_name, storagr_type);
+    }
+
+    public fun borrow_field<StorageType: store>(uid: &UID, field_name: vector<u8>): &StorageType {
+        df::borrow(uid, field_name)
+    }
+
+    public fun borrow_mut_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>): &mut StorageType {
+        df::borrow_mut(uid, field_name)
+    }
+
+    public fun field_exists(uid: &UID, field_name: vector<u8>): bool {
+        df::exists_(uid, field_name)
+    }
+}

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

@@ -0,0 +1,398 @@
+#[test_only]
+module dubhe::storage_tests {
+    use dubhe::storage_double_map::StorageDoubleMap;
+    use dubhe::storage_map::StorageMap;
+    use dubhe::storage_double_map;
+    use dubhe::storage_map;
+    use dubhe::storage_value::StorageValue;
+    use sui::test_scenario;
+    use sui::transfer::public_share_object;
+    use dubhe::storage_value;
+
+    public struct TestValue has drop, copy, store {
+        value: u64,
+    }
+
+    public struct TestStoreValue has store {
+        value: u64,
+    }
+
+    /// Destroy a TestStoreValue`.
+    public fun destroy_value(value: TestStoreValue) {
+        let TestStoreValue { value: _ } = value;
+    }
+
+    public struct TestObject has key, store {
+        id: UID,
+        value: StorageValue<TestValue>,
+        immutable_value: StorageValue<TestStoreValue>,
+        map: StorageMap<u32, TestValue>,
+        immutable_map: StorageMap<u32, TestStoreValue>,
+        double_map: StorageDoubleMap<u32, u32, TestValue>,
+        immutable_double_map: StorageDoubleMap<u32, u32, TestStoreValue>,
+    }
+
+    public fun value(self: &mut TestObject): &mut StorageValue<TestValue> {
+        &mut self.value
+    }
+
+
+    #[test]
+    public fun test_double_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut double_map = storage_double_map::new();
+
+        double_map.insert(0, 0, TestValue { value: 0 });
+        double_map.insert(0, 1, TestValue { value: 1 });
+        double_map.insert(0, 2, TestValue { value: 2 });
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0, 0], 0);
+        assert!(keys2 == vector[0, 1, 2], 0);
+        assert!(double_map.values() == vector[TestValue { value: 0 }, TestValue { value: 1 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 3);
+        assert!(double_map.borrow(0, 0).value == 0);
+        assert!(double_map.borrow(0, 1).value == 1);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+        assert!(double_map.get(0, 0).value == 0);
+        assert!(double_map.get(0, 1).value == 1);
+        assert!(double_map.get(0, 2).value == 2);
+        assert!(double_map.try_get(0, 0) == option::some(TestValue { value: 0 }));
+        assert!(double_map.try_get(0, 1) == option::some(TestValue { value: 1 }));
+        assert!(double_map.try_get(0, 2) == option::some(TestValue { value: 2 }));
+        assert!(double_map.try_get(0, 3) == option::none());
+
+        double_map.take(0, 1);
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(!double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[0, 2]);
+        assert!(double_map.values() == vector[TestValue { value: 0 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 2);
+        assert!(double_map.borrow(0, 0).value == 0);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+
+        double_map.mutate!(0, 0,  |value| {
+            *value = TestValue { value: 2 };
+        });
+
+        assert!(double_map.contains_key(0, 0));
+        assert!(!double_map.contains_key(0, 1));
+        assert!(double_map.contains_key(0, 2));
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[0, 2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 2 }]);
+        assert!(double_map.length() == 2);
+        assert!(double_map.borrow(0, 0).value == 2);
+        assert!(double_map.borrow_mut(0, 2).value == 2);
+
+        double_map.remove(0, 0);
+        assert!(!double_map.contains_key(0,0));
+        assert!(double_map.length() == 1);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0]);
+        assert!(keys2 == vector[2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }]);
+
+        double_map.remove(0,3);
+        assert!(double_map.length() == 1);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0]);
+        assert!(keys2 == vector[2]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }]);
+
+        double_map.set(0,3, TestValue { value: 0 });
+        assert!(double_map.contains_key(0,3));
+        assert!(double_map.length() == 2);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[2, 3]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 0 }]);
+        assert!(double_map.get(0,3).value == 0);
+
+        double_map.set(0,3, TestValue { value: 3 });
+        assert!(double_map.contains_key(0,3));
+        assert!(double_map.length() == 2);
+        let (keys1, keys2) = double_map.keys();
+        assert!(keys1 == vector[0, 0]);
+        assert!(keys2 == vector[2, 3]);
+        assert!(double_map.values() == vector[TestValue { value: 2 }, TestValue { value: 3 }]);
+        assert!(double_map.get(0,3).value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map: storage_map::new(),
+            immutable_map: storage_map::new(),
+            double_map,
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_value() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut value = storage_value::new();
+        value.set(TestValue { value: 1 });
+        assert!(value.get() == TestValue { value: 1 });
+        assert!(*value.borrow() == TestValue { value: 1 });
+        assert!(*value.borrow_mut() == TestValue { value: 1 });
+
+        value.set(TestValue { value: 2 });
+        assert!(value.get() == TestValue { value: 2 });
+
+        value.mutate!(|value| {
+            *value = TestValue { value: 3 };
+        });
+        assert!(value.get() == TestValue { value: 3 });
+
+        value.set(TestValue { value: 4 });
+        assert!(value.get() == TestValue { value: 4 });
+
+
+        let mut immutable_value = storage_value::new();
+        immutable_value.put(TestStoreValue { value: 1 });
+        assert!(immutable_value.borrow().value == 1);
+
+        immutable_value.mutate!(|store_value| {
+            store_value.value = 2;
+        });
+        assert!(immutable_value.borrow().value == 2);
+        assert!(immutable_value.borrow_mut().value == 2);
+
+        immutable_value.mutate!(|store_value| {
+            store_value.value = 3;
+        });
+        assert!(immutable_value.borrow().value == 3);
+        assert!(immutable_value.borrow_mut().value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value,
+            immutable_value,
+            map: storage_map::new(),
+            immutable_map: storage_map::new(),
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut map = storage_map::new();
+        map.insert(0, TestValue { value: 0 });
+        map.insert(1, TestValue { value: 1 });
+        map.insert(2, TestValue { value: 2 });
+
+        assert!(map.contains_key(0));
+        assert!(map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 1, 2]);
+        assert!(map.values() == vector[TestValue { value: 0 }, TestValue { value: 1 }, TestValue { value: 2 }]);
+        assert!(map.length() == 3);
+        assert!(map.borrow(0).value == 0);
+        assert!(map.borrow(1).value == 1);
+        assert!(map.borrow_mut(2).value == 2);
+        assert!(map.get(0).value == 0);
+        assert!(map.get(1).value == 1);
+        assert!(map.get(2).value == 2);
+        assert!(map.try_get(0) == option::some(TestValue { value: 0 }));
+        assert!(map.try_get(1) == option::some(TestValue { value: 1 }));
+        assert!(map.try_get(2) == option::some(TestValue { value: 2 }));
+        assert!(map.try_get(3) == option::none());
+
+        map.take(1);
+
+        assert!(map.contains_key(0));
+        assert!(!map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 2]);
+        assert!(map.values() == vector[TestValue { value: 0 }, TestValue { value: 2 }]);
+        assert!(map.length() == 2);
+        assert!(map.borrow(0).value == 0);
+        assert!(map.borrow_mut(2).value == 2);
+
+
+        map.mutate!(0, |store_value| {
+            store_value.value = 2;
+        });
+        assert!(map.contains_key(0));
+        assert!(!map.contains_key(1));
+        assert!(map.contains_key(2));
+        assert!(map.keys() == vector[0, 2]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 2 }]);
+        assert!(map.length() == 2);
+        assert!(map.borrow(0).value == 2);
+        assert!(map.borrow_mut(2).value == 2);
+
+        map.remove(0);
+        assert!(!map.contains_key(0));
+        assert!(map.length() == 1);
+        assert!(map.keys() == vector[2]);
+        assert!(map.values() == vector[TestValue { value: 2 }]);
+
+        map.remove(3);
+        assert!(map.length() == 1);
+        assert!(map.keys() == vector[2]);
+        assert!(map.values() == vector[TestValue { value: 2 }]);
+
+        map.set(3, TestValue { value: 0 });
+        assert!(map.contains_key(3));
+        assert!(map.length() == 2);
+        assert!(map.keys() == vector[2, 3]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 0 }]);
+        assert!(map.get(3).value == 0);
+
+        map.set(3, TestValue { value: 3 });
+        assert!(map.contains_key(3));
+        assert!(map.length() == 2);
+        assert!(map.keys() == vector[2, 3]);
+        assert!(map.values() == vector[TestValue { value: 2 }, TestValue { value: 3 }]);
+        assert!(map.get(3).value == 3);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map,
+            immutable_map: storage_map::new(),
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    #[test]
+    public fun test_immutable_map() {
+        let mut scenario = test_scenario::begin(@0x0001);
+        let ctx = test_scenario::ctx(&mut scenario);
+
+        let mut immutable_map = storage_map::new();
+        immutable_map.insert(0, TestStoreValue { value: 0 });
+        immutable_map.insert(1, TestStoreValue { value: 1 });
+        immutable_map.insert(2, TestStoreValue { value: 2 });
+
+        assert!(immutable_map.contains_key(0));
+        assert!(immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 1, 2]);
+        assert!(immutable_map.length() == 3);
+        assert!(immutable_map.borrow(0).value == 0);
+        assert!(immutable_map.borrow(1).value == 1);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+        let detele_store_value = immutable_map.take(1);
+        destroy_value(detele_store_value);
+        assert!(immutable_map.contains_key(0));
+        assert!(!immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 2]);
+        assert!(immutable_map.length() == 2);
+        assert!(immutable_map.borrow(0).value == 0);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+
+        immutable_map.mutate!(0, |store_value| {
+            store_value.value = 2;
+        });
+        assert!(immutable_map.contains_key(0));
+        assert!(!immutable_map.contains_key(1));
+        assert!(immutable_map.contains_key(2));
+        assert!(immutable_map.keys() == vector[0, 2]);
+        assert!(immutable_map.length() == 2);
+        assert!(immutable_map.borrow(0).value == 2);
+        assert!(immutable_map.borrow_mut(2).value == 2);
+
+        public_share_object(TestObject {
+            id: object::new(ctx),
+            value: storage_value::new(),
+            immutable_value: storage_value::new(),
+            map: storage_map::new(),
+            immutable_map,
+            double_map: storage_double_map::new(),
+            immutable_double_map: storage_double_map::new(),
+        });
+
+        scenario.end();
+    }
+
+    // #[test]
+    // public fun test_immutable_map2() {
+    //     let mut scenario = test_scenario::begin(@0x0001);
+    //     let ctx = test_scenario::ctx(&mut scenario);
+    //
+    //     let mut immutable_map = storage_immutable_map::new(ctx);
+    //     immutable_map.set(0, TestValue { value: 1 });
+    //
+    //     // immutable_map.mutate!(|store_value| {
+    //     //     store_value.value = 2;
+    //     // });
+    //     // assert!(immutable_map.get().value == 2);
+    //     // assert!(immutable_map.borrow_mut().value == 2);
+    //     //
+    //     // immutable_map.mutate!(|store_value| {
+    //     //     store_value.value = 3;
+    //     // });
+    //     // assert!(immutable_map.get().value == 3);
+    //     // assert!(immutable_map.borrow_mut().value == 3);
+    //
+    //     public_share_object(TestObject2 {
+    //         id: object::new(ctx),
+    //         value: storage_value::new(TestValue { value: 1 }),
+    //         immutable_value: storage_value::new(TestStoreValue { value: 1 }),
+    //         immutable_map,
+    //     });
+    //
+    //     scenario.end();
+    // }
+
+    // #[test]
+    // public fun test_object() {
+    //     let sender = @0x0001;
+    //     let mut scenario_val = test_scenario::begin(sender);
+    //     let scenario = &mut scenario_val;
+    //
+    //     let obj = TestObject {
+    //         id: object::new(test_scenario::ctx(scenario)),
+    //         value: storage_value::empty(),
+    //     };
+    //     public_share_object(obj);
+    //
+    //     test_scenario::next_tx(scenario, sender);
+    //
+    //     let mut obj = test_scenario::take_shared<TestObject>(scenario);
+    //
+    //     obj.value.set(TestValue { value: 1 });
+    //     assert!(obj.value.contains());
+    //     assert!(!obj.value.is_empty());
+    //     assert!(obj.value.get() == TestValue { value: 1 });
+    //
+    //     obj.value.set(TestValue { value: 2 });
+    //     assert!(obj.value.contains());
+    //     assert!(!obj.value.is_empty());
+    //     assert!(obj.value.get() == TestValue { value: 2 });
+    //
+    //     test_scenario::return_shared<TestObject>(obj);
+    //     test_scenario::end(scenario_val);
+    // }
+}

package/template/nextjs/sui-template/localnet/dubhe-framework/sources/storages/value.move

@@ -1,6 +1,3 @@
-// Copyright (c) Mysten Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
 module dubhe::storage_value {
 
     /// This key does not exist in the map

package/template/nextjs/sui-template/package.json

@@ -5,39 +5,31 @@
   "author": "team@0xobelisk.com",
   "license": "MIT",
   "scripts": {
-    "// Development Environment": "----------------",
-    "dev": "pnpm dev:localnet",
-    "dev:localnet": "pnpm localnet:setup && pnpm next",
-    "dev:testnet": "pnpm testnet:setup && pnpm next",
-    "// Production Environment": "----------------",
-    "prod:localnet": "pnpm config:store localnet && pnpm next",
-    "prod:testnet": "pnpm config:store testnet && pnpm next",
-    "// Local Network": "----------------",
-    "localnet:setup": "pnpm localnet:start && pnpm localnet:wait && pnpm localnet:account && pnpm localnet:faucet && pnpm localnet:deploy",
-    "localnet:start": "pnpm dubhe localnode start -b",
-    "localnet:restart": "pnpm dubhe localnode restart -b",
-    "localnet:stop": "pnpm dubhe localnode stop",
-    "localnet:status": "pnpm dubhe localnode status",
-    "localnet:wait": "NODE_NO_WARNINGS=1 ts-node scripts/waitNode.ts",
-    "localnet:account": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
-    "localnet:faucet": "pnpm dubhe faucet --network localnet",
-    "localnet:deploy": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/localnet/deploy.ts",
-    "// Test Network": "----------------",
-    "testnet:setup": "pnpm testnet:account && pnpm testnet:check-balance && pnpm testnet:deploy",
-    "testnet:account": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
-    "testnet:check-balance": "NODE_NO_WARNINGS=1 ts-node scripts/checkBalance.ts testnet",
-    "testnet:faucet": "pnpm dubhe faucet --network testnet",
-    "testnet:deploy": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/testnet/deploy.ts",
     "// Utility Commands": "----------------",
     "schema:gen": "pnpm dubhe schemagen --configPath ./dubhe.config.ts",
+    "account:gen": "NODE_NO_WARNINGS=1 ts-node scripts/generateAccount.ts",
     "config:store": "ts-node scripts/storeConfig.ts",
+    "start:localnet": "pnpm dubhe localnode start",
+    "faucet": "pnpm dubhe faucet --network",
+    "check-balance": "NODE_NO_WARNINGS=1 ts-node scripts/checkBalance.ts",
+    "deploy:localnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/localnet/deploy.ts",
+    "deploy:testnet": "NODE_NO_WARNINGS=1 ts-node scripts/deployment/testnet/deploy.ts",
+    "// Development Environment": "----------------",
+    "dev": "pnpm dev:localnet",
+    "dev:localnet": "pnpm setup:localnet && pnpm next",
+    "dev:testnet": "pnpm setup:testnet && pnpm next",
+    "setup:localnet": "pnpm account:gen && pnpm faucet localnet && pnpm deploy:localnet",
+    "setup:testnet": "pnpm account:gen && pnpm check-balance testnet && pnpm deploy:testnet",
     "build": "next build",
-    "start": "next start"
+    "start": "next start",
+    "// Production Environment": "----------------",
+    "prod:localnet": "pnpm config:store localnet && pnpm next",
+    "prod:testnet": "pnpm config:store testnet && pnpm next"
   },
   "dependencies": {
-    "@0xobelisk/sui-cli": "^0.5.23",
-    "@0xobelisk/sui-client": "^0.5.27",
-    "@0xobelisk/sui-common": "^0.5.19",
+    "@0xobelisk/sui-cli": "^0.5.25",
+    "@0xobelisk/sui-client": "v0.5.28",
+    "@0xobelisk/sui-common": "^0.5.21",
     "@mysten/dapp-kit": "0.14.9",
     "@mysten/sui": "1.7.0",
     "dotenv": "^16.4.5",

package/template/nextjs/sui-template/scripts/deployment/testnet/deploy.ts

@@ -4,7 +4,7 @@ import { dubheConfig } from '../../../dubhe.config';
 import fs from 'fs/promises';
 import path from 'path';
 
-const TESTNET_FRAMEWORK_ID = '0x1736475f476c5dec96f33c03c778843f572239d3a887d795eef66d2836484c28';
+const TESTNET_FRAMEWORK_ID = '0x417ad1864a56a29ad0b5aaddd2e11bac1eeab6a68883ef53184a4cc5c293fec6';
 
 async function updateDubheMoveToml(projectName: string) {
   try {
@@ -14,7 +14,7 @@ async function updateDubheMoveToml(projectName: string) {
 
     content = content.replace(
       /Dubhe = \{[^}]+\}/,
-      `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" }`,
     );
 
     content = content.replace(/^dubhe\s+=\s+"0x[0-9a-fA-F]+"/m, `dubhe = "${TESTNET_FRAMEWORK_ID}"`);

package/template/nextjs/sui-template/src/chain/config.ts

@@ -2,6 +2,6 @@ type NetworkType = 'testnet' | 'mainnet' | 'devnet' | 'localnet';
 
 export const NETWORK: NetworkType = 'testnet';
 
-export const PACKAGE_ID = '0xde82669197017965ce955ea7a5bb67750218523ca5f942f395b45610a1ec82d0'
+export const PACKAGE_ID = '0x7dea0ab27de6a4c85ddd1cdede7dd0d1a8e5aa77d3c0e9c9268e8a1eb97e73bc'
 
-export const Counter_Object_Id = '0x88b0fcdec5a83cdebb308cbc8e721b146938273bcb439917674155c25ef9e895'
+export const Counter_Object_Id = '0x5a1b868e71da437ba1eabfe7c7d6ee6ba45de5934bf6d36ff321105b6be8a099'

package/template/101/sui-template/localnet/dubhe-framework/README.md

@@ -1,18 +0,0 @@
-## Dubhe Framework
-
-### Testnet
-```txt
-PackageID: 0xf68ab6ceb5cfce6a73d76e5ef64f28d3cbe684413c80232871b31a9df0e09496                 
-Version: 1                                                                                    
-Digest: HwpoK2ZUoxsDzFyeszWzdcAm4aLi5g2CxBq3JBodxA16                                        
-Modules: access_control, events, resource_id, resource_tyeps, schema, world
-
-ObjectID: 0x9f4cd3e0aa5587b2d9191fa20ea877a0d66c6eb6a4f49ec34328122b29d1d9c6
-ObjectType: 0x2::package::UpgradeCap
-```
-
-```shell
-# upgrade
-sui client upgrade --gas-budget 1000000000 --upgrade-capability 0x9f4cd3e0aa5587b2d9191fa20ea877a0d66c6eb6a4f49ec34328122b29d1d9c6
-```
-

package/template/101/sui-template/localnet/dubhe-framework/sources/access_control.move

@@ -1,35 +0,0 @@
-module dubhe::access_control {
-    use dubhe::world::{AdminCap, World};
-    use sui::dynamic_field as df;
-
-    const ENotAdmin: u64 = 4;
-    const EAppNotAuthorized: u64 = 5;
-
-    public struct AppKey<phantom App: drop> has copy, store, drop {}
-    
-    /// Authorize an application to access protected features of the World.
-    public fun authorize_app<App: drop>(admin_cap: &AdminCap, world: &mut World) {
-        assert!(world.admin() == object::id(admin_cap), ENotAdmin);
-        df::add(world.mut_uid(), AppKey<App>{}, true);
-    }
-
-    /// Deauthorize an application by removing its authorization key.
-    public fun deauthorize_app<App: drop>(admin_cap: &AdminCap, world: &mut World): bool {
-        assert!(world.admin() == object::id(admin_cap), ENotAdmin);
-        df::remove(world.mut_uid(), AppKey<App>{})
-    }
-
-    // Check if an application is authorized to access protected features of
-    /// the World.
-    public fun is_app_authorized<App: drop>(world: &World): bool {
-        df::exists_(world.uid(), AppKey<App>{})
-    }
-
-    /// Assert that an application is authorized to access protected features of
-    /// the World. Aborts with `EAppNotAuthorized` if not.
-    public fun assert_app_is_authorized<App: drop>(world: &World) {
-        assert!(is_app_authorized<App>(world), EAppNotAuthorized);
-    }
-
-
-}

package/template/101/sui-template/localnet/dubhe-framework/sources/events.move

@@ -1,23 +0,0 @@
-module dubhe::events {
-    use sui::event;
-
-    public struct SchemaSetRecord<T: copy + drop> has copy, drop {
-        _dubhe_schema_id: vector<u8>,
-        _dubhe_schema_type: u8,
-        _dubhe_entity_key: Option<address>,
-        data: T
-    }
-
-    public struct SchemaRemoveRecord has copy, drop {
-        _dubhe_schema_id: vector<u8>,
-        _dubhe_entity_key: address
-    }
-
-    public fun emit_set<T: copy + drop>(_dubhe_schema_id: vector<u8>, _dubhe_schema_type: u8, _dubhe_entity_key: Option<address>, data: T) {
-        event::emit(SchemaSetRecord { _dubhe_schema_id, _dubhe_schema_type, _dubhe_entity_key, data})
-    }
-
-    public fun emit_remove(_dubhe_schema_id: vector<u8>, _dubhe_entity_key: address) {
-        event::emit(SchemaRemoveRecord { _dubhe_schema_id, _dubhe_entity_key })
-    }
-}