wip

crates/cache/src/lib.rs

@@ -215,7 +215,8 @@ pub fn delete_cache(key: &str) -> Result<(), Error> {
 #[allow(deprecated)]
 pub fn read_cache<T>(key: &str) -> Result<Option<T>, Error>
 where
-    T: 'static + DeserializeOwned, {
+    T: 'static + DeserializeOwned,
+{
     let home = home_dir().ok_or(Error::Generic(
         "failed to get home directory. does your os support `std::env::home_dir()`?".to_string(),
     ))?;
@@ -238,8 +239,8 @@ where
         .map_err(|e| Error::Generic(format!("failed to deserialize cache object: {:?}", e)))?;
 
     // check if the cache has expired, if so, delete it and return None
-    if cache.expiry <
-        std::time::SystemTime::now()
+    if cache.expiry
+        < std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .map_err(|e| Error::Generic(format!("failed to get current time: {:?}", e)))?
             .as_secs()
@@ -266,7 +267,8 @@ where
 #[allow(deprecated)]
 pub fn store_cache<T>(key: &str, value: T, expiry: Option<u64>) -> Result<(), Error>
 where
-    T: Serialize, {
+    T: Serialize,
+{
     let home = home_dir().ok_or(Error::Generic(
         "failed to get home directory. does your os support `std::env::home_dir()`?".to_string(),
     ))?;
@@ -278,8 +280,8 @@ where
         std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .map_err(|e| Error::Generic(format!("failed to get current time: {:?}", e)))?
-            .as_secs() +
-            60 * 60 * 24 * 90,
+            .as_secs()
+            + 60 * 60 * 24 * 90,
     );
 
     let cache = Cache { value, expiry };
@@ -304,7 +306,8 @@ pub async fn with_cache<T, F, Fut>(key: &str, func: F) -> eyre::Result<T>
 where
     T: 'static + Serialize + DeserializeOwned + Send + Sync,
     F: FnOnce() -> Fut + Send,
-    Fut: std::future::Future<Output = Result<T, eyre::Report>> + Send, {
+    Fut: std::future::Future<Output = Result<T, eyre::Report>> + Send,
+{
     // Try to read from cache
     match read_cache::<T>(key) {
         Ok(Some(cached_value)) => {

crates/cfg/src/core/graph.rs

@@ -61,8 +61,8 @@ pub fn build_cfg(
                 .first()
                 .ok_or_eyre("failed to get first operation")?
                 .last_instruction
-                .opcode ==
-                JUMPDEST,
+                .opcode
+                == JUMPDEST,
         )?;
     }
 

crates/common/src/ether/signatures.rs

@@ -286,18 +286,18 @@ pub fn score_signature(signature: &str, num_words: Option<usize>) -> u32 {
 
     // prioritize signatures with less numbers
     score -= (signature.split('(').next().unwrap_or("").matches(|c: char| c.is_numeric()).count()
-        as u32) *
-        3;
+        as u32)
+        * 3;
 
     // prioritize signatures with parameters
     let num_params = signature.matches(',').count() + 1;
     score += num_params as u32 * 10;
 
     // count the number of parameters in the signature, if enabled
     if let Some(num_words) = num_words {
-        let num_dyn_params = signature.matches("bytes").count() +
-            signature.matches("string").count() +
-            signature.matches('[').count();
+        let num_dyn_params = signature.matches("bytes").count()
+            + signature.matches("string").count()
+            + signature.matches('[').count();
         let num_static_params = num_params - num_dyn_params;
 
         // reduce the score if the signature has less static parameters than there are words in the

crates/common/src/ether/tokenize.rs

@@ -130,17 +130,17 @@ pub fn tokenize(s: &str) -> Token {
                 let mut op = ch.to_string();
                 iter.next();
                 if let Some(&next_ch) = iter.peek() {
-                    if (ch == '=' && (next_ch == '=' || next_ch == '>')) ||
-                        (ch == '&' && next_ch == '&') ||
-                        (ch == '|' && next_ch == '|') ||
-                        (ch == '<' && next_ch == '=') ||
-                        (ch == '>' && next_ch == '=') ||
-                        (ch == '!' && next_ch == '=') ||
-                        (ch == '+' && next_ch == '+') ||
-                        (ch == '-' && next_ch == '-') ||
-                        (ch == '*' && next_ch == '*') ||
-                        (ch == '>' && next_ch == '>') ||
-                        (ch == '<' && next_ch == '<')
+                    if (ch == '=' && (next_ch == '=' || next_ch == '>'))
+                        || (ch == '&' && next_ch == '&')
+                        || (ch == '|' && next_ch == '|')
+                        || (ch == '<' && next_ch == '=')
+                        || (ch == '>' && next_ch == '=')
+                        || (ch == '!' && next_ch == '=')
+                        || (ch == '+' && next_ch == '+')
+                        || (ch == '-' && next_ch == '-')
+                        || (ch == '*' && next_ch == '*')
+                        || (ch == '>' && next_ch == '>')
+                        || (ch == '<' && next_ch == '<')
                     {
                         op.push(next_ch);
                         iter.next();
@@ -188,9 +188,9 @@ fn parse_literal(iter: &mut std::iter::Peekable<std::str::Chars>) -> String {
     }
 
     // literal validation
-    if literal.starts_with("0x") &&
-        literal.len() > 2 &&
-        literal[2..].chars().all(|c| c.is_ascii_hexdigit())
+    if literal.starts_with("0x")
+        && literal.len() > 2
+        && literal[2..].chars().all(|c| c.is_ascii_hexdigit())
     {
         return literal;
     }

crates/common/src/utils/strings.rs

@@ -330,8 +330,8 @@ pub fn tokenize(s: &str) -> Vec<String> {
             // Check if current character and last character form a compound operator (like "==",
             // ">=", "&&", "||")
             if let Some(last) = last_char {
-                if compound_operator_first_chars.contains(&last) &&
-                    (c == '=' || c == '&' || c == '|')
+                if compound_operator_first_chars.contains(&last)
+                    && (c == '=' || c == '&' || c == '|')
                 {
                     // Remove the last character as a single token
                     tokens.pop();

crates/common/src/utils/sync.rs

@@ -1,6 +1,7 @@
 /// Take in a non-async function and await it. This functions should be blocking.
 pub fn blocking_await<F, T>(f: F) -> T
 where
-    F: FnOnce() -> T, {
+    F: FnOnce() -> T,
+{
     tokio::task::block_in_place(f)
 }

crates/common/src/utils/version.rs

@@ -93,46 +93,46 @@ impl Display for Version {
 impl Version {
     /// greater than
     pub fn gt(&self, other: &Version) -> bool {
-        self.major > other.major ||
-            (self.major == other.major && self.minor > other.minor) ||
-            (self.major == other.major && self.minor == other.minor && self.patch > other.patch)
+        self.major > other.major
+            || (self.major == other.major && self.minor > other.minor)
+            || (self.major == other.major && self.minor == other.minor && self.patch > other.patch)
     }
 
     /// greater than or equal to
     pub fn gte(&self, other: &Version) -> bool {
-        self.major > other.major ||
-            (self.major == other.major && self.minor > other.minor) ||
-            (self.major == other.major && self.minor == other.minor && self.patch >= other.patch)
+        self.major > other.major
+            || (self.major == other.major && self.minor > other.minor)
+            || (self.major == other.major && self.minor == other.minor && self.patch >= other.patch)
     }
 
     /// less than
     pub fn lt(&self, other: &Version) -> bool {
-        self.major < other.major ||
-            (self.major == other.major && self.minor < other.minor) ||
-            (self.major == other.major && self.minor == other.minor && self.patch < other.patch)
+        self.major < other.major
+            || (self.major == other.major && self.minor < other.minor)
+            || (self.major == other.major && self.minor == other.minor && self.patch < other.patch)
     }
 
     /// less than or equal to
     pub fn lte(&self, other: &Version) -> bool {
-        self.major < other.major ||
-            (self.major == other.major && self.minor < other.minor) ||
-            (self.major == other.major && self.minor == other.minor && self.patch <= other.patch)
+        self.major < other.major
+            || (self.major == other.major && self.minor < other.minor)
+            || (self.major == other.major && self.minor == other.minor && self.patch <= other.patch)
     }
 
     #[allow(clippy::should_implement_trait)]
     pub fn eq(&self, other: &Version) -> bool {
-        self.major == other.major &&
-            self.minor == other.minor &&
-            self.patch == other.patch &&
-            self.channel == other.channel
+        self.major == other.major
+            && self.minor == other.minor
+            && self.patch == other.patch
+            && self.channel == other.channel
     }
 
     /// not equal to
     pub fn ne(&self, other: &Version) -> bool {
-        self.major != other.major ||
-            self.minor != other.minor ||
-            self.patch != other.patch ||
-            self.channel != other.channel
+        self.major != other.major
+            || self.minor != other.minor
+            || self.patch != other.patch
+            || self.channel != other.channel
     }
 
     /// if the version is a nightly version

crates/decode/src/utils/abi.rs

@@ -185,8 +185,8 @@ fn try_decode_dynamic_parameter_bytes(
     // (5) we've covered all words from `data_start_word_offset` to `data_end_word_offset`,
     // so add them to `word_coverages`.
     coverages.extend(
-        (word_offset.try_into().unwrap_or(usize::MAX)..
-            data_end_word_offset.try_into().unwrap_or(usize::MAX))
+        (word_offset.try_into().unwrap_or(usize::MAX)
+            ..data_end_word_offset.try_into().unwrap_or(usize::MAX))
             .collect::<Vec<usize>>(),
     );
 
@@ -211,8 +211,8 @@ fn try_decode_dynamic_parameter_array(
 
     // (1) join all words from `data_start_word_offset` to `data_end_word_offset`. This is where
     // the encoded data may be stored.
-    let data_words = &calldata_words[data_start_word_offset.try_into().unwrap_or(usize::MAX)..
-        data_end_word_offset.try_into().unwrap_or(usize::MAX)];
+    let data_words = &calldata_words[data_start_word_offset.try_into().unwrap_or(usize::MAX)
+        ..data_end_word_offset.try_into().unwrap_or(usize::MAX)];
     trace!("potential array items: {:#?}", data_words);
 
     // (2) first, check if this is a `string` type, since some string encodings may appear to be
@@ -234,8 +234,8 @@ fn try_decode_dynamic_parameter_array(
     // `word_coverages` with the indices of all words from `data_start_word_offset` to
     // `data_end_word_offset`, since we've now covered all words in the ABI-encoded type.
     coverages.extend(
-        (word_offset.try_into().unwrap_or(usize::MAX)..
-            data_end_word_offset.try_into().unwrap_or(usize::MAX))
+        (word_offset.try_into().unwrap_or(usize::MAX)
+            ..data_end_word_offset.try_into().unwrap_or(usize::MAX))
             .collect::<Vec<usize>>(),
     );
 
@@ -296,8 +296,8 @@ fn try_decode_dynamic_parameter_string(
     trace!(
         "with data: {:#?}",
         encode_hex(
-            &calldata_words[data_start_word_offset.try_into().unwrap_or(usize::MAX)..
-                data_end_word_offset.try_into().unwrap_or(usize::MAX)]
+            &calldata_words[data_start_word_offset.try_into().unwrap_or(usize::MAX)
+                ..data_end_word_offset.try_into().unwrap_or(usize::MAX)]
                 .concat()
         )
     );
@@ -321,8 +321,8 @@ fn try_decode_dynamic_parameter_string(
     // (5) we've covered all words from `data_start_word_offset` to `data_end_word_offset`,
     // so add them to `word_coverages`.
     coverages.extend(
-        (word_offset.try_into().unwrap_or(usize::MAX)..
-            data_end_word_offset.try_into().unwrap_or(usize::MAX))
+        (word_offset.try_into().unwrap_or(usize::MAX)
+            ..data_end_word_offset.try_into().unwrap_or(usize::MAX))
             .collect::<Vec<usize>>(),
     );
 

crates/decode/src/utils/constructor.rs

@@ -42,16 +42,16 @@ pub fn parse_deployment_bytecode(input: Vec<u8>) -> Result<Constructor> {
 
     let constructor_offset = 0;
     let metadata_length = u32::from_str_radix(
-        &input[(contract_offset + contract_length - 4) as usize..
-            (contract_offset + contract_length) as usize],
+        &input[(contract_offset + contract_length - 4) as usize
+            ..(contract_offset + contract_length) as usize],
         16,
-    )? * 2 +
-        4;
+    )? * 2
+        + 4;
 
     let constructor = &input[constructor_offset as usize..contract_offset as usize];
     let contract = &input[contract_offset as usize..(contract_offset + contract_length) as usize];
-    let metadata = &input[(contract_offset + contract_length - metadata_length) as usize..
-        (contract_offset + contract_length) as usize];
+    let metadata = &input[(contract_offset + contract_length - metadata_length) as usize
+        ..(contract_offset + contract_length) as usize];
     let arguments = &input[(contract_offset + contract_length) as usize..];
 
     Ok(Constructor {

crates/decompile/src/core/analyze.rs

@@ -156,8 +156,8 @@ impl Analyzer {
         }
 
         // check if the ending brackets are needed
-        if analyzer_state.jumped_conditional.is_some() &&
-            analyzer_state.conditional_stack.contains(
+        if analyzer_state.jumped_conditional.is_some()
+            && analyzer_state.conditional_stack.contains(
                 analyzer_state
                     .jumped_conditional
                     .as_ref()
@@ -166,8 +166,8 @@ impl Analyzer {
         {
             // remove the conditional
             for (i, conditional) in analyzer_state.conditional_stack.iter().enumerate() {
-                if conditional ==
-                    analyzer_state.jumped_conditional.as_ref().expect(
+                if conditional
+                    == analyzer_state.jumped_conditional.as_ref().expect(
                         "impossible case: should have short-circuited in previous conditional",
                     )
                 {

crates/decompile/src/core/out/source.rs

@@ -67,9 +67,9 @@ pub fn build_source(
     functions
         .iter()
         .filter(|f| {
-            !f.fallback &&
-                (analyzer_type == AnalyzerType::Yul ||
-                    (f.maybe_getter_for.is_none() && !f.is_constant()))
+            !f.fallback
+                && (analyzer_type == AnalyzerType::Yul
+                    || (f.maybe_getter_for.is_none() && !f.is_constant()))
         })
         .for_each(|f| {
             let mut function_source = Vec::new();

crates/decompile/src/core/postprocess.rs

@@ -130,8 +130,8 @@ impl PostprocessOrchestrator {
         // Note: this can't be done with a postprocessor because it needs all lines
         if !function.payable && (function.pure || function.view) && function.arguments.is_empty() {
             // check for RLP encoding. very naive check, but it works for now
-            if function.logic.iter().any(|line| line.contains("0x0100 *")) &&
-                function.logic.iter().any(|line| line.contains("0x01) &"))
+            if function.logic.iter().any(|line| line.contains("0x0100 *"))
+                && function.logic.iter().any(|line| line.contains("0x01) &"))
             {
                 // find any storage accesses
                 let joined = function.logic.join(" ");

crates/decompile/src/utils/heuristics/arguments.rs

@@ -28,8 +28,8 @@ pub fn argument_heuristic(
             // calculate the argument index, with the 4byte signature padding removed
             // for example, CALLDATALOAD(4) -> (4-4)/32 = 0
             //              CALLDATALOAD(36) -> (36-4)/32 = 1
-            let arg_index = (state.last_instruction.inputs[0].saturating_sub(U256::from(4)) /
-                U256::from(32))
+            let arg_index = (state.last_instruction.inputs[0].saturating_sub(U256::from(4))
+                / U256::from(32))
             .try_into()
             .unwrap_or(usize::MAX);
 

crates/decompile/src/utils/heuristics/modifiers.rs

@@ -38,9 +38,9 @@ pub fn modifier_heuristic(
 
     // if the instruction is a JUMPI with non-zero CALLVALUE requirement, the function is
     // non-payable exactly: ISZERO(CALLVALUE())
-    if function.payable &&
-        state.last_instruction.opcode == JUMPI &&
-        state.last_instruction.input_operations[1] == w_iszero!(w_callvalue!())
+    if function.payable
+        && state.last_instruction.opcode == JUMPI
+        && state.last_instruction.input_operations[1] == w_iszero!(w_callvalue!())
     {
         debug!(
             "conditional at instruction {} indicates a non-payable function",

crates/decompile/src/utils/heuristics/solidity.rs

@@ -95,10 +95,10 @@ pub fn solidity_heuristic(
 
             // perform a series of checks to determine if the condition
             // is added by the compiler and can be ignored
-            if (conditional.contains("msg.data.length") && conditional.contains("0x04")) ||
-                VARIABLE_SIZE_CHECK_REGEX.is_match(&conditional).unwrap_or(false) ||
-                (conditional.replace('!', "") == "success") ||
-                (conditional == "!msg.value")
+            if (conditional.contains("msg.data.length") && conditional.contains("0x04"))
+                || VARIABLE_SIZE_CHECK_REGEX.is_match(&conditional).unwrap_or(false)
+                || (conditional.replace('!', "") == "success")
+                || (conditional == "!msg.value")
             {
                 return Ok(());
             }

crates/decompile/src/utils/heuristics/yul.rs

@@ -76,8 +76,8 @@ pub fn yul_heuristic(
         // CALLDATACOPY, CODECOPY, EXTCODECOPY, RETURNDATACOPY, TSTORE,
         // SSTORE, RETURN, SELFDESTRUCT, LOG0, LOG1, LOG2, LOG3, LOG4
         // we simply want to add the operation to the function's logic
-        0x37 | 0x39 | 0x3c | 0x3e | 0x55 | 0x5d | 0xf0 | 0xf1 | 0xf2 | 0xf4 | 0xf5 | 0xfa |
-        0xff | 0xA0 | 0xA1 | 0xA2 | 0xA3 | 0xA4 => {
+        0x37 | 0x39 | 0x3c | 0x3e | 0x55 | 0x5d | 0xf0 | 0xf1 | 0xf2 | 0xf4 | 0xf5 | 0xfa
+        | 0xff | 0xA0 | 0xA1 | 0xA2 | 0xA3 | 0xA4 => {
             function.logic.push(format!(
                 "{}({})",
                 opcode_name(instruction.opcode).to_lowercase(),