Support inbuilt devnet accounts

crates/sncast/src/helpers/account.rs

@@ -1,7 +1,14 @@
-use crate::NestedMap;
-use anyhow::Result;
+use crate::{
+    NestedMap, build_account, check_account_file_exists, helpers::devnet_provider::DevnetProvider,
+};
+use anyhow::{Result, ensure};
 use camino::Utf8PathBuf;
-use std::collections::HashSet;
+use starknet::{
+    accounts::SingleOwnerAccount,
+    providers::{JsonRpcClient, Provider, jsonrpc::HttpTransport},
+    signers::LocalWallet,
+};
+use std::collections::{HashMap, HashSet};
 use std::fs;
 
 use crate::{AccountData, read_and_parse_json_file};
@@ -48,3 +55,64 @@ pub fn load_accounts(accounts_file: &Utf8PathBuf) -> Result<Value> {
 
     Ok(accounts)
 }
+
+pub fn check_account_exists(
+    account_name: &str,
+    network_name: &str,
+    accounts_file: &Utf8PathBuf,
+) -> Result<bool> {
+    check_account_file_exists(accounts_file)?;
+
+    let accounts: HashMap<String, HashMap<String, AccountData>> =
+        read_and_parse_json_file(accounts_file)?;
+
+    accounts
+        .get(network_name)
+        .map(|network_accounts| network_accounts.contains_key(account_name))
+        .ok_or_else(|| {
+            anyhow::anyhow!("Network with name {network_name} does not exist in accounts file")
+        })
+}
+
+#[must_use]
+pub fn is_devnet_account(account: &str) -> bool {
+    account.starts_with("devnet-")
+}
+
+pub async fn get_account_from_devnet<'a>(
+    account: &str,
+    provider: &'a JsonRpcClient<HttpTransport>,
+    url: &str,
+) -> Result<SingleOwnerAccount<&'a JsonRpcClient<HttpTransport>, LocalWallet>> {
+    let account_number: u8 = account
+        .strip_prefix("devnet-")
+        .map(|s| s.parse::<u8>().expect("Invalid devnet account number"))
+        .context("Failed to parse devnet account number")?;
+
+    let devnet_provider = DevnetProvider::new(url);
+    devnet_provider.ensure_alive().await?;
+
+    let devnet_config = devnet_provider.get_config().await;
+    let devnet_config = match devnet_config {
+        Ok(config) => config,
+        Err(err) => {
+            return Err(err);
+        }
+    };
+
+    ensure!(
+        account_number <= devnet_config.total_accounts && account_number != 0,
+        "Devnet account number must be between 1 and {}",
+        devnet_config.total_accounts
+    );
+
+    let devnet_accounts = devnet_provider.get_predeployed_accounts().await?;
+    let predeployed_account = devnet_accounts
+        .get((account_number - 1) as usize)
+        .expect("Failed to get devnet account")
+        .to_owned();
+
+    let account_data = AccountData::from(predeployed_account);
+    let chain_id = provider.chain_id().await?;
+    build_account(account_data, chain_id, provider).await
+}

crates/sncast/src/helpers/devnet_provider.rs

@@ -0,0 +1,130 @@
+use crate::AccountData;
+use ::serde::{Deserialize, Serialize, de::DeserializeOwned};
+use anyhow::{Context, Error, ensure};
+use reqwest::Client;
+use serde_json::json;
+use starknet_types_core::felt::Felt;
+use url::Url;
+
+/// A Devnet-RPC client.
+#[derive(Debug, Clone)]
+pub struct DevnetProvider {
+    client: Client,
+    url: Url,
+}
+
+/// All Devnet-RPC methods as listed in the official docs.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum DevnetProviderMethod {
+    #[serde(rename = "devnet_getConfig")]
+    GetConfig,
+
+    #[serde(rename = "devnet_getPredeployedAccounts")]
+    GetPredeployedAccounts,
+}
+
+impl DevnetProvider {
+    #[must_use]
+    pub fn new(url: &str) -> Self {
+        let url = Url::parse(url).expect("Invalid URL");
+        Self {
+            client: Client::new(),
+            url,
+        }
+    }
+}
+
+impl DevnetProvider {
+    async fn send_request<P, R>(&self, method: DevnetProviderMethod, params: P) -> anyhow::Result<R>
+    where
+        P: Serialize + Send + Sync,
+        R: DeserializeOwned,
+    {
+        let res = self
+            .client
+            .post(self.url.clone())
+            .header("Content-Type", "application/json")
+            .json(&json!({
+                "jsonrpc": "2.0",
+                "method": method,
+                "params": params,
+                "id": 1,
+            }))
+            .send()
+            .await
+            .context("Failed to send request")?
+            .json::<serde_json::Value>()
+            .await
+            .context("Failed to parse response")?;
+
+        if let Some(error) = res.get("error") {
+            Err(anyhow::anyhow!(error.to_string()))
+        } else if let Some(result) = res.get("result") {
+            serde_json::from_value(result.clone()).map_err(anyhow::Error::from)
+        } else {
+            panic!("Malformed RPC response: {res}")
+        }
+    }
+
+    /// Fetches the current Devnet configuration.
+    pub async fn get_config(&self) -> Result<Config, Error> {
+        self.send_request(DevnetProviderMethod::GetConfig, json!({}))
+            .await
+    }
+
+    /// Fetches the list of predeployed accounts in Devnet.
+    pub async fn get_predeployed_accounts(&self) -> Result<Vec<PredeployedAccount>, Error> {
+        self.send_request(DevnetProviderMethod::GetPredeployedAccounts, json!({}))
+            .await
+    }
+
+    /// Ensures the Devnet instance is alive.
+    pub async fn ensure_alive(&self) -> Result<(), Error> {
+        let is_alive = self
+            .client
+            .get(format!(
+                "{}/is_alive",
+                self.url.to_string().replace("/rpc", "")
+            ))
+            .send()
+            .await
+            .map(|res| res.status().is_success())
+            .unwrap_or(false);
+
+        ensure!(
+            is_alive,
+            "Node at {} is not responding to the Devnet health check (GET `/is_alive`). It may not be a Devnet instance or it may be down.",
+            self.url
+        );
+        Ok(())
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Config {
+    pub seed: u32,
+    pub account_contract_class_hash: Felt,
+    pub total_accounts: u8,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PredeployedAccount {
+    pub address: Felt,
+    pub private_key: Felt,
+    pub public_key: Felt,
+}
+
+impl From<&PredeployedAccount> for AccountData {
+    fn from(predeployed_account: &PredeployedAccount) -> Self {
+        Self {
+            address: Some(predeployed_account.address),
+            private_key: predeployed_account.private_key,
+            public_key: predeployed_account.public_key,
+            class_hash: None,
+            salt: None,
+            deployed: None,
+            legacy: None,
+            account_type: None,
+        }
+    }
+}

crates/sncast/src/helpers/mod.rs

@@ -4,6 +4,7 @@ pub mod braavos;
 pub mod config;
 pub mod configuration;
 pub mod constants;
+pub mod devnet_provider;
 pub mod fee;
 pub mod interactive;
 pub mod output_format;

crates/sncast/src/helpers/rpc.rs

@@ -45,7 +45,7 @@ impl RpcArgs {
     }
 
     #[must_use]
-    fn get_url(&self, config_url: &String) -> Option<String> {
+    pub fn get_url(&self, config_url: &String) -> Option<String> {
         if let Some(network) = self.network {
             let free_provider = FreeProvider::semi_random();
             Some(network.url(&free_provider))

crates/sncast/src/lib.rs

@@ -1,10 +1,12 @@
+use crate::helpers::account::{check_account_exists, get_account_from_devnet, is_devnet_account};
 use crate::helpers::constants::{DEFAULT_STATE_FILE_SUFFIX, WAIT_RETRY_INTERVAL, WAIT_TIMEOUT};
 use crate::response::errors::SNCastProviderError;
 use anyhow::{Context, Error, Result, anyhow, bail};
 use camino::Utf8PathBuf;
 use clap::ValueEnum;
 use conversions::serde::serialize::CairoSerialize;
 use foundry_ui::UI;
+use foundry_ui::components::warning::WarningMessage;
 use helpers::constants::{KEYSTORE_PASSWORD_ENV_VAR, UDC_ADDRESS};
 use rand::RngCore;
 use rand::rngs::OsRng;
@@ -245,6 +247,37 @@ pub async fn get_nonce(
 }
 
 pub async fn get_account<'a>(
+    account: &str,
+    accounts_file: &Utf8PathBuf,
+    provider: &'a JsonRpcClient<HttpTransport>,
+    url: &str,
+    keystore: Option<&Utf8PathBuf>,
+    ui: &UI,
+) -> Result<SingleOwnerAccount<&'a JsonRpcClient<HttpTransport>, LocalWallet>> {
+    let chain_id = get_chain_id(provider).await?;
+    let network_name = chain_id_to_network_name(chain_id);
+    let is_devnet_account = is_devnet_account(account);
+    let exists_in_accounts_file = check_account_exists(account, &network_name, accounts_file)?;
+
+    match (is_devnet_account, exists_in_accounts_file) {
+        (true, true) => {
+            ui.println(&WarningMessage::new(format!(
+                "Using account {account} from accounts file {accounts_file}. \
+                 To use an inbuilt devnet account, please rename your existing account."
+            )));
+            ui.print_blank_line();
+            return get_account_from_accounts_file(account, accounts_file, provider, keystore)
+                .await;
+        }
+        (true, false) => return get_account_from_devnet(account, provider, url).await,
+        _ => {
+            return get_account_from_accounts_file(account, accounts_file, provider, keystore)
+                .await;
+        }
+    }
+}
+
+pub async fn get_account_from_accounts_file<'a>(
     account: &str,
     accounts_file: &Utf8PathBuf,
     provider: &'a JsonRpcClient<HttpTransport>,

crates/sncast/src/main.rs

@@ -266,14 +266,20 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
     match cli.command {
         Commands::Declare(declare) => {
             let provider = declare.rpc.get_provider(&config, ui).await?;
+            let url = declare
+                .rpc
+                .get_url(&config.url)
+                .context("Failed to get url")?;
 
             let rpc = declare.rpc.clone();
 
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
                 &provider,
+                &url,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
             let manifest_path = assert_manifest_path_exists()?;
@@ -320,11 +326,17 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             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 url = declare_from
+                .rpc
+                .get_url(&config.url)
+                .context("Failed to get url")?;
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
                 &provider,
+                &url,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
 
@@ -367,12 +379,15 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             } = deploy;
 
             let provider = rpc.get_provider(&config, ui).await?;
+            let url = rpc.get_url(&config.url).context("Failed to get url")?;
 
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
                 &provider,
+                &url,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
 
@@ -456,12 +471,15 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             } = invoke;
 
             let provider = rpc.get_provider(&config, ui).await?;
+            let url = rpc.get_url(&config.url).context("Failed to get url")?;
 
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
                 &provider,
+                &url,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
 

crates/sncast/src/starknet_commands/multicall/mod.rs

@@ -1,3 +1,4 @@
+use anyhow::Context;
 use clap::{Args, Subcommand};
 
 pub mod new;
@@ -50,12 +51,15 @@ pub async fn multicall(
         }
         starknet_commands::multicall::Commands::Run(run) => {
             let provider = run.rpc.get_provider(&config, ui).await?;
+            let url = run.rpc.get_url(&config.url).context("Failed to get url")?;
 
             let account = get_account(
                 &config.account,
                 &config.accounts_file,
                 &provider,
+                &url,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
             let result =

crates/sncast/src/starknet_commands/script/mod.rs

@@ -1,6 +1,7 @@
 use crate::starknet_commands::script::run::Run;
 use crate::{Cli, starknet_commands::script::init::Init};
 use crate::{get_cast_config, process_command_result, starknet_commands};
+use anyhow::Context;
 use clap::{Args, Subcommand};
 use foundry_ui::UI;
 use sncast::helpers::scarb_utils::{
@@ -78,12 +79,14 @@ pub fn run_script_command(
                 )))
             };
 
+            let url = run.rpc.get_url(&config.url).context("Failed to get url")?;
             let result = starknet_commands::script::run::run(
                 &run.script_name,
                 &metadata_with_deps,
                 &package_metadata,
                 &mut artifacts,
                 &provider,
+                &url,
                 runtime,
                 &config,
                 state_file_path,