create-dubhe 0.0.4 → 0.0.5

package/template/contract/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/contract/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/contract/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/contract/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);
+    }
+}

package/template/contract/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/contract/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/contract/sui-template/localnet/dubhe-framework/sources/storages/double_map.move

@@ -0,0 +1,153 @@
+#[allow(unused_variable)]
+module dubhe::storage_double_map {
+
+    // This key does not exist in the map
+    const EKeyDoesNotExist: u64 = 0;
+
+    /// This key already exists in the map
+    const EKeyAlreadyExists: u64 = 1;
+
+    // An entry in the map
+    public struct Entry<K1: copy + drop + store, K2: copy + drop + store, V: store> has copy, drop, store {
+        key1: K1,
+        key2: K2,
+        value: V,
+    }
+
+    // A map data structure backed by a vector. The map is guaranteed not to contain duplicate keys, but entries
+    public struct StorageDoubleMap<K1: copy + drop + store, K2: copy + drop + store, V: store> has store {
+        contents: vector<Entry<K1, K2, V>>,
+    }
+
+    // Create an empty `StorageDoubleMap`
+    public fun new<K1: copy + drop + store, K2: copy + drop + store, V: store>(): StorageDoubleMap<K1, K2,V> {
+        StorageDoubleMap { contents: vector[] }
+    }
+
+    // Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains_key<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): bool {
+        get_idx_opt(self, key1, key2).is_some()
+    }
+
+    // Return the number of entries in `self`
+    public fun length<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>): u64 {
+        self.contents.length()
+    }
+
+    // Get a reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun borrow<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): &V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &self.contents[idx];
+        &entry.value
+    }
+
+    // Get a mutable reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun borrow_mut<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): &mut V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &mut self.contents[idx];
+        &mut entry.value
+    }
+
+    // Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2): V {
+        let idx = self.get_idx(key1, key2);
+        let Entry { key1, key2, value } = self.contents.remove(idx);
+        value
+    }
+
+    public macro fun mutate<$K1: copy + drop, $K2: copy + drop, $V: copy + drop>(
+        $self: &mut StorageDoubleMap<$K1, $K2, $V>,
+        $key1: $K1,
+        $key2: $K2,
+        $f: |&mut $V|
+    ) {
+        let self = $self;
+        let key1 = $key1;
+        let key2 = $key2;
+        $f(borrow_mut(self, key1, key2));
+    }
+
+    // Returns a list of keys in the map.
+    // Do not assume any particular ordering.
+    public fun keys<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>): (vector<K1>, vector<K2>) {
+        let mut i = 0;
+        let n = self.contents.length();
+        let mut keys1 = vector[];
+        let mut keys2 = vector[];
+        while (i < n) {
+            let entry = self.contents.borrow(i);
+            keys1.push_back(entry.key1);
+            keys2.push_back(entry.key2);
+            i = i + 1;
+        };
+        (keys1, keys2)
+    }
+
+    // Find the index of `key` in `self`. Return `None` if `key` is not in `self`.
+    // Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx_opt<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): Option<u64> {
+        self.contents.find_index!(|entry| { entry.key1 == key1 && entry.key2 == key2 })
+    }
+
+    // Find the index of `key` in `self`. Aborts if `key` is not in `self`.
+    // Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): u64 {
+        let idx_opt = self.get_idx_opt(key1, key2);
+        assert!(idx_opt.is_some(), EKeyDoesNotExist);
+        idx_opt.destroy_some()
+    }
+
+    /// Insert the entry `key` |-> `value` into `self`.
+    /// Aborts if `key` is already bound in `self`.
+    public fun insert<K1: copy + drop + store, K2: copy + drop + store, V: store>(self: &mut StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2, value: V) {
+        assert!(!self.contains_key(key1, key2), EKeyAlreadyExists);
+        self.contents.push_back(Entry { key1, key2, value })
+    }
+
+    // =======================================Value: drop + copy + store=======================================
+
+    // Insert the entry `key` |-> `value` into `self`.
+    public fun set<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2, value: V) {
+        let idx = self.get_idx_opt(key1, key2);
+        if (idx.is_some()) {
+            self.contents[idx.destroy_some()].value = value;
+        } else {
+            self.contents.push_back(Entry { key1, key2, value })
+        }
+    }
+
+    // Get a reference to the value bound to `key` in `self`.
+    // Aborts if `key` is not bound in `self`.
+    public fun get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): V {
+        let idx = self.get_idx(key1, key2);
+        let entry = &self.contents[idx];
+        entry.value
+    }
+
+    // Safely try borrow a value bound to `key` in `self`.
+    // Return Some(V) if the value exists, None otherwise.
+    // Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>, key1: K1, key2: K2): Option<V> {
+        if (self.contains_key(key1, key2)) {
+            option::some(get(self, key1, key2))
+        } else {
+            option::none()
+        }
+    }
+
+    // Remove the entry `key` |-> `value` from self.
+    public fun remove<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &mut StorageDoubleMap<K1, K2,V>, key1: K1, key2: K2) {
+        let idx = self.get_idx_opt(key1, key2);
+        if (idx.is_some()) {
+            self.contents.remove(idx.destroy_some());
+        }
+    }
+
+    // Returns a list of values in the map.
+    // Do not assume any particular ordering.
+    public fun values<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(self: &StorageDoubleMap<K1, K2, V>): vector<V> {
+        self.contents.map!(|entry| entry.value)
+    }
+}

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

@@ -0,0 +1,156 @@
+#[allow(unused_variable)]
+module dubhe::storage_map {
+
+    /// This key already exists in the map
+    const EKeyAlreadyExists: u64 = 0;
+
+    /// This key does not exist in the map
+    const EKeyDoesNotExist: u64 = 1;
+
+    /// An entry in the map
+    public struct Entry<K: copy + drop + store, V: store> has copy, drop, store {
+        key: K,
+        value: V,
+    }
+
+    /// A map data structure backed by a vector. The map is guaranteed not to contain duplicate keys, but entries
+    /// are *not* sorted by key--entries are included in insertion order.
+    /// All operations are O(N) in the size of the map--the intention of this data structure is only to provide
+    /// the convenience of programming against a map API.
+    /// Large maps should use handwritten parent/child relationships instead.
+    /// Maps that need sorted iteration rather than insertion order iteration should also be handwritten.
+    public struct StorageMap<K: copy + drop + store, V: store> has store {
+        contents: vector<Entry<K, V>>,
+    }
+
+    /// Create an empty `StorageMap`
+    public fun new<K: copy + drop + store, V: store>(): StorageMap<K, V> {
+        StorageMap { contents: vector[] }
+    }
+
+    /// Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains_key<K: copy + drop + store, V: store>(self: &StorageMap<K, V>, key: K): bool {
+        get_idx_opt(self, key).is_some()
+    }
+
+    /// Return the number of entries in `self`
+    public fun length<K: copy + drop + store, V: store>(self: &StorageMap<K,V>): u64 {
+        self.contents.length()
+    }
+
+    /// Get a reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun borrow<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): &V {
+        let idx = self.get_idx(key);
+        let entry = &self.contents[idx];
+        &entry.value
+    }
+
+
+    /// Get a mutable reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun borrow_mut<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K): &mut V {
+        let idx = self.get_idx(key);
+        let entry = &mut self.contents[idx];
+        &mut entry.value
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K): V {
+        let idx = self.get_idx(key);
+        let Entry { key, value } = self.contents.remove(idx);
+        value
+    }
+
+    public macro fun mutate<$K: copy + drop + store, $V: store>(
+        $self: &mut StorageMap<$K, $V>,
+        $key: $K,
+        $f: |&mut $V|
+    ) {
+        let self = $self;
+        let key = $key;
+        $f(borrow_mut(self, key));
+    }
+
+    /// Returns a list of keys in the map.
+    /// Do not assume any particular ordering.
+    public fun keys<K: copy + drop + store, V: store>(self: &StorageMap<K, V>): vector<K> {
+        let mut i = 0;
+        let n = self.contents.length();
+        let mut keys = vector[];
+        while (i < n) {
+            let entry = self.contents.borrow(i);
+            keys.push_back(entry.key);
+            i = i + 1;
+        };
+        keys
+    }
+
+    /// Find the index of `key` in `self`. Return `None` if `key` is not in `self`.
+    /// Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx_opt<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): Option<u64> {
+        self.contents.find_index!(|entry| { entry.key == key})
+    }
+
+    /// Find the index of `key` in `self`. Aborts if `key` is not in `self`.
+    /// Note that map entries are stored in insertion order, *not* sorted by key.
+    public fun get_idx<K: copy + drop + store, V: store>(self: &StorageMap<K,V>, key: K): u64 {
+        let idx_opt = self.get_idx_opt(key);
+        assert!(idx_opt.is_some(), EKeyDoesNotExist);
+        idx_opt.destroy_some()
+    }
+
+    /// Insert the entry `key` |-> `value` into `self`.
+    /// Aborts if `key` is already bound in `self`.
+    public fun insert<K: copy + drop + store, V: store>(self: &mut StorageMap<K,V>, key: K, value: V) {
+        assert!(!self.contains_key(key), EKeyAlreadyExists);
+        self.contents.push_back(Entry { key, value })
+    }
+
+    // =======================================Value: drop + copy + store=======================================
+
+    /// Adds a key-value pair to the self `self: &mut StorageMap<K, V>`
+    /// Aborts with `sui::dynamic_field::EFieldAlreadyExists` if the self already has an entry with
+    /// that key `k: K`.
+    public fun set<K: copy + drop + store, V: copy + drop + store>(self: &mut StorageMap<K, V>, key: K, value: V) {
+        let idx = self.get_idx_opt(key);
+        if (idx.is_some()) {
+            self.contents[idx.destroy_some()].value = value;
+        } else {
+            self.contents.push_back(Entry { key, value })
+        }
+    }
+
+    /// Get a reference to the value bound to `key` in `self`.
+    /// Aborts if `key` is not bound in `self`.
+    public fun get<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K,V>, key: K): V {
+        let idx = self.get_idx(key);
+        let entry = &self.contents[idx];
+        entry.value
+    }
+
+    /// Safely try borrow a value bound to `key` in `self`.
+    /// Return Some(V) if the value exists, None otherwise.
+    /// Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K,V>, key: K): Option<V> {
+        if (self.contains_key(key)) {
+            option::some(get(self, key))
+        } else {
+            option::none()
+        }
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun remove<K: copy + drop + store, V: copy + drop + store>(self: &mut StorageMap<K,V>, key: K) {
+        let idx = self.get_idx_opt(key);
+        if (idx.is_some()) {
+            self.contents.remove(idx.destroy_some());
+        }
+    }
+
+    // Returns a list of values in the map.
+    // Do not assume any particular ordering.
+    public fun values<K: copy + drop + store, V: copy + drop + store>(self: &StorageMap<K, V>): vector<V> {
+        self.contents.map!(|entry| entry.value)
+    }
+}

package/template/contract/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/contract/sui-template/localnet/dubhe-framework/sources/storages/value.move

@@ -0,0 +1,97 @@
+module dubhe::storage_value {
+
+    /// This key does not exist in the map
+    const EValueDoesNotExist: u64 = 0;
+
+    /// This key does not exist in the map
+    const EValueAlreadyExist: u64 = 1;
+
+    /// An entry in the value
+    public struct Entry<Value: store> has copy, drop, store {
+        value: Value,
+    }
+
+    /// A storable handler for values in general. Is used in the `StorageValue`
+    public struct StorageValue<Value: store> has store {
+        contents: vector<Entry<Value>>,
+    }
+
+    /// Creates a new, empty StorageValue
+    public fun new<Value: store>(): StorageValue<Value> {
+        StorageValue { contents: vector[] }
+    }
+
+    /// Gets the value of the StorageValue `self: &StorageValue<Value>`.
+    public fun borrow<Value: store>(self: &StorageValue<Value>): &Value {
+        assert!(self.contains(), EValueDoesNotExist);
+        &self.contents[0].value
+    }
+
+    /// Gets the value of the StorageValue `self: &mut StorageValue<Value>`.
+    public fun borrow_mut<Value: store>(self: &mut StorageValue<Value>): &mut Value {
+        assert!(self.contains(), EValueDoesNotExist);
+        &mut self.contents[0].value
+    }
+
+    /// Update the `value` of the `StorageValue`.
+    public macro fun mutate<$Value: store>($self: &mut StorageValue<$Value>, $f: |&mut $Value|) {
+        let self = $self;
+        $f(borrow_mut(self));
+    }
+
+    /// Return true if `self` contains_key an entry for `key`, false otherwise
+    public fun contains<V: store>(self: &StorageValue<V>): bool {
+        self.contents.length() == 1
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun take<V: store>(self: &mut StorageValue<V>): V {
+        assert!(self.contains(), EValueDoesNotExist);
+        let Entry { value } = self.contents.remove(0);
+        value
+    }
+
+    /// Set the `value` of the `StorageValue`.
+    public fun put<V: store>(self: &mut StorageValue<V>, value: V) {
+        assert!(!self.contains(), EValueAlreadyExist);
+        self.contents.push_back(Entry { value });
+    }
+
+
+    // ======================================= Value: drop + copy + store =======================================
+
+    /// Set the `value` of the `StorageValue`.
+    public fun set<V: copy + drop + store>(self: &mut StorageValue<V>, value: V) {
+        if (self.contains()) {
+            *self.borrow_mut() = value;
+        } else {
+            self.contents.push_back(Entry { value });
+        }
+    }
+
+    /// Get the `value` of the `StorageValue`.
+    public fun get<V: copy + drop + store>(self: &StorageValue<V>): V {
+        assert!(self.contains(), EValueDoesNotExist);
+        self.contents[0].value
+    }
+
+    /// Safely try borrow a value bound to `key` in `self`.
+    /// Return Some(V) if the value exists, None otherwise.
+    /// Only works for a "copyable" value as references cannot be stored in `vector`.
+    public fun try_get<V: copy + drop + store>(self: &StorageValue<V>): Option<V> {
+        if (self.contains()) {
+            option::some(self.contents[0].value)
+        } else {
+            option::none()
+        }
+    }
+
+    /// Remove the entry `key` |-> `value` from self. Aborts if `key` is not bound in `self`.
+    public fun remove<V: copy + drop + store>(self: &mut StorageValue<V>) {
+        if (self.contains()) {
+            self.contents.remove(0);
+        }
+    }
+
+    // ============================================================================================
+}