create-dubhe 0.0.19 → 0.1.1

package/template/contract/sui-template/contracts/dubhe-framework/sources/storages/tests.move

@@ -1,195 +1,49 @@
 #[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();
+        let mut value = storage_value::new(b"value", ctx);
         value.set(TestValue { value: 1 });
+        assert!(value.contains() == true);
         assert!(value.get() == TestValue { value: 1 });
-        assert!(*value.borrow() == TestValue { value: 1 });
-        assert!(*value.borrow_mut() == TestValue { value: 1 });
+        assert!(value[] == TestValue { value: 1 });
 
         value.set(TestValue { value: 2 });
         assert!(value.get() == TestValue { value: 2 });
-
-        value.mutate!(|value| {
-            *value = TestValue { value: 3 };
-        });
+        value.set(TestValue { value: 3 });
         assert!(value.get() == TestValue { value: 3 });
+        assert!(value.try_get() == option::some(TestValue { value: 3 }));
+        assert!(value.is_empty() == false);
 
-        value.set(TestValue { value: 4 });
-        assert!(value.get() == TestValue { value: 4 });
-
+        value.remove();
+        assert!(value.contains() == false);
+        assert!(value.try_get() == option::none<TestValue>());
+        assert!(value.is_empty() == true);
 
-        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(),
+        value.set(TestValue { value: 4 });
+        assert!(value.contains() == true);
+        assert!(value.try_remove() == option::some(TestValue { value: 4 }));
+        assert!(value.try_remove() == option::none<TestValue>());
+        assert!(value.contains() == false);
+
+        let x: u64 = 0;
+        x.range_do!(1000, |x| {
+            value.set(TestValue { value: x });
         });
 
+        value.drop();
         scenario.end();
     }
 
@@ -198,201 +52,95 @@ module dubhe::storage_tests {
         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 });
+        let mut map = storage_map::new(b"TestValueMap", ctx);
+        assert!(map.is_empty() == true);
+        assert!(map.length() == 0);
+        map.set(0, TestValue { value: 0 });
+        map.set(1, TestValue { value: 1 });
+        map.set(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[0] == TestValue { value: 0 });
+        assert!(map.get(0) == TestValue { value: 0 });
         assert!(map.try_get(0) == option::some(TestValue { value: 0 }));
+        assert!(map[1] == TestValue { value: 1 });
+        assert!(map.get(1) == TestValue { value: 1 });
         assert!(map.try_get(1) == option::some(TestValue { value: 1 }));
+        assert!(map[2] == TestValue { value: 2 });
+        assert!(map.get(2) == TestValue { value: 2 });
         assert!(map.try_get(2) == option::some(TestValue { value: 2 }));
         assert!(map.try_get(3) == option::none());
+        assert!(map.contains(0) == true);
+        assert!(map.contains(1) == true);
+        assert!(map.contains(2) == true);
+        assert!(map.contains(3) == false);
+        assert!(map.is_empty() == false);
+        assert!(map.length() == 3);
 
-        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 }]);
+        map.remove(1);
+        assert!(map.try_get(1) == option::none());
+        assert!(map.contains(0) == true);
+        assert!(map.contains(1) == false);
+        assert!(map.contains(2) == true);
         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.try_remove(2) == option::some(TestValue { value: 2 }));
+        assert!(map.contains(2) == false);
         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(),
+        let x: u32 = 1000;
+        x.range_do!(2000, |x| {
+            map.set(x, TestValue { value: 2 });
         });
 
+        map.drop();
         scenario.end();
     }
 
     #[test]
-    public fun test_immutable_map() {
+    public fun test_double_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 });
+        let mut double_map = storage_double_map::new(b"TestValueDoubleMap", ctx);
 
-        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);
+        double_map.set(0, 0, TestValue { value: 0 });
+        double_map.set(0, 0, TestValue { value: 0 });
+        double_map.set(0, 1, TestValue { value: 1 });
+        double_map.set(0, 2, TestValue { 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);
+        assert!(double_map.contains(0, 0));
+        assert!(double_map.contains(0, 1));
+        assert!(double_map.contains(0, 2));
+        assert!(double_map.length() == 3);
+        assert!(double_map.is_empty() == false);
 
+        assert!(double_map.get(0, 0) == TestValue { value: 0 });
+        assert!(double_map[0, 0] == TestValue { value: 0 });
+        assert!(double_map.try_get(0, 0) == option::some(TestValue { value: 0 }));
+        assert!(double_map.get(0, 1) == TestValue { value: 1 });
+        assert!(double_map[0, 1] == TestValue { value: 1 });
+        assert!(double_map.try_get(0, 1) == option::some(TestValue { value: 1 }));
+        assert!(double_map.get(0, 2) == TestValue { value: 2 });
+        assert!(double_map[0, 2] == TestValue { value: 2 });
+        assert!(double_map.try_get(0, 2) == option::some(TestValue { 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);
+        double_map.remove(0, 1);
+        assert!(double_map.try_get(0, 1) == option::none());
+        assert!(double_map.contains(0, 1) == false);
+        assert!(double_map.length() == 2);
+
+        assert!(double_map.try_remove(0, 2) == option::some(TestValue { value: 2 }));
+        assert!(double_map.try_get(0, 2) == option::none());
+        assert!(double_map.contains(0, 2) == false);
+        assert!(double_map.length() == 1);
 
-        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(),
+        let x: u32 = 1000;
+        x.range_do!(1000, |x| {
+            double_map.set(x, x, TestValue { value: 2 });
         });
 
+        double_map.drop();
         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/contract/sui-template/contracts/dubhe-framework/sources/storages/value.move

@@ -1,97 +1,91 @@
-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));
-    }
+module dubhe::storage_value;
+
+use std::ascii::{String, string};
+use sui::dynamic_field as field;
+use dubhe::storage_event;
+use std::option::some;
+use std::option::none;
+
+public struct StorageValue<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,
+}
 
-    /// 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
+/// Creates a new, empty table
+public fun new<V: copy + drop + store>(name: vector<u8>, ctx: &mut TxContext): StorageValue<V> {
+    StorageValue {
+        id: object::new(ctx),
+        name: string(name),
+        size: 0,
     }
+}
 
-    /// 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
-    }
+/// Adds a key-value pair to the table `table: &mut Table<K, V>`
+public fun set<V: copy + drop + store>(table: &mut StorageValue<V>, v: V) {
+    if (table.contains()) {
+        field::remove<u8, V>(&mut table.id, 0);
+    };
+    field::add<u8, V>(&mut table.id, 0, v);
+    storage_event::emit_set_record<u8, u8, V>(table.name, none(), none(), some(v));
+}
 
-    /// Put 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 });
+/// Immutable borrows the value associated with the key in the table `table: &Table<K, V>`.
+public fun try_get<V: copy + drop + store>(table: &StorageValue<V>): Option<V> {
+    if (table.contains()) {
+        option::some(table[])
+    } 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<V: copy + drop + store>(table: &StorageValue<V>): &V {
+    field::borrow<u8, V>(&table.id, 0)
+}
 
-    // ======================================= 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 });
-        }
+/// 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<V: copy + drop + store>(table: &mut StorageValue<V>) {
+    if (table.contains()) {
+        field::remove<u8, V>(&mut table.id, 0);
+        storage_event::emit_remove_record<u8, u8>(table.name, none(), none());
     }
+}
 
-    /// 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
+/// 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<V: copy + drop + store>(table: &mut StorageValue<V>): Option<V> {
+    if (table.contains()) {
+        let v = field::remove<u8, V>(&mut table.id, 0);
+        storage_event::emit_remove_record<u8, u8>(table.name, none(), none());
+        option::some(v)
+    } else {
+        option::none()
     }
+}
 
-    /// 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()
-        }
-    }
+/// Returns true iff there is a value associated with the key `k: K` in table `table: &Table<K, V>`
+public fun contains<V: copy + drop + store>(table: &StorageValue<V>): bool {
+    field::exists_with_type<u8, V>(&table.id, 0)
+}
 
-    /// 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);
-        }
-    }
+/// Returns true iff the table is empty (if `length` returns `0`)
+public fun is_empty<V: copy + drop + store>(table: &StorageValue<V>): bool {
+    !field::exists_with_type<u8, V>(&table.id, 0)
+}
 
-    // ============================================================================================
+/// Drop a possibly non-empty table.
+/// Usable only if the value type `V` has the `drop` ability
+public fun drop<V: copy + drop + store>(table: StorageValue<V>) {
+    let StorageValue { id, name: _, size: _ } = table;
+    id.delete()
 }