create-dubhe 0.0.8 → 0.0.10

package/template/101/movement-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/string_utils.move

@@ -0,0 +1,148 @@
+/// A module for formatting move values as strings.
+module aptos_std::string_utils {
+    use std::string::String;
+
+    /// The number of values in the list does not match the number of "{}" in the format string.
+    const EARGS_MISMATCH: u64 = 1;
+    /// The format string is not valid.
+    const EINVALID_FORMAT: u64 = 2;
+    /// Formatting is not possible because the value contains delayed fields such as aggregators.
+    const EUNABLE_TO_FORMAT_DELAYED_FIELD: u64 = 3;
+
+    /// Format a move value as a human readable string,
+    /// eg. `to_string(&1u64) == "1"`, `to_string(&false) == "false"`, `to_string(&@0x1) == "@0x1"`.
+    /// For vectors and structs the format is similar to rust, eg.
+    /// `to_string(&cons(1,2)) == "Cons { car: 1, cdr: 2 }"` and `to_string(&vector[1, 2, 3]) == "[ 1, 2, 3 ]"`
+    /// For vectors of u8 the output is hex encoded, eg. `to_string(&vector[1u8, 2u8, 3u8]) == "0x010203"`
+    /// For std::string::String the output is the string itself including quotes, eg.
+    /// `to_string(&std::string::utf8(b"My string")) == "\"My string\""`
+    public fun to_string<T>(s: &T): String {
+        native_format(s, false, false, true, false)
+    }
+
+    /// Format addresses as 64 zero-padded hexadecimals.
+    public fun to_string_with_canonical_addresses<T>(s: &T): String {
+        native_format(s, false, true, true, false)
+    }
+
+    /// Format emitting integers with types ie. 6u8 or 128u32.
+    public fun to_string_with_integer_types<T>(s: &T): String {
+        native_format(s, false, true, true, false)
+    }
+
+    /// Format vectors and structs with newlines and indentation.
+    public fun debug_string<T>(s: &T): String {
+        native_format(s, true, false, false, false)
+    }
+
+    /// Formatting with a rust-like format string, eg. `format2(&b"a = {}, b = {}", 1, 2) == "a = 1, b = 2"`.
+    public fun format1<T0: drop>(fmt: &vector<u8>, a: T0): String {
+        native_format_list(fmt, &list1(a))
+    }
+    public fun format2<T0: drop, T1: drop>(fmt: &vector<u8>, a: T0, b: T1): String {
+        native_format_list(fmt, &list2(a, b))
+    }
+    public fun format3<T0: drop, T1: drop, T2: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2): String {
+        native_format_list(fmt, &list3(a, b, c))
+    }
+    public fun format4<T0: drop, T1: drop, T2: drop, T3: drop>(fmt: &vector<u8>, a: T0, b: T1, c: T2, d: T3): String {
+        native_format_list(fmt, &list4(a, b, c, d))
+    }
+
+    // Helper struct to allow passing a generic heterogeneous list of values to native_format_list.
+    struct Cons<T, N> has copy, drop, store {
+        car: T,
+        cdr: N,
+    }
+
+    struct NIL has copy, drop, store {}
+
+    // Create a pair of values.
+    fun cons<T, N>(car: T, cdr: N): Cons<T, N> { Cons { car, cdr } }
+
+    // Create a nil value.
+    fun nil(): NIL { NIL {} }
+
+    // Create a list of values.
+    inline fun list1<T0>(a: T0): Cons<T0, NIL> { cons(a, nil()) }
+    inline fun list2<T0, T1>(a: T0, b: T1): Cons<T0, Cons<T1, NIL>> { cons(a, list1(b)) }
+    inline fun list3<T0, T1, T2>(a: T0, b: T1, c: T2): Cons<T0, Cons<T1, Cons<T2, NIL>>> { cons(a, list2(b, c)) }
+    inline fun list4<T0, T1, T2, T3>(a: T0, b: T1, c: T2, d: T3): Cons<T0, Cons<T1, Cons<T2, Cons<T3, NIL>>>> { cons(a, list3(b, c, d)) }
+
+    // Native functions
+    native fun native_format<T>(s: &T, type_tag: bool, canonicalize: bool, single_line: bool, include_int_types: bool): String;
+    native fun native_format_list<T>(fmt: &vector<u8>, val: &T): String;
+
+    #[test]
+    fun test_format() {
+        assert!(to_string(&1u64) == std::string::utf8(b"1"), 1);
+        assert!(to_string(&false) == std::string::utf8(b"false"), 2);
+        assert!(to_string(&1u256) == std::string::utf8(b"1"), 3);
+        assert!(to_string(&vector[1, 2, 3]) == std::string::utf8(b"[ 1, 2, 3 ]"), 4);
+        assert!(to_string(&cons(std::string::utf8(b"My string"),2)) == std::string::utf8(b"Cons { car: \"My string\", cdr: 2 }"), 5);
+        assert!(to_string(&std::option::none<u64>()) == std::string::utf8(b"None"), 6);
+        assert!(to_string(&std::option::some(1)) == std::string::utf8(b"Some(1)"), 7);
+    }
+
+    #[test]
+    fun test_format_list() {
+        let s = format3(&b"a = {} b = {} c = {}", 1, 2, std::string::utf8(b"My string"));
+        assert!(s == std::string::utf8(b"a = 1 b = 2 c = \"My string\""), 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EARGS_MISMATCH)]
+    fun test_format_list_to_many_vals() {
+        format4(&b"a = {} b = {} c = {}", 1, 2, 3, 4);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EARGS_MISMATCH)]
+    fun test_format_list_not_enough_vals() {
+        format2(&b"a = {} b = {} c = {}", 1, 2);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EARGS_MISMATCH)]
+    fun test_format_list_not_valid_nil() {
+        let l = cons(1, cons(2, cons(3, 4)));
+        native_format_list(&b"a = {} b = {} c = {}", &l);
+    }
+
+    /// #[test_only]
+    struct FakeCons<T, N> has copy, drop, store {
+        car: T,
+        cdr: N,
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EARGS_MISMATCH)]
+    fun test_format_list_not_valid_list() {
+        let l = cons(1, FakeCons { car: 2, cdr: cons(3, nil())});
+        native_format_list(&b"a = {} b = {} c = {}", &l);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EINVALID_FORMAT)]
+    fun test_format_unclosed_braces() {
+        format3(&b"a = {} b = {} c = {", 1, 2 ,3);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EINVALID_FORMAT)]
+    fun test_format_unclosed_braces_2() {
+        format3(&b"a = {} b = { c = {}", 1, 2, 3);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = EINVALID_FORMAT)]
+    fun test_format_unopened_braces() {
+        format3(&b"a = } b = {} c = {}", 1, 2, 3);
+    }
+
+    #[test]
+    fun test_format_escape_braces_works() {
+        let s = format3(&b"{{a = {} b = {} c = {}}}", 1, 2, 3);
+        assert!(s == std::string::utf8(b"{a = 1 b = 2 c = 3}"), 1);
+    }
+}

package/template/101/movement-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/table.move

@@ -0,0 +1,152 @@
+/// Type of large-scale storage tables.
+/// source: https://github.com/move-language/move/blob/1b6b7513dcc1a5c866f178ca5c1e74beb2ce181e/language/extensions/move-table-extension/sources/Table.move#L1
+///
+/// It implements the Table type which supports individual table items to be represented by
+/// separate global state items. The number of items and a unique handle are tracked on the table
+/// struct itself, while the operations are implemented as native functions. No traversal is provided.
+
+module aptos_std::table {
+    friend aptos_std::table_with_length;
+
+    /// Type of tables
+    struct Table<phantom K: copy + drop, phantom V> has store {
+        handle: address,
+    }
+
+    /// Create a new Table.
+    public fun new<K: copy + drop, V: store>(): Table<K, V> {
+        Table {
+            handle: new_table_handle<K, V>(),
+        }
+    }
+
+    /// Add a new entry to the table. Aborts if an entry for this
+    /// key already exists. The entry itself is not stored in the
+    /// table, and cannot be discovered from it.
+    public fun add<K: copy + drop, V>(self: &mut Table<K, V>, key: K, val: V) {
+        add_box<K, V, Box<V>>(self, key, Box { val })
+    }
+
+    /// Acquire an immutable reference to the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun borrow<K: copy + drop, V>(self: &Table<K, V>, key: K): &V {
+        &borrow_box<K, V, Box<V>>(self, key).val
+    }
+
+    /// Acquire an immutable reference to the value which `key` maps to.
+    /// Returns specified default value if there is no entry for `key`.
+    public fun borrow_with_default<K: copy + drop, V>(self: &Table<K, V>, key: K, default: &V): &V {
+        if (!contains(self, copy key)) {
+            default
+        } else {
+            borrow(self, copy key)
+        }
+    }
+
+    /// Acquire a mutable reference to the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun borrow_mut<K: copy + drop, V>(self: &mut Table<K, V>, key: K): &mut V {
+        &mut borrow_box_mut<K, V, Box<V>>(self, key).val
+    }
+
+    /// Acquire a mutable reference to the value which `key` maps to.
+    /// Insert the pair (`key`, `default`) first if there is no entry for `key`.
+    public fun borrow_mut_with_default<K: copy + drop, V: drop>(self: &mut Table<K, V>, key: K, default: V): &mut V {
+        if (!contains(self, copy key)) {
+            add(self, copy key, default)
+        };
+        borrow_mut(self, key)
+    }
+
+    /// Insert the pair (`key`, `value`) if there is no entry for `key`.
+    /// update the value of the entry for `key` to `value` otherwise
+    public fun upsert<K: copy + drop, V: drop>(self: &mut Table<K, V>, key: K, value: V) {
+        if (!contains(self, copy key)) {
+            add(self, copy key, value)
+        } else {
+            let ref = borrow_mut(self, key);
+            *ref = value;
+        };
+    }
+
+    /// Remove from `self` and return the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun remove<K: copy + drop, V>(self: &mut Table<K, V>, key: K): V {
+        let Box { val } = remove_box<K, V, Box<V>>(self, key);
+        val
+    }
+
+    /// Returns true iff `self` contains an entry for `key`.
+    public fun contains<K: copy + drop, V>(self: &Table<K, V>, key: K): bool {
+        contains_box<K, V, Box<V>>(self, key)
+    }
+
+    #[test_only]
+    /// Testing only: allows to drop a table even if it is not empty.
+    public fun drop_unchecked<K: copy + drop, V>(self: Table<K, V>) {
+        drop_unchecked_box<K, V, Box<V>>(self)
+    }
+
+    public(friend) fun destroy<K: copy + drop, V>(self: Table<K, V>) {
+        destroy_empty_box<K, V, Box<V>>(&self);
+        drop_unchecked_box<K, V, Box<V>>(self)
+    }
+
+    #[test_only]
+    struct TableHolder<phantom K: copy + drop, phantom V: drop> has key {
+        t: Table<K, V>
+    }
+
+    #[test(account = @0x1)]
+    fun test_upsert(account: signer) {
+        let t = new<u64, u8>();
+        let key: u64 = 111;
+        let error_code: u64 = 1;
+        assert!(!contains(&t, key), error_code);
+        upsert(&mut t, key, 12);
+        assert!(*borrow(&t, key) == 12, error_code);
+        upsert(&mut t, key, 23);
+        assert!(*borrow(&t, key) == 23, error_code);
+
+        move_to(&account, TableHolder { t });
+    }
+
+    #[test(account = @0x1)]
+    fun test_borrow_with_default(account: signer) {
+        let t = new<u64, u8>();
+        let key: u64 = 100;
+        let error_code: u64 = 1;
+        assert!(!contains(&t, key), error_code);
+        assert!(*borrow_with_default(&t, key, &12) == 12, error_code);
+        add(&mut t, key, 1);
+        assert!(*borrow_with_default(&t, key, &12) == 1, error_code);
+
+        move_to(&account, TableHolder{ t });
+    }
+
+    // ======================================================================================================
+    // Internal API
+
+    /// Wrapper for values. Required for making values appear as resources in the implementation.
+    struct Box<V> has key, drop, store {
+        val: V
+    }
+
+    // Primitives which take as an additional type parameter `Box<V>`, so the implementation
+    // can use this to determine serialization layout.
+    native fun new_table_handle<K, V>(): address;
+
+    native fun add_box<K: copy + drop, V, B>(table: &mut Table<K, V>, key: K, val: Box<V>);
+
+    native fun borrow_box<K: copy + drop, V, B>(table: &Table<K, V>, key: K): &Box<V>;
+
+    native fun borrow_box_mut<K: copy + drop, V, B>(table: &mut Table<K, V>, key: K): &mut Box<V>;
+
+    native fun contains_box<K: copy + drop, V, B>(table: &Table<K, V>, key: K): bool;
+
+    native fun remove_box<K: copy + drop, V, B>(table: &mut Table<K, V>, key: K): Box<V>;
+
+    native fun destroy_empty_box<K: copy + drop, V, B>(table: &Table<K, V>);
+
+    native fun drop_unchecked_box<K: copy + drop, V, B>(table: Table<K, V>);
+}

package/template/101/movement-template/contracts/counter/build/counter/sources/dependencies/AptosStdlib/table_with_length.move

@@ -0,0 +1,141 @@
+/// Extends Table and provides functions such as length and the ability to be destroyed
+
+module aptos_std::table_with_length {
+    use std::error;
+    use aptos_std::table::{Self, Table};
+
+    // native code raises this with error::invalid_arguments()
+    const EALREADY_EXISTS: u64 = 100;
+    // native code raises this with error::invalid_arguments()
+    const ENOT_FOUND: u64 = 101;
+    const ENOT_EMPTY: u64 = 102;
+
+    /// Type of tables
+    struct TableWithLength<phantom K: copy + drop, phantom V> has store {
+        inner: Table<K, V>,
+        length: u64,
+    }
+
+    /// Create a new Table.
+    public fun new<K: copy + drop, V: store>(): TableWithLength<K, V> {
+        TableWithLength {
+            inner: table::new<K, V>(),
+            length: 0,
+        }
+    }
+
+    /// Destroy a table. The table must be empty to succeed.
+    public fun destroy_empty<K: copy + drop, V>(self: TableWithLength<K, V>) {
+        assert!(self.length == 0, error::invalid_state(ENOT_EMPTY));
+        let TableWithLength { inner, length: _ } = self;
+        table::destroy(inner)
+    }
+
+    /// Add a new entry to the table. Aborts if an entry for this
+    /// key already exists. The entry itself is not stored in the
+    /// table, and cannot be discovered from it.
+    public fun add<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K, val: V) {
+        table::add(&mut self.inner, key, val);
+        self.length = self.length + 1;
+    }
+
+    /// Acquire an immutable reference to the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun borrow<K: copy + drop, V>(self: &TableWithLength<K, V>, key: K): &V {
+        table::borrow(&self.inner, key)
+    }
+
+    /// Acquire a mutable reference to the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun borrow_mut<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K): &mut V {
+        table::borrow_mut(&mut self.inner, key)
+    }
+
+    /// Returns the length of the table, i.e. the number of entries.
+    public fun length<K: copy + drop, V>(self: &TableWithLength<K, V>): u64 {
+        self.length
+    }
+
+    /// Returns true if this table is empty.
+    public fun empty<K: copy + drop, V>(self: &TableWithLength<K, V>): bool {
+        self.length == 0
+    }
+
+    /// Acquire a mutable reference to the value which `key` maps to.
+    /// Insert the pair (`key`, `default`) first if there is no entry for `key`.
+    public fun borrow_mut_with_default<K: copy + drop, V: drop>(self: &mut TableWithLength<K, V>, key: K, default: V): &mut V {
+        if (table::contains(&self.inner, key)) {
+            table::borrow_mut(&mut self.inner, key)
+        } else {
+            table::add(&mut self.inner, key, default);
+            self.length = self.length + 1;
+            table::borrow_mut(&mut self.inner, key)
+        }
+    }
+
+    /// Insert the pair (`key`, `value`) if there is no entry for `key`.
+    /// update the value of the entry for `key` to `value` otherwise
+    public fun upsert<K: copy + drop, V: drop>(self: &mut TableWithLength<K, V>, key: K, value: V) {
+        if (!table::contains(&self.inner, key)) {
+            add(self, copy key, value)
+        } else {
+            let ref = table::borrow_mut(&mut self.inner, key);
+            *ref = value;
+        };
+    }
+
+    /// Remove from `table` and return the value which `key` maps to.
+    /// Aborts if there is no entry for `key`.
+    public fun remove<K: copy + drop, V>(self: &mut TableWithLength<K, V>, key: K): V {
+        let val = table::remove(&mut self.inner, key);
+        self.length = self.length - 1;
+        val
+    }
+
+    /// Returns true iff `table` contains an entry for `key`.
+    public fun contains<K: copy + drop, V>(self: &TableWithLength<K, V>, key: K): bool {
+        table::contains(&self.inner, key)
+    }
+
+    #[test_only]
+    /// Drop table even if not empty, only when testing.
+    public fun drop_unchecked<K: copy + drop, V>(self: TableWithLength<K, V>) {
+        // Unpack table with length, dropping length count but not
+        // inner table.
+        let TableWithLength{inner, length: _} = self;
+        table::drop_unchecked(inner); // Drop inner table.
+    }
+
+    #[test]
+    /// Verify test-only drop functionality.
+    fun test_drop_unchecked() {
+        let table = new<bool, bool>(); // Declare new table.
+        add(&mut table, true, false); // Add table entry.
+        drop_unchecked(table); // Drop table.
+    }
+
+    #[test]
+    fun test_upsert() {
+        let t = new<u8, u8>();
+        // Table should not have key 0 yet
+        assert!(!contains(&t, 0), 1);
+        // This should insert key 0, with value 10, and length should be 1
+        upsert(&mut t, 0, 10);
+        // Ensure the value is correctly set to 10
+        assert!(*borrow(&t, 0) == 10, 1);
+        // Ensure the length is correctly set
+        assert!(length(&t) == 1, 1);
+        // Lets upsert the value to something else, and verify it's correct
+        upsert(&mut t, 0, 23);
+        assert!(*borrow(&t, 0) == 23, 1);
+        // Since key 0 already existed, the length should not have changed
+        assert!(length(&t) == 1, 1);
+        // If we upsert a non-existing key, the length should increase
+        upsert(&mut t, 1, 7);
+        assert!(length(&t) == 2, 1);
+
+        remove(&mut t, 0);
+        remove(&mut t, 1);
+        destroy_empty(t);
+    }
+}