create-dubhe 0.1.13 → 1.2.0-pre.51

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

@@ -1,148 +0,0 @@
-/// 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

@@ -1,152 +0,0 @@
-/// 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

@@ -1,141 +0,0 @@
-/// 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);
-    }
-}