create-dubhe 0.1.13 → 1.2.0-pre.51

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

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

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

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

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