[account-address] Make all inputs fuzzy for unknown hex literals

Given that there is a lot of code around hex literals, including a bunch that are questionable about how they add 0x in front, I've switched them to fuzzy for now. We can clean them up later and ensure it's in a better state later, but some functionality is currently broken due to inconsistent outputs.
move-language · Apr 20, 2022 · 01e13bb · 01e13bb
1 parent 9ddee79
commit 01e13bb
Show file tree

Hide file tree

Showing 13 changed files with 16 additions and 16 deletions.
diff --git a/language/extensions/async/move-async-vm/tests/testsuite.rs b/language/extensions/async/move-async-vm/tests/testsuite.rs
@@ -274,9 +274,9 @@ impl Harness {
             if parts.len() != 3 {
                 bail!("malformed instance decl `{}`", inst)
             }
-            let address = AccountAddress::from_hex_literal(parts[0])?;
+            let address = AccountAddress::from_hex_fuzzy(parts[0])?;
             let module = Identifier::from_str(parts[1])?;
-            let inst_address = AccountAddress::from_hex_literal(parts[2])?;
+            let inst_address = AccountAddress::from_hex_fuzzy(parts[2])?;
             result.push((ModuleId::new(address, module), inst_address))
         }
         Ok(result)

diff --git a/language/move-core/types/src/parser.rs b/language/move-core/types/src/parser.rs
@@ -287,7 +287,7 @@ impl<I: Iterator<Item = Token>> Parser<I> {
                                     vec![]
                                 };
                                 TypeTag::Struct(StructTag {
-                                    address: AccountAddress::from_hex_literal(&addr)?,
+                                    address: AccountAddress::from_hex_fuzzy(&addr)?,
                                     module: Identifier::new(module)?,
                                     name: Identifier::new(name)?,
                                     type_params: ty_args,
@@ -311,7 +311,7 @@ impl<I: Iterator<Item = Token>> Parser<I> {
             Token::True => TransactionArgument::Bool(true),
             Token::False => TransactionArgument::Bool(false),
             Token::Address(addr) => {
-                TransactionArgument::Address(AccountAddress::from_hex_literal(&addr)?)
+                TransactionArgument::Address(AccountAddress::from_hex_fuzzy(&addr)?)
             }
             Token::Bytes(s) => TransactionArgument::U8Vector(hex::decode(s)?),
             tok => bail!("unexpected token {:?}, expected transaction argument", tok),

diff --git a/language/move-ir-compiler/move-ir-to-bytecode/syntax/src/syntax.rs b/language/move-ir-compiler/move-ir-to-bytecode/syntax/src/syntax.rs
@@ -187,7 +187,7 @@ fn parse_account_address(
             message: "expected Tok::AccountAddressValue".to_string(),
         });
     }
-    let addr = AccountAddress::from_hex_literal(tokens.content())
+    let addr = AccountAddress::from_hex_fuzzy(tokens.content())
         .with_context(|| {
             format!(
                 "The address {:?} is of invalid length. Addresses are at most 32-bytes long",

diff --git a/language/move-model/src/lib.rs b/language/move-model/src/lib.rs
@@ -563,7 +563,7 @@ pub fn addr_to_big_uint(addr: &AccountAddress) -> BigUint {
 pub fn big_uint_to_addr(i: &BigUint) -> AccountAddress {
     // TODO: do this in more efficient way (e.g., i.to_le_bytes() and pad out the resulting Vec<u8>
     // to ADDRESS_LENGTH
-    AccountAddress::from_hex_literal(&format!("{:#x}", i)).unwrap()
+    AccountAddress::from_hex_literal(&format!("{:#X}", i)).unwrap()
 }
 
 pub fn parse_addresses_from_options(

diff --git a/language/move-prover/interpreter/src/concrete/evaluator.rs b/language/move-prover/interpreter/src/concrete/evaluator.rs
@@ -236,7 +236,7 @@ impl<'env> Evaluator<'env> {
     fn evaluate_constant(&self, val: &Value) -> BaseValue {
         match val {
             Value::Address(v) => BaseValue::mk_address(
-                AccountAddress::from_hex_literal(&format!("{:#x}", v)).unwrap(),
+                AccountAddress::from_hex_literal(&format!("{:#X}", v)).unwrap(),
             ),
             Value::Number(v) => BaseValue::mk_num(v.clone()),
             Value::Bool(v) => BaseValue::mk_bool(*v),

diff --git a/language/move-prover/interpreter/src/concrete/player.rs b/language/move-prover/interpreter/src/concrete/player.rs
@@ -404,7 +404,7 @@ impl<'env> FunctionContext<'env> {
             Constant::U128(v) => TypedValue::mk_u128(*v),
             Constant::U256(_) => unimplemented!(),
             Constant::Address(v) => TypedValue::mk_address(
-                AccountAddress::from_hex_literal(&format!("{:#x}", v)).unwrap(),
+                AccountAddress::from_hex_literal(&format!("{:#X}", v)).unwrap(),
             ),
             Constant::ByteArray(v) => {
                 let elems = v.iter().map(|e| TypedValue::mk_u8(*e)).collect();

diff --git a/language/move-prover/interpreter/src/lib.rs b/language/move-prover/interpreter/src/lib.rs
@@ -88,7 +88,7 @@ fn parse_entrypoint(input: &str) -> Result<(ModuleId, Identifier)> {
         bail!("Invalid entrypoint: {}", input);
     }
     let module_id = ModuleId::new(
-        AccountAddress::from_hex_literal(tokens[0])?,
+        AccountAddress::from_hex_fuzzy(tokens[0])?,
         Identifier::new(tokens[1])?,
     );
     let func_name = Identifier::new(tokens[2])?;

diff --git a/language/move-prover/move-errmapgen/src/errmapgen.rs b/language/move-prover/move-errmapgen/src/errmapgen.rs
@@ -130,7 +130,7 @@ impl<'env> ErrmapGen<'env> {
 
     fn get_module_id_for_name(&self, module: &ModuleEnv<'_>) -> ModuleId {
         let name = module.get_name();
-        let addr = AccountAddress::from_hex_literal(&format!("0x{:x}", name.addr())).unwrap();
+        let addr = AccountAddress::from_hex_literal(&format!("{:#X}", name.addr())).unwrap();
         let name = Identifier::new(self.name_string(name.name()).to_string()).unwrap();
         ModuleId::new(addr, name)
     }

diff --git a/language/tools/move-cli/src/experimental/commands/read_writeset_analysis.rs b/language/tools/move-cli/src/experimental/commands/read_writeset_analysis.rs
@@ -44,7 +44,7 @@ pub fn analyze_read_write_set(
 
     let signer_addresses = signers
         .iter()
-        .map(|s| AccountAddress::from_hex_literal(s))
+        .map(|s| AccountAddress::from_hex_fuzzy(s))
         .collect::<Result<Vec<AccountAddress>, _>>()?;
     // TODO: parse Value's directly instead of going through the indirection of TransactionArgument?
     let script_args: Vec<Vec<u8>> = convert_txn_args(txn_args);

diff --git a/language/tools/move-cli/src/sandbox/commands/run.rs b/language/tools/move-cli/src/sandbox/commands/run.rs
@@ -66,7 +66,7 @@ move run` must be applied to a module inside `storage/`",
 
     let signer_addresses = signers
         .iter()
-        .map(|s| AccountAddress::from_hex_literal(s))
+        .map(|s| AccountAddress::from_hex_fuzzy(s))
         .collect::<Result<Vec<AccountAddress>, _>>()?;
     // TODO: parse Value's directly instead of going through the indirection of TransactionArgument?
     let vm_args: Vec<Vec<u8>> = convert_txn_args(txn_args);

diff --git a/language/tools/move-cli/src/sandbox/utils/on_disk_state_view.rs b/language/tools/move-cli/src/sandbox/utils/on_disk_state_view.rs
@@ -140,7 +140,7 @@ impl OnDiskStateView {
         match p.parent().map(|parent| parent.parent()).flatten() {
             Some(parent) => {
                 let addr =
-                    AccountAddress::from_hex_literal(parent.file_stem().unwrap().to_str().unwrap())
+                    AccountAddress::from_hex_fuzzy(parent.file_stem().unwrap().to_str().unwrap())
                         .unwrap();
                 Some(ModuleId::new(addr, name))
             }

diff --git a/language/tools/move-coverage/src/coverage_map.rs b/language/tools/move-coverage/src/coverage_map.rs
@@ -77,7 +77,7 @@ impl CoverageMap {
                 let func_name = Identifier::new(context_segs.pop().unwrap()).unwrap();
                 let module_name = Identifier::new(context_segs.pop().unwrap()).unwrap();
                 let module_addr =
-                    AccountAddress::from_hex_literal(context_segs.pop().unwrap()).unwrap();
+                    AccountAddress::from_hex_fuzzy(context_segs.pop().unwrap()).unwrap();
                 self.insert(exec_id, module_addr, module_name, func_name, pc);
             } else {
                 // Don't count scripts (for now)
@@ -286,7 +286,7 @@ impl TraceMap {
                 let func_name = Identifier::new(context_segs.pop().unwrap()).unwrap();
                 let module_name = Identifier::new(context_segs.pop().unwrap()).unwrap();
                 let module_addr =
-                    AccountAddress::from_hex_literal(context_segs.pop().unwrap()).unwrap();
+                    AccountAddress::from_hex_fuzzy(context_segs.pop().unwrap()).unwrap();
                 self.insert(exec_id, module_addr, module_name, func_name, pc);
             } else {
                 // Don't count scripts (for now)

diff --git a/language/tools/move-package/src/source_package/manifest_parser.rs b/language/tools/move-package/src/source_package/manifest_parser.rs
@@ -385,7 +385,7 @@ fn parse_substitution(tval: TV) -> Result<PM::Substitution> {
                 let addr_ident = PM::NamedAddress::from(addr_name.as_str());
                 match tval {
                     TV::String(addr_or_name) => {
-                        if let Ok(addr) = AccountAddress::from_hex_literal(&addr_or_name) {
+                        if let Ok(addr) = AccountAddress::from_hex_fuzzy(&addr_or_name) {
                             subst.insert(addr_ident, PM::SubstOrRename::Assign(addr));
                         } else {
                             let rename_from = PM::NamedAddress::from(addr_or_name.as_str());