create-dubhe 0.0.8 → 0.0.10

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

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

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

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

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

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

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