From db3cd343491d6c2bf20ae43d5c8fb9c838ba9543 Mon Sep 17 00:00:00 2001 From: Bob Ong <2261238+welbon@users.noreply.github.com> Date: Fri, 13 Dec 2024 11:18:28 +0800 Subject: [PATCH] [compiler-v2] fixed all unittest errors after modify address format (#4343) * [compiler-v2 framework] fixed known_attribute warning in `mpm package test ` command * [compiler-v2 framework] fixed known_attribute warning in `mpm package test ` command * [compiler-v2 framework] remove unused code * [compiler-v2 framework] fixed stderr after 0x1 changed * [compiler-v2 framework] fixed error caused by address format changed * [compiler-v2 framework] fixed fmt * [compiler-v2 framework] Remove starcoin-framework from the nextest exclude list --------- Co-authored-by: nk_ysg --- scripts/nextest.sh | 1 - .../src/natives/cryptography/algebra/mod.rs | 96 ++++++++++++------- vm/framework/starcoin-stdlib/doc/type_info.md | 4 +- .../starcoin-stdlib/sources/debug.move | 19 ++-- .../starcoin-stdlib/sources/from_bcs.move | 3 - .../starcoin-stdlib/sources/type_info.move | 12 +-- .../doc/object_property_map.md | 6 +- .../sources/object_property_map.move | 40 ++++---- vm/framework/tests/move_prover_tests.rs | 8 ++ vm/move-package-manager/src/package.rs | 11 ++- 10 files changed, 119 insertions(+), 81 deletions(-) diff --git a/scripts/nextest.sh b/scripts/nextest.sh index d81a865637..68402d2190 100755 --- a/scripts/nextest.sh +++ b/scripts/nextest.sh @@ -23,7 +23,6 @@ cargo nextest -V >/dev/null 2>&1 || cargo install cargo-nextest --version "0.9.5 # --build-jobs 8, a little (~20s) faster than 5 or 10 build jobs cargo nextest run --workspace \ --exclude starcoin-transactional-test-harness \ ---exclude starcoin-framework \ --exclude starcoin-consensus \ --retries 2 --build-jobs 8 --test-threads 12 --no-fail-fast --failure-output immediate-final diff --git a/vm/framework/src/natives/cryptography/algebra/mod.rs b/vm/framework/src/natives/cryptography/algebra/mod.rs index 289d2ba3e4..6bd9fd08b2 100644 --- a/vm/framework/src/natives/cryptography/algebra/mod.rs +++ b/vm/framework/src/natives/cryptography/algebra/mod.rs @@ -71,18 +71,20 @@ impl TryFrom for Structure { fn try_from(value: TypeTag) -> Result { match value.to_string().as_str() { - "0x1::bls12381_algebra::Fr" => Ok(Structure::BLS12381Fr), - "0x1::bls12381_algebra::Fq12" => Ok(Structure::BLS12381Fq12), - "0x1::bls12381_algebra::G1" => Ok(Structure::BLS12381G1), - "0x1::bls12381_algebra::G2" => Ok(Structure::BLS12381G2), - "0x1::bls12381_algebra::Gt" => Ok(Structure::BLS12381Gt), - - "0x1::bn254_algebra::Fr" => Ok(Self::BN254Fr), - "0x1::bn254_algebra::Fq" => Ok(Self::BN254Fq), - "0x1::bn254_algebra::Fq12" => Ok(Self::BN254Fq12), - "0x1::bn254_algebra::G1" => Ok(Self::BN254G1), - "0x1::bn254_algebra::G2" => Ok(Self::BN254G2), - "0x1::bn254_algebra::Gt" => Ok(Self::BN254Gt), + "0x00000000000000000000000000000001::bls12381_algebra::Fr" => Ok(Structure::BLS12381Fr), + "0x00000000000000000000000000000001::bls12381_algebra::Fq12" => { + Ok(Structure::BLS12381Fq12) + } + "0x00000000000000000000000000000001::bls12381_algebra::G1" => Ok(Structure::BLS12381G1), + "0x00000000000000000000000000000001::bls12381_algebra::G2" => Ok(Structure::BLS12381G2), + "0x00000000000000000000000000000001::bls12381_algebra::Gt" => Ok(Structure::BLS12381Gt), + + "0x00000000000000000000000000000001::bn254_algebra::Fr" => Ok(Self::BN254Fr), + "0x00000000000000000000000000000001::bn254_algebra::Fq" => Ok(Self::BN254Fq), + "0x00000000000000000000000000000001::bn254_algebra::Fq12" => Ok(Self::BN254Fq12), + "0x00000000000000000000000000000001::bn254_algebra::G1" => Ok(Self::BN254G1), + "0x00000000000000000000000000000001::bn254_algebra::G2" => Ok(Self::BN254G2), + "0x00000000000000000000000000000001::bn254_algebra::Gt" => Ok(Self::BN254Gt), _ => Err(()), } } @@ -125,31 +127,59 @@ impl TryFrom for SerializationFormat { fn try_from(value: TypeTag) -> Result { match value.to_string().as_str() { - "0x1::bls12381_algebra::FormatFq12LscLsb" => { + "0x00000000000000000000000000000001::bls12381_algebra::FormatFq12LscLsb" => { Ok(SerializationFormat::BLS12381Fq12LscLsb) } - "0x1::bls12381_algebra::FormatG1Uncompr" => { + "0x00000000000000000000000000000001::bls12381_algebra::FormatG1Uncompr" => { Ok(SerializationFormat::BLS12381G1Uncompressed) } - "0x1::bls12381_algebra::FormatG1Compr" => Ok(SerializationFormat::BLS12381G1Compressed), - "0x1::bls12381_algebra::FormatG2Uncompr" => { + "0x00000000000000000000000000000001::bls12381_algebra::FormatG1Compr" => { + Ok(SerializationFormat::BLS12381G1Compressed) + } + "0x00000000000000000000000000000001::bls12381_algebra::FormatG2Uncompr" => { Ok(SerializationFormat::BLS12381G2Uncompressed) } - "0x1::bls12381_algebra::FormatG2Compr" => Ok(SerializationFormat::BLS12381G2Compressed), - "0x1::bls12381_algebra::FormatGt" => Ok(SerializationFormat::BLS12381Gt), - "0x1::bls12381_algebra::FormatFrLsb" => Ok(SerializationFormat::BLS12381FrLsb), - "0x1::bls12381_algebra::FormatFrMsb" => Ok(SerializationFormat::BLS12381FrMsb), - - "0x1::bn254_algebra::FormatG1Uncompr" => Ok(Self::BN254G1Uncompressed), - "0x1::bn254_algebra::FormatG1Compr" => Ok(Self::BN254G1Compressed), - "0x1::bn254_algebra::FormatG2Uncompr" => Ok(Self::BN254G2Uncompressed), - "0x1::bn254_algebra::FormatG2Compr" => Ok(Self::BN254G2Compressed), - "0x1::bn254_algebra::FormatGt" => Ok(Self::BN254Gt), - "0x1::bn254_algebra::FormatFrLsb" => Ok(Self::BN254FrLsb), - "0x1::bn254_algebra::FormatFrMsb" => Ok(Self::BN254FrMsb), - "0x1::bn254_algebra::FormatFqLsb" => Ok(Self::BN254FqLsb), - "0x1::bn254_algebra::FormatFqMsb" => Ok(Self::BN254FqMsb), - "0x1::bn254_algebra::FormatFq12LscLsb" => Ok(Self::BN254Fq12LscLsb), + "0x00000000000000000000000000000001::bls12381_algebra::FormatG2Compr" => { + Ok(SerializationFormat::BLS12381G2Compressed) + } + "0x00000000000000000000000000000001::bls12381_algebra::FormatGt" => { + Ok(SerializationFormat::BLS12381Gt) + } + "0x00000000000000000000000000000001::bls12381_algebra::FormatFrLsb" => { + Ok(SerializationFormat::BLS12381FrLsb) + } + "0x00000000000000000000000000000001::bls12381_algebra::FormatFrMsb" => { + Ok(SerializationFormat::BLS12381FrMsb) + } + + "0x00000000000000000000000000000001::bn254_algebra::FormatG1Uncompr" => { + Ok(Self::BN254G1Uncompressed) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatG1Compr" => { + Ok(Self::BN254G1Compressed) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatG2Uncompr" => { + Ok(Self::BN254G2Uncompressed) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatG2Compr" => { + Ok(Self::BN254G2Compressed) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatGt" => Ok(Self::BN254Gt), + "0x00000000000000000000000000000001::bn254_algebra::FormatFrLsb" => { + Ok(Self::BN254FrLsb) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatFrMsb" => { + Ok(Self::BN254FrMsb) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatFqLsb" => { + Ok(Self::BN254FqLsb) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatFqMsb" => { + Ok(Self::BN254FqMsb) + } + "0x00000000000000000000000000000001::bn254_algebra::FormatFq12LscLsb" => { + Ok(Self::BN254Fq12LscLsb) + } _ => Err(()), } } @@ -167,10 +197,10 @@ impl TryFrom for HashToStructureSuite { fn try_from(value: TypeTag) -> Result { match value.to_string().as_str() { - "0x1::bls12381_algebra::HashG1XmdSha256SswuRo" => { + "0x00000000000000000000000000000001::bls12381_algebra::HashG1XmdSha256SswuRo" => { Ok(HashToStructureSuite::Bls12381g1XmdSha256SswuRo) } - "0x1::bls12381_algebra::HashG2XmdSha256SswuRo" => { + "0x00000000000000000000000000000001::bls12381_algebra::HashG2XmdSha256SswuRo" => { Ok(HashToStructureSuite::Bls12381g2XmdSha256SswuRo) } _ => Err(()), diff --git a/vm/framework/starcoin-stdlib/doc/type_info.md b/vm/framework/starcoin-stdlib/doc/type_info.md index f123213c25..17155cc4c7 100644 --- a/vm/framework/starcoin-stdlib/doc/type_info.md +++ b/vm/framework/starcoin-stdlib/doc/type_info.md @@ -218,8 +218,8 @@ Return the TypeInfo -Or: 0x1::table::Table<0x1::string::String, 0x1::string::String> +Example: 0x00000000000000000000000000000001::coin::CoinStore<0x00000000000000000000000000000001::aptos_coin::AptosCoin> +Or: 0x00000000000000000000000000000001::table::Table<0x00000000000000000000000000000001::string::String, 0x00000000000000000000000000000001::string::String> 
public fun type_name<T>(): string::String
diff --git a/vm/framework/starcoin-stdlib/sources/debug.move b/vm/framework/starcoin-stdlib/sources/debug.move
index 4109892c27..b7fcb2052f 100644
--- a/vm/framework/starcoin-stdlib/sources/debug.move
+++ b/vm/framework/starcoin-stdlib/sources/debug.move
@@ -74,13 +74,13 @@ module starcoin_std::debug {
         assert_equal(&v, b"[ 100, 200, 300 ]");
 
         let foo = Foo {};
-        assert_equal(&foo, b"0x1::debug::Foo {\n  dummy_field: false\n}");
+        assert_equal(&foo, b"0x00000000000000000000000000000001::debug::Foo {\n  dummy_field: false\n}");
 
         let bar = Bar { x: 404, y: Foo {}, z: true };
-        assert_equal(&bar, b"0x1::debug::Bar {\n  x: 404,\n  y: 0x1::debug::Foo {\n    dummy_field: false\n  },\n  z: true\n}");
+        assert_equal(&bar, b"0x00000000000000000000000000000001::debug::Bar {\n  x: 404,\n  y: 0x00000000000000000000000000000001::debug::Foo {\n    dummy_field: false\n  },\n  z: true\n}");
 
         let box = Box { x: Foo {} };
-        assert_equal(&box, b"0x1::debug::Box<0x1::debug::Foo> {\n  x: 0x1::debug::Foo {\n    dummy_field: false\n  }\n}");
+        assert_equal(&box, b"0x00000000000000000000000000000001::debug::Box<0x00000000000000000000000000000001::debug::Foo> {\n  x: 0x00000000000000000000000000000001::debug::Foo {\n    dummy_field: false\n  }\n}");
     }
 
     #[test]
@@ -155,7 +155,7 @@ module starcoin_std::debug {
             msgs: vector[MSG_1, MSG_2],
         };
 
-        assert_equal(&obj, b"0x1::debug::TestInner {\n  val: 100,\n  vec: [ 200, 400 ],\n  msgs: [\n    0x616263646566,\n    0x313233343536\n  ]\n}");
+        assert_equal(&obj, b"0x00000000000000000000000000000001::debug::TestInner {\n  val: 100,\n  vec: [ 200, 400 ],\n  msgs: [\n    0x616263646566,\n    0x313233343536\n  ]\n}");
 
         let obj = TestInner {
             val: 10,
@@ -163,7 +163,7 @@ module starcoin_std::debug {
             msgs: vector[],
         };
 
-        assert_equal(&obj, b"0x1::debug::TestInner {\n  val: 10,\n  vec: [],\n  msgs: []\n}");
+        assert_equal(&obj, b"0x00000000000000000000000000000001::debug::TestInner {\n  val: 10,\n  vec: [],\n  msgs: []\n}");
     }
 
     #[test(_s1 = @0x123, _s2 = @0x456)]
@@ -210,7 +210,7 @@ module starcoin_std::debug {
                 msgs: vector[x"0000"],
             }
         ];
-        assert_equal(&v, b"[\n  0x1::debug::TestInner {\n    val: 4,\n    vec: [ 127, 128 ],\n    msgs: [\n      0x00ff,\n      0xabcd\n    ]\n  },\n  0x1::debug::TestInner {\n    val: 8,\n    vec: [ 128, 129 ],\n    msgs: [\n      0x0000\n    ]\n  }\n]");
+        assert_equal(&v, b"[\n  0x00000000000000000000000000000001::debug::TestInner {\n    val: 4,\n    vec: [ 127, 128 ],\n    msgs: [\n      0x00ff,\n      0xabcd\n    ]\n  },\n  0x00000000000000000000000000000001::debug::TestInner {\n    val: 8,\n    vec: [ 128, 129 ],\n    msgs: [\n      0x0000\n    ]\n  }\n]");
     }
 
     #[test(_s1 = @0x123, _s2 = @0x456)]
@@ -255,7 +255,7 @@ module starcoin_std::debug {
                 TestInner { val: 8u128 , vec: vector[128u128, 129u128], msgs: vector[] }
             ]
         ];
-        assert_equal(&v, b"[\n  [\n    0x1::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ],\n  [\n    0x1::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ]\n]");
+        assert_equal(&v, b"[\n  [\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ],\n  [\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ]\n]");
     }
 
     #[test]
@@ -270,8 +270,7 @@ module starcoin_std::debug {
                 TestInner { val: 2, vec: vector[132u128, 133u128], msgs: vector[] }
             ],
         };
-
-        assert_equal(&obj, b"0x1::debug::TestStruct {\n  addr: @0x1,\n  number: 255,\n  bytes: 0xc0ffee,\n  name: \"He\\\"llo\",\n  vec: [\n    0x1::debug::TestInner {\n      val: 1,\n      vec: [ 130, 131 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 2,\n      vec: [ 132, 133 ],\n      msgs: []\n    }\n  ]\n}");
+        assert_equal(&obj, b"0x00000000000000000000000000000001::debug::TestStruct {\n  addr: @0x1,\n  number: 255,\n  bytes: 0xc0ffee,\n  name: \"He\\\"llo\",\n  vec: [\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 1,\n      vec: [ 130, 131 ],\n      msgs: []\n    },\n    0x00000000000000000000000000000001::debug::TestInner {\n      val: 2,\n      vec: [ 132, 133 ],\n      msgs: []\n    }\n  ]\n}");
     }
 
     #[test]
@@ -280,6 +279,6 @@ module starcoin_std::debug {
             val: 60u64,
         };
 
-        assert_equal(&obj, b"0x1::debug::GenericStruct<0x1::debug::Foo> {\n  val: 60\n}");
+        assert_equal(&obj, b"0x00000000000000000000000000000001::debug::GenericStruct<0x00000000000000000000000000000001::debug::Foo> {\n  val: 60\n}");
     }
 }
diff --git a/vm/framework/starcoin-stdlib/sources/from_bcs.move b/vm/framework/starcoin-stdlib/sources/from_bcs.move
index 8a22459ef7..a90c9f4593 100644
--- a/vm/framework/starcoin-stdlib/sources/from_bcs.move
+++ b/vm/framework/starcoin-stdlib/sources/from_bcs.move
@@ -73,9 +73,6 @@ module starcoin_std::from_bcs {
     #[test_only]
     use std::bcs;
 
-    #[test_only]
-    use std::debug;
-
     #[test]
     fun test_address() {
         let addr = @0x01;
diff --git a/vm/framework/starcoin-stdlib/sources/type_info.move b/vm/framework/starcoin-stdlib/sources/type_info.move
index 455aad482d..35a416da0d 100644
--- a/vm/framework/starcoin-stdlib/sources/type_info.move
+++ b/vm/framework/starcoin-stdlib/sources/type_info.move
@@ -51,8 +51,8 @@ module starcoin_std::type_info {
     public native fun type_of(): TypeInfo;
 
     /// Return the human readable string for the type, including the address, module name, and any type arguments.
-    /// Example: 0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>
-    /// Or: 0x1::table::Table<0x1::string::String, 0x1::string::String>
+    /// Example: 0x00000000000000000000000000000001::coin::CoinStore<0x00000000000000000000000000000001::aptos_coin::AptosCoin>
+    /// Or: 0x00000000000000000000000000000001::table::Table<0x00000000000000000000000000000001::string::String, 0x00000000000000000000000000000001::string::String>
     public native fun type_name(): String;
 
     native fun chain_id_internal(): u8;
@@ -85,7 +85,7 @@ module starcoin_std::type_info {
         let type_info = type_of>();
         assert!(account_address(&type_info) == @starcoin_std, 0);
         assert!(module_name(&type_info) == b"table", 1);
-        assert!(struct_name(&type_info) == b"Table<0x1::string::String, 0x1::string::String>", 2);
+        assert!(struct_name(&type_info) == b"Table<0x00000000000000000000000000000001::string::String, 0x00000000000000000000000000000001::string::String>", 2);
     }
 
     #[test(fx = @std)]
@@ -114,17 +114,17 @@ module starcoin_std::type_info {
         // vector
         assert!(type_name>() == string::utf8(b"vector"), 6);
         assert!(type_name>>() == string::utf8(b"vector>"), 7);
-        assert!(type_name>>() == string::utf8(b"vector>"), 8);
+        assert!(type_name>>() == string::utf8(b"vector>"), 8);
 
 
         // struct
-        assert!(type_name() == string::utf8(b"0x1::type_info::TypeInfo"), 9);
+        assert!(type_name() == string::utf8(b"0x00000000000000000000000000000001::type_info::TypeInfo"), 9);
         assert!(type_name<
             Table<
                 TypeInfo,
                 Table>
             >
-        >() == string::utf8(b"0x1::table::Table<0x1::type_info::TypeInfo, 0x1::table::Table>>"), 10);
+        >() == string::utf8(b"0x00000000000000000000000000000001::table::Table<0x00000000000000000000000000000001::type_info::TypeInfo, 0x00000000000000000000000000000001::table::Table>>"), 10);
     }
 
     #[verify_only]
diff --git a/vm/framework/starcoin-token-objects/doc/object_property_map.md b/vm/framework/starcoin-token-objects/doc/object_property_map.md
index b4de609e6e..9cbf860e3c 100644
--- a/vm/framework/starcoin-token-objects/doc/object_property_map.md
+++ b/vm/framework/starcoin-token-objects/doc/object_property_map.md
@@ -507,7 +507,7 @@ Maps String representation of types from their u8 repr
     } else if (type == BYTE_VECTOR) {
         string::utf8(b"vector<u8>")
     } else if (type == STRING) {
-        string::utf8(b"0x1::string::String")
+        string::utf8(b"0x00000000000000000000000000000001::string::String")
     } else {
         abort (error::invalid_argument(ETYPE_INVALID))
     }
@@ -553,7 +553,7 @@ Maps the String representation of types to u8
         ADDRESS
     } else if (type == string::utf8(b"vector<u8>")) {
         BYTE_VECTOR
-    } else if (type == string::utf8(b"0x1::string::String")) {
+    } else if (type == string::utf8(b"0x00000000000000000000000000000001::string::String")) {
         STRING
     } else {
         abort (error::invalid_argument(ETYPE_INVALID))
@@ -1268,7 +1268,7 @@ Removes a property from the map, ensuring that it does in fact exist
         6
     );
     assert!(read_bytes(&object, &string::utf8(b"vector<u8>")) == vector[0x01], 7);
-    assert!(read_string(&object, &string::utf8(b"0x1::string::String")) == string::utf8(b"a"), 8);
+    assert!(read_string(&object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"a"), 8);
 
     assert!(length(&object) == 9, 9);
 }
diff --git a/vm/framework/starcoin-token-objects/sources/object_property_map.move b/vm/framework/starcoin-token-objects/sources/object_property_map.move
index eab6e1ba8a..20e6b1e5e6 100644
--- a/vm/framework/starcoin-token-objects/sources/object_property_map.move
+++ b/vm/framework/starcoin-token-objects/sources/object_property_map.move
@@ -3,13 +3,14 @@
 /// represent types and storing values in bcs format.
 module starcoin_token_objects::object_property_map {
     use std::bcs;
-    use std::vector;
     use std::error;
     use std::string::{Self, String};
+    use std::vector;
+
+    use starcoin_framework::object::{Self, ConstructorRef, ExtendRef, Object, ObjectCore};
     use starcoin_std::from_bcs;
     use starcoin_std::simple_map::{Self, SimpleMap};
     use starcoin_std::type_info;
-    use starcoin_framework::object::{Self, ConstructorRef, Object, ExtendRef, ObjectCore};
 
     // Errors
     /// The property map does not exist
@@ -133,7 +134,7 @@ module starcoin_token_objects::object_property_map {
         } else if (type == BYTE_VECTOR) {
             string::utf8(b"vector")
         } else if (type == STRING) {
-            string::utf8(b"0x1::string::String")
+            string::utf8(b"0x00000000000000000000000000000001::string::String")
         } else {
             abort (error::invalid_argument(ETYPE_INVALID))
         }
@@ -159,7 +160,7 @@ module starcoin_token_objects::object_property_map {
             ADDRESS
         } else if (type == string::utf8(b"vector")) {
             BYTE_VECTOR
-        } else if (type == string::utf8(b"0x1::string::String")) {
+        } else if (type == string::utf8(b"0x00000000000000000000000000000001::string::String")) {
             STRING
         } else {
             abort (error::invalid_argument(ETYPE_INVALID))
@@ -355,7 +356,6 @@ module starcoin_token_objects::object_property_map {
         assert_end_to_end_input(object);
 
         test_end_to_end_update_typed(&mutator, &object);
-
         assert!(length(&object) == 9, 19);
 
         remove(&mutator, &string::utf8(b"bool"));
@@ -366,7 +366,7 @@ module starcoin_token_objects::object_property_map {
         remove(&mutator, &string::utf8(b"u128"));
         remove(&mutator, &string::utf8(b"u256"));
         remove(&mutator, &string::utf8(b"vector"));
-        remove(&mutator, &string::utf8(b"0x1::string::String"));
+        remove(&mutator, &string::utf8(b"0x00000000000000000000000000000001::string::String"));
 
         assert!(length(&object) == 0, 20);
 
@@ -382,7 +382,7 @@ module starcoin_token_objects::object_property_map {
         remove(&mutator, &string::utf8(b"u128"));
         remove(&mutator, &string::utf8(b"u256"));
         remove(&mutator, &string::utf8(b"vector"));
-        remove(&mutator, &string::utf8(b"0x1::string::String"));
+        remove(&mutator, &string::utf8(b"0x00000000000000000000000000000001::string::String"));
 
         assert!(length(&object) == 0, 31);
 
@@ -411,8 +411,8 @@ module starcoin_token_objects::object_property_map {
         );
         add(
             &mutator,
-            string::utf8(b"0x1::string::String"),
-            string::utf8(b"0x1::string::String"),
+            string::utf8(b"0x00000000000000000000000000000001::string::String"),
+            string::utf8(b"0x00000000000000000000000000000001::string::String"),
             bcs::to_bytes(&string::utf8(b"a"))
         );
 
@@ -430,7 +430,7 @@ module starcoin_token_objects::object_property_map {
             38
         );
         assert!(read_bytes(&object, &string::utf8(b"vector")) == vector[0x01], 39);
-        assert!(read_string(&object, &string::utf8(b"0x1::string::String")) == string::utf8(b"a"), 40);
+        assert!(read_string(&object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"a"), 40);
 
         assert!(length(&object) == 9, 41);
 
@@ -449,8 +449,8 @@ module starcoin_token_objects::object_property_map {
         );
         update(
             &mutator,
-            &string::utf8(b"0x1::string::String"),
-            string::utf8(b"0x1::string::String"),
+            &string::utf8(b"0x00000000000000000000000000000001::string::String"),
+            string::utf8(b"0x00000000000000000000000000000001::string::String"),
             bcs::to_bytes(&string::utf8(b"ha"))
         );
 
@@ -462,7 +462,7 @@ module starcoin_token_objects::object_property_map {
         assert!(read_u128(&object, &string::utf8(b"u128")) == 0x25, 15);
         assert!(read_u256(&object, &string::utf8(b"u256")) == 0x26, 16);
         assert!(read_bytes(&object, &string::utf8(b"vector")) == vector[0x02], 17);
-        assert!(read_string(&object, &string::utf8(b"0x1::string::String")) == string::utf8(b"ha"), 18);
+        assert!(read_string(&object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"ha"), 18);
     }
 
     #[test_only]
@@ -475,7 +475,7 @@ module starcoin_token_objects::object_property_map {
         update_typed(mutator, &string::utf8(b"u128"), 0x25);
         update_typed(mutator, &string::utf8(b"u256"), 0x26);
         update_typed>(mutator, &string::utf8(b"vector"), vector[0x02]);
-        update_typed(mutator, &string::utf8(b"0x1::string::String"), string::utf8(b"ha"));
+        update_typed(mutator, &string::utf8(b"0x00000000000000000000000000000001::string::String"), string::utf8(b"ha"));
 
         assert!(!read_bool(object, &string::utf8(b"bool")), 10);
         assert!(read_u8(object, &string::utf8(b"u8")) == 0x21, 11);
@@ -485,7 +485,7 @@ module starcoin_token_objects::object_property_map {
         assert!(read_u128(object, &string::utf8(b"u128")) == 0x25, 15);
         assert!(read_u256(object, &string::utf8(b"u256")) == 0x26, 16);
         assert!(read_bytes(object, &string::utf8(b"vector")) == vector[0x02], 17);
-        assert!(read_string(object, &string::utf8(b"0x1::string::String")) == string::utf8(b"ha"), 18);
+        assert!(read_string(object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"ha"), 18);
     }
 
     #[test_only]
@@ -498,7 +498,7 @@ module starcoin_token_objects::object_property_map {
         add_typed(mutator, string::utf8(b"u128"), 0x25);
         add_typed(mutator, string::utf8(b"u256"), 0x26);
         add_typed>(mutator, string::utf8(b"vector"), vector[0x02]);
-        add_typed(mutator, string::utf8(b"0x1::string::String"), string::utf8(b"ha"));
+        add_typed(mutator, string::utf8(b"0x00000000000000000000000000000001::string::String"), string::utf8(b"ha"));
 
         assert!(!read_bool(object, &string::utf8(b"bool")), 21);
         assert!(read_u8(object, &string::utf8(b"u8")) == 0x21, 22);
@@ -508,7 +508,7 @@ module starcoin_token_objects::object_property_map {
         assert!(read_u128(object, &string::utf8(b"u128")) == 0x25, 26);
         assert!(read_u256(object, &string::utf8(b"u256")) == 0x26, 27);
         assert!(read_bytes(object, &string::utf8(b"vector")) == vector[0x02], 28);
-        assert!(read_string(object, &string::utf8(b"0x1::string::String")) == string::utf8(b"ha"), 29);
+        assert!(read_string(object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"ha"), 29);
     }
 
     #[test(creator = @0x123)]
@@ -533,7 +533,7 @@ module starcoin_token_objects::object_property_map {
                 string::utf8(b"u128"),
                 string::utf8(b"u256"),
                 string::utf8(b"vector"),
-                string::utf8(b"0x1::string::String"),
+                string::utf8(b"0x00000000000000000000000000000001::string::String"),
             ],
             vector[
                 string::utf8(b"bool"),
@@ -544,7 +544,7 @@ module starcoin_token_objects::object_property_map {
                 string::utf8(b"u128"),
                 string::utf8(b"u256"),
                 string::utf8(b"vector"),
-                string::utf8(b"0x1::string::String"),
+                string::utf8(b"0x00000000000000000000000000000001::string::String"),
             ],
             vector[
                 bcs::to_bytes(&true),
@@ -661,7 +661,7 @@ module starcoin_token_objects::object_property_map {
             6
         );
         assert!(read_bytes(&object, &string::utf8(b"vector")) == vector[0x01], 7);
-        assert!(read_string(&object, &string::utf8(b"0x1::string::String")) == string::utf8(b"a"), 8);
+        assert!(read_string(&object, &string::utf8(b"0x00000000000000000000000000000001::string::String")) == string::utf8(b"a"), 8);
 
         assert!(length(&object) == 9, 9);
     }
diff --git a/vm/framework/tests/move_prover_tests.rs b/vm/framework/tests/move_prover_tests.rs
index 364ec35b02..7da67af694 100644
--- a/vm/framework/tests/move_prover_tests.rs
+++ b/vm/framework/tests/move_prover_tests.rs
@@ -67,21 +67,29 @@ pub fn run_prover_for_pkg(path_to_pkg: impl Into) {
     }
 }
 
+// TODO(BobOng): [framework-upgrade] to install pover env and running it
+#[ignore]
 #[test]
 fn move_framework_prover_tests() {
     run_prover_for_pkg("starcoin-framework");
 }
 
+// TODO(BobOng): [framework-upgrade] to install pover env and running it
+#[ignore]
 #[test]
 fn move_token_prover_tests() {
     run_prover_for_pkg("starcoin-token");
 }
 
+// TODO(BobOng): [framework-upgrade] to install pover env and running it
+#[ignore]
 #[test]
 fn move_starcoin_stdlib_prover_tests() {
     run_prover_for_pkg("starcoin-stdlib");
 }
 
+// TODO(BobOng): [framework-upgrade] to install pover env and running it
+#[ignore]
 #[test]
 fn move_stdlib_prover_tests() {
     run_prover_for_pkg("move-stdlib");
diff --git a/vm/move-package-manager/src/package.rs b/vm/move-package-manager/src/package.rs
index f2f09f5848..add1ccb5a9 100644
--- a/vm/move-package-manager/src/package.rs
+++ b/vm/move-package-manager/src/package.rs
@@ -9,11 +9,11 @@ use move_vm_runtime::native_functions::NativeFunctionTable;
 use starcoin_framework::extended_checks;
 use starcoin_vm_runtime::natives;
 
-pub const STARCOIN_STDLIB_PACKAGE_NAME: &str = "StarcoinFramework";
+pub const STARCOIN_STDLIB_PACKAGE_NAME: &str = "starcoin_framework";
 pub const STARCOIN_STDLIB_PACKAGE_PATH: &str = "{ \
     git = \"https://github.com/starcoinorg/starcoin-framework.git\", rev = \"main\" \
 }";
-pub const STARCOIN_STDLIB_ADDR_NAME: &str = "StarcoinFramework";
+pub const STARCOIN_STDLIB_ADDR_NAME: &str = "starcoin_framework";
 pub const STARCOIN_STDLIB_ADDR_VALUE: &str = "0x1";
 
 #[derive(Parser)]
@@ -44,6 +44,7 @@ pub enum PackageCommand {
     #[clap(name = "disassemble")]
     Disassemble(Disassemble),
 }
+
 pub fn handle_package_commands(
     natives: NativeFunctionTable,
     move_args: Move,
@@ -65,9 +66,13 @@ pub fn handle_package_commands(
         PackageCommand::Test(c) => {
             natives::configure_for_unit_test();
             extended_checks::configure_extended_checks_for_unit_test();
+
+            let mut build_config = move_args.build_config.clone();
+            build_config.compiler_config.known_attributes =
+                extended_checks::get_all_attribute_names().clone();
             c.execute(
                 move_args.package_path,
-                move_args.build_config,
+                build_config,
                 natives,
                 Changes::new(),
                 None,