Implement declare-from (#3727)

<!-- Reference any GitHub issues resolved by this PR -->

Towards #3587

**Stack**:
- #3729
- #3727 ⬅
- #3726

## Introduced changes

Add `sncast declare-from` command

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [ ] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

Author: franciszekjob

Cargo.lock

@@ -57,6 +57,7 @@ dialoguer.workspace = true
 toml_edit.workspace = true
 num-traits.workspace = true
 foundry-ui = { path = "../foundry-ui" }
+universal-sierra-compiler-api = { path = "../universal-sierra-compiler-api" }
 
 [dev-dependencies]
 ctor.workspace = true

crates/sncast/Cargo.toml

@@ -1,3 +1,4 @@
+use crate::starknet_commands::declare_from::DeclareFrom;
 use crate::starknet_commands::deploy::DeployArguments;
 use crate::starknet_commands::multicall;
 use crate::starknet_commands::script::run_script_command;
@@ -118,6 +119,9 @@ enum Commands {
     /// Declare a contract
     Declare(Declare),
 
+    /// Declare a contract by fetching it from a different Starknet instance
+    DeclareFrom(DeclareFrom),
+
     /// Deploy a contract
     Deploy(Deploy),
 
@@ -284,6 +288,48 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             Ok(())
         }
 
+        Commands::DeclareFrom(declare_from) => {
+            let provider = declare_from.rpc.get_provider(&config, ui).await?;
+            let rpc_args = declare_from.rpc.clone();
+            let source_provider = declare_from.source_rpc.get_provider(ui).await?;
+            let account = get_account(
+                &config.account,
+                &config.accounts_file,
+                &provider,
+                config.keystore.as_ref(),
+            )
+            .await?;
+
+            let result = starknet_commands::declare_from::declare_from(
+                declare_from,
+                &account,
+                wait_config,
+                false,
+                &source_provider,
+                ui,
+            )
+            .await
+            .map_err(handle_starknet_command_error)
+            .map(|result| match result {
+                DeclareResponse::Success(declare_transaction_response) => {
+                    declare_transaction_response
+                }
+                DeclareResponse::AlreadyDeclared(_) => {
+                    unreachable!("Argument `skip_on_already_declared` is false")
+                }
+            });
+
+            let block_explorer_link = block_explorer_link_if_allowed(
+                &result,
+                provider.chain_id().await?,
+                &rpc_args,
+                &config,
+            );
+            process_command_result("declare-from", result, ui, block_explorer_link);
+
+            Ok(())
+        }
+
         Commands::Deploy(deploy) => {
             let Deploy {
                 arguments,

crates/sncast/src/main.rs

@@ -0,0 +1,154 @@
+use crate::starknet_commands::declare::declare_with_artifacts;
+use anyhow::{Context, Result};
+use clap::Args;
+use foundry_ui::UI;
+use shared::verify_and_warn_if_incompatible_rpc_version;
+use sncast::helpers::fee::FeeArgs;
+use sncast::helpers::rpc::{FreeProvider, RpcArgs};
+use sncast::response::declare::DeclareResponse;
+use sncast::response::errors::{SNCastProviderError, StarknetCommandError};
+use sncast::{Network, WaitForTx, get_block_id, get_provider};
+use starknet::accounts::SingleOwnerAccount;
+use starknet::core::types::contract::{AbiEntry, CompiledClass, SierraClass, SierraClassDebugInfo};
+use starknet::core::types::{ContractClass, FlattenedSierraClass};
+use starknet::providers::Provider;
+use starknet::providers::jsonrpc::{HttpTransport, JsonRpcClient};
+use starknet::signers::LocalWallet;
+use starknet_types_core::felt::Felt;
+use universal_sierra_compiler_api::{SierraType, compile_sierra};
+
+#[derive(Args)]
+#[command(about = "Declare a contract by fetching it from a different Starknet instance", long_about = None)]
+pub struct DeclareFrom {
+    /// Class hash of contract declared on a different Starknet instance
+    #[arg(short = 'g', long)]
+    pub class_hash: Felt,
+
+    #[command(flatten)]
+    pub fee_args: FeeArgs,
+
+    /// Nonce of the transaction. If not provided, nonce will be set automatically
+    #[arg(short, long)]
+    pub nonce: Option<Felt>,
+
+    #[command(flatten)]
+    pub source_rpc: SourceRpcArgs,
+
+    #[command(flatten)]
+    pub rpc: RpcArgs,
+
+    /// Block identifier from which the contract will be fetched.
+    /// Possible values: `pre_confirmed`, `latest`, block hash (0x prefixed string)
+    /// and block number (u64)
+    #[arg(short, long, default_value = "latest")]
+    pub block_id: String,
+}
+
+#[derive(Args, Clone, Debug, Default)]
+#[group(required = false, multiple = false)]
+pub struct SourceRpcArgs {
+    /// RPC provider url address
+    #[arg(short, long)]
+    pub source_url: Option<String>,
+
+    /// Use predefined network with a public provider. Note that this option may result in rate limits or other unexpected behavior
+    #[arg(long)]
+    pub source_network: Option<Network>,
+}
+
+impl SourceRpcArgs {
+    pub async fn get_provider(&self, ui: &UI) -> Result<JsonRpcClient<HttpTransport>> {
+        let url = self
+            .get_url()
+            .context("Either `--source-network` or `--source-url` must be provided")?;
+
+        assert!(!url.is_empty(), "url cannot be empty");
+
+        let provider = get_provider(&url)?;
+        verify_and_warn_if_incompatible_rpc_version(&provider, url, ui).await?;
+
+        Ok(provider)
+    }
+
+    #[must_use]
+    fn get_url(&self) -> Option<String> {
+        if let Some(network) = self.source_network {
+            let free_provider = FreeProvider::semi_random();
+            Some(network.url(&free_provider))
+        } else {
+            self.source_url
+                .as_ref()
+                .map(std::string::ToString::to_string)
+        }
+    }
+}
+
+pub async fn declare_from(
+    declare_from: DeclareFrom,
+    account: &SingleOwnerAccount<&JsonRpcClient<HttpTransport>, LocalWallet>,
+    wait_config: WaitForTx,
+    skip_on_already_declared: bool,
+    source_provider: &JsonRpcClient<HttpTransport>,
+    ui: &UI,
+) -> Result<DeclareResponse, StarknetCommandError> {
+    let block_id = get_block_id(&declare_from.block_id)?;
+    let class = source_provider
+        .get_class(block_id, declare_from.class_hash)
+        .await
+        .map_err(SNCastProviderError::from)
+        .map_err(StarknetCommandError::from)?;
+
+    let flattened_sierra = match class {
+        ContractClass::Sierra(class) => class,
+        ContractClass::Legacy(_) => {
+            return Err(StarknetCommandError::UnknownError(anyhow::anyhow!(
+                "Declaring from Cairo 0 (legacy) contracts is not supported"
+            )));
+        }
+    };
+    let sierra: SierraClass = flattened_sierra_to_sierra(flattened_sierra)
+        .expect("Failed to parse flattened sierra class");
+
+    let casm_json: String = compile_sierra(
+        &serde_json::to_value(&sierra).expect("Failed to convert sierra to json value"),
+        &SierraType::Contract,
+    )
+    .expect("Failed to compile sierra to casm");
+    let casm: CompiledClass = serde_json::from_str(&casm_json)
+        .expect("Failed to deserialize casm JSON into CompiledClass");
+    let sierra_class_hash = sierra.class_hash().map_err(anyhow::Error::from)?;
+
+    if declare_from.class_hash != sierra_class_hash {
+        return Err(StarknetCommandError::UnknownError(anyhow::anyhow!(
+            "The provided sierra class hash {:#x} does not match the computed class hash {:#x} from the fetched contract.",
+            declare_from.class_hash,
+            sierra_class_hash
+        )));
+    }
+
+    declare_with_artifacts(
+        sierra,
+        casm,
+        declare_from.fee_args,
+        declare_from.nonce,
+        account,
+        wait_config,
+        skip_on_already_declared,
+        ui,
+    )
+    .await
+}
+
+fn flattened_sierra_to_sierra(class: FlattenedSierraClass) -> Result<SierraClass> {
+    Ok(SierraClass {
+        sierra_program: class.sierra_program,
+        sierra_program_debug_info: SierraClassDebugInfo {
+            type_names: vec![],
+            libfunc_names: vec![],
+            user_func_names: vec![],
+        },
+        contract_class_version: class.contract_class_version,
+        entry_points_by_type: class.entry_points_by_type,
+        abi: serde_json::from_str::<Vec<AbiEntry>>(&class.abi)?,
+    })
+}

crates/sncast/src/starknet_commands/declare_from.rs

@@ -1,6 +1,7 @@
 pub mod account;
 pub mod call;
 pub mod declare;
+pub mod declare_from;
 pub mod deploy;
 pub mod invoke;
 pub mod multicall;