create-dubhe 0.1.13 → 1.2.0-pre.51

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

@@ -1,87 +0,0 @@
-module initia_std::transaction_context {
-    /// Return a transaction hash of this execution.
-    native public fun get_transaction_hash(): vector<u8>;
-
-    /// Return a universally unique identifier (of type address) generated
-    /// by hashing the execution id of this execution and a sequence number
-    /// specific to this execution. This function can be called any
-    /// number of times inside a single execution. Each such call increments
-    /// the sequence number and generates a new unique address.
-    native public fun generate_unique_address(): address;
-
-    #[test_only]
-    native fun get_session_id(): vector<u8>;
-
-    #[test_only]
-    use initia_std::vector;
-
-    #[test_only]
-    public fun set_transaction_hash(transaction_hash: vector<u8>) {
-        assert!(vector::length(&transaction_hash) == 32, 100);
-        set_transaction_hash_internal(transaction_hash);
-    }
-
-    #[test_only]
-    native fun set_transaction_hash_internal(transaction_hash: vector<u8>);
-
-    #[test]
-    fun test_address_uniquess() {
-        use std::vector;
-
-        let addrs: vector<address> = vector<address>[];
-        let i: u64 = 0;
-        let count: u64 = 50;
-        while (i < count) {
-            i = i + 1;
-            vector::push_back(&mut addrs, generate_unique_address());
-        };
-
-        i = 0;
-        while (i < count - 1) {
-            let j: u64 = i + 1;
-            while (j < count) {
-                assert!(
-                    *vector::borrow(&addrs, i) != *vector::borrow(&addrs, j),
-                    0
-                );
-                j = j + 1;
-            };
-            i = i + 1;
-        };
-    }
-
-    #[test]
-    fun test_correct_unique_address() {
-        use std::vector;
-
-        let addr1 = initia_std::transaction_context::generate_unique_address();
-
-        // UID_PREFIX for transaction context
-        let bytes = x"00000001";
-        let session_id = initia_std::transaction_context::get_session_id();
-        vector::append(&mut bytes, session_id);
-        std::vector::push_back(&mut bytes, 1);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-        std::vector::push_back(&mut bytes, 0);
-
-        let addr2 = initia_std::from_bcs::to_address(std::hash::sha3_256(bytes));
-        assert!(addr1 == addr2, 0);
-    }
-
-    #[test]
-    fun test_get_transaction_hash() {
-        set_transaction_hash(
-            x"0000000000000000000000000000000000000000000000000000000000000001"
-        );
-        assert!(
-            get_transaction_hash()
-                == x"0000000000000000000000000000000000000000000000000000000000000001",
-            0
-        );
-    }
-}

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

@@ -1,80 +0,0 @@
-module initia_std::type_info {
-    use std::string;
-
-    struct TypeInfo has copy, drop, store {
-        account_address: address,
-        module_name: vector<u8>,
-        struct_name: vector<u8>
-    }
-
-    public fun account_address(type_info: &TypeInfo): address {
-        type_info.account_address
-    }
-
-    public fun module_name(type_info: &TypeInfo): vector<u8> {
-        type_info.module_name
-    }
-
-    public fun struct_name(type_info: &TypeInfo): vector<u8> {
-        type_info.struct_name
-    }
-
-    native public fun type_of<T>(): TypeInfo;
-
-    native public fun type_name<T>(): string::String;
-
-    #[test]
-    fun test() {
-        let type_info = type_of<TypeInfo>();
-        assert!(account_address(&type_info) == @initia_std, 0);
-        assert!(module_name(&type_info) == b"type_info", 1);
-        assert!(struct_name(&type_info) == b"TypeInfo", 2);
-    }
-
-    // TODO: uncomment after add table
-    #[test]
-    fun test_type_name() {
-        use initia_std::table::Table;
-
-        assert!(type_name<bool>() == string::utf8(b"bool"), 0);
-        assert!(type_name<u8>() == string::utf8(b"u8"), 1);
-        assert!(type_name<u64>() == string::utf8(b"u64"), 2);
-        assert!(type_name<u128>() == string::utf8(b"u128"), 3);
-        assert!(
-            type_name<address>() == string::utf8(b"address"),
-            4
-        );
-        assert!(
-            type_name<signer>() == string::utf8(b"signer"),
-            5
-        );
-
-        // vector
-        assert!(
-            type_name<vector<u8>>() == string::utf8(b"vector<u8>"),
-            6
-        );
-        assert!(
-            type_name<vector<vector<u8>>>() == string::utf8(b"vector<vector<u8>>"),
-            7
-        );
-        assert!(
-            type_name<vector<vector<TypeInfo>>>()
-                == string::utf8(b"vector<vector<0x1::type_info::TypeInfo>>"),
-            8
-        );
-
-        // struct
-        assert!(
-            type_name<TypeInfo>() == string::utf8(b"0x1::type_info::TypeInfo"),
-            9
-        );
-        assert!(
-            type_name<Table<TypeInfo, Table<u8, vector<TypeInfo>>>>()
-                == string::utf8(
-                    b"0x1::table::Table<0x1::type_info::TypeInfo, 0x1::table::Table<u8, vector<0x1::type_info::TypeInfo>>>"
-                ),
-            10
-        );
-    }
-}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveNursery/acl.move

@@ -1,52 +0,0 @@
-/// Access control list (ACL) module. An ACL is a list of account addresses who
-/// have the access permission to a certain object.
-/// This module uses a `vector` to represent the list, but can be refactored to
-/// use a "set" instead when it's available in the language in the future.
-
-module std::acl {
-    use std::vector;
-    use std::error;
-
-    /// The ACL already contains the address.
-    const ECONTAIN: u64 = 0;
-    /// The ACL does not contain the address.
-    const ENOT_CONTAIN: u64 = 1;
-
-    struct ACL has store, drop, copy {
-        list: vector<address>
-    }
-
-    /// Return an empty ACL.
-    public fun empty(): ACL {
-        ACL { list: vector::empty<address>() }
-    }
-
-    /// Add the address to the ACL.
-    public fun add(acl: &mut ACL, addr: address) {
-        assert!(
-            !vector::contains(&mut acl.list, &addr),
-            error::invalid_argument(ECONTAIN)
-        );
-        vector::push_back(&mut acl.list, addr);
-    }
-
-    /// Remove the address from the ACL.
-    public fun remove(acl: &mut ACL, addr: address) {
-        let (found, index) = vector::index_of(&mut acl.list, &addr);
-        assert!(found, error::invalid_argument(ENOT_CONTAIN));
-        vector::remove(&mut acl.list, index);
-    }
-
-    /// Return true iff the ACL contains the address.
-    public fun contains(acl: &ACL, addr: address): bool {
-        vector::contains(&acl.list, &addr)
-    }
-
-    /// assert! that the ACL has the address.
-    public fun assert_contains(acl: &ACL, addr: address) {
-        assert!(
-            contains(acl, addr),
-            error::invalid_argument(ENOT_CONTAIN)
-        );
-    }
-}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveNursery/capability.move

@@ -1,231 +0,0 @@
-/// A module which defines the basic concept of
-/// [*capabilities*](https://en.wikipedia.org/wiki/Capability-based_security) for managing access control.
-///
-/// EXPERIMENTAL
-///
-/// # Overview
-///
-/// A capability is a unforgeable token which testifies that a signer has authorized a certain operation.
-/// The token is valid during the transaction where it is obtained. Since the type `capability::Cap` has
-/// no ability to be stored in global memory, capabilities cannot leak out of a transaction. For every function
-/// called within a transaction which has a capability as a parameter, it is guaranteed that the capability
-/// has been obtained via a proper signer-based authorization step previously in the transaction's execution.
-///
-/// ## Usage
-///
-/// Initializing and acquiring capabilities is usually encapsulated in a module with a type
-/// tag which can only be constructed by this module.
-///
-/// ```
-/// module Pkg::Feature {
-///   use std::capability::Cap;
-///
-///   /// A type tag used in Cap<Feature>. Only this module can create an instance,
-///   /// and there is no public function other than Self::acquire which returns a value of this type.
-///   /// This way, this module has full control how Cap<Feature> is given out.
-///   struct Feature has drop {}
-///
-///   /// Initializes this module.
-///   public fun initialize(s: &signer) {
-///     // Create capability. This happens once at module initialization time.
-///     // One needs to provide a witness for being the owner of Feature
-///     // in the 2nd parameter.
-///     <<additional conditions allowing to initialize this capability>>
-///     capability::create<Feature>(s, &Feature{});
-///   }
-///
-///   /// Acquires the capability to work with this feature.
-///   public fun acquire(s: &signer): Cap<Feature> {
-///     <<additional conditions allowing to acquire this capability>>
-///     capability::acquire<Feature>(s, &Feature{});
-///   }
-///
-///   /// Does something related to the feature. The caller must pass a Cap<Feature>.
-///   public fun do_something(_cap: Cap<Feature>) { ... }
-/// }
-/// ```
-///
-/// ## Delegation
-///
-/// Capabilities come with the optional feature of *delegation*. Via `Self::delegate`, an owner of a capability
-/// can designate another signer to be also capable of acquiring the capability. Like the original creator,
-/// the delegate needs to present his signer to obtain the capability in his transactions. Delegation can
-/// be revoked via `Self::revoke`, removing this access right from the delegate.
-///
-/// While the basic authorization mechanism for delegates is the same as with core capabilities, the
-/// target of delegation might be subject of restrictions which need to be specified and verified. This can
-/// be done via global invariants in the specification language. For example, in order to prevent delegation
-/// all together for a capability, one can use the following invariant:
-///
-/// ```
-///   invariant forall a: address where capability::spec_has_cap<Feature>(a):
-///               len(capability::spec_delegates<Feature>(a)) == 0;
-/// ```
-///
-/// Similarly, the following invariant would enforce that delegates, if existent, must satisfy a certain
-/// predicate:
-///
-/// ```
-///   invariant forall a: address where capability::spec_has_cap<Feature>(a):
-///               forall d in capability::spec_delegates<Feature>(a):
-///                  is_valid_delegate_for_feature(d);
-/// ```
-///
-module std::capability {
-    use std::error;
-    use std::signer;
-    use std::vector;
-
-    const ECAP: u64 = 0;
-    const EDELEGATE: u64 = 1;
-
-    /// The token representing an acquired capability. Cannot be stored in memory, but copied and dropped freely.
-    struct Cap<phantom Feature> has copy, drop {
-        root: address
-    }
-
-    /// A linear version of a capability token. This can be used if an acquired capability should be enforced
-    /// to be used only once for an authorization.
-    struct LinearCap<phantom Feature> has drop {
-        root: address
-    }
-
-    /// An internal data structure for representing a configured capability.
-    struct CapState<phantom Feature> has key {
-        delegates: vector<address>
-    }
-
-    /// An internal data structure for representing a configured delegated capability.
-    struct CapDelegateState<phantom Feature> has key {
-        root: address
-    }
-
-    /// Creates a new capability class, owned by the passed signer. A caller must pass a witness that
-    /// they own the `Feature` type parameter.
-    public fun create<Feature>(
-        owner: &signer, _feature_witness: &Feature
-    ) {
-        let addr = signer::address_of(owner);
-        assert!(
-            !exists<CapState<Feature>>(addr),
-            error::already_exists(ECAP)
-        );
-        move_to<CapState<Feature>>(owner, CapState { delegates: vector::empty() });
-    }
-
-    /// Acquires a capability token. Only the owner of the capability class, or an authorized delegate,
-    /// can succeed with this operation. A caller must pass a witness that they own the `Feature` type
-    /// parameter.
-    public fun acquire<Feature>(
-        requester: &signer, _feature_witness: &Feature
-    ): Cap<Feature> acquires CapState, CapDelegateState {
-        Cap<Feature> {
-            root: validate_acquire<Feature>(requester)
-        }
-    }
-
-    /// Acquires a linear capability token. It is up to the module which owns `Feature` to decide
-    /// whether to expose a linear or non-linear capability.
-    public fun acquire_linear<Feature>(
-        requester: &signer, _feature_witness: &Feature
-    ): LinearCap<Feature> acquires CapState, CapDelegateState {
-        LinearCap<Feature> {
-            root: validate_acquire<Feature>(requester)
-        }
-    }
-
-    /// Helper to validate an acquire. Returns the root address of the capability.
-    fun validate_acquire<Feature>(requester: &signer): address acquires CapState, CapDelegateState {
-        let addr = signer::address_of(requester);
-        if (exists<CapDelegateState<Feature>>(addr)) {
-            let root_addr = borrow_global<CapDelegateState<Feature>>(addr).root;
-            // double check that requester is actually registered as a delegate
-            assert!(
-                exists<CapState<Feature>>(root_addr),
-                error::invalid_state(EDELEGATE)
-            );
-            assert!(
-                vector::contains(
-                    &borrow_global<CapState<Feature>>(root_addr).delegates,
-                    &addr
-                ),
-                error::invalid_state(EDELEGATE)
-            );
-            root_addr
-        } else {
-            assert!(
-                exists<CapState<Feature>>(addr),
-                error::not_found(ECAP)
-            );
-            addr
-        }
-    }
-
-    /// Returns the root address associated with the given capability token. Only the owner
-    /// of the feature can do this.
-    public fun root_addr<Feature>(
-        cap: Cap<Feature>, _feature_witness: &Feature
-    ): address {
-        cap.root
-    }
-
-    /// Returns the root address associated with the given linear capability token.
-    public fun linear_root_addr<Feature>(
-        cap: LinearCap<Feature>, _feature_witness: &Feature
-    ): address {
-        cap.root
-    }
-
-    /// Registers a delegation relation. If the relation already exists, this function does
-    /// nothing.
-    // TODO: explore whether this should be idempotent like now or abort
-    public fun delegate<Feature>(
-        cap: Cap<Feature>, _feature_witness: &Feature, to: &signer
-    ) acquires CapState {
-        let addr = signer::address_of(to);
-        if (exists<CapDelegateState<Feature>>(addr)) return;
-        move_to(to, CapDelegateState<Feature> { root: cap.root });
-        add_element(
-            &mut borrow_global_mut<CapState<Feature>>(cap.root).delegates,
-            addr
-        );
-    }
-
-    /// Revokes a delegation relation. If no relation exists, this function does nothing.
-    // TODO: explore whether this should be idempotent like now or abort
-    public fun revoke<Feature>(
-        cap: Cap<Feature>, _feature_witness: &Feature, from: address
-    ) acquires CapState, CapDelegateState {
-        if (!exists<CapDelegateState<Feature>>(from)) return;
-        let CapDelegateState { root: _root } = move_from<CapDelegateState<Feature>>(from);
-        remove_element(
-            &mut borrow_global_mut<CapState<Feature>>(cap.root).delegates,
-            &from
-        );
-    }
-
-    /// Helper to remove an element from a vector.
-    fun remove_element<E: drop>(v: &mut vector<E>, x: &E) {
-        let (found, index) = vector::index_of(v, x);
-        if (found) {
-            vector::remove(v, index);
-        }
-    }
-
-    /// Helper to add an element to a vector.
-    fun add_element<E: drop>(v: &mut vector<E>, x: E) {
-        if (!vector::contains(v, &x)) {
-            vector::push_back(v, x)
-        }
-    }
-
-    /// Helper specification function to check whether a capability exists at address.
-    spec fun spec_has_cap<Feature>(addr: address): bool {
-        exists<CapState<Feature>>(addr)
-    }
-
-    /// Helper specification function to obtain the delegates of a capability.
-    spec fun spec_delegates<Feature>(addr: address): vector<address> {
-        global<CapState<Feature>>(addr).delegates
-    }
-}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveNursery/compare.move

@@ -1,76 +0,0 @@
-/// Utilities for comparing Move values based on their representation in BCS.
-module std::compare {
-    use std::vector;
-
-    // Move does not have signed integers, so we cannot use the usual 0, -1, 1 convention to
-    // represent EQUAL, LESS_THAN, and GREATER_THAN. Instead, we fun a new convention using u8
-    // constants:
-    const EQUAL: u8 = 0;
-    const LESS_THAN: u8 = 1;
-    const GREATER_THAN: u8 = 2;
-
-    /// compare vectors `v1` and `v2` using (1) vector contents from right to left and then
-    /// (2) vector length to break ties.
-    /// Returns either `EQUAL` (0u8), `LESS_THAN` (1u8), or `GREATER_THAN` (2u8).
-    ///
-    /// This function is designed to compare BCS (Binary Canonical Serialization)-encoded values
-    /// (i.e., vectors produced by `bcs::to_bytes`). A typical client will call
-    /// `compare::cmp_bcs_bytes(bcs::to_bytes(&t1), bcs::to_bytes(&t2))`. The comparison provides the
-    /// following guarantees w.r.t the original values t1 and t2:
-    /// - `cmp_bcs_bytes(bcs(t1), bcs(t2)) == LESS_THAN` iff `cmp_bcs_bytes(t2, t1) == GREATER_THAN`
-    /// - `compare::cmp<T>(t1, t2) == EQUAL` iff `t1 == t2` and (similarly)
-    ///   `compare::cmp<T>(t1, t2) != EQUAL` iff `t1 != t2`, where `==` and `!=` denote the Move
-    ///    bytecode operations for polymorphic equality.
-    /// - for all primitive types `T` with `<` and `>` comparison operators exposed in Move bytecode
-    ///   (`u8`, `u16`, `u32`, `u64`, `u128`, `u256`), we have
-    ///   `compare_bcs_bytes(bcs(t1), bcs(t2)) == LESS_THAN` iff `t1 < t2` and (similarly)
-    ///   `compare_bcs_bytes(bcs(t1), bcs(t2)) == LESS_THAN` iff `t1 > t2`.
-    ///
-    /// For all other types, the order is whatever the BCS encoding of the type and the comparison
-    /// strategy above gives you. One case where the order might be surprising is the `address`
-    /// type.
-    /// CoreAddresses are 16 byte hex values that BCS encodes with the identity function. The right
-    /// to left, byte-by-byte comparison means that (for example)
-    /// `compare_bcs_bytes(bcs(0x01), bcs(0x10)) == LESS_THAN` (as you'd expect), but
-    /// `compare_bcs_bytes(bcs(0x100), bcs(0x001)) == LESS_THAN` (as you probably wouldn't expect).
-    /// Keep this in mind when using this function to compare addresses.
-    ///
-    /// > TODO: there is currently no specification for this function, which causes no problem because it is not yet
-    /// > used in the Diem framework. However, should this functionality be needed in specification, a customized
-    /// > native abstraction is needed in the prover framework.
-    public fun cmp_bcs_bytes(v1: &vector<u8>, v2: &vector<u8>): u8 {
-        let i1 = vector::length(v1);
-        let i2 = vector::length(v2);
-        let len_cmp = cmp_u64(i1, i2);
-
-        // BCS uses little endian encoding for all integer types, so we choose to compare from left
-        // to right. Going right to left would make the behavior of compare::cmp diverge from the
-        // bytecode operators < and > on integer values (which would be confusing).
-        while (i1 > 0 && i2 > 0) {
-            i1 = i1 - 1;
-            i2 = i2 - 1;
-            let elem_cmp = cmp_u8(
-                *vector::borrow(v1, i1),
-                *vector::borrow(v2, i2)
-            );
-            if (elem_cmp != 0) return elem_cmp
-            // else, compare next element
-        };
-        // all compared elements equal; use length comparison to break the tie
-        len_cmp
-    }
-
-    /// Compare two `u8`'s
-    fun cmp_u8(i1: u8, i2: u8): u8 {
-        if (i1 == i2) EQUAL
-        else if (i1 < i2) LESS_THAN
-        else GREATER_THAN
-    }
-
-    /// Compare two `u64`'s
-    fun cmp_u64(i1: u64, i2: u64): u8 {
-        if (i1 == i2) EQUAL
-        else if (i1 < i2) LESS_THAN
-        else GREATER_THAN
-    }
-}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/MoveNursery/guid.move

@@ -1,116 +0,0 @@
-/// A module for generating globally unique identifiers
-module std::guid {
-    use std::signer;
-
-    /// A generator for new GUIDs.
-    struct Generator has key {
-        /// A monotonically increasing counter
-        counter: u64
-    }
-
-    /// A globally unique identifier derived from the sender's address and a counter
-    struct GUID has drop, store {
-        id: ID
-    }
-
-    /// A non-privileged identifier that can be freely created by anyone. Useful for looking up GUID's.
-    struct ID has copy, drop, store {
-        /// If creation_num is `i`, this is the `i+1`th GUID created by `addr`
-        creation_num: u64,
-        /// Address that created the GUID
-        addr: address
-    }
-
-    /// A capability to create a privileged identifier on behalf of the given address
-    struct CreateCapability has key, store, drop {
-        addr: address
-    }
-
-    /// GUID generator must be published ahead of first usage of `create_with_capability` function.
-    const EGUID_GENERATOR_NOT_PUBLISHED: u64 = 0;
-
-    /// Generates a capability to create the privileged GUID on behalf of the signer
-    // (also makes sure that the Generator is published under the signer account)
-    public fun gen_create_capability(account: &signer): CreateCapability {
-        let addr = signer::address_of(account);
-        if (!exists<Generator>(addr)) {
-            move_to(account, Generator { counter: 0 })
-        };
-        CreateCapability { addr }
-    }
-
-    /// Create a non-privileged id from `addr` and `creation_num`
-    public fun create_id(addr: address, creation_num: u64): ID {
-        ID { creation_num, addr }
-    }
-
-    public fun create_with_capability(
-        addr: address, _cap: &CreateCapability
-    ): GUID acquires Generator {
-        assert!(
-            exists<Generator>(addr),
-            EGUID_GENERATOR_NOT_PUBLISHED
-        );
-        create_impl(addr)
-    }
-
-    /// Create and return a new GUID. Creates a `Generator` under `account`
-    /// if it does not already have one
-    public fun create(account: &signer): GUID acquires Generator {
-        let addr = signer::address_of(account);
-        if (!exists<Generator>(addr)) {
-            move_to(account, Generator { counter: 0 })
-        };
-        create_impl(addr)
-    }
-
-    fun create_impl(addr: address): GUID acquires Generator {
-        let generator = borrow_global_mut<Generator>(addr);
-        let creation_num = generator.counter;
-        generator.counter = creation_num + 1;
-        GUID { id: ID { creation_num, addr } }
-    }
-
-    /// Publish a Generator resource under `account`
-    public fun publish_generator(account: &signer) {
-        move_to(account, Generator { counter: 0 })
-    }
-
-    /// Get the non-privileged ID associated with a GUID
-    public fun id(guid: &GUID): ID {
-        *&guid.id
-    }
-
-    /// Return the account address that created the GUID
-    public fun creator_address(guid: &GUID): address {
-        guid.id.addr
-    }
-
-    /// Return the account address that created the guid::ID
-    public fun id_creator_address(id: &ID): address {
-        id.addr
-    }
-
-    /// Return the creation number associated with the GUID
-    public fun creation_num(guid: &GUID): u64 {
-        guid.id.creation_num
-    }
-
-    /// Return the creation number associated with the guid::ID
-    public fun id_creation_num(id: &ID): u64 {
-        id.creation_num
-    }
-
-    /// Return true if the GUID's ID is `id`
-    public fun eq_id(guid: &GUID, id: &ID): bool {
-        &guid.id == id
-    }
-
-    /// Return the number of the next GUID to be created by `addr`
-    public fun get_next_creation_num(addr: address): u64 acquires Generator {
-        if (!exists<Generator>(addr)) { 0 }
-        else {
-            borrow_global<Generator>(addr).counter
-        }
-    }
-}