create-dubhe 0.1.13 → 1.2.0-pre.51

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

@@ -1,234 +0,0 @@
-/// A module for formatting move values as strings.
-module initia_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, true)
-    }
-
-    /// 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/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/table.move

@@ -1,362 +0,0 @@
-/// Type of large-scale storage tables.
-module initia_std::table {
-    use std::error;
-    use std::account;
-    use std::vector;
-    use std::bcs;
-    use std::option::{Self, Option};
-
-    // native code raises this with error::invalid_arguments()
-    const EALREADY_EXISTS: u64 = 100;
-    const ENOT_FOUND: u64 = 101;
-
-    const ENOT_EMPTY: u64 = 102;
-
-    /// Type of tables
-    struct Table<phantom K: copy + drop, phantom V> has store {
-        handle: address,
-        length: u64
-    }
-
-    /// Type of table iterators
-    struct TableIter<phantom K: copy + drop, phantom V> has drop {
-        iterator_id: u64
-    }
-
-    /// Create a new Table.
-    public fun new<K: copy + drop, V: store>(): Table<K, V> {
-        let handle = new_table_handle<K, V>();
-        account::create_table_account(handle);
-        Table { handle, length: 0 }
-    }
-
-    /// Destroy a table. The table must be empty to succeed.
-    public fun destroy_empty<K: copy + drop, V>(table: Table<K, V>) {
-        assert!(
-            table.length == 0,
-            error::invalid_state(ENOT_EMPTY)
-        );
-        destroy_empty_box<K, V, Box<V>>(&table);
-        drop_unchecked_box<K, V, Box<V>>(table)
-    }
-
-    /// Return a table handle address.
-    public fun handle<K: copy + drop, V>(table: &Table<K, V>): address {
-        table.handle
-    }
-
-    /// 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>(table: &mut Table<K, V>, key: K, val: V) {
-        add_box<K, V, Box<V>>(table, key, Box { val });
-        table.length = table.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>(table: &Table<K, V>, key: K): &V {
-        &borrow_box<K, V, Box<V>>(table, 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>(
-        table: &Table<K, V>, key: K, default: &V
-    ): &V {
-        if (!contains(table, copy key)) {
-            default
-        } else {
-            borrow(table, 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>(table: &mut Table<K, V>, key: K): &mut V {
-        &mut borrow_box_mut<K, V, Box<V>>(table, key).val
-    }
-
-    /// Returns the length of the table, i.e. the number of entries.
-    public fun length<K: copy + drop, V>(table: &Table<K, V>): u64 {
-        table.length
-    }
-
-    /// Returns true if this table is empty.
-    public fun empty<K: copy + drop, V>(table: &Table<K, V>): bool {
-        table.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>(
-        table: &mut Table<K, V>,
-        key: K,
-        default: V
-    ): &mut V {
-        if (!contains(table, copy key)) {
-            add(table, copy key, default)
-        };
-        borrow_mut(table, 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>(
-        table: &mut Table<K, V>,
-        key: K,
-        value: V
-    ) {
-        if (!contains(table, copy key)) {
-            add(table, copy key, value)
-        } else {
-            let ref = borrow_mut(table, 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>(table: &mut Table<K, V>, key: K): V {
-        let Box { val } = remove_box<K, V, Box<V>>(table, key);
-        table.length = table.length - 1;
-        val
-    }
-
-    /// Returns true iff `table` contains an entry for `key`.
-    public fun contains<K: copy + drop, V>(table: &Table<K, V>, key: K): bool {
-        contains_box<K, V, Box<V>>(table, key)
-    }
-
-    #[test_only]
-    /// Testing only: allows to drop a table even if it is not empty.
-    public fun drop_unchecked<K: copy + drop, V>(table: Table<K, V>) {
-        drop_unchecked_box<K, V, Box<V>>(table)
-    }
-
-    /// Create iterator for `table`.
-    /// A user has to check `prepare` before calling `next` to prevent abort.
-    ///
-    /// let iter = table::iter(&t, start, end, order);
-    /// loop {
-    ///     if (!table::prepare<K, V>(&mut iter)) {
-    ///         break;
-    ///     }
-    ///
-    ///     let (key, value) = table::next<K, V>(&mut iter);
-    /// }
-    ///
-    /// NOTE: The default BCS number encoding follows the Little Endian method.
-    /// As a result, the byte order may differ from the numeric order. To maintain
-    /// the numeric order, use `vector<u8>` as the key and utilize `0x1::std::table_key`
-    /// functions to obtain the Big Endian key bytes of a number.
-    ///
-    public fun iter<K: copy + drop, V>(
-        table: &Table<K, V>,
-        start: Option<K>, /* inclusive */
-        end: Option<K>, /* exclusive */
-        order: u8 /* 1: Ascending, 2: Descending */
-    ): &TableIter<K, V> {
-        let start_bytes: vector<u8> =
-            if (option::is_some(&start)) {
-                bcs::to_bytes<K>(&option::extract(&mut start))
-            } else {
-                vector::empty()
-            };
-
-        let end_bytes: vector<u8> =
-            if (option::is_some(&end)) {
-                bcs::to_bytes<K>(&option::extract(&mut end))
-            } else {
-                vector::empty()
-            };
-
-        new_table_iter<K, V, Box<V>>(table, start_bytes, end_bytes, order)
-    }
-
-    public fun prepare<K: copy + drop, V>(table_iter: &TableIter<K, V>): bool {
-        prepare_box<K, V, Box<V>>(table_iter)
-    }
-
-    public fun next<K: copy + drop, V>(table_iter: &TableIter<K, V>): (K, &V) {
-        let (key, box) = next_box<K, V, Box<V>>(table_iter);
-        (key, &box.val)
-    }
-
-    /// Create mutable iterator for `table`.
-    /// A user has to check `prepare` before calling `next` to prevent abort.
-    ///
-    /// let iter = table::iter_mut(&mut t, start, end, order);
-    /// loop {
-    ///     if (!table::prepare_mut(iter)) {
-    ///         break;
-    ///     }
-    ///
-    ///     let (key, value) = table::next_mut(iter);
-    /// }
-    ///
-    /// NOTE: The default BCS number encoding follows the Little Endian method.
-    /// As a result, the byte order may differ from the numeric order. To maintain
-    /// the numeric order, use `vector<u8>` as the key and utilize `0x1::std::table_key`
-    /// functions to obtain the Big Endian key bytes of a number.
-    ///
-    public fun iter_mut<K: copy + drop, V>(
-        table: &mut Table<K, V>,
-        start: Option<K>, /* inclusive */
-        end: Option<K>, /* exclusive */
-        order: u8 /* 1: Ascending, 2: Descending */
-    ): &mut TableIter<K, V> {
-        let start_bytes: vector<u8> =
-            if (option::is_some(&start)) {
-                bcs::to_bytes<K>(&option::extract(&mut start))
-            } else {
-                vector::empty()
-            };
-
-        let end_bytes: vector<u8> =
-            if (option::is_some(&end)) {
-                bcs::to_bytes<K>(&option::extract(&mut end))
-            } else {
-                vector::empty()
-            };
-
-        new_table_iter_mut<K, V, Box<V>>(table, start_bytes, end_bytes, order)
-    }
-
-    public fun prepare_mut<K: copy + drop, V>(
-        table_iter: &mut TableIter<K, V>
-    ): bool {
-        prepare_box_mut<K, V, Box<V>>(table_iter)
-    }
-
-    public fun next_mut<K: copy + drop, V>(table_iter: &mut TableIter<K, V>): (K, &mut V) {
-        let (key, box) = next_box_mut<K, V, Box<V>>(table_iter);
-        (key, &mut box.val)
-    }
-
-    // ======================================================================================================
-    // 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>);
-
-    native fun new_table_iter<K: copy + drop, V, B>(
-        table: &Table<K, V>,
-        start: vector<u8>,
-        end: vector<u8>,
-        order: u8
-    ): &TableIter<K, V>;
-
-    native fun new_table_iter_mut<K: copy + drop, V, B>(
-        table: &mut Table<K, V>,
-        start: vector<u8>,
-        end: vector<u8>,
-        order: u8
-    ): &mut TableIter<K, V>;
-
-    native fun next_box<K: copy + drop, V, B>(table_iter: &TableIter<K, V>): (K, &Box<V>);
-
-    native fun prepare_box<K: copy + drop, V, B>(table_iter: &TableIter<K, V>): bool;
-
-    native fun next_box_mut<K: copy + drop, V, B>(
-        table_iter: &mut TableIter<K, V>
-    ): (K, &mut Box<V>);
-
-    native fun prepare_box_mut<K: copy + drop, V, B>(
-        table_iter: &mut TableIter<K, V>
-    ): bool;
-
-    // ======================================================================================================
-    // Tests
-
-    #[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 });
-    }
-
-    #[test(account = @0x1)]
-    fun test_iterator(account: &signer) {
-        let t = new<u64, u8>();
-        add(&mut t, 1, 1);
-        add(&mut t, 2, 2);
-
-        let iter = iter(&t, option::none(), option::none(), 1);
-        let iter2 = iter(&t, option::none(), option::none(), 1);
-        assert!(iter.iterator_id == 0, 1);
-        assert!(iter2.iterator_id == 1, 1);
-        prepare(iter);
-        let (key, value) = next(iter);
-        assert!(key == 1 && *value == 1, 1);
-
-        move_to(account, TableHolder { t });
-    }
-
-    #[test(account = @0x1, account2 = @0x2)]
-    fun test_address_uniqueness(account: &signer, account2: &signer) {
-        let t1 = new<u64, u8>();
-        let t2 = new<u64, u8>();
-        assert!(handle(&t1) != handle(&t2), 1);
-
-        move_to(account, TableHolder { t: t1 });
-        move_to(account2, TableHolder { t: t2 });
-    }
-}

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

@@ -1,47 +0,0 @@
-module initia_std::table_key {
-    use std::bcs;
-    use std::vector;
-    use std::from_bcs;
-
-    /// return big endian bytes of `u64`
-    public fun encode_u64(key: u64): vector<u8> {
-        let key_bytes = bcs::to_bytes<u64>(&key);
-        vector::reverse(&mut key_bytes);
-
-        key_bytes
-    }
-
-    /// return `u64` from the big endian key bytes
-    public fun decode_u64(key_bytes: vector<u8>): u64 {
-        vector::reverse(&mut key_bytes);
-        from_bcs::to_u64(key_bytes)
-    }
-
-    /// return big endian bytes of `u128`
-    public fun encode_u128(key: u128): vector<u8> {
-        let key_bytes = bcs::to_bytes<u128>(&key);
-        vector::reverse(&mut key_bytes);
-
-        key_bytes
-    }
-
-    /// return `u128` from the big endian key bytes
-    public fun decode_u128(key_bytes: vector<u8>): u128 {
-        vector::reverse(&mut key_bytes);
-        from_bcs::to_u128(key_bytes)
-    }
-
-    /// return big endian bytes of `u256`
-    public fun encode_u256(key: u256): vector<u8> {
-        let key_bytes = bcs::to_bytes<u256>(&key);
-        vector::reverse(&mut key_bytes);
-
-        key_bytes
-    }
-
-    /// return `u256` from the big endian key bytes
-    public fun decode_u256(key_bytes: vector<u8>): u256 {
-        vector::reverse(&mut key_bytes);
-        from_bcs::to_u256(key_bytes)
-    }
-}

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

@@ -1,49 +0,0 @@
-/// Timestamp module exists to provide compatibility with aptos.
-module initia_std::timestamp {
-    use initia_std::block::get_block_info;
-
-    /// Conversion factor between seconds and microseconds
-    const MICRO_CONVERSION_FACTOR: u64 = 1000000;
-
-    #[view]
-    /// Gets the current time in microseconds.
-    public fun now_microseconds(): u64 {
-        let timestamp = now_seconds();
-        timestamp * MICRO_CONVERSION_FACTOR
-    }
-
-    #[view]
-    /// Gets the current time in seconds.
-    public fun now_seconds(): u64 {
-        let (_, timestamp) = get_block_info();
-        timestamp
-    }
-
-    #[test_only]
-    public fun set_time_has_started_for_testing(_: &signer) {
-        // no-op
-    }
-
-    /// The blockchain is not in an operating state yet
-    const ENOT_OPERATING: u64 = 1;
-    /// An invalid timestamp was provided
-    const EINVALID_TIMESTAMP: u64 = 2;
-
-    #[test_only]
-    use initia_std::block::set_block_info;
-
-    #[test_only]
-    use std::error;
-
-    #[test_only]
-    public fun update_global_time_for_test(timestamp_microsecs: u64) {
-        update_global_time_for_test_secs(timestamp_microsecs / MICRO_CONVERSION_FACTOR);
-    }
-
-    #[test_only]
-    public fun update_global_time_for_test_secs(timestamp_seconds: u64) {
-        let (height, now) = get_block_info();
-        assert!(now < timestamp_seconds, error::invalid_argument(EINVALID_TIMESTAMP));
-        set_block_info(height, timestamp_seconds);
-    }
-}