create-dubhe 0.0.8 → 0.0.9

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

@@ -0,0 +1,176 @@
+/// Provides a framework for comparing two elements
+module initia_std::comparator {
+    use std::bcs;
+    use std::vector;
+
+    const EQUAL: u8 = 0;
+    const SMALLER: u8 = 1;
+    const GREATER: u8 = 2;
+
+    struct Result has drop {
+        inner: u8
+    }
+
+    public fun is_equal(result: &Result): bool {
+        return result.inner == EQUAL
+    }
+
+    public fun is_smaller_than(result: &Result): bool {
+        return result.inner == SMALLER
+    }
+
+    public fun is_greater_than(result: &Result): bool {
+        result.inner == GREATER
+    }
+
+    // Performs a comparison of two types after BCS serialization.
+    public fun compare<T>(left: &T, right: &T): Result {
+        let left_bytes = bcs::to_bytes(left);
+        let right_bytes = bcs::to_bytes(right);
+
+        compare_u8_vector(left_bytes, right_bytes)
+    }
+
+    // Performs a comparison of two vector<u8>s or byte vectors
+    public fun compare_u8_vector(left: vector<u8>, right: vector<u8>): Result {
+        let left_length = vector::length(&left);
+        let right_length = vector::length(&right);
+
+        let idx = 0;
+
+        while (idx < left_length && idx < right_length) {
+            let left_byte = *vector::borrow(&left, idx);
+            let right_byte = *vector::borrow(&right, idx);
+
+            if (left_byte < right_byte) {
+                return Result { inner: SMALLER }
+            } else if (left_byte > right_byte) {
+                return Result { inner: GREATER }
+            };
+            idx = idx + 1;
+        };
+
+        if (left_length < right_length) {
+            Result { inner: SMALLER }
+        } else if (left_length > right_length) {
+            Result { inner: GREATER }
+        } else {
+            Result { inner: EQUAL }
+        }
+    }
+
+    #[test]
+    public fun test_strings() {
+        use std::string;
+
+        let value0 = string::utf8(b"alpha");
+        let value1 = string::utf8(b"beta");
+        let value2 = string::utf8(b"betaa");
+
+        assert!(is_equal(&compare(&value0, &value0)), 0);
+        assert!(is_equal(&compare(&value1, &value1)), 1);
+        assert!(is_equal(&compare(&value2, &value2)), 2);
+
+        assert!(
+            is_greater_than(&compare(&value0, &value1)),
+            3
+        );
+        assert!(
+            is_smaller_than(&compare(&value1, &value0)),
+            4
+        );
+
+        assert!(
+            is_smaller_than(&compare(&value0, &value2)),
+            5
+        );
+        assert!(
+            is_greater_than(&compare(&value2, &value0)),
+            6
+        );
+
+        assert!(
+            is_smaller_than(&compare(&value1, &value2)),
+            7
+        );
+        assert!(
+            is_greater_than(&compare(&value2, &value1)),
+            8
+        );
+    }
+
+    #[test]
+    public fun test_u128() {
+        let value0: u128 = 5;
+        let value1: u128 = 152;
+        let value2: u128 = 511; // 0x1ff
+
+        assert!(is_equal(&compare(&value0, &value0)), 0);
+        assert!(is_equal(&compare(&value1, &value1)), 1);
+        assert!(is_equal(&compare(&value2, &value2)), 2);
+
+        assert!(
+            is_smaller_than(&compare(&value0, &value1)),
+            2
+        );
+        assert!(
+            is_greater_than(&compare(&value1, &value0)),
+            3
+        );
+
+        assert!(
+            is_smaller_than(&compare(&value0, &value2)),
+            3
+        );
+        assert!(
+            is_greater_than(&compare(&value2, &value0)),
+            4
+        );
+
+        assert!(
+            is_smaller_than(&compare(&value1, &value2)),
+            5
+        );
+        assert!(
+            is_greater_than(&compare(&value2, &value1)),
+            6
+        );
+    }
+
+    #[test_only]
+    struct Complex has drop {
+        value0: vector<u128>,
+        value1: u8,
+        value2: u64
+    }
+
+    #[test]
+    public fun test_complex() {
+        let value0_0 = vector::empty();
+        vector::push_back(&mut value0_0, 10);
+        vector::push_back(&mut value0_0, 9);
+        vector::push_back(&mut value0_0, 5);
+
+        let value0_1 = vector::empty();
+        vector::push_back(&mut value0_1, 10);
+        vector::push_back(&mut value0_1, 9);
+        vector::push_back(&mut value0_1, 5);
+        vector::push_back(&mut value0_1, 1);
+
+        let base = Complex { value0: value0_0, value1: 13, value2: 41 };
+
+        let other_0 = Complex { value0: value0_1, value1: 13, value2: 41 };
+
+        let other_1 = Complex { value0: copy value0_0, value1: 14, value2: 41 };
+
+        let other_2 = Complex { value0: value0_0, value1: 13, value2: 42 };
+
+        assert!(is_equal(&compare(&base, &base)), 0);
+        assert!(is_smaller_than(&compare(&base, &other_0)), 1);
+        assert!(is_greater_than(&compare(&other_0, &base)), 2);
+        assert!(is_smaller_than(&compare(&base, &other_1)), 3);
+        assert!(is_greater_than(&compare(&other_1, &base)), 4);
+        assert!(is_smaller_than(&compare(&base, &other_2)), 5);
+        assert!(is_greater_than(&compare(&other_2, &base)), 6);
+    }
+}

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

@@ -0,0 +1,53 @@
+module initia_std::copyable_any {
+    use initia_std::type_info;
+    use initia_std::from_bcs::from_bytes;
+    use std::bcs;
+    use std::error;
+    use std::string::String;
+
+    /// The type provided for `unpack` is not the same as was given for `pack`.
+    const ETYPE_MISMATCH: u64 = 0;
+
+    /// The same as `any::Any` but with the copy ability.
+    struct Any has drop, store, copy {
+        type_name: String,
+        data: vector<u8>
+    }
+
+    /// Pack a value into the `Any` representation. Because Any can be stored, dropped, and copied this is
+    /// also required from `T`.
+    public fun pack<T: drop + store + copy>(x: T): Any {
+        Any {
+            type_name: type_info::type_name<T>(),
+            data: bcs::to_bytes(&x)
+        }
+    }
+
+    /// Unpack a value from the `Any` representation. This aborts if the value has not the expected type `T`.
+    public fun unpack<T>(x: Any): T {
+        assert!(
+            type_info::type_name<T>() == x.type_name,
+            error::invalid_argument(ETYPE_MISMATCH)
+        );
+        from_bytes<T>(x.data)
+    }
+
+    /// Returns the type name of this Any
+    public fun type_name(x: &Any): &String {
+        &x.type_name
+    }
+
+    #[test_only]
+    struct S has store, drop, copy {
+        x: u64
+    }
+
+    #[test]
+    fun test_any() {
+        assert!(unpack<u64>(pack(22)) == 22, 1);
+        assert!(
+            unpack<S>(pack(S { x: 22 })) == S { x: 22 },
+            2
+        );
+    }
+}