Build with scarb for declare

cast/Cargo.toml

@@ -15,6 +15,7 @@ starknet = { git = "https://github.com/xJonathanLEI/starknet-rs" }
 tokio = { version = "1.28.2", features = ["full"] }
 url = "2.2.2"
 rand = "0.8.5"
+scarb-metadata = "1.4.2"
 
 [dev-dependencies]
 ctor = "0.2.2"

cast/src/lib.rs

@@ -105,7 +105,7 @@ pub fn get_account<'a>(
             &account_info.address
         )
     })?;
-    let mut account = SingleOwnerAccount::new(provider, signer, address, network.get_chain_id());
+    let account = SingleOwnerAccount::new(provider, signer, address, network.get_chain_id());
 
     Ok(account)
 }

cast/src/main.rs

@@ -4,6 +4,8 @@ use camino::Utf8PathBuf;
 use cast::{get_account, get_block_id, get_network, get_provider, print_formatted};
 use clap::{Parser, Subcommand};
 use console::style;
+use scarb_metadata;
+use std::env::current_dir;
 
 mod starknet_commands;
 
@@ -24,6 +26,7 @@ struct Cli {
     account: String,
 
     /// Path to the file holding accounts info, defaults to ~/.starknet_accounts/starknet_open_zeppelin_accounts.json
+    // TODO #2147
     #[clap(
         short = 'f',
         long = "accounts-file",
@@ -57,12 +60,36 @@ enum Commands {
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
-
-    // todo: #2052 take network from scarb config if flag not provided
-    let network_name = cli.network.unwrap_or_else(|| {
+    let mut maybe_network_name = None;
+    if let Some(network_name) = cli.network {
+        maybe_network_name = Some(network_name);
+    } else {
+        let metadata = scarb_metadata::MetadataCommand::new()
+            .inherit_stderr()
+            .current_dir(current_dir().expect("failed to read current directory"))
+            .no_deps()
+            .exec()
+            .unwrap();
+        if metadata.packages.len() != 1 {
+            anyhow::bail!("invalid number of packages obtained from scarb metadata");
+        }
+        let package = &metadata.packages[0];
+        if let Some(tool) = &package.manifest_metadata.tool {
+            if let Some(protostar_tool) = tool.get("protostar") {
+                if let Some(network) = protostar_tool.get("network") {
+                    if let Some(network_str) = network.as_str() {
+                        maybe_network_name = Some(network_str.to_string());
+                    }
+                }
+            }
+        }
+    }
+    if maybe_network_name.is_none() {
+        // todo: #2107
         eprintln!("{}", style("No --network flag passed!").red());
         std::process::exit(1);
-    });
+    };
+    let network_name = maybe_network_name.expect("Could not find network neither in args nor in scarb config");
     let network = get_network(&network_name)?;
     let provider = get_provider(&cli.rpc_url)?;
 
@@ -72,8 +99,7 @@ async fn main() -> Result<()> {
                 get_account(&cli.account, &cli.accounts_file_path, &provider, &network)?;
 
             let declared_contract = starknet_commands::declare::declare(
-                &declare.sierra_contract_path,
-                &declare.casm_contract_path,
+                &declare.contract,
                 declare.max_fee,
                 &mut account,
             )

cast/src/starknet_commands/call.rs

@@ -6,15 +6,15 @@ use starknet::core::utils::get_selector_from_name;
 use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::{JsonRpcClient, Provider};
 
+use crate::starknet_commands::helpers::parse_number;
+
 #[derive(Args)]
 #[command(about = "Call a contract instance on Starknet", long_about = None)]
 pub struct Call {
     /// Address of the called contract (hex)
-    #[clap(short = 'a', long = "contract-address")]
     pub contract_address: String,
 
     /// Name of the contract function to be called
-    #[clap(short = 'f', long = "function-name")]
     pub function_name: String,
 
     /// Arguments of the called function (list of hex)
@@ -36,14 +36,13 @@ pub async fn call(
     block_id: &BlockId,
 ) -> Result<Vec<FieldElement>> {
     let function_call = FunctionCall {
-        contract_address: FieldElement::from_hex_be(contract_address)
-            .context("Failed to convert contract address to FieldElement")?,
+        contract_address: parse_number(contract_address)?,
         entry_point_selector: get_selector_from_name(func_name)
             .context("Failed to convert entry point selector to FieldElement")?,
         calldata: calldata
             .iter()
             .map(|x| {
-                FieldElement::from_hex_be(x).context("Failed to convert calldata to FieldElement")
+                parse_number(x).context("Failed to convert calldata to FieldElement")
             })
             .collect::<Result<Vec<_>>>()?,
     };

cast/src/starknet_commands/declare.rs

@@ -15,41 +15,112 @@ use starknet::{
     signers::LocalWallet,
 };
 use std::sync::Arc;
+use std::process::{Command, Stdio};
+use serde::Deserialize;
+use std::path::PathBuf;
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+struct ScarbStarknetArtifacts {
+    version: u32,
+    contracts: Vec<ScarbStarknetContract>,
+}
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+struct ScarbStarknetContract {
+    id: String,
+    package_name: String,
+    contract_name: String,
+    artifacts: ScarbStarknetContractArtifact,
+}
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+struct ScarbStarknetContractArtifact {
+    sierra: PathBuf,
+    casm: Option<PathBuf>,
+}
 
 #[derive(Args)]
 #[command(about = "Declare a contract to starknet", long_about = None)]
 pub struct Declare {
-    /// Path to the sierra compiled contract
-    #[clap(short = 's', long = "sierra-contract-path")]
-    pub sierra_contract_path: Utf8PathBuf,
-
-    /// Path to the casm compiled contract
-    #[clap(short = 'c', long = "casm-contract-path")]
-    pub casm_contract_path: Utf8PathBuf,
+    /// contract name
+    pub contract: String,
 
     /// Max fee for the transaction. If not provided, max fee will be automatically estimated
     #[clap(short, long)]
     pub max_fee: Option<u128>,
 }
 
 pub async fn declare(
-    sierra_contract_path: &Utf8PathBuf,
-    casm_contract_path: &Utf8PathBuf,
+    contract_name: &str,
     max_fee: Option<u128>,
     account: &mut SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
 ) -> Result<DeclareTransactionResult> {
+    let contract_name: String = contract_name.to_string();
+    let command_result = Command::new("scarb")
+        .current_dir(std::env::current_dir().context("Failed to obtain current dir")?)
+        .arg("build")
+        .stdout(Stdio::piped())
+        .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")?;
+    if result_code != 0 {
+        anyhow::bail!("scarb build returned non-zero exit code: {}", result_code);
+    }
+
+    // TODO #2141 improve handling starknet artifacts
+    let current_dir = std::env::current_dir()
+                .context("Failed to get current directory")?
+                .join("target/dev");
+    let mut paths = std::fs::read_dir(&current_dir)
+            .context("Failed to read ./target/dev, scarb build probably failed")?;
+
+    let starknet_artifacts = &paths
+        .find_map(|path| match path {
+            Ok(path) => {
+                let name = path.file_name().into_string().ok()?;
+                name.contains("starknet_artifacts").then_some(path)
+            }
+            Err(_) => None,
+        })
+        .context("Failed to find starknet_artifacts.json file")?;
+    let starknet_artifacts = std::fs::read_to_string(starknet_artifacts.path())
+        .context("Failed to read starknet_artifacts.json contents")?;
+    let starknet_artifacts: ScarbStarknetArtifacts =
+        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_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_contract_path = current_dir.join(casm_path);
+
     let contract_definition: SierraClass = {
-        let file_contents = std::fs::read(sierra_contract_path)
-            .with_context(|| format!("Failed to read contract file: {sierra_contract_path}"))?;
+        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}")
+            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)
-            .with_context(|| format!("Failed to read contract file: {casm_contract_path}"))?;
+        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}"))?
+            .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/helpers.rs

@@ -0,0 +1,10 @@
+use starknet::core::types::FieldElement;
+use anyhow::Result;
+
+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)
+}

cast/src/starknet_commands/invoke.rs

@@ -10,15 +10,15 @@ use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::JsonRpcClient;
 use starknet::signers::LocalWallet;
 
+use crate::starknet_commands::helpers::parse_number;
+
 #[derive(Args)]
 #[command(about = "Invoke a contract on Starknet")]
 pub struct Invoke {
     /// Address of contract to invoke
-    #[clap(short = 'a', long)]
     pub contract_address: String,
 
     /// Name of the function to invoke
-    #[clap(short, long)]
     pub entry_point_name: String,
 
     /// Calldata for the invoked function
@@ -38,12 +38,12 @@ pub async fn invoke(
     account: &mut SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
 ) -> Result<FieldElement> {
     let call = Call {
-        to: FieldElement::from_hex_be(contract_address)?,
+        to: parse_number(contract_address)?,
         selector: get_selector_from_name(entry_point_name)?,
         calldata: calldata
             .iter()
             .map(|cd| {
-                FieldElement::from_hex_be(cd).context("Failed to convert calldata to FieldElement")
+                parse_number(cd).context("Failed to convert calldata to FieldElement")
             })
             .collect::<Result<Vec<_>>>()?,
     };

cast/src/starknet_commands/mod.rs

@@ -1,3 +1,5 @@
+mod helpers;
+
 pub mod call;
 pub mod declare;
 pub mod deploy;