create-dubhe 0.0.8 → 0.0.10

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

@@ -0,0 +1,386 @@
+module initia_std::account {
+    use std::error;
+
+    #[test_only]
+    use std::vector;
+    #[test_only]
+    use std::bcs;
+
+    friend initia_std::staking;
+    friend initia_std::object;
+    friend initia_std::table;
+
+    /// Account Types
+    const ACCOUNT_TYPE_BASE: u8 = 0;
+    const ACCOUNT_TYPE_OBJECT: u8 = 1;
+    const ACCOUNT_TYPE_TABLE: u8 = 2;
+    const ACCOUNT_TYPE_MODULE: u8 = 3;
+
+    /// This error type is used in native function.
+    const EACCOUNT_ALREADY_EXISTS: u64 = 100;
+    const EACCOUNT_NOT_FOUND: u64 = 101;
+
+    struct AccountInfo has copy, drop {
+        account_number: u64,
+        sequence_number: u64,
+        account_type: u8,
+        is_blocked: bool
+    }
+
+    public entry fun create_account_script(addr: address) {
+        create_account(addr);
+    }
+
+    public fun create_account(addr: address): u64 {
+        let (found, _, _, _, _) = account_info(addr);
+        assert!(
+            !found,
+            error::already_exists(EACCOUNT_ALREADY_EXISTS)
+        );
+
+        request_create_account(addr, 0, ACCOUNT_TYPE_BASE)
+    }
+
+    /// TableAccount is similar to CosmosSDK's ModuleAccount in concept,
+    /// as both cannot have a pubkey, there is no way to use the account externally.
+    public(friend) fun create_table_account(addr: address): u64 {
+        let (found, account_number, sequence, account_type, _) = account_info(addr);
+        assert!(
+            !found || (account_type == ACCOUNT_TYPE_BASE && sequence == 0),
+            error::already_exists(EACCOUNT_ALREADY_EXISTS)
+        );
+
+        request_create_account(addr, account_number, ACCOUNT_TYPE_TABLE)
+    }
+
+    /// ObjectAccount is similar to CosmosSDK's ModuleAccount in concept,
+    /// as both cannot have a pubkey, there is no way to use the account externally.
+    public(friend) fun create_object_account(addr: address): u64 {
+        let (found, account_number, sequence, account_type, _) = account_info(addr);
+
+        // base account with sequence 0 is considered as not created.
+        if (!found || (account_type == ACCOUNT_TYPE_BASE && sequence == 0)) {
+            request_create_account(addr, account_number, ACCOUNT_TYPE_OBJECT)
+        } else {
+            // When an Object is deleted, the ObjectAccount in CosmosSDK is designed
+            // not to be deleted in order to prevent unexpected issues. Therefore,
+            // in this case, the creation of an account is omitted.
+            //
+            // Also object is doing its own already exists check.
+            if (account_type == ACCOUNT_TYPE_OBJECT) {
+                account_number
+            } else {
+                abort(error::already_exists(EACCOUNT_ALREADY_EXISTS))
+            }
+        }
+    }
+
+    #[view]
+    public fun exists_at(addr: address): bool {
+        let (found, _, _, _, _) = account_info(addr);
+        found
+    }
+
+    #[view]
+    public fun is_blocked(addr: address): bool {
+        let (_, _, _, _, blocked) = account_info(addr);
+        blocked
+    }
+
+    #[view]
+    public fun get_account_number(addr: address): u64 {
+        let (found, account_number, _, _, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        account_number
+    }
+
+    #[view]
+    public fun get_sequence_number(addr: address): u64 {
+        let (found, _, sequence_number, _, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        sequence_number
+    }
+
+    #[view]
+    public fun is_base_account(addr: address): bool {
+        let (found, _, _, account_type, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        account_type == ACCOUNT_TYPE_BASE
+    }
+
+    #[view]
+    public fun is_object_account(addr: address): bool {
+        let (found, _, _, account_type, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        account_type == ACCOUNT_TYPE_OBJECT
+    }
+
+    #[view]
+    public fun is_table_account(addr: address): bool {
+        let (found, _, _, account_type, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        account_type == ACCOUNT_TYPE_TABLE
+    }
+
+    #[view]
+    public fun is_module_account(addr: address): bool {
+        let (found, _, _, account_type, _) = account_info(addr);
+        assert!(found, error::not_found(EACCOUNT_NOT_FOUND));
+
+        account_type == ACCOUNT_TYPE_MODULE
+    }
+
+    #[view]
+    public fun get_account_info(addr: address): (bool, AccountInfo) {
+        let (found, account_number, sequence_number, account_type, is_blocked) =
+            account_info(addr);
+
+        (found, AccountInfo { account_number, sequence_number, account_type, is_blocked })
+    }
+
+    public fun is_module_account_with_info(info: &AccountInfo): bool {
+        info.account_type == ACCOUNT_TYPE_MODULE
+    }
+
+    public fun is_base_account_with_info(info: &AccountInfo): bool {
+        info.account_type == ACCOUNT_TYPE_BASE
+    }
+
+    public fun is_object_account_with_info(info: &AccountInfo): bool {
+        info.account_type == ACCOUNT_TYPE_OBJECT
+    }
+
+    public fun is_table_account_with_info(info: &AccountInfo): bool {
+        info.account_type == ACCOUNT_TYPE_TABLE
+    }
+
+    public fun is_blocked_with_info(info: &AccountInfo): bool {
+        info.is_blocked
+    }
+
+    public fun get_account_number_with_info(info: &AccountInfo): u64 {
+        info.account_number
+    }
+
+    public fun get_sequence_number_with_info(info: &AccountInfo): u64 {
+        info.sequence_number
+    }
+
+    native fun request_create_account(
+        addr: address, account_number: u64, account_type: u8
+    ): u64;
+    native public fun account_info(addr: address):
+        (
+        bool /* found */,
+        u64 /* account_number */,
+        u64 /* sequence_number */,
+        u8 /* account_type */,
+        bool /* is_blocked */
+    );
+    native public(friend) fun create_address(bytes: vector<u8>): address;
+    native public(friend) fun create_signer(addr: address): signer;
+
+    #[test_only]
+    native public fun set_account_info(
+        addr: address,
+        account_number: u64,
+        sequence: u64,
+        account_type: u8,
+        is_blocked: bool
+    );
+
+    #[test_only]
+    /// Create signer for testing
+    public fun create_signer_for_test(addr: address): signer {
+        create_signer(addr)
+    }
+
+    #[test]
+    public fun test_create_account() {
+        // base account
+        let bob =
+            create_address(
+                x"0000000000000000000000000000000000000000000000000000000000000b0b"
+            );
+        let carol =
+            create_address(
+                x"00000000000000000000000000000000000000000000000000000000000ca501"
+            );
+        assert!(!exists_at(bob), 0);
+        assert!(!exists_at(carol), 1);
+
+        let bob_account_num = create_account(bob);
+        assert!(exists_at(bob), 2);
+        assert!(!exists_at(carol), 3);
+
+        let carol_account_num = create_account(carol);
+        assert!(exists_at(bob), 4);
+        assert!(exists_at(carol), 5);
+
+        assert!(bob_account_num + 1 == carol_account_num, 6);
+        assert!(bob_account_num == get_account_number(bob), 7);
+        assert!(
+            carol_account_num == get_account_number(carol),
+            7
+        );
+
+        // object account
+        let dan =
+            create_address(
+                x"000000000000000000000000000000000000000000000000000000000000da17"
+            );
+        assert!(!exists_at(dan), 8);
+        let dan_object_account_num = create_object_account(dan);
+        assert!(
+            dan_object_account_num == get_account_number(dan),
+            9
+        );
+        assert!(is_object_account(dan), 10);
+        assert!(exists_at(dan), 11);
+
+        // table account
+        let erin =
+            create_address(
+                x"00000000000000000000000000000000000000000000000000000000000e5117"
+            );
+        assert!(!exists_at(erin), 12);
+        let erin_table_account_num = create_table_account(erin);
+        assert!(
+            erin_table_account_num == get_account_number(erin),
+            13
+        );
+        assert!(is_table_account(erin), 14);
+        assert!(exists_at(erin), 15);
+    }
+
+    #[test]
+    public fun test_create_address() {
+        let bob =
+            create_address(
+                x"0000000000000000000000000000000000000000000000000000000000000b0b"
+            );
+        let carol =
+            create_address(
+                x"00000000000000000000000000000000000000000000000000000000000ca501"
+            );
+        assert!(
+            bob == @0x0000000000000000000000000000000000000000000000000000000000000b0b,
+            0
+        );
+        assert!(
+            carol == @0x00000000000000000000000000000000000000000000000000000000000ca501,
+            1
+        );
+    }
+
+    #[test(new_address = @0x42)]
+    public fun test_create_signer(new_address: address) {
+        let _new_account = create_signer(new_address);
+        let authentication_key = bcs::to_bytes(&new_address);
+        assert!(vector::length(&authentication_key) == 32, 0);
+    }
+
+    #[
+        test(
+            new_address = @0x41,
+            new_address2 = @0x42,
+            new_address3 = @0x43,
+            new_address4 = @0x44
+        )
+    ]
+    public fun test_create_table_account_and_object_account(
+        new_address: address,
+        new_address2: address,
+        new_address3: address,
+        new_address4: address
+    ) {
+        let table_account_num = create_table_account(new_address);
+        assert!(
+            table_account_num == get_account_number(new_address),
+            0
+        );
+        assert!(is_table_account(new_address), 1);
+        assert!(exists_at(new_address), 2);
+
+        // set base account with 0 sequence
+        set_account_info(new_address2, 100, 0, ACCOUNT_TYPE_BASE, false);
+        let table_account_num = create_table_account(new_address2);
+        assert!(
+            table_account_num == get_account_number(new_address2),
+            0
+        );
+        assert!(table_account_num == 100, 0);
+        assert!(is_table_account(new_address2), 1);
+        assert!(exists_at(new_address2), 2);
+        assert!(!is_blocked(new_address2), 3);
+
+        let object_account_num = create_object_account(new_address3);
+        assert!(
+            object_account_num == get_account_number(new_address3),
+            3
+        );
+        assert!(is_object_account(new_address3), 4);
+        assert!(exists_at(new_address3), 5);
+
+        // set base account with 0 sequence
+        set_account_info(new_address4, 200, 0, ACCOUNT_TYPE_BASE, false);
+        let object_account_num = create_object_account(new_address4);
+        assert!(
+            object_account_num == get_account_number(new_address4),
+            0
+        );
+        assert!(object_account_num == 200, 0);
+        assert!(is_object_account(new_address4), 1);
+        assert!(exists_at(new_address4), 2);
+        assert!(!is_blocked(new_address4), 3);
+    }
+
+    #[test(new_address = @0x42, new_address2 = @0x43)]
+    public fun test_blocked_address(
+        new_address: address, new_address2: address
+    ) {
+        set_account_info(new_address, 200, 0, ACCOUNT_TYPE_BASE, true);
+        assert!(is_blocked(new_address), 1);
+
+        set_account_info(new_address2, 100, 0, ACCOUNT_TYPE_BASE, false);
+        assert!(!is_blocked(new_address2), 2);
+    }
+
+    #[test(new_address = @0x42)]
+    #[expected_failure(abort_code = 0x80064, location = Self)]
+    public fun test_create_account_already_exists(new_address: address) {
+        create_account(new_address);
+        create_account(new_address);
+    }
+
+    #[test(new_address = @0x42)]
+    #[expected_failure(abort_code = 0x80064, location = Self)]
+    public fun test_create_table_account_already_exists(
+        new_address: address
+    ) {
+        create_table_account(new_address);
+        create_table_account(new_address);
+    }
+
+    #[test(new_address = @0x42)]
+    #[expected_failure(abort_code = 0x80064, location = Self)]
+    public fun test_create_object_account_already_exists(
+        new_address: address
+    ) {
+        create_table_account(new_address);
+        create_object_account(new_address);
+    }
+
+    // functions for compatibility with the aptos
+
+    #[test_only]
+    public fun create_account_for_test(new_address: address): signer {
+        create_account(new_address);
+        create_signer_for_test(new_address)
+    }
+}

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

@@ -0,0 +1,97 @@
+module initia_std::address {
+    use std::string::String;
+    use std::bcs;
+    use initia_std::from_bcs;
+    use initia_std::query;
+    use initia_std::json;
+
+    struct FromSdkRequest has copy, drop {
+        sdk_addr: String
+    }
+
+    struct FromSdkResponse has copy, drop {
+        vm_addr: address
+    }
+
+    public fun from_sdk(sdk_addr: String): address {
+        let res =
+            json::unmarshal<FromSdkResponse>(
+                query::query_custom(
+                    b"from_sdk_address",
+                    json::marshal(&FromSdkRequest { sdk_addr: sdk_addr })
+                )
+            );
+
+        res.vm_addr
+    }
+
+    struct ToSdkRequest has copy, drop {
+        vm_addr: address
+    }
+
+    struct ToSdkResponse has copy, drop {
+        sdk_addr: String
+    }
+
+    public fun to_sdk(vm_addr: address): String {
+        let res =
+            json::unmarshal<ToSdkResponse>(
+                query::query_custom(
+                    b"to_sdk_address",
+                    json::marshal(&ToSdkRequest { vm_addr: vm_addr })
+                )
+            );
+
+        res.sdk_addr
+    }
+
+    #[test_only]
+    use std::string;
+
+    #[test]
+    fun test_to_string() {
+        let addr = @0x123abc;
+        let addr_str =
+            string::utf8(
+                b"0x0000000000000000000000000000000000000000000000000000000000123abc"
+            );
+        assert!(to_string(addr) == addr_str, 0)
+    }
+
+    #[test]
+    fun test_from_string() {
+        let addr = @0x908def;
+        let addr_str =
+            string::utf8(
+                b"0x0000000000000000000000000000000000000000000000000000000000908def"
+            );
+        assert!(from_string(addr_str) == addr, 0)
+    }
+
+    #[test]
+    fun test_to_sdk() {
+        let addr = @0x123abc;
+        let addr_sdk = string::utf8(b"init1qqqqqqqqqqqqqqqqqqqqqqqqqqqpyw4utfmfp0");
+        assert!(to_sdk(addr) == addr_sdk, 0)
+    }
+
+    #[test]
+    fun test_from_sdk() {
+        let addr = @0x123abc;
+        let addr_sdk = string::utf8(b"init1qqqqqqqqqqqqqqqqqqqqqqqqqqqpyw4utfmfp0");
+        assert!(addr == from_sdk(addr_sdk), 0)
+    }
+
+    // hex string <> address
+    native public fun to_string(addr: address): String;
+    native public fun from_string(addr_str: String): address;
+
+    // bytes <> address
+    public fun to_bytes(addr: address): vector<u8> {
+        bcs::to_bytes(&addr)
+    }
+
+    public fun from_bytes(bytes: vector<u8>): address {
+        from_bcs::to_address(bytes)
+    }
+}

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

@@ -0,0 +1,63 @@
+module initia_std::any {
+    use initia_std::type_info;
+    use initia_std::from_bcs::from_bytes;
+    use std::bcs::to_bytes;
+    use std::error;
+    use std::string::String;
+
+    /// The type provided for `unpack` is not the same as was given for `pack`.
+    const ETYPE_MISMATCH: u64 = 1;
+
+    /// A type which can represent a value of any type. This allows for representation of 'unknown' future
+    /// values. For example, to define a resource such that it can be later be extended without breaking
+    /// changes one can do
+    ///
+    /// ```move
+    ///   struct Resource {
+    ///      field: Type,
+    ///      ...
+    ///      extension: Option<Any>
+    ///   }
+    /// ```
+    struct Any has drop, store {
+        type_name: String,
+        data: vector<u8>
+    }
+
+    /// Pack a value into the `Any` representation. Because Any can be stored and dropped, this is
+    /// also required from `T`.
+    public fun pack<T: drop + store>(x: T): Any {
+        Any {
+            type_name: type_info::type_name<T>(),
+            data: to_bytes(&x)
+        }
+    }
+
+    /// Unpack a value from the `Any` representation. This aborts if the value has not the expected type `T`.
+    public fun unpack<T>(x: Any): T {
+        assert!(
+            type_info::type_name<T>() == x.type_name,
+            error::invalid_argument(ETYPE_MISMATCH)
+        );
+        from_bytes<T>(x.data)
+    }
+
+    /// Returns the type name of this Any
+    public fun type_name(x: &Any): &String {
+        &x.type_name
+    }
+
+    #[test_only]
+    struct S has store, drop {
+        x: u64
+    }
+
+    #[test]
+    fun test_any() {
+        assert!(unpack<u64>(pack(22)) == 22, 1);
+        assert!(
+            unpack<S>(pack(S { x: 22 })) == S { x: 22 },
+            2
+        );
+    }
+}

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

@@ -0,0 +1,20 @@
+/// AptosHash module exists to provide compatibility with aptos.
+module initia_std::aptos_hash {
+    use std::hash::{sha2_256 as s2_256, sha3_256 as s3_256};
+    use initia_std::keccak::{keccak256 as k256};
+
+    public fun sha2_256(data: vector<u8>): vector<u8> {
+        s2_256(data)
+    }
+
+    public fun sha3_256(data: vector<u8>): vector<u8> {
+        s3_256(data)
+    }
+
+    public fun keccak256(data: vector<u8>): vector<u8> {
+        k256(data)
+    }
+
+    // TODO - add ripemd160
+    // TODO - add blake2b_256
+}

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

@@ -0,0 +1,14 @@
+module initia_std::base64 {
+    use std::string::{Self, String};
+
+    public fun to_string(bytes: vector<u8>): String {
+        string::utf8(encode(bytes))
+    }
+
+    public fun from_string(str: String): vector<u8> {
+        decode(*string::bytes(&str))
+    }
+
+    native public fun encode(bytes: vector<u8>): vector<u8>;
+    native public fun decode(bytes: vector<u8>): vector<u8>;
+}

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

@@ -0,0 +1,37 @@
+module initia_std::bech32 {
+    use initia_std::string::String;
+
+    native public fun encode(prefix: String, data: vector<u8>): String;
+    native public fun decode(addr: String): (String, vector<u8>);
+
+    #[test_only]
+    use initia_std::string;
+
+    #[test]
+    fun test_bech32_encode() {
+        let prefix = string::utf8(b"init");
+        let data = x"12eafdba79c3dd7b90e3712ee475423153a722c7";
+        let got = encode(prefix, data);
+        let expected = string::utf8(b"init1zt40mwnec0whhy8rwyhwga2zx9f6wgk8p3x098");
+        assert!(got == expected, 0);
+
+        let prefix = string::utf8(b"celestia");
+        let data = x"12eafdba79c3dd7b90e3712ee475423153a722c7";
+        let got = encode(prefix, data);
+        let expected = string::utf8(b"celestia1zt40mwnec0whhy8rwyhwga2zx9f6wgk87dhv5g");
+        assert!(got == expected, 1);
+    }
+
+    #[test]
+    fun test_bech32_decode() {
+        let addr = string::utf8(b"init1zt40mwnec0whhy8rwyhwga2zx9f6wgk8p3x098");
+        let (prefix, data) = decode(addr);
+        assert!(prefix == string::utf8(b"init"), 0);
+        assert!(data == x"12eafdba79c3dd7b90e3712ee475423153a722c7", 1);
+
+        let addr = string::utf8(b"celestia1zt40mwnec0whhy8rwyhwga2zx9f6wgk87dhv5g");
+        let (prefix, data) = decode(addr);
+        assert!(prefix == string::utf8(b"celestia"), 2);
+        assert!(data == x"12eafdba79c3dd7b90e3712ee475423153a722c7", 3);
+    }
+}