create-dubhe 0.0.8 → 0.0.10

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

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

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

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

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