fix vesting_store_seed to use @initia_std (#68)

* fix vesting_store_seed to use @initia_std

* use type_name

* change import

* change to private

* recompile vip contracts

* fix movefmt

---------

Co-authored-by: beer-1 <[email protected]>

Author: JSHan94

Makefile

@@ -82,10 +82,13 @@ build-go: prebuild-go
 
 fmt:
 	cargo fmt
+
 move-fmt: install-move-fmt
-	cargo fmt
+	movefmt
+
 install-move-fmt:
 	cargo install --git https://github.com/movebit/movefmt --branch develop movefmt
+
 update-bindings:
 	cp libmovevm/bindings.h api
 	cp libcompiler/bindings_compiler.h api

crates/e2e-move-tests/src/tests/args.data/pack/sources/hello.move

@@ -49,12 +49,11 @@ module 0xCAFE::test {
         find_hello_in_option_msgs(&msgs);
 
         let msg = vector::borrow(&msgs, i);
-        let str_msg =
-            if (option::is_some(msg)) {
-                *option::borrow(msg)
-            } else {
-                string::utf8(vector::empty())
-            };
+        let str_msg = if (option::is_some(msg)) {
+            *option::borrow(msg)
+        } else {
+            string::utf8(vector::empty())
+        };
 
         hi(sender, str_msg);
     }
@@ -89,8 +88,8 @@ module 0xCAFE::test {
             move_to(sender,
                 ModuleData<String> { state: *vector::borrow(vector::borrow(&msgs, i), j) });
         } else {
-            borrow_global_mut<ModuleData<String>>(addr).state = *vector::borrow(vector::borrow(
-                    &msgs, i), j);
+            borrow_global_mut<ModuleData<String>>(addr).state = *vector::borrow(
+                vector::borrow(&msgs, i), j);
         }
     }
 

crates/e2e-move-tests/src/tests/std_coin.data/pack/sources/StdCoin.move

@@ -13,14 +13,15 @@ module 0x2::StdCoin {
     }
 
     entry fun init(sender: &signer) {
-        let (mint, burn, freeze) =
-            coin::initialize(sender,
-                option::none(),
-                string::utf8(b"Std Coin"),
-                string::utf8(b"STDC"),
-                8,
-                string::utf8(b""),
-                string::utf8(b""),);
+        let (mint, burn, freeze) = coin::initialize(
+            sender,
+            option::none(),
+            string::utf8(b"Std Coin"),
+            string::utf8(b"STDC"),
+            8,
+            string::utf8(b""),
+            string::utf8(b""),
+        );
 
         move_to(sender, CapStore { burn, freeze, mint });
     }

precompile/binaries/stdlib/vip.mv

@@ -134,12 +134,10 @@ module initia_std::account {
     #[test]
     public fun test_create_account() {
         // base account
-        let bob =
-            create_address(
-                x"0000000000000000000000000000000000000000000000000000000000000b0b");
-        let carol =
-            create_address(
-                x"00000000000000000000000000000000000000000000000000000000000ca501");
+        let bob = create_address(
+            x"0000000000000000000000000000000000000000000000000000000000000b0b");
+        let carol = create_address(
+            x"00000000000000000000000000000000000000000000000000000000000ca501");
         assert!(!exists_at(bob), 0);
         assert!(!exists_at(carol), 1);
 
@@ -156,19 +154,17 @@ module initia_std::account {
         assert!(carol_account_num == get_account_number(carol), 7);
 
         // object account
-        let dan =
-            create_address(
-                x"000000000000000000000000000000000000000000000000000000000000da17");
+        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");
+        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);
@@ -178,16 +174,14 @@ module initia_std::account {
 
     #[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);
+        let bob = create_address(
+            x"0000000000000000000000000000000000000000000000000000000000000b0b");
+        let carol = create_address(
+            x"00000000000000000000000000000000000000000000000000000000000ca501");
+        assert!(bob == @0x0000000000000000000000000000000000000000000000000000000000000b0b,
+            0);
+        assert!(carol ==
+            @0x00000000000000000000000000000000000000000000000000000000000ca501, 1);
     }
 
     #[test(new_address = @0x42)]
@@ -240,14 +234,18 @@ module initia_std::account {
 
     #[test(new_address = @0x42)]
     #[expected_failure(abort_code = 0x80064, location = Self)]
-    public fun test_create_table_account_already_exists(new_address: address) {
+    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) {
+    public fun test_create_object_account_already_exists(
+        new_address: address
+    ) {
         create_table_account(new_address);
         create_object_account(new_address);
     }

precompile/binaries/stdlib/vip_vesting.mv

@@ -43,18 +43,16 @@ module initia_std::address {
     #[test]
     fun test_to_string() {
         let addr = @0x123abc;
-        let addr_str =
-            string::utf8(
-                b"0x0000000000000000000000000000000000000000000000000000000000123abc");
+        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");
+        let addr_str = string::utf8(
+            b"0x0000000000000000000000000000000000000000000000000000000000908def");
         assert!(from_string(addr_str) == addr, 0)
     }
 

precompile/binaries/stdlib/vip_zapping.mv

@@ -106,7 +106,8 @@ module initia_std::code {
             error::permission_denied(EINVALID_CHAIN_OPERATOR));
 
         let metadata_table = table::new<String, ModuleMetadata>();
-        vector::for_each_ref(&module_ids,
+        vector::for_each_ref(
+            &module_ids,
             |module_id| {
                 table::add<String, ModuleMetadata>(&mut metadata_table, *module_id,
                     ModuleMetadata { upgrade_policy: UPGRADE_POLICY_COMPATIBLE, });
@@ -143,7 +144,8 @@ module initia_std::code {
 
         // duplication check
         let module_ids_set = simple_map::create<String, bool>();
-        vector::for_each_ref(&module_ids,
+        vector::for_each_ref(
+            &module_ids,
             |module_id| {
                 assert!(!simple_map::contains_key(&module_ids_set, module_id),
                     error::invalid_argument(EDUPLICATE_MODULE_ID));
@@ -164,15 +166,15 @@ module initia_std::code {
 
         // Check upgradability
         let metadata_table = &mut borrow_global_mut<MetadataStore>(addr).metadata;
-        vector::for_each_ref(&module_ids,
+        vector::for_each_ref(
+            &module_ids,
             |module_id| {
                 if (table::contains<String, ModuleMetadata>(metadata_table, *module_id)) {
-                    let metadata =
-                        table::borrow_mut<String, ModuleMetadata>(metadata_table, *module_id);
+                    let metadata = table::borrow_mut<String, ModuleMetadata>(metadata_table, *module_id);
                     assert!(metadata.upgrade_policy < UPGRADE_POLICY_IMMUTABLE,
                         error::invalid_argument(EUPGRADE_IMMUTABLE));
-                    assert!(can_change_upgrade_policy_to(metadata.upgrade_policy,
-                            upgrade_policy),
+                    assert!(
+                        can_change_upgrade_policy_to(metadata.upgrade_policy, upgrade_policy),
                         error::invalid_argument(EUPGRADE_WEAKER_POLICY));
 
                     metadata.upgrade_policy = upgrade_policy;

precompile/modules/initia_stdlib/sources/account.move

@@ -60,9 +60,8 @@ module initia_std::coin {
         icon_uri: String,
         project_uri: String,
     ): (MintCapability, BurnCapability, FreezeCapability) {
-        let (mint_cap, burn_cap, freeze_cap, _) =
-            initialize_and_generate_extend_ref(creator, maximum_supply, name, symbol,
-                decimals, icon_uri, project_uri,);
+        let (mint_cap, burn_cap, freeze_cap, _) = initialize_and_generate_extend_ref(creator,
+            maximum_supply, name, symbol, decimals, icon_uri, project_uri,);
 
         (mint_cap, burn_cap, freeze_cap)
     }
@@ -77,16 +76,18 @@ module initia_std::coin {
         project_uri: String,
     ): (MintCapability, BurnCapability, FreezeCapability, ExtendRef) {
         // create object for fungible asset metadata
-        let constructor_ref =
-            &object::create_named_object(creator, *string::bytes(&symbol), false);
+        let constructor_ref = &object::create_named_object(creator, *string::bytes(&symbol),
+            false);
 
-        primary_fungible_store::create_primary_store_enabled_fungible_asset(constructor_ref,
+        primary_fungible_store::create_primary_store_enabled_fungible_asset(
+            constructor_ref,
             maximum_supply,
             name,
             symbol,
             decimals,
             icon_uri,
-            project_uri,);
+            project_uri,
+        );
 
         let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
         let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
@@ -286,14 +287,14 @@ module initia_std::coin {
 
     #[view]
     public fun denom_to_metadata(denom: String): Object<Metadata> {
-        let addr =
-            if (string::length(&denom) > 5 && &b"move/" == string::bytes(&string::sub_string(&denom, 0, 5))) {
-                let len = string::length(&denom);
-                let hex_string = string::sub_string(&denom, 5, len);
-                from_bcs::to_address(hex::decode_string(&hex_string))
-            } else {
-                metadata_address(@initia_std, denom)
-            };
+        let addr = if (string::length(&denom) > 5 && &b"move/" == string::bytes(
+                &string::sub_string(&denom, 0, 5))) {
+            let len = string::length(&denom);
+            let hex_string = string::sub_string(&denom, 5, len);
+            from_bcs::to_address(hex::decode_string(&hex_string))
+        } else {
+            metadata_address(@initia_std, denom)
+        };
 
         object::address_to_object(addr)
     }
@@ -302,16 +303,17 @@ module initia_std::coin {
     fun initialized_coin(account: &signer, symbol: String,)
         : (BurnCapability, FreezeCapability,
         MintCapability) {
-        let (mint_cap, burn_cap, freeze_cap, _) =
-            initialize_and_generate_extend_ref(account,
-                std::option::none(),
-                string::utf8(b""),
-                symbol,
-                6,
-                string::utf8(b""),
-                string::utf8(b""),);
+        let (mint_cap, burn_cap, freeze_cap, _) = initialize_and_generate_extend_ref(
+            account,
+            std::option::none(),
+            string::utf8(b""),
+            symbol,
+            6,
+            string::utf8(b""),
+            string::utf8(b""),
+        );
 
-        return(burn_cap, freeze_cap, mint_cap)
+        return (burn_cap, freeze_cap, mint_cap)
     }
 
     #[test(chain = @0x1, not_chain = @0x2)]
@@ -320,8 +322,7 @@ module initia_std::coin {
         initialized_coin(&chain, string::utf8(b"INIT"));
         initialized_coin(&not_chain, string::utf8(b"INIT"));
         let metadata = metadata(std::signer::address_of(&chain), string::utf8(b"INIT"));
-        let metadata_ =
-            metadata(std::signer::address_of(&not_chain), string::utf8(b"INIT"));
+        let metadata_ = metadata(std::signer::address_of(&not_chain), string::utf8(b"INIT"));
         let denom = metadata_to_denom(metadata);
         let denom_ = metadata_to_denom(metadata_);
         let metadata_from_denom = denom_to_metadata(denom);

precompile/modules/initia_stdlib/sources/address.move

@@ -121,17 +121,13 @@ module initia_std::comparator {
         vector::push_back(&mut value0_1, 5);
         vector::push_back(&mut value0_1, 1);
 
-        let base =
-            Complex { value0: value0_0, value1: 13, value2: 41, };
+        let base = Complex { value0: value0_0, value1: 13, value2: 41, };
 
-        let other_0 =
-            Complex { value0: value0_1, value1: 13, value2: 41, };
+        let other_0 = Complex { value0: value0_1, value1: 13, value2: 41, };
 
-        let other_1 =
-            Complex { value0: copy value0_0, value1: 14, value2: 41, };
+        let other_1 = Complex { value0: copy value0_0, value1: 14, value2: 41, };
 
-        let other_2 =
-            Complex { value0: value0_0, value1: 13, value2: 42, };
+        let other_2 = Complex { value0: value0_0, value1: 13, value2: 42, };
 
         assert!(is_equal(&compare(&base, &base)), 0);
         assert!(is_smaller_than(&compare(&base, &other_0)), 1);