create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/property_map.move

@@ -1,907 +0,0 @@
-/// `PropertyMap` provides generic metadata support for `SimpleNft` and `SoulBoundToken`. It is a specialization of
-/// `Table` that enforces strict typing with minimal storage use by using constant u64 to
-/// represent types and storing values in bcs format.
-module initia_std::property_map {
-    use std::bcs;
-    use std::vector;
-    use std::error;
-    use std::string::{Self, String};
-    use std::signer;
-    use initia_std::from_bcs;
-    use initia_std::simple_map::{Self, SimpleMap};
-    use initia_std::type_info;
-    use initia_std::object::{Self, Object};
-
-    // Errors
-    /// The property map does not exist
-    const EPROPERTY_MAP_DOES_NOT_EXIST: u64 = 1;
-    /// The property key already exists
-    const EKEY_ALREADY_EXISTS_IN_PROPERTY_MAP: u64 = 2;
-    /// The number of properties exceeds the maximum
-    const ETOO_MANY_PROPERTIES: u64 = 3;
-    /// Property key and value counts do not match
-    const EKEY_VALUE_COUNT_MISMATCH: u64 = 4;
-    /// Property key and type counts do not match
-    const EKEY_TYPE_COUNT_MISMATCH: u64 = 5;
-    /// Property value does not match expected type
-    const ETYPE_MISMATCH: u64 = 6;
-    /// Invalid value type specified
-    const ETYPE_INVALID: u64 = 7;
-    /// The key of the property is too long
-    const EPROPERTY_MAP_KEY_TOO_LONG: u64 = 8;
-
-    // Constants
-    /// Maximum number of items in a `PropertyMap`
-    const MAX_PROPERTY_MAP_SIZE: u64 = 1000;
-    /// Maximum number of characters in a property name
-    const MAX_PROPERTY_NAME_LENGTH: u64 = 128;
-
-    // PropertyValue::type
-    const BOOL: u8 = 0;
-    const U8: u8 = 1;
-    const U16: u8 = 2;
-    const U32: u8 = 3;
-    const U64: u8 = 4;
-    const U128: u8 = 5;
-    const U256: u8 = 6;
-    const ADDRESS: u8 = 7;
-    const BYTE_VECTOR: u8 = 8;
-    const STRING: u8 = 9;
-
-    // Structs
-
-    /// A Map for typed key to value mapping, the contract using it
-    /// should keep track of what keys are what types, and parse them accordingly.
-    struct PropertyMap has drop, key {
-        inner: SimpleMap<String, PropertyValue>
-    }
-
-    /// A typed value for the `PropertyMap` to ensure that typing is always consistent
-    struct PropertyValue has drop, store {
-        type: u8,
-        value: vector<u8>
-    }
-
-    /// A mutator ref that allows for mutation of the property map
-    struct MutatorRef has drop, store {
-        self: address
-    }
-
-    public fun init(s: &signer, container: PropertyMap) {
-        move_to(s, container);
-    }
-
-    /// Burns the entire property map
-    /// TODO: handle when table is not empty
-    public fun burn(ref: MutatorRef) acquires PropertyMap {
-        move_from<PropertyMap>(ref.self);
-    }
-
-    /// Helper for external entry functions to produce a valid container for property values.
-    public fun prepare_input(
-        keys: vector<String>,
-        types: vector<String>,
-        values: vector<vector<u8>>
-    ): PropertyMap {
-        let length = vector::length(&keys);
-        assert!(
-            length <= MAX_PROPERTY_MAP_SIZE,
-            error::invalid_argument(ETOO_MANY_PROPERTIES)
-        );
-        assert!(
-            length == vector::length(&values),
-            error::invalid_argument(EKEY_VALUE_COUNT_MISMATCH)
-        );
-        assert!(
-            length == vector::length(&types),
-            error::invalid_argument(EKEY_TYPE_COUNT_MISMATCH)
-        );
-
-        let container = simple_map::create<String, PropertyValue>();
-        while (!vector::is_empty(&keys)) {
-            let key = vector::pop_back(&mut keys);
-            assert!(
-                string::length(&key) <= MAX_PROPERTY_NAME_LENGTH,
-                error::invalid_argument(EPROPERTY_MAP_KEY_TOO_LONG)
-            );
-
-            let value = vector::pop_back(&mut values);
-            let type = vector::pop_back(&mut types);
-
-            let new_type = to_internal_type(type);
-            validate_type(new_type, value);
-
-            simple_map::add(
-                &mut container,
-                key,
-                PropertyValue { value, type: new_type }
-            );
-        };
-
-        PropertyMap { inner: container }
-    }
-
-    /// Maps `String` representation of types from their `u8` representation
-    inline fun to_external_type(type: u8): String {
-        if (type == BOOL) {
-            string::utf8(b"bool")
-        } else if (type == U8) {
-            string::utf8(b"u8")
-        } else if (type == U16) {
-            string::utf8(b"u16")
-        } else if (type == U32) {
-            string::utf8(b"u32")
-        } else if (type == U64) {
-            string::utf8(b"u64")
-        } else if (type == U128) {
-            string::utf8(b"u128")
-        } else if (type == U256) {
-            string::utf8(b"u256")
-        } else if (type == ADDRESS) {
-            string::utf8(b"address")
-        } else if (type == BYTE_VECTOR) {
-            string::utf8(b"vector<u8>")
-        } else if (type == STRING) {
-            string::utf8(b"0x1::string::String")
-        } else {
-            abort(error::invalid_argument(ETYPE_INVALID))
-        }
-    }
-
-    /// Maps the `String` representation of types to `u8`
-    inline fun to_internal_type(type: String): u8 {
-        if (type == string::utf8(b"bool")) { BOOL }
-        else if (type == string::utf8(b"u8")) { U8 }
-        else if (type == string::utf8(b"u16")) { U16 }
-        else if (type == string::utf8(b"u32")) { U32 }
-        else if (type == string::utf8(b"u64")) { U64 }
-        else if (type == string::utf8(b"u128")) { U128 }
-        else if (type == string::utf8(b"u256")) { U256 }
-        else if (type == string::utf8(b"address")) {
-            ADDRESS
-        } else if (type == string::utf8(b"vector<u8>")) {
-            BYTE_VECTOR
-        } else if (type == string::utf8(b"0x1::string::String")) { STRING }
-        else {
-            abort(error::invalid_argument(ETYPE_INVALID))
-        }
-    }
-
-    /// Maps Move type to `u8` representation
-    inline fun type_info_to_internal_type<T>(): u8 {
-        let type = type_info::type_name<T>();
-        to_internal_type(type)
-    }
-
-    /// Validates property value type against its expected type
-    inline fun validate_type(type: u8, value: vector<u8>) {
-        if (type == BOOL) {
-            from_bcs::to_bool(value);
-        } else if (type == U8) {
-            from_bcs::to_u8(value);
-        } else if (type == U16) {
-            from_bcs::to_u16(value);
-        } else if (type == U32) {
-            from_bcs::to_u32(value);
-        } else if (type == U64) {
-            from_bcs::to_u64(value);
-        } else if (type == U128) {
-            from_bcs::to_u128(value);
-        } else if (type == U256) {
-            from_bcs::to_u256(value);
-        } else if (type == ADDRESS) {
-            from_bcs::to_address(value);
-        } else if (type == BYTE_VECTOR) {
-            // nothing to validate...
-        } else if (type == STRING) {
-            from_bcs::to_string(value);
-        } else {
-            abort(error::invalid_argument(ETYPE_MISMATCH))
-        };
-    }
-
-    public fun generate_mutator_ref(s: &signer): MutatorRef {
-        MutatorRef { self: signer::address_of(s) }
-    }
-
-    // Accessors
-
-    public fun contains_key<T: key>(object: Object<T>, key: &String): bool acquires PropertyMap {
-        assert_exists(object::object_address(&object));
-        let property_map = borrow_global<PropertyMap>(object::object_address(&object));
-        simple_map::contains_key(&property_map.inner, key)
-    }
-
-    public fun length<T: key>(object: Object<T>): u64 acquires PropertyMap {
-        assert_exists(object::object_address(&object));
-        let property_map = borrow_global<PropertyMap>(object::object_address(&object));
-        simple_map::length(&property_map.inner)
-    }
-
-    /// Read the property and get it's external type in it's bcs encoded format
-    ///
-    /// The preferred method is to use `read_<type>` where the type is already known.
-    public fun read<T: key>(object: Object<T>, key: &String): (String, vector<u8>) acquires PropertyMap {
-        assert_exists(object::object_address(&object));
-        let property_map = borrow_global<PropertyMap>(object::object_address(&object));
-        let property_value = simple_map::borrow(&property_map.inner, key);
-        let new_type = to_external_type(property_value.type);
-        (new_type, property_value.value)
-    }
-
-    inline fun assert_exists(object: address) {
-        assert!(
-            exists<PropertyMap>(object),
-            error::not_found(EPROPERTY_MAP_DOES_NOT_EXIST)
-        );
-    }
-
-    /// Read a type and verify that the type is correct
-    inline fun read_typed<T: key, V>(object: Object<T>, key: &String): vector<u8> acquires PropertyMap {
-        let (type, value) = read(object, key);
-        assert!(
-            type == type_info::type_name<V>(),
-            error::invalid_argument(ETYPE_MISMATCH)
-        );
-        value
-    }
-
-    public fun read_bool<T: key>(object: Object<T>, key: &String): bool acquires PropertyMap {
-        let value = read_typed<T, bool>(object, key);
-        from_bcs::to_bool(value)
-    }
-
-    public fun read_u8<T: key>(object: Object<T>, key: &String): u8 acquires PropertyMap {
-        let value = read_typed<T, u8>(object, key);
-        from_bcs::to_u8(value)
-    }
-
-    public fun read_u16<T: key>(object: Object<T>, key: &String): u16 acquires PropertyMap {
-        let value = read_typed<T, u16>(object, key);
-        from_bcs::to_u16(value)
-    }
-
-    public fun read_u32<T: key>(object: Object<T>, key: &String): u32 acquires PropertyMap {
-        let value = read_typed<T, u32>(object, key);
-        from_bcs::to_u32(value)
-    }
-
-    public fun read_u64<T: key>(object: Object<T>, key: &String): u64 acquires PropertyMap {
-        let value = read_typed<T, u64>(object, key);
-        from_bcs::to_u64(value)
-    }
-
-    public fun read_u128<T: key>(object: Object<T>, key: &String): u128 acquires PropertyMap {
-        let value = read_typed<T, u128>(object, key);
-        from_bcs::to_u128(value)
-    }
-
-    public fun read_u256<T: key>(object: Object<T>, key: &String): u256 acquires PropertyMap {
-        let value = read_typed<T, u256>(object, key);
-        from_bcs::to_u256(value)
-    }
-
-    public fun read_address<T: key>(object: Object<T>, key: &String): address acquires PropertyMap {
-        let value = read_typed<T, address>(object, key);
-        from_bcs::to_address(value)
-    }
-
-    public fun read_bytes<T: key>(object: Object<T>, key: &String): vector<u8> acquires PropertyMap {
-        let value = read_typed<T, vector<u8>>(object, key);
-        from_bcs::to_bytes(value)
-    }
-
-    public fun read_string<T: key>(object: Object<T>, key: &String): String acquires PropertyMap {
-        let value = read_typed<T, String>(object, key);
-        from_bcs::to_string(value)
-    }
-
-    // Mutators
-    /// Add a property, already bcs encoded as a `vector<u8>`
-    public fun add(
-        ref: &MutatorRef,
-        key: String,
-        type: String,
-        value: vector<u8>
-    ) acquires PropertyMap {
-        let new_type = to_internal_type(type);
-        validate_type(new_type, value);
-        add_internal(ref, key, new_type, value);
-    }
-
-    /// Add a property that isn't already encoded as a `vector<u8>`
-    public fun add_typed<T: drop>(ref: &MutatorRef, key: String, value: T) acquires PropertyMap {
-        let type = type_info_to_internal_type<T>();
-        add_internal(ref, key, type, bcs::to_bytes(&value));
-    }
-
-    inline fun add_internal(
-        ref: &MutatorRef,
-        key: String,
-        type: u8,
-        value: vector<u8>
-    ) acquires PropertyMap {
-        assert_exists(ref.self);
-        let property_map = borrow_global_mut<PropertyMap>(ref.self);
-        simple_map::add(
-            &mut property_map.inner,
-            key,
-            PropertyValue { type, value }
-        );
-    }
-
-    /// Updates a property in place already bcs encoded
-    public fun update(
-        ref: &MutatorRef,
-        key: &String,
-        type: String,
-        value: vector<u8>
-    ) acquires PropertyMap {
-        let new_type = to_internal_type(type);
-        validate_type(new_type, value);
-        update_internal(ref, key, new_type, value);
-    }
-
-    /// Updates a property in place that is not already bcs encoded
-    public fun update_typed<T: drop>(
-        ref: &MutatorRef, key: &String, value: T
-    ) acquires PropertyMap {
-        let type = type_info_to_internal_type<T>();
-        update_internal(ref, key, type, bcs::to_bytes(&value));
-    }
-
-    inline fun update_internal(
-        ref: &MutatorRef,
-        key: &String,
-        type: u8,
-        value: vector<u8>
-    ) acquires PropertyMap {
-        assert_exists(ref.self);
-        let property_map = borrow_global_mut<PropertyMap>(ref.self);
-        let old_value = simple_map::borrow_mut(&mut property_map.inner, key);
-        *old_value = PropertyValue { type, value };
-    }
-
-    /// Removes a property from the map, ensuring that it does in fact exist
-    public fun remove(ref: &MutatorRef, key: &String) acquires PropertyMap {
-        assert_exists(ref.self);
-        let property_map = borrow_global_mut<PropertyMap>(ref.self);
-        simple_map::remove(&mut property_map.inner, key);
-    }
-
-    // Tests
-    #[test(creator = @0x123)]
-    fun test_end_to_end(creator: &signer) acquires PropertyMap {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-        let object =
-            object::object_from_constructor_ref<object::ObjectCore>(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[
-                    string::utf8(b"bool"), string::utf8(b"u8"), string::utf8(b"u16"), string::utf8(
-                        b"u32"
-                    ), string::utf8(b"u64"), string::utf8(b"u128"), string::utf8(b"u256"), string::utf8(
-                        b"vector<u8>"
-                    ), string::utf8(b"0x1::string::String")
-                ],
-                vector[
-                    string::utf8(b"bool"), string::utf8(b"u8"), string::utf8(b"u16"), string::utf8(
-                        b"u32"
-                    ), string::utf8(b"u64"), string::utf8(b"u128"), string::utf8(b"u256"), string::utf8(
-                        b"vector<u8>"
-                    ), string::utf8(b"0x1::string::String")
-                ],
-                vector[
-                    bcs::to_bytes<bool>(&true),
-                    bcs::to_bytes<u8>(&0x12),
-                    bcs::to_bytes<u16>(&0x1234),
-                    bcs::to_bytes<u32>(&0x12345678),
-                    bcs::to_bytes<u64>(&0x1234567812345678),
-                    bcs::to_bytes<u128>(&0x12345678123456781234567812345678),
-                    bcs::to_bytes<u256>(
-                        &
-                        0x1234567812345678123456781234567812345678123456781234567812345678
-                    ),
-                    bcs::to_bytes<vector<u8>>(&vector[0x01]),
-                    bcs::to_bytes<String>(&string::utf8(b"a"))
-                ]
-            );
-        init(&s, input);
-        let mutator = generate_mutator_ref(&s);
-
-        assert!(read_bool(object, &string::utf8(b"bool")), 0);
-        assert!(
-            read_u8(object, &string::utf8(b"u8")) == 0x12,
-            1
-        );
-        assert!(
-            read_u16(object, &string::utf8(b"u16")) == 0x1234,
-            2
-        );
-        assert!(
-            read_u32(object, &string::utf8(b"u32")) == 0x12345678,
-            3
-        );
-        assert!(
-            read_u64(object, &string::utf8(b"u64")) == 0x1234567812345678,
-            4
-        );
-        assert!(
-            read_u128(object, &string::utf8(b"u128"))
-                == 0x12345678123456781234567812345678,
-            5
-        );
-        assert!(
-            read_u256(object, &string::utf8(b"u256"))
-                == 0x1234567812345678123456781234567812345678123456781234567812345678,
-            6
-        );
-        assert!(
-            read_bytes(object, &string::utf8(b"vector<u8>")) == vector[0x01],
-            7
-        );
-        assert!(
-            read_string(
-                object,
-                &string::utf8(b"0x1::string::String")
-            ) == string::utf8(b"a"),
-            8
-        );
-
-        assert!(length(object) == 9, 9);
-
-        update_typed<bool>(&mutator, &string::utf8(b"bool"), false);
-        update_typed<u8>(&mutator, &string::utf8(b"u8"), 0x21);
-        update_typed<u16>(&mutator, &string::utf8(b"u16"), 0x22);
-        update_typed<u32>(&mutator, &string::utf8(b"u32"), 0x23);
-        update_typed<u64>(&mutator, &string::utf8(b"u64"), 0x24);
-        update_typed<u128>(&mutator, &string::utf8(b"u128"), 0x25);
-        update_typed<u256>(&mutator, &string::utf8(b"u256"), 0x26);
-        update_typed<vector<u8>>(
-            &mutator,
-            &string::utf8(b"vector<u8>"),
-            vector[0x02]
-        );
-        update_typed<String>(
-            &mutator,
-            &string::utf8(b"0x1::string::String"),
-            string::utf8(b"ha")
-        );
-
-        assert!(
-            !read_bool(object, &string::utf8(b"bool")),
-            10
-        );
-        assert!(
-            read_u8(object, &string::utf8(b"u8")) == 0x21,
-            11
-        );
-        assert!(
-            read_u16(object, &string::utf8(b"u16")) == 0x22,
-            12
-        );
-        assert!(
-            read_u32(object, &string::utf8(b"u32")) == 0x23,
-            13
-        );
-        assert!(
-            read_u64(object, &string::utf8(b"u64")) == 0x24,
-            14
-        );
-        assert!(
-            read_u128(object, &string::utf8(b"u128")) == 0x25,
-            15
-        );
-        assert!(
-            read_u256(object, &string::utf8(b"u256")) == 0x26,
-            16
-        );
-        assert!(
-            read_bytes(object, &string::utf8(b"vector<u8>")) == vector[0x02],
-            17
-        );
-        assert!(
-            read_string(
-                object,
-                &string::utf8(b"0x1::string::String")
-            ) == string::utf8(b"ha"),
-            18
-        );
-
-        assert!(length(object) == 9, 19);
-
-        remove(&mutator, &string::utf8(b"bool"));
-        remove(&mutator, &string::utf8(b"u8"));
-        remove(&mutator, &string::utf8(b"u16"));
-        remove(&mutator, &string::utf8(b"u32"));
-        remove(&mutator, &string::utf8(b"u64"));
-        remove(&mutator, &string::utf8(b"u128"));
-        remove(&mutator, &string::utf8(b"u256"));
-        remove(&mutator, &string::utf8(b"vector<u8>"));
-        remove(
-            &mutator,
-            &string::utf8(b"0x1::string::String")
-        );
-
-        assert!(length(object) == 0, 20);
-
-        add_typed<bool>(&mutator, string::utf8(b"bool"), false);
-        add_typed<u8>(&mutator, string::utf8(b"u8"), 0x21);
-        add_typed<u16>(&mutator, string::utf8(b"u16"), 0x22);
-        add_typed<u32>(&mutator, string::utf8(b"u32"), 0x23);
-        add_typed<u64>(&mutator, string::utf8(b"u64"), 0x24);
-        add_typed<u128>(&mutator, string::utf8(b"u128"), 0x25);
-        add_typed<u256>(&mutator, string::utf8(b"u256"), 0x26);
-        add_typed<vector<u8>>(
-            &mutator,
-            string::utf8(b"vector<u8>"),
-            vector[0x02]
-        );
-        add_typed<String>(
-            &mutator,
-            string::utf8(b"0x1::string::String"),
-            string::utf8(b"ha")
-        );
-
-        assert!(
-            !read_bool(object, &string::utf8(b"bool")),
-            21
-        );
-        assert!(
-            read_u8(object, &string::utf8(b"u8")) == 0x21,
-            22
-        );
-        assert!(
-            read_u16(object, &string::utf8(b"u16")) == 0x22,
-            23
-        );
-        assert!(
-            read_u32(object, &string::utf8(b"u32")) == 0x23,
-            24
-        );
-        assert!(
-            read_u64(object, &string::utf8(b"u64")) == 0x24,
-            25
-        );
-        assert!(
-            read_u128(object, &string::utf8(b"u128")) == 0x25,
-            26
-        );
-        assert!(
-            read_u256(object, &string::utf8(b"u256")) == 0x26,
-            27
-        );
-        assert!(
-            read_bytes(object, &string::utf8(b"vector<u8>")) == vector[0x02],
-            28
-        );
-        assert!(
-            read_string(
-                object,
-                &string::utf8(b"0x1::string::String")
-            ) == string::utf8(b"ha"),
-            29
-        );
-
-        assert!(length(object) == 9, 30);
-
-        remove(&mutator, &string::utf8(b"bool"));
-        remove(&mutator, &string::utf8(b"u8"));
-        remove(&mutator, &string::utf8(b"u16"));
-        remove(&mutator, &string::utf8(b"u32"));
-        remove(&mutator, &string::utf8(b"u64"));
-        remove(&mutator, &string::utf8(b"u128"));
-        remove(&mutator, &string::utf8(b"u256"));
-        remove(&mutator, &string::utf8(b"vector<u8>"));
-        remove(
-            &mutator,
-            &string::utf8(b"0x1::string::String")
-        );
-
-        assert!(length(object) == 0, 31);
-
-        add(
-            &mutator,
-            string::utf8(b"bool"),
-            string::utf8(b"bool"),
-            bcs::to_bytes<bool>(&true)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u8"),
-            string::utf8(b"u8"),
-            bcs::to_bytes<u8>(&0x12)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u16"),
-            string::utf8(b"u16"),
-            bcs::to_bytes<u16>(&0x1234)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u32"),
-            string::utf8(b"u32"),
-            bcs::to_bytes<u32>(&0x12345678)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u64"),
-            string::utf8(b"u64"),
-            bcs::to_bytes<u64>(&0x1234567812345678)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u128"),
-            string::utf8(b"u128"),
-            bcs::to_bytes<u128>(&0x12345678123456781234567812345678)
-        );
-        add(
-            &mutator,
-            string::utf8(b"u256"),
-            string::utf8(b"u256"),
-            bcs::to_bytes<u256>(
-                &0x1234567812345678123456781234567812345678123456781234567812345678
-            )
-        );
-        add(
-            &mutator,
-            string::utf8(b"vector<u8>"),
-            string::utf8(b"vector<u8>"),
-            bcs::to_bytes<vector<u8>>(&vector[0x01])
-        );
-        add(
-            &mutator,
-            string::utf8(b"0x1::string::String"),
-            string::utf8(b"0x1::string::String"),
-            bcs::to_bytes<String>(&string::utf8(b"a"))
-        );
-
-        assert!(read_bool(object, &string::utf8(b"bool")), 32);
-        assert!(
-            read_u8(object, &string::utf8(b"u8")) == 0x12,
-            33
-        );
-        assert!(
-            read_u16(object, &string::utf8(b"u16")) == 0x1234,
-            34
-        );
-        assert!(
-            read_u32(object, &string::utf8(b"u32")) == 0x12345678,
-            35
-        );
-        assert!(
-            read_u64(object, &string::utf8(b"u64")) == 0x1234567812345678,
-            36
-        );
-        assert!(
-            read_u128(object, &string::utf8(b"u128"))
-                == 0x12345678123456781234567812345678,
-            37
-        );
-        assert!(
-            read_u256(object, &string::utf8(b"u256"))
-                == 0x1234567812345678123456781234567812345678123456781234567812345678,
-            38
-        );
-        assert!(
-            read_bytes(object, &string::utf8(b"vector<u8>")) == vector[0x01],
-            39
-        );
-        assert!(
-            read_string(
-                object,
-                &string::utf8(b"0x1::string::String")
-            ) == string::utf8(b"a"),
-            40
-        );
-
-        assert!(length(object) == 9, 41);
-
-        update(
-            &mutator,
-            &string::utf8(b"bool"),
-            string::utf8(b"bool"),
-            bcs::to_bytes<bool>(&false)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u8"),
-            string::utf8(b"u8"),
-            bcs::to_bytes<u8>(&0x21)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u16"),
-            string::utf8(b"u16"),
-            bcs::to_bytes<u16>(&0x22)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u32"),
-            string::utf8(b"u32"),
-            bcs::to_bytes<u32>(&0x23)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u64"),
-            string::utf8(b"u64"),
-            bcs::to_bytes<u64>(&0x24)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u128"),
-            string::utf8(b"u128"),
-            bcs::to_bytes<u128>(&0x25)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"u256"),
-            string::utf8(b"u256"),
-            bcs::to_bytes<u256>(&0x26)
-        );
-        update(
-            &mutator,
-            &string::utf8(b"vector<u8>"),
-            string::utf8(b"vector<u8>"),
-            bcs::to_bytes<vector<u8>>(&vector[0x02])
-        );
-        update(
-            &mutator,
-            &string::utf8(b"0x1::string::String"),
-            string::utf8(b"0x1::string::String"),
-            bcs::to_bytes<String>(&string::utf8(b"ha"))
-        );
-
-        assert!(
-            !read_bool(object, &string::utf8(b"bool")),
-            10
-        );
-        assert!(
-            read_u8(object, &string::utf8(b"u8")) == 0x21,
-            11
-        );
-        assert!(
-            read_u16(object, &string::utf8(b"u16")) == 0x22,
-            12
-        );
-        assert!(
-            read_u32(object, &string::utf8(b"u32")) == 0x23,
-            13
-        );
-        assert!(
-            read_u64(object, &string::utf8(b"u64")) == 0x24,
-            14
-        );
-        assert!(
-            read_u128(object, &string::utf8(b"u128")) == 0x25,
-            15
-        );
-        assert!(
-            read_u256(object, &string::utf8(b"u256")) == 0x26,
-            16
-        );
-        assert!(
-            read_bytes(object, &string::utf8(b"vector<u8>")) == vector[0x02],
-            17
-        );
-        assert!(
-            read_string(
-                object,
-                &string::utf8(b"0x1::string::String")
-            ) == string::utf8(b"ha"),
-            18
-        );
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10064, location = initia_std::from_bcs)]
-    fun test_invalid_init(creator: &signer) {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool")],
-                vector[string::utf8(b"u16")],
-                vector[bcs::to_bytes<bool>(&true)]
-            );
-        init(&s, input);
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10004, location = Self)]
-    fun test_init_wrong_values(creator: &signer) {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool"), string::utf8(b"u8")],
-                vector[string::utf8(b"bool"), string::utf8(b"u8")],
-                vector[bcs::to_bytes<bool>(&true)]
-            );
-        init(&s, input);
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10005, location = Self)]
-    fun test_init_wrong_types(creator: &signer) {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool"), string::utf8(b"u8")],
-                vector[string::utf8(b"bool")],
-                vector[bcs::to_bytes<bool>(&true), bcs::to_bytes<u8>(&0x2)]
-            );
-        init(&s, input);
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10064, location = initia_std::from_bcs)]
-    fun test_invalid_add(creator: &signer) acquires PropertyMap {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool")],
-                vector[string::utf8(b"bool")],
-                vector[bcs::to_bytes<bool>(&true)]
-            );
-        init(&s, input);
-        let mutator = generate_mutator_ref(&s);
-
-        update(
-            &mutator,
-            &string::utf8(b"u16"),
-            string::utf8(b"bool"),
-            bcs::to_bytes<u16>(&0x1234)
-        );
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10064, location = initia_std::from_bcs)]
-    fun test_invalid_update(creator: &signer) acquires PropertyMap {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool")],
-                vector[string::utf8(b"bool")],
-                vector[bcs::to_bytes<bool>(&true)]
-            );
-        init(&s, input);
-        let mutator = generate_mutator_ref(&s);
-
-        update(
-            &mutator,
-            &string::utf8(b"bool"),
-            string::utf8(b"bool"),
-            bcs::to_bytes<u16>(&0x1234)
-        );
-    }
-
-    #[test(creator = @0x123)]
-    #[expected_failure(abort_code = 0x10006, location = Self)]
-    fun test_invalid_read(creator: &signer) acquires PropertyMap {
-        let constructor_ref = object::create_named_object(creator, b"");
-        let s = object::generate_signer(&constructor_ref);
-        let object =
-            object::object_from_constructor_ref<object::ObjectCore>(&constructor_ref);
-
-        let input =
-            prepare_input(
-                vector[string::utf8(b"bool")],
-                vector[string::utf8(b"bool")],
-                vector[bcs::to_bytes<bool>(&true)]
-            );
-        init(&s, input);
-        read_u8(object, &string::utf8(b"bool"));
-    }
-}