create-dubhe 0.0.19 → 0.1.0

package/template/101/sui-template/contracts/dubhe-framework/sources/storages/double_map.move

@@ -1,153 +1,111 @@
-#[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)
-    }
-}
+module dubhe::storage_double_map;
+
+use std::ascii::{String, string};
+use sui::dynamic_field as field;
+use dubhe::storage_event;
+use std::option::some;
+
+// An entry in the map
+public struct Entry<K1: copy + drop + store, K2: copy + drop + store> has copy, drop, store {
+    key1: K1,
+    key2: K2,
+}
+
+public struct StorageDoubleMap<phantom K1: copy + drop + store, phantom K2: copy + drop + store, phantom V: copy + drop + store> has key, store {
+    /// the ID of this Storage
+    id: UID,
+    // the name of the Storage
+    name: String,
+    /// the number of key-value pairs in the Storage
+    size: u64,
+}
+
+/// Creates a new, empty table
+public fun new<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(name: vector<u8>, ctx: &mut TxContext): StorageDoubleMap<K1, K2, V> {
+    StorageDoubleMap {
+        id: object::new(ctx),
+        name: string(name),
+        size: 0,
+    }
+}
+
+/// Adds a key-value pair to the table `table: &mut Table<K, V>`
+public fun set<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &mut StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2, v: V) {
+    let k = Entry { key1: k1, key2: k2 };
+    if (table.contains(k1, k2)) {
+        field::remove<Entry<K1, K2>, V>(&mut table.id, k);
+        field::add(&mut table.id, k, v);
+    } else {
+        field::add(&mut table.id, k, v);
+        table.size = table.size + 1;
+    };
+    storage_event::emit_set_record<K1, K2, V>(table.name, some(k1), some(k2), some(v));
+}
+
+/// Immutable borrows the value associated with the key in the table `table: &Table<K, V>`.
+public fun try_get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2): Option<V> {
+    if (table.contains(k1, k2)) {
+        option::some(table[k1, k2])
+    } else {
+        option::none()
+    }
+}
+
+#[syntax(index)]
+/// Immutable borrows the value associated with the key in the table `table: &Table<K, V>`.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun get<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2): &V {
+    let k = Entry { key1: k1, key2: k2 };
+    field::borrow(&table.id, k)
+}
+
+/// Removes the key-value pair in the table `table: &mut Table<K, V>` and returns the value.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun remove<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &mut StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2) {
+    if (table.contains(k1, k2)) {
+        let k = Entry { key1: k1, key2: k2 };
+        field::remove<Entry<K1, K2>, V>(&mut table.id, k);
+        table.size = table.size - 1;
+        storage_event::emit_remove_record<K1, K2>(table.name, some(k1), some(k2));
+    }
+}
+
+/// Removes the key-value pair in the table `table: &mut Table<K, V>` and returns the value.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun try_remove<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &mut StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2): Option<V> {
+    if (table.contains(k1, k2)) {
+        let k = Entry { key1: k1, key2: k2 };
+        let v = field::remove<Entry<K1, K2>, V>(&mut table.id, k);
+        table.size = table.size - 1;
+        storage_event::emit_remove_record<K1, K2>(table.name, some(k1), some(k2));
+        option::some(v)
+    } else {
+        option::none()
+    }
+}
+
+/// Returns true iff there is a value associated with the key `k: K` in table `table: &Table<K, V>`
+public fun contains<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &StorageDoubleMap<K1, K2, V>, k1: K1, k2: K2): bool {
+    let k = Entry { key1: k1, key2: k2 };
+    field::exists_with_type<Entry<K1, K2>, V>(&table.id, k)
+}
+
+/// Returns the size of the table, the number of key-value pairs
+public fun length<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &StorageDoubleMap<K1, K2, V>): u64 {
+    table.size
+}
+
+/// Returns true iff the table is empty (if `length` returns `0`)
+public fun is_empty<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: &StorageDoubleMap<K1, K2, V>): bool {
+    table.size == 0
+}
+
+/// Drop a possibly non-empty table.
+/// Usable only if the value type `V` has the `drop` ability
+public fun drop<K1: copy + drop + store, K2: copy + drop + store, V: copy + drop + store>(table: StorageDoubleMap<K1, K2, V>) {
+    let StorageDoubleMap { id, name: _, size: _ } = table;
+    id.delete()
+}

package/template/101/sui-template/contracts/dubhe-framework/sources/storages/map.move

@@ -1,156 +1,102 @@
-#[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
-    }
+module dubhe::storage_map;
+
+use std::ascii::String;
+use std::ascii::string;
+use sui::dynamic_field as field;
+use dubhe::storage_event;
+use std::option::some;
+use std::option::none;
+
+public struct StorageMap<phantom K: copy + drop + store, phantom V: copy + drop + store> has key, store {
+    /// the ID of this Storage
+    id: UID,
+    // the name of the Storage
+    name: String,
+    /// the number of key-value pairs in the Storage
+    size: u64,
+}
 
-    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));
+/// Creates a new, empty table
+public fun new<K: copy + drop + store, V: copy + drop + store>(name: vector<u8>, ctx: &mut TxContext): StorageMap<K, V> {
+    StorageMap {
+        id: object::new(ctx),
+        name: string(name),
+        size: 0,
     }
+}
 
-    /// 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
-    }
+/// Adds a key-value pair to the table `table: &mut Table<K, V>`
+public fun set<K: copy + drop + store, V: copy + drop + store>(table: &mut StorageMap<K, V>, k: K, v: V) {
+    if (table.contains(k)) {
+        field::remove<K, V>(&mut table.id, k);
+        field::add(&mut table.id, k, v);
+    } else {
+        field::add(&mut table.id, k, v);
+        table.size = table.size + 1;
+    };
+    storage_event::emit_set_record<K, K, V>(table.name, some(k), none(), some(v));
+}
 
-    /// 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})
+/// Immutable borrows the value associated with the key in the table `table: &Table<K, V>`.
+public fun try_get<K: copy + drop + store, V: copy + drop + store>(table: &StorageMap<K, V>, k: K): Option<V> {
+    if (table.contains(k)) {
+        option::some(table[k])
+    } else {
+        option::none()
     }
+}
 
-    /// 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()
-    }
+#[syntax(index)]
+/// Immutable borrows the value associated with the key in the table `table: &Table<K, V>`.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun get<K: copy + drop + store, V: copy + drop + store>(table: &StorageMap<K, V>, k: K): &V {
+    field::borrow(&table.id, k)
+}
 
-    /// 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 })
+/// Removes the key-value pair in the table `table: &mut Table<K, V>` and returns the value.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun remove<K: copy + drop + store, V: copy + drop + store>(table: &mut StorageMap<K, V>, k: K) {
+    if (table.contains(k)) {
+        field::remove<K, V>(&mut table.id, k);
+        table.size = table.size - 1;
+        storage_event::emit_remove_record<K, K>(table.name, some(k), none());
     }
+}
 
-    // =======================================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 })
-        }
+/// Removes the key-value pair in the table `table: &mut Table<K, V>` and returns the value.
+/// Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry with
+/// that key `k: K`.
+public fun try_remove<K: copy + drop + store, V: copy + drop + store>(table: &mut StorageMap<K, V>, k: K): Option<V> {
+    if (table.contains(k)) {
+        let v = field::remove(&mut table.id, k);
+        table.size = table.size - 1;
+        storage_event::emit_remove_record<K, K>(table.name, some(k), none());
+        option::some(v)
+    } else {
+        option::none()
     }
+}
 
-    /// 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
-    }
+/// Returns true iff there is a value associated with the key `k: K` in table `table: &Table<K, V>`
+public fun contains<K: copy + drop + store, V: copy + drop + store>(table: &StorageMap<K, V>, k: K): bool {
+    field::exists_with_type<K, V>(&table.id, k)
+}
 
-    /// 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()
-        }
-    }
+/// Returns the size of the table, the number of key-value pairs
+public fun length<K: copy + drop + store, V: copy + drop + store>(table: &StorageMap<K, V>): u64 {
+    table.size
+}
 
-    /// 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 true iff the table is empty (if `length` returns `0`)
+public fun is_empty<K: copy + drop + store, V: copy + drop + store>(table: &StorageMap<K, V>): bool {
+    table.size == 0
+}
 
-    // 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)
-    }
+/// Drop a possibly non-empty table.
+/// Usable only if the value type `V` has the `drop` ability
+public fun drop<K: copy + drop + store, V: copy + drop + store>(table: StorageMap<K, V>) {
+    let StorageMap { id, name: _, size: _ } = table;
+    id.delete()
 }

package/template/{nextjs/sui-template/contracts/dubhe-framework/sources/storages/migration.move → 101/sui-template/contracts/dubhe-framework/sources/storages/storage.move}

@@ -1,8 +1,8 @@
-module dubhe::storage_migration {
+module dubhe::storage {
     use sui::dynamic_field as df;
 
-    public fun add_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>, storagre_type: StorageType) {
-        df::add(uid, field_name, storagre_type);
+    public fun add_field<StorageType: store>(uid: &mut UID, field_name: vector<u8>, storage_type: StorageType) {
+        df::add(uid, field_name, storage_type);
     }
 
     public fun borrow_field<StorageType: store>(uid: &UID, field_name: vector<u8>): &StorageType {