create-dubhe 0.0.8 → 0.0.10

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

@@ -0,0 +1,266 @@
+module initia_std::json {
+    use std::vector;
+    use std::string::{Self, String};
+    use std::option::{Self, Option};
+
+    /// JSONValue is a struct to hold any JSON value which is unknown at compile time.
+    struct JSONValue has copy, drop {
+        value: vector<u8>
+    }
+
+    /// JSONObject is a struct to hold any json object which is unknown at compile time.
+    struct JSONObject has copy, drop {
+        elems: vector<Element>
+    }
+
+    /// Element is a struct to hold key-value pair in JSON object.
+    struct Element has copy, drop {
+        key: vector<u8>,
+        value: vector<u8>
+    }
+
+    /// Unmarshal JSON value to the given type.
+    public fun unmarshal_json_value<T: drop>(json_value: JSONValue): T {
+        unmarshal_internal(json_value.value)
+    }
+
+    /// Get the list of keys from the JSON object.
+    public fun keys(obj: &JSONObject): vector<String> {
+        vector::map_ref(
+            &obj.elems,
+            |elem| {
+                use_elem(elem);
+                string::utf8(elem.key)
+            }
+        )
+    }
+
+    /// Get the value of the given key from the JSON object.
+    public fun get_elem<T: drop>(obj: &JSONObject, key: String): Option<T> {
+        let key_bytes = string::bytes(&key);
+        let (found, idx) = vector::find(
+            &obj.elems,
+            |elem| {
+                use_elem(elem);
+                elem.key == *key_bytes
+            }
+        );
+
+        if (!found) {
+            return option::none()
+        };
+
+        let elem = vector::borrow(&obj.elems, idx);
+        option::some(unmarshal_internal<T>(elem.value))
+    }
+
+    /// Set or overwrite the element in the JSON object.
+    public fun set_elem<T: drop>(
+        obj: &mut JSONObject, key: String, value: &T
+    ) {
+        let key_bytes = string::bytes(&key);
+        let (found, idx) = vector::find(
+            &obj.elems,
+            |elem| {
+                use_elem(elem);
+                elem.key == *key_bytes
+            }
+        );
+
+        if (!found) {
+            vector::push_back(
+                &mut obj.elems,
+                Element { key: *key_bytes, value: marshal(value) }
+            );
+        } else {
+            let elem = vector::borrow_mut(&mut obj.elems, idx);
+            elem.value = marshal(value);
+        }
+    }
+
+    //
+    // (only on compiler v1) for preventing compile error; because of inferring type issue
+    //
+    inline fun use_elem(_elem: &Element) {}
+
+    /// Marshal data to JSON bytes.
+    ///
+    /// NOTE: key `_type_` is converted to `@type`
+    /// NOTE: key `_move_` is converted to `move`
+    /// NOTE: key `_signer_` is converted to `signer`
+    public fun marshal<T: drop>(value: &T): vector<u8> {
+        marshal_internal(value)
+    }
+
+    /// Marshal data to JSON string.
+    ///
+    /// NOTE: key `_type_` is converted to `@type`
+    /// NOTE: key `_move_` is converted to `move`
+    /// /// NOTE: key `_signer_` is converted to `signer`
+    public fun marshal_to_string<T: drop>(value: &T): String {
+        marshal_to_string_internal(value)
+    }
+
+    /// Unmarshal JSON bytes to the given struct.
+    ///
+    /// NOTE: key `@type` is converted to `_type_`
+    /// NOTE: key `move` is converted to `_move_`
+    /// NOTE: key `signer` is converted to `_signer_`
+    public fun unmarshal<T: drop>(json: vector<u8>): T {
+        unmarshal_internal(json)
+    }
+
+    native fun marshal_internal<T: drop>(value: &T): vector<u8>;
+    native fun marshal_to_string_internal<T: drop>(value: &T): String;
+    native fun unmarshal_internal<T: drop>(json: vector<u8>): T;
+
+    #[test_only]
+    use std::biguint::{Self, BigUint};
+
+    #[test_only]
+    use std::bigdecimal::{Self, BigDecimal};
+
+    #[test_only]
+    struct TestObject has copy, drop {
+        a: u64,
+        b: bool,
+        c: vector<u8>,
+        d: address,
+        e: Option<TestObject2>,
+        f: Option<TestObject2>,
+        _type_: String,
+        _move_: String,
+        _signer_: String,
+        biguint: BigUint,
+        bigdecimal: BigDecimal
+    }
+
+    #[test_only]
+    struct TestObject2 has copy, drop {
+        a: u64,
+        b: bool,
+        c: vector<u8>
+    }
+
+    #[test_only]
+    struct EmptyObject has copy, drop {}
+
+    #[test]
+    fun test_json_empty_marshal_unmarshal_empty() {
+        let json = marshal(&EmptyObject {});
+        assert!(json == b"{}", 1);
+
+        let val = unmarshal<EmptyObject>(json);
+        assert!(val == EmptyObject {}, 2);
+    }
+
+    #[test]
+    fun test_json_marshal_unmarshal_u64() {
+        let json = marshal(&10u64);
+        assert!(json == b"\"10\"", 1);
+
+        let val = unmarshal<u64>(json);
+        assert!(val == 10u64, 2);
+    }
+
+    #[test]
+    fun test_json_marshal_unmarshal_vector_u8() {
+        let json = marshal(&vector[1u8, 2u8, 3u8]);
+        assert!(json == b"\"010203\"", 1);
+
+        let val = unmarshal<vector<u8>>(json);
+        assert!(val == vector[1u8, 2u8, 3u8], 2);
+    }
+
+    #[test]
+    fun test_json_marshal_unmarshal() {
+        let obj = TestObject {
+            a: 42,
+            b: true,
+            c: vector[1, 2, 3],
+            d: @0x1,
+            e: option::some(TestObject2 { a: 42, b: true, c: vector[1, 2, 3] }),
+            f: option::none(),
+            _type_: string::utf8(b"/cosmos.gov.v1.MsgVote"),
+            _move_: string::utf8(b"move"),
+            _signer_: string::utf8(b"signer"),
+            biguint: biguint::from_u64(42),
+            bigdecimal: bigdecimal::from_ratio_u64(123, 10000)
+        };
+
+        let json = marshal(&obj);
+        assert!(
+            json
+                == b"{\"@type\":\"/cosmos.gov.v1.MsgVote\",\"a\":\"42\",\"b\":true,\"bigdecimal\":\"0.0123\",\"biguint\":\"42\",\"c\":\"010203\",\"d\":\"0x1\",\"e\":{\"a\":\"42\",\"b\":true,\"c\":\"010203\"},\"f\":null,\"move\":\"move\",\"signer\":\"signer\"}",
+            1
+        );
+
+        let obj2 = unmarshal<TestObject>(json);
+        let json2 = marshal<TestObject>(&obj2);
+        assert!(json2 == json, 1);
+
+        let json_val = unmarshal<JSONValue>(json);
+        let json3 = marshal(&json_val);
+        assert!(json3 == json, 2);
+
+        let obj3 = unmarshal_json_value<TestObject>(json_val);
+        let json4 = marshal(&obj3);
+        assert!(json4 == json, 3);
+
+        let json_obj = unmarshal<JSONObject>(json);
+        let json5 = marshal(&json_obj);
+        assert!(json5 == json, 4);
+
+        assert!(
+            option::extract(
+                &mut get_elem<u64>(&json_obj, string::utf8(b"a"))
+            ) == 42,
+            4
+        );
+        assert!(
+            option::extract(
+                &mut get_elem<bool>(&json_obj, string::utf8(b"b"))
+            ) == true,
+            5
+        );
+        assert!(
+            option::extract(
+                &mut get_elem<vector<u8>>(&json_obj, string::utf8(b"c"))
+            ) == vector[1, 2, 3],
+            6
+        );
+        assert!(
+            option::extract(
+                &mut get_elem<address>(&json_obj, string::utf8(b"d"))
+            ) == @0x1,
+            7
+        );
+
+        set_elem(&mut json_obj, string::utf8(b"c"), &string::utf8(b"hello"));
+        assert!(
+            option::extract(
+                &mut get_elem<String>(&json_obj, string::utf8(b"c"))
+            ) == string::utf8(b"hello"),
+            8
+        );
+
+        let json5 = marshal(&json_obj);
+        assert!(
+            json5
+                == b"{\"@type\":\"/cosmos.gov.v1.MsgVote\",\"a\":\"42\",\"b\":true,\"bigdecimal\":\"0.0123\",\"biguint\":\"42\",\"c\":\"hello\",\"d\":\"0x1\",\"e\":{\"a\":\"42\",\"b\":true,\"c\":\"010203\"},\"f\":null,\"move\":\"move\",\"signer\":\"signer\"}",
+            9
+        );
+    }
+
+    #[test_only]
+    use std::object::{Self, ConstructorRef};
+
+    #[test]
+    #[expected_failure(abort_code = 0x10006, location = Self)]
+    /// cannot create other module's struct resource.
+    public fun test_json_module_permission() {
+        let ref = object::create_object(@std, true);
+        let bz = marshal(&ref);
+        let _ref2 = unmarshal<ConstructorRef>(bz);
+    }
+}

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

@@ -0,0 +1,33 @@
+/// Cryptographic hashes:
+/// - Keccak-256: see https://keccak.team/keccak.html
+///
+/// In addition, SHA2-256 and SHA3-256 are available in `std::hash`. Note that SHA3-256 is a variant of Keccak: it is
+/// NOT the same as Keccak-256.
+module initia_std::keccak {
+    /// Returns the Keccak-256 hash of `bytes`.
+    native public fun keccak256(byte: vector<u8>): vector<u8>;
+    //
+    // Testing
+    //
+
+    #[test]
+    fun keccak256_test() {
+        let inputs = vector[b"testing", b""];
+
+        let outputs = vector[
+            x"5f16f4c7f149ac4f9510d9cf8cf384038ad348b3bcdc01915f95de12df9d1b02",
+            x"c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
+        ];
+
+        let i = 0;
+        while (i < std::vector::length(&inputs)) {
+            let input = *std::vector::borrow(&inputs, i);
+            let hash_expected = *std::vector::borrow(&outputs, i);
+            let hash = keccak256(input);
+
+            assert!(hash_expected == hash, 1);
+
+            i = i + 1;
+        };
+    }
+}

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

@@ -0,0 +1,283 @@
+/// ManagedCoin is built to make a simple walkthrough of the Coins module.
+/// It contains scripts you will need to initialize, mint, burn, transfer coins.
+/// By utilizing this current module, a developer can create his own coin and care less about mint and burn capabilities,
+module initia_std::managed_coin {
+    use std::error;
+    use std::signer;
+    use std::string::String;
+    use std::option::Option;
+
+    use initia_std::object::{Self, Object};
+    use initia_std::fungible_asset::{Metadata, FungibleAsset};
+    use initia_std::coin::{Self, BurnCapability, FreezeCapability, MintCapability};
+
+    //
+    // Errors
+    //
+
+    /// Metadata has no capabilities (burn/mint).
+    const ENO_CAPABILITIES: u64 = 1;
+
+    /// Account is not a owner of metadata object.
+    const EUNAUTHORIZED: u64 = 2;
+
+    //
+    // Data structures
+    //
+
+    /// Capabilities resource storing mint and burn capabilities.
+    /// The resource is stored on the account that initialized coin `CoinType`.
+    struct Capabilities has key {
+        mint_cap: MintCapability,
+        burn_cap: BurnCapability,
+        freeze_cap: FreezeCapability
+    }
+
+    //
+    // sudo functions
+    //
+
+    fun check_sudo(account: &signer) {
+        assert!(
+            signer::address_of(account) == @initia_std,
+            error::permission_denied(EUNAUTHORIZED)
+        );
+    }
+
+    /// Create new metadata coins and deposit them into dst_addr's account.
+    public entry fun sudo_mint(
+        account: &signer,
+        dst_addr: address,
+        metadata: Object<Metadata>,
+        amount: u64
+    ) acquires Capabilities {
+        check_sudo(account);
+
+        let account_addr = signer::address_of(account);
+        assert!(
+            object::is_owner(metadata, account_addr),
+            error::not_found(EUNAUTHORIZED)
+        );
+
+        let object_addr = object::object_address(&metadata);
+        assert!(
+            exists<Capabilities>(object_addr),
+            error::not_found(ENO_CAPABILITIES)
+        );
+
+        let capabilities = borrow_global<Capabilities>(object_addr);
+        let fa = coin::mint(&capabilities.mint_cap, amount);
+        coin::sudo_deposit(dst_addr, fa);
+    }
+
+    //
+    // Public functions
+    //
+
+    /// Initialize new coin metadata in Initia Blockchain.
+    /// Mint and Burn Capabilities will be stored under `metadata` in `Capabilities` resource.
+    public entry fun initialize(
+        account: &signer,
+        maximum_supply: Option<u128>,
+        name: String,
+        symbol: String,
+        decimals: u8,
+        icon_uri: String,
+        project_uri: String
+    ) {
+        let (mint_cap, burn_cap, freeze_cap, extend_ref) =
+            coin::initialize_and_generate_extend_ref(
+                account,
+                maximum_supply,
+                name,
+                symbol,
+                decimals,
+                icon_uri,
+                project_uri
+            );
+
+        let metadata_signer = object::generate_signer_for_extending(&extend_ref);
+        move_to(
+            &metadata_signer,
+            Capabilities { mint_cap, burn_cap, freeze_cap }
+        );
+    }
+
+    /// Withdraw an `amount` of metadata coin from `account` and burn it.
+    public entry fun burn(
+        account: &signer, metadata: Object<Metadata>, amount: u64
+    ) acquires Capabilities {
+        let account_addr = signer::address_of(account);
+
+        assert!(
+            object::is_owner(metadata, account_addr),
+            error::not_found(EUNAUTHORIZED)
+        );
+
+        let object_addr = object::object_address(&metadata);
+        assert!(
+            exists<Capabilities>(object_addr),
+            error::not_found(ENO_CAPABILITIES)
+        );
+
+        let capabilities = borrow_global<Capabilities>(object_addr);
+
+        let to_burn = coin::withdraw(account, metadata, amount);
+        coin::burn(&capabilities.burn_cap, to_burn);
+    }
+
+    /// Create new metadata coins.
+    public fun mint(
+        account: &signer, metadata: Object<Metadata>, amount: u64
+    ): FungibleAsset acquires Capabilities {
+        let account_addr = signer::address_of(account);
+
+        assert!(
+            object::is_owner(metadata, account_addr),
+            error::not_found(EUNAUTHORIZED)
+        );
+
+        let object_addr = object::object_address(&metadata);
+        assert!(
+            exists<Capabilities>(object_addr),
+            error::not_found(ENO_CAPABILITIES)
+        );
+
+        let capabilities = borrow_global<Capabilities>(object_addr);
+        coin::mint(&capabilities.mint_cap, amount)
+    }
+
+    /// Create new metadata coins and deposit them into dst_addr's account.
+    public entry fun mint_to(
+        account: &signer,
+        dst_addr: address,
+        metadata: Object<Metadata>,
+        amount: u64
+    ) acquires Capabilities {
+        let fa = mint(account, metadata, amount);
+
+        coin::deposit(dst_addr, fa);
+    }
+
+    //
+    // Tests
+    //
+
+    #[test_only]
+    use initia_std::primary_fungible_store;
+
+    #[test_only]
+    use initia_std::string;
+
+    #[test_only]
+    use initia_std::option;
+
+    #[test_only]
+    const TEST_SYMBOL: vector<u8> = b"FMD";
+
+    #[test_only]
+    public fun test_metadata(): Object<Metadata> {
+        coin::metadata(@initia_std, string::utf8(TEST_SYMBOL))
+    }
+
+    #[test(source = @0xa11ce, destination = @0xb0b, mod_account = @0x1)]
+    public entry fun test_end_to_end(
+        source: signer, destination: signer, mod_account: signer
+    ) acquires Capabilities {
+        primary_fungible_store::init_module_for_test();
+
+        let source_addr = signer::address_of(&source);
+        let destination_addr = signer::address_of(&destination);
+
+        initialize(
+            &mod_account,
+            option::none(),
+            string::utf8(b"Fake Money"),
+            string::utf8(TEST_SYMBOL),
+            10,
+            string::utf8(b""),
+            string::utf8(b"")
+        );
+
+        let metadata = test_metadata();
+        assert!(coin::is_coin(object::object_address(&metadata)), 0);
+
+        mint_to(&mod_account, source_addr, metadata, 50);
+        mint_to(&mod_account, destination_addr, metadata, 10);
+        assert!(coin::balance(source_addr, metadata) == 50, 1);
+        assert!(
+            coin::balance(destination_addr, metadata) == 10,
+            2
+        );
+
+        let supply = coin::supply(metadata);
+        assert!(supply == option::some(60), 2);
+
+        coin::transfer(&source, destination_addr, metadata, 10);
+        assert!(coin::balance(source_addr, metadata) == 40, 3);
+        assert!(
+            coin::balance(destination_addr, metadata) == 20,
+            4
+        );
+
+        coin::transfer(
+            &source,
+            signer::address_of(&mod_account),
+            metadata,
+            40
+        );
+        burn(&mod_account, metadata, 40);
+
+        assert!(coin::balance(source_addr, metadata) == 0, 1);
+
+        let new_supply = coin::supply(metadata);
+        assert!(new_supply == option::some(20), 2);
+    }
+
+    #[test(source = @0xa11ce, destination = @0xb0b, mod_account = @0x1)]
+    #[expected_failure(abort_code = 0x60002, location = Self)]
+    public entry fun fail_mint(
+        source: signer, destination: signer, mod_account: signer
+    ) acquires Capabilities {
+        primary_fungible_store::init_module_for_test();
+
+        let source_addr = signer::address_of(&source);
+
+        initialize(
+            &mod_account,
+            option::none(),
+            string::utf8(b"Fake Money"),
+            string::utf8(TEST_SYMBOL),
+            10,
+            string::utf8(b""),
+            string::utf8(b"")
+        );
+
+        let metadata = test_metadata();
+        mint_to(&destination, source_addr, metadata, 100);
+    }
+
+    #[test(source = @0xa11ce, destination = @0xb0b, mod_account = @0x1)]
+    #[expected_failure(abort_code = 0x60002, location = Self)]
+    public entry fun fail_burn(
+        source: signer, destination: signer, mod_account: signer
+    ) acquires Capabilities {
+        primary_fungible_store::init_module_for_test();
+
+        let source_addr = signer::address_of(&source);
+
+        initialize(
+            &mod_account,
+            option::none(),
+            string::utf8(b"Fake Money"),
+            string::utf8(TEST_SYMBOL),
+            10,
+            string::utf8(b""),
+            string::utf8(b"")
+        );
+
+        let metadata = test_metadata();
+        mint_to(&mod_account, source_addr, metadata, 100);
+        burn(&destination, metadata, 10);
+    }
+}