Support inbuilt devnet accounts (#3761)

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

Towards #3603 

**Stack**:
- #3762
- #3761 ⬅
- #3760

## 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`

---------

Co-authored-by: Artur Michalek <[email protected]>
Co-authored-by: Artur Michałek <[email protected]>

Author: franciszekjob

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/lib.rs

@@ -1,10 +1,14 @@
+use crate::helpers::account::{check_account_exists, get_account_from_devnet, is_devnet_account};
+use crate::helpers::configuration::CastConfig;
 use crate::helpers::constants::{DEFAULT_STATE_FILE_SUFFIX, WAIT_RETRY_INTERVAL, WAIT_TIMEOUT};
+use crate::helpers::rpc::RpcArgs;
 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;
@@ -85,7 +89,7 @@ pub const MAINNET: Felt =
 pub const SEPOLIA: Felt =
     Felt::from_hex_unchecked(const_hex::const_encode::<10, true>(b"SN_SEPOLIA").as_str());
 
-#[derive(ValueEnum, Clone, Copy, Debug)]
+#[derive(ValueEnum, Clone, Copy, Debug, PartialEq)]
 pub enum Network {
     Mainnet,
     Sepolia,
@@ -245,6 +249,51 @@ pub async fn get_nonce(
 }
 
 pub async fn get_account<'a>(
+    config: &CastConfig,
+    provider: &'a JsonRpcClient<HttpTransport>,
+    rpc_args: &RpcArgs,
+    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 account = &config.account;
+    let is_devnet_account = is_devnet_account(account);
+
+    if is_devnet_account
+        && let Some(network) = rpc_args.network
+        && (network == Network::Mainnet || network == Network::Sepolia)
+    {
+        bail!(format!(
+            "Devnet accounts cannot be used with `--network {network}`"
+        ));
+    }
+
+    let accounts_file = &config.accounts_file;
+    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 or use an account with a different number."
+            )));
+            ui.print_blank_line();
+            return get_account_from_accounts_file(account, accounts_file, provider, keystore)
+                .await;
+        }
+        (true, false) => {
+            let url = rpc_args.get_url(&config.url).context("Failed to get url")?;
+            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

@@ -269,10 +269,11 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
             let rpc = declare.rpc.clone();
 
             let account = get_account(
-                &config.account,
-                &config.accounts_file,
+                &config,
                 &provider,
+                &declare.rpc,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
             let manifest_path = assert_manifest_path_exists()?;
@@ -347,11 +348,13 @@ 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 account = get_account(
-                &config.account,
-                &config.accounts_file,
+                &config,
                 &provider,
+                &declare_from.rpc,
                 config.keystore.as_ref(),
+                ui,
             )
             .await?;
 
@@ -395,13 +398,8 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
 
             let provider = rpc.get_provider(&config, ui).await?;
 
-            let account = get_account(
-                &config.account,
-                &config.accounts_file,
-                &provider,
-                config.keystore.as_ref(),
-            )
-            .await?;
+            let account =
+                get_account(&config, &provider, &rpc, config.keystore.as_ref(), ui).await?;
 
             // safe to unwrap because "constructor" is a standardized name
             let selector = get_selector_from_name("constructor").unwrap();
@@ -484,13 +482,8 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
 
             let provider = rpc.get_provider(&config, ui).await?;
 
-            let account = get_account(
-                &config.account,
-                &config.accounts_file,
-                &provider,
-                config.keystore.as_ref(),
-            )
-            .await?;
+            let account =
+                get_account(&config, &provider, &rpc, config.keystore.as_ref(), ui).await?;
 
             let selector = get_selector_from_name(&function)
                 .context("Failed to convert entry point selector to FieldElement")?;

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

@@ -51,13 +51,8 @@ pub async fn multicall(
         starknet_commands::multicall::Commands::Run(run) => {
             let provider = run.rpc.get_provider(&config, ui).await?;
 
-            let account = get_account(
-                &config.account,
-                &config.accounts_file,
-                &provider,
-                config.keystore.as_ref(),
-            )
-            .await?;
+            let account =
+                get_account(&config, &provider, &run.rpc, config.keystore.as_ref(), ui).await?;
             let result =
                 starknet_commands::multicall::run::run(run.clone(), &account, wait_config, ui)
                     .await;

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,

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

@@ -284,6 +284,7 @@ pub fn run(
     package_metadata: &PackageMetadata,
     artifacts: &mut HashMap<String, StarknetContractArtifacts>,
     provider: &JsonRpcClient<HttpTransport>,
+    url: &str,
     tokio_runtime: Runtime,
     config: &CastConfig,
     state_file_path: Option<Utf8PathBuf>,
@@ -364,11 +365,16 @@ pub fn run(
     let account = if config.account.is_empty() {
         None
     } else {
+        let rpc_args = RpcArgs {
+            url: Some(url.to_string()),
+            network: None,
+        };
         Some(tokio_runtime.block_on(get_account(
-            &config.account,
-            &config.accounts_file,
+            config,
             provider,
+            &rpc_args,
             config.keystore.as_ref(),
+            ui,
         ))?)
     };
     let state = StateManager::from(state_file_path)?;

crates/sncast/tests/data/accounts/accounts.json

@@ -140,6 +140,11 @@
             "public_key": "0x36a64f9d432cce317c3e50bc467d48f2797463babe8f29c83c2e6125ddd1947",
             "salt": "0x25e7144fce03d200",
             "type": "open_zeppelin"
+        },
+        "devnet-1": {
+            "private_key": "0x0000000000000000000000000000000056c12e097e49ea382ca8eadec0839401",
+            "public_key": "0x048234b9bc6c1e749f4b908d310d8c53dae6564110b05ccf79016dca8ce7dfac",
+            "address": "0x06f4621e7ad43707b3f69f9df49425c3d94fdc5ab2e444bfa0e7e4edeff7992d"
         }
     }
 }