create-dubhe 0.0.8 → 0.0.10

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveStdlib/ascii.move

@@ -0,0 +1,153 @@
+/// The `ASCII` module defines basic string and char newtypes in Move that verify
+/// that characters are valid ASCII, and that strings consist of only valid ASCII characters.
+module std::ascii {
+    use std::vector;
+    use std::option::{Self, Option};
+
+    /// An invalid ASCII character was encountered when creating an ASCII string.
+    const EINVALID_ASCII_CHARACTER: u64 = 0x10000;
+
+    /// The `String` struct holds a vector of bytes that all represent
+    /// valid ASCII characters. Note that these ASCII characters may not all
+    /// be printable. To determine if a `String` contains only "printable"
+    /// characters you should use the `all_characters_printable` predicate
+    /// defined in this module.
+    struct String has copy, drop, store {
+        bytes: vector<u8>
+    }
+
+    spec String {
+        invariant forall i in 0..len(bytes): is_valid_char(bytes[i]);
+    }
+
+    /// An ASCII character.
+    struct Char has copy, drop, store {
+        byte: u8
+    }
+
+    spec Char {
+        invariant is_valid_char(byte);
+    }
+
+    /// Convert a `byte` into a `Char` that is checked to make sure it is valid ASCII.
+    public fun char(byte: u8): Char {
+        assert!(is_valid_char(byte), EINVALID_ASCII_CHARACTER);
+        Char { byte }
+    }
+
+    spec char {
+        aborts_if !is_valid_char(byte) with EINVALID_ASCII_CHARACTER;
+    }
+
+    /// Convert a vector of bytes `bytes` into an `String`. Aborts if
+    /// `bytes` contains non-ASCII characters.
+    public fun string(bytes: vector<u8>): String {
+        let x = try_string(bytes);
+        assert!(option::is_some(&x), EINVALID_ASCII_CHARACTER);
+        option::destroy_some(x)
+    }
+
+    spec string {
+        aborts_if exists i in 0..len(bytes): !is_valid_char(bytes[i]) with EINVALID_ASCII_CHARACTER;
+    }
+
+    /// Convert a vector of bytes `bytes` into an `String`. Returns
+    /// `Some(<ascii_string>)` if the `bytes` contains all valid ASCII
+    /// characters. Otherwise returns `None`.
+    public fun try_string(bytes: vector<u8>): Option<String> {
+        let len = vector::length(&bytes);
+        let i = 0;
+        while ({
+            spec {
+                invariant i <= len;
+                invariant forall j in 0..i: is_valid_char(bytes[j]);
+            };
+            i < len
+        }) {
+            let possible_byte = *vector::borrow(&bytes, i);
+            if (!is_valid_char(possible_byte)) return option::none();
+            i = i + 1;
+        };
+        spec {
+            assert i == len;
+            assert forall j in 0..len: is_valid_char(bytes[j]);
+        };
+        option::some(String { bytes })
+    }
+
+    /// Returns `true` if all characters in `string` are printable characters
+    /// Returns `false` otherwise. Not all `String`s are printable strings.
+    public fun all_characters_printable(string: &String): bool {
+        let len = vector::length(&string.bytes);
+        let i = 0;
+        while ({
+            spec {
+                invariant i <= len;
+                invariant forall j in 0..i: is_printable_char(string.bytes[j]);
+            };
+            i < len
+        }) {
+            let byte = *vector::borrow(&string.bytes, i);
+            if (!is_printable_char(byte)) return false;
+            i = i + 1;
+        };
+        spec {
+            assert i == len;
+            assert forall j in 0..len: is_printable_char(string.bytes[j]);
+        };
+        true
+    }
+
+    spec all_characters_printable {
+        ensures result ==>
+            (forall j in 0..len(string.bytes): is_printable_char(string.bytes[j]));
+    }
+
+    public fun push_char(string: &mut String, char: Char) {
+        vector::push_back(&mut string.bytes, char.byte);
+    }
+
+    spec push_char {
+        ensures len(string.bytes) == len(old(string.bytes)) + 1;
+    }
+
+    public fun pop_char(string: &mut String): Char {
+        Char { byte: vector::pop_back(&mut string.bytes) }
+    }
+
+    spec pop_char {
+        ensures len(string.bytes) == len(old(string.bytes)) - 1;
+    }
+
+    public fun length(string: &String): u64 {
+        vector::length(as_bytes(string))
+    }
+
+    /// Get the inner bytes of the `string` as a reference
+    public fun as_bytes(string: &String): &vector<u8> {
+        &string.bytes
+    }
+
+    /// Unpack the `string` to get its backing bytes
+    public fun into_bytes(string: String): vector<u8> {
+        let String { bytes } = string;
+        bytes
+    }
+
+    /// Unpack the `char` into its underlying byte.
+    public fun byte(char: Char): u8 {
+        let Char { byte } = char;
+        byte
+    }
+
+    /// Returns `true` if `b` is a valid ASCII character. Returns `false` otherwise.
+    public fun is_valid_char(b: u8): bool {
+        b <= 0x7F
+    }
+
+    /// Returns `true` if `byte` is an printable ASCII character. Returns `false` otherwise.
+    public fun is_printable_char(byte: u8): bool {
+        byte >= 0x20 && // Disallow metacharacters
+        byte <= 0x7E // Don't allow DEL metacharacter
+    }
+}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveStdlib/bcs.move

@@ -0,0 +1,17 @@
+/// Utility for converting a Move value to its binary representation in BCS (Binary Canonical
+/// Serialization). BCS is the binary encoding for Move resources and other non-module values
+/// published on-chain. See https://github.com/diem/bcs#binary-canonical-serialization-bcs for more
+/// details on BCS.
+module std::bcs {
+    /// Return the binary representation of `v` in BCS (Binary Canonical Serialization) format
+    native public fun to_bytes<MoveValue>(v: &MoveValue): vector<u8>;
+
+    // ==============================
+    // Module Specification
+    spec module {} // switch to module documentation context
+
+    spec module {
+        /// Native function which is defined in the prover's prelude.
+        native fun serialize<MoveValue>(v: &MoveValue): vector<u8>;
+    }
+}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveStdlib/bit_vector.move

@@ -0,0 +1,179 @@
+module std::bit_vector {
+    use std::vector;
+
+    /// The provided index is out of bounds
+    const EINDEX: u64 = 0x20000;
+    /// An invalid length of bitvector was given
+    const ELENGTH: u64 = 0x20001;
+
+    const WORD_SIZE: u64 = 1;
+    /// The maximum allowed bitvector size
+    const MAX_SIZE: u64 = 1024;
+
+    struct BitVector has copy, drop, store {
+        length: u64,
+        bit_field: vector<bool>
+    }
+
+    public fun new(length: u64): BitVector {
+        assert!(length > 0, ELENGTH);
+        assert!(length < MAX_SIZE, ELENGTH);
+        let counter = 0;
+        let bit_field = vector::empty();
+        while ({
+            spec {
+                invariant counter <= length;
+                invariant len(bit_field) == counter;
+            };
+            (counter < length)
+        }) {
+            vector::push_back(&mut bit_field, false);
+            counter = counter + 1;
+        };
+        spec {
+            assert counter == length;
+            assert len(bit_field) == length;
+        };
+
+        BitVector { length, bit_field }
+    }
+
+    spec new {
+        include NewAbortsIf;
+        ensures result.length == length;
+        ensures len(result.bit_field) == length;
+    }
+
+    spec schema NewAbortsIf {
+        length: u64;
+        aborts_if length <= 0 with ELENGTH;
+        aborts_if length >= MAX_SIZE with ELENGTH;
+    }
+
+    /// Set the bit at `bit_index` in the `bitvector` regardless of its previous state.
+    public fun set(bitvector: &mut BitVector, bit_index: u64) {
+        assert!(
+            bit_index < vector::length(&bitvector.bit_field),
+            EINDEX
+        );
+        let x = vector::borrow_mut(&mut bitvector.bit_field, bit_index);
+        *x = true;
+    }
+
+    spec set {
+        include SetAbortsIf;
+        ensures bitvector.bit_field[bit_index];
+    }
+
+    spec schema SetAbortsIf {
+        bitvector: BitVector;
+        bit_index: u64;
+        aborts_if bit_index >= length(bitvector) with EINDEX;
+    }
+
+    /// Unset the bit at `bit_index` in the `bitvector` regardless of its previous state.
+    public fun unset(bitvector: &mut BitVector, bit_index: u64) {
+        assert!(
+            bit_index < vector::length(&bitvector.bit_field),
+            EINDEX
+        );
+        let x = vector::borrow_mut(&mut bitvector.bit_field, bit_index);
+        *x = false;
+    }
+
+    spec unset {
+        include UnsetAbortsIf;
+        ensures !bitvector.bit_field[bit_index];
+    }
+
+    spec schema UnsetAbortsIf {
+        bitvector: BitVector;
+        bit_index: u64;
+        aborts_if bit_index >= length(bitvector) with EINDEX;
+    }
+
+    /// Shift the `bitvector` left by `amount`. If `amount` is greater than the
+    /// bitvector's length the bitvector will be zeroed out.
+    public fun shift_left(bitvector: &mut BitVector, amount: u64) {
+        if (amount >= bitvector.length) {
+            let len = vector::length(&bitvector.bit_field);
+            let i = 0;
+            while (i < len) {
+                let elem = vector::borrow_mut(&mut bitvector.bit_field, i);
+                *elem = false;
+                i = i + 1;
+            };
+        } else {
+            let i = amount;
+
+            while (i < bitvector.length) {
+                if (is_index_set(bitvector, i)) set(bitvector, i - amount)
+                else unset(bitvector, i - amount);
+                i = i + 1;
+            };
+
+            i = bitvector.length - amount;
+
+            while (i < bitvector.length) {
+                unset(bitvector, i);
+                i = i + 1;
+            };
+        }
+    }
+
+    /// Return the value of the bit at `bit_index` in the `bitvector`. `true`
+    /// represents "1" and `false` represents a 0
+    public fun is_index_set(bitvector: &BitVector, bit_index: u64): bool {
+        assert!(
+            bit_index < vector::length(&bitvector.bit_field),
+            EINDEX
+        );
+        *vector::borrow(&bitvector.bit_field, bit_index)
+    }
+
+    spec is_index_set {
+        include IsIndexSetAbortsIf;
+        ensures result == bitvector.bit_field[bit_index];
+    }
+
+    spec schema IsIndexSetAbortsIf {
+        bitvector: BitVector;
+        bit_index: u64;
+        aborts_if bit_index >= length(bitvector) with EINDEX;
+    }
+
+    spec fun spec_is_index_set(bitvector: BitVector, bit_index: u64): bool {
+        if (bit_index >= length(bitvector)) { false }
+        else {
+            bitvector.bit_field[bit_index]
+        }
+    }
+
+    /// Return the length (number of usable bits) of this bitvector
+    public fun length(bitvector: &BitVector): u64 {
+        vector::length(&bitvector.bit_field)
+    }
+
+    /// Returns the length of the longest sequence of set bits starting at (and
+    /// including) `start_index` in the `bitvector`. If there is no such
+    /// sequence, then `0` is returned.
+    public fun longest_set_sequence_starting_at(
+        bitvector: &BitVector, start_index: u64
+    ): u64 {
+        assert!(start_index < bitvector.length, EINDEX);
+        let index = start_index;
+
+        // Find the greatest index in the vector such that all indices less than it are set.
+        while (index < bitvector.length) {
+            if (!is_index_set(bitvector, index)) break;
+            index = index + 1;
+        };
+
+        index - start_index
+    }
+
+    #[test_only]
+    public fun word_size(): u64 {
+        WORD_SIZE
+    }
+}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveStdlib/error.move

@@ -0,0 +1,116 @@
+/// This module defines a set of canonical error codes which are optional to use by applications for the
+/// `abort` and `assert!` features.
+///
+/// Canonical error codes use the 3 lowest bytes of the u64 abort code range (the upper 5 bytes are free for other use).
+/// Of those, the highest byte represents the *error category* and the lower two bytes the *error reason*.
+/// Given an error category `0x1` and a reason `0x3`, a canonical abort code looks as `0x10003`.
+///
+/// A module can use a canonical code with a constant declaration of the following form:
+///
+/// ```
+/// ///  An invalid ASCII character was encountered when creating a string.
+/// const EINVALID_CHARACTER: u64 = 0x010003;
+/// ```
+///
+/// This code is both valid in the worlds with and without canonical errors. It can be used as a plain module local
+/// error reason understand by the existing error map tooling, or as a canonical code.
+///
+/// The actual canonical categories have been adopted from Google's canonical error codes, which in turn are derived
+/// from Unix error codes [see here](https://cloud.google.com/apis/design/errors#handling_errors). Each code has an
+/// associated HTTP error code which can be used in REST apis. The mapping from error code to http code is not 1:1;
+/// error codes here are a bit richer than HTTP codes.
+module std::error {
+
+    /// Caller specified an invalid argument (http: 400)
+    const INVALID_ARGUMENT: u64 = 0x1;
+
+    /// An input or result of a computation is out of range (http: 400)
+    const OUT_OF_RANGE: u64 = 0x2;
+
+    /// The system is not in a state where the operation can be performed (http: 400)
+    const INVALID_STATE: u64 = 0x3;
+
+    /// Request not authenticated due to missing, invalid, or expired auth token (http: 401)
+    const UNAUTHENTICATED: u64 = 0x4;
+
+    /// client does not have sufficient permission (http: 403)
+    const PERMISSION_DENIED: u64 = 0x5;
+
+    /// A specified resource is not found (http: 404)
+    const NOT_FOUND: u64 = 0x6;
+
+    /// Concurrency conflict, such as read-modify-write conflict (http: 409)
+    const ABORTED: u64 = 0x7;
+
+    /// The resource that a client tried to create already exists (http: 409)
+    const ALREADY_EXISTS: u64 = 0x8;
+
+    /// Out of gas or other forms of quota (http: 429)
+    const RESOURCE_EXHAUSTED: u64 = 0x9;
+
+    /// Request cancelled by the client (http: 499)
+    const CANCELLED: u64 = 0xA;
+
+    /// Internal error (http: 500)
+    const INTERNAL: u64 = 0xB;
+
+    /// Feature not implemented (http: 501)
+    const NOT_IMPLEMENTED: u64 = 0xC;
+
+    /// The service is currently unavailable. Indicates that a retry could solve the issue (http: 503)
+    const UNAVAILABLE: u64 = 0xD;
+
+    /// Construct a canonical error code from a category and a reason.
+    public fun canonical(category: u64, reason: u64): u64 {
+        (category << 16) + reason
+    }
+
+    /// Functions to construct a canonical error code of the given category.
+    public fun invalid_argument(r: u64): u64 {
+        canonical(INVALID_ARGUMENT, r)
+    }
+
+    public fun out_of_range(r: u64): u64 {
+        canonical(OUT_OF_RANGE, r)
+    }
+
+    public fun invalid_state(r: u64): u64 {
+        canonical(INVALID_STATE, r)
+    }
+
+    public fun unauthenticated(r: u64): u64 {
+        canonical(UNAUTHENTICATED, r)
+    }
+
+    public fun permission_denied(r: u64): u64 {
+        canonical(PERMISSION_DENIED, r)
+    }
+
+    public fun not_found(r: u64): u64 {
+        canonical(NOT_FOUND, r)
+    }
+
+    public fun aborted(r: u64): u64 {
+        canonical(ABORTED, r)
+    }
+
+    public fun already_exists(r: u64): u64 {
+        canonical(ALREADY_EXISTS, r)
+    }
+
+    public fun resource_exhausted(r: u64): u64 {
+        canonical(RESOURCE_EXHAUSTED, r)
+    }
+
+    public fun internal(r: u64): u64 {
+        canonical(INTERNAL, r)
+    }
+
+    public fun not_implemented(r: u64): u64 {
+        canonical(NOT_IMPLEMENTED, r)
+    }
+
+    public fun unavailable(r: u64): u64 {
+        canonical(UNAVAILABLE, r)
+    }
+}