[CLI] format code

cast/src/lib.rs

@@ -264,14 +264,13 @@ fn write_to_output<T: std::fmt::Display>(value: T, error: bool) {
 }
 
 pub fn parse_number(number_as_str: &str) -> Result<FieldElement> {
-  let contract_address = match &number_as_str[..2] {
-      "0x" => FieldElement::from_hex_be(number_as_str)?,
-      _ => FieldElement::from_dec_str(number_as_str)?,
-  };
-  Ok(contract_address)
+    let contract_address = match &number_as_str[..2] {
+        "0x" => FieldElement::from_hex_be(number_as_str)?,
+        _ => FieldElement::from_dec_str(number_as_str)?,
+    };
+    Ok(contract_address)
 }
 
-
 #[cfg(test)]
 mod tests {
     use crate::{get_account, get_block_id, get_network, get_provider, Network};

cast/src/main.rs

@@ -65,7 +65,8 @@ enum Commands {
 async fn main() -> Result<()> {
     let cli = Cli::parse();
 
-    let accounts_file_path = Utf8PathBuf::from(shellexpand::tilde(&cli.accounts_file_path).to_string());
+    let accounts_file_path =
+        Utf8PathBuf::from(shellexpand::tilde(&cli.accounts_file_path).to_string());
     if !&accounts_file_path.exists() {
         bail! {"Accounts file {} does not exist! Make sure to supply correct path to accounts file.", cli.accounts_file_path}
     }
@@ -79,8 +80,7 @@ async fn main() -> Result<()> {
 
     match cli.command {
         Commands::Declare(declare) => {
-            let mut account =
-                get_account(&cli.account, &accounts_file_path, &provider, &network)?;
+            let mut account = get_account(&cli.account, &accounts_file_path, &provider, &network)?;
 
             let result = starknet_commands::declare::declare(
                 &declare.contract,
@@ -190,8 +190,7 @@ async fn main() -> Result<()> {
             Ok(())
         }
         Commands::Invoke(invoke) => {
-            let mut account =
-                get_account(&cli.account, &accounts_file_path, &provider, &network)?;
+            let mut account = get_account(&cli.account, &accounts_file_path, &provider, &network)?;
             let result = starknet_commands::invoke::invoke(
                 &invoke.contract_address,
                 &invoke.entry_point_name,

cast/src/starknet_commands/call.rs

@@ -43,9 +43,7 @@ pub async fn call(
             .context("Failed to convert entry point selector to FieldElement")?,
         calldata: calldata
             .iter()
-            .map(|x| {
-                parse_number(x).context("Failed to convert calldata to FieldElement")
-            })
+            .map(|x| parse_number(x).context("Failed to convert calldata to FieldElement"))
             .collect::<Result<Vec<_>>>()?,
     };
     let res = provider.call(function_call, block_id).await;

cast/src/starknet_commands/declare.rs

@@ -67,18 +67,21 @@ pub async fn declare(
         .stderr(Stdio::piped())
         .output()
         .context("Failed to start building contracts with Scarb")?;
-    let result_code = command_result.status.code().context("failed to obtain status code from scarb build")?;
+    let result_code = command_result
+        .status
+        .code()
+        .context("failed to obtain status code from scarb build")?;
     if result_code != 0 {
         anyhow::bail!("scarb build returned non-zero exit code: {}", result_code);
     }
 
     // TODO #2141 improve handling starknet artifacts
     // TODO #2154 consider using `scarb manifest-path` instead of current_dir
     let current_dir = std::env::current_dir()
-                .context("Failed to get current directory")?
-                .join("target/release");
+        .context("Failed to get current directory")?
+        .join("target/release");
     let mut paths = std::fs::read_dir(&current_dir)
-            .context("Failed to read ./target/release, scarb build probably failed")?;
+        .context("Failed to read ./target/release, scarb build probably failed")?;
 
     let starknet_artifacts = &paths
         .find_map(|path| match path {
@@ -95,34 +98,70 @@ pub async fn declare(
         serde_json::from_str(starknet_artifacts.as_str())
             .context("Failed to parse starknet_artifacts.json contents")?;
 
-    let sierra_path = starknet_artifacts.contracts.iter().find_map(|contract| {
-        if contract.contract_name == contract_name {
-            return Some(contract.artifacts.sierra.clone());
-        }
-        None
-    }).unwrap_or_else(|| panic!("Failed to find contract {contract_name} in starknet_artifacts.json"));
+    let sierra_path = starknet_artifacts
+        .contracts
+        .iter()
+        .find_map(|contract| {
+            if contract.contract_name == contract_name {
+                return Some(contract.artifacts.sierra.clone());
+            }
+            None
+        })
+        .unwrap_or_else(|| {
+            panic!("Failed to find contract {contract_name} in starknet_artifacts.json")
+        });
     let sierra_contract_path = current_dir.join(sierra_path);
 
-    let casm_path = starknet_artifacts.contracts.iter().find_map(|contract| {
-        if contract.contract_name == contract_name {
-            return Some(contract.artifacts.casm.clone());
-        }
-        None
-    }).unwrap_or_else(|| panic!("Failed to find contract {contract_name} in starknet_artifacts.json")).unwrap();
+    let casm_path = starknet_artifacts
+        .contracts
+        .iter()
+        .find_map(|contract| {
+            if contract.contract_name == contract_name {
+                return Some(contract.artifacts.casm.clone());
+            }
+            None
+        })
+        .unwrap_or_else(|| {
+            panic!("Failed to find contract {contract_name} in starknet_artifacts.json")
+        })
+        .unwrap();
     let casm_contract_path = current_dir.join(casm_path);
 
     let contract_definition: SierraClass = {
-        let file_contents = std::fs::read(sierra_contract_path.clone())
-            .with_context(|| format!("Failed to read contract file: {}", sierra_contract_path.to_str().expect("failed to convert sierra_contract_path to string")))?;
+        let file_contents = std::fs::read(sierra_contract_path.clone()).with_context(|| {
+            format!(
+                "Failed to read contract file: {}",
+                sierra_contract_path
+                    .to_str()
+                    .expect("failed to convert sierra_contract_path to string")
+            )
+        })?;
         serde_json::from_slice(&file_contents).with_context(|| {
-            format!("Failed to parse contract definition: {}", sierra_contract_path.to_str().expect("failed to convert sierra_contract_path to string"))
+            format!(
+                "Failed to parse contract definition: {}",
+                sierra_contract_path
+                    .to_str()
+                    .expect("failed to convert sierra_contract_path to string")
+            )
         })?
     };
     let casm_contract_definition: CompiledClass = {
-        let file_contents = std::fs::read(casm_contract_path.clone())
-            .with_context(|| format!("Failed to read contract file: {}", casm_contract_path.to_str().expect("failed to convert casm_contract_path to string")))?;
-        serde_json::from_slice(&file_contents)
-            .with_context(|| format!("Failed to parse contract definition: {}", casm_contract_path.to_str().expect("failed to convert casm_contract_path to string")))?
+        let file_contents = std::fs::read(casm_contract_path.clone()).with_context(|| {
+            format!(
+                "Failed to read contract file: {}",
+                casm_contract_path
+                    .to_str()
+                    .expect("failed to convert casm_contract_path to string")
+            )
+        })?;
+        serde_json::from_slice(&file_contents).with_context(|| {
+            format!(
+                "Failed to parse contract definition: {}",
+                casm_contract_path
+                    .to_str()
+                    .expect("failed to convert casm_contract_path to string")
+            )
+        })?
     };
 
     let casm_class_hash = casm_contract_definition.class_hash()?;

cast/src/starknet_commands/invoke.rs

@@ -44,9 +44,7 @@ pub async fn invoke(
         selector: get_selector_from_name(entry_point_name)?,
         calldata: calldata
             .iter()
-            .map(|cd| {
-                parse_number(cd).context("Failed to convert calldata to FieldElement")
-            })
+            .map(|cd| parse_number(cd).context("Failed to convert calldata to FieldElement"))
             .collect::<Result<Vec<_>>>()?,
     };
     let execution = account.execute(vec![call]);

cast/tests/e2e/helpers/fixtures.rs

@@ -21,17 +21,15 @@ pub async fn declare_deploy_simple_balance_contract() {
     .expect("Could not get the account");
 
     let contract_definition: SierraClass = {
-        let file_contents = std::fs::read(
-            CONTRACTS_DIR.to_string() + "/map/target/dev/map_Map.sierra.json",
-        )
-        .expect("Could not read balance's sierra file");
+        let file_contents =
+            std::fs::read(CONTRACTS_DIR.to_string() + "/map/target/dev/map_Map.sierra.json")
+                .expect("Could not read balance's sierra file");
         serde_json::from_slice(&file_contents).expect("Could not cast sierra file to SierraClass")
     };
     let casm_contract_definition: CompiledClass = {
-        let file_contents = std::fs::read(
-            CONTRACTS_DIR.to_string() + "/map/target/dev/map_Map.casm.json",
-        )
-        .expect("Could not read balance's casm file");
+        let file_contents =
+            std::fs::read(CONTRACTS_DIR.to_string() + "/map/target/dev/map_Map.casm.json")
+                .expect("Could not read balance's casm file");
         serde_json::from_slice(&file_contents).expect("Could not cast casm file to CompiledClass")
     };