Predeclare Argent accounts (#658)

Author: FabijanC

crates/starknet-devnet-core/contracts/accounts_artifacts/Argent/argent_0.4.0.sierra

@@ -51,6 +51,24 @@ pub(crate) const UDC_CONTRACT: &str = include_str!(concat!(
     "/contracts/system_artifacts/UDC_OZ_0.5.0.json"
 ));
 
+/// https://github.com/argentlabs/argent-contracts-starknet/blob/main/deployments/account.txt
+pub const ARGENT_CONTRACT_VERSION: &str = "0.4.0";
+pub(crate) const ARGENT_CONTRACT_SIERRA: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/contracts/accounts_artifacts/Argent/argent_0.4.0.sierra"
+));
+pub const ARGENT_CONTRACT_CLASS_HASH: Felt =
+    Felt::from_hex_unchecked("0x36078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f");
+
+/// https://github.com/argentlabs/argent-contracts-starknet/blob/main/deployments/multisig.txt
+pub const ARGENT_MULTISIG_CONTRACT_VERSION: &str = "0.2.0";
+pub(crate) const ARGENT_MULTISIG_CONTRACT_SIERRA: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/contracts/accounts_artifacts/Argent/argent_multisig_0.2.0.sierra"
+));
+pub const ARGENT_MULTISIG_CONTRACT_CLASS_HASH: Felt =
+    Felt::from_hex_unchecked("0x7aeca3456816e3b833506d7cc5c1313d371fbdb0ae95ee70af72a4ddbf42594");
+
 pub const UDC_CONTRACT_CLASS_HASH: Felt =
     Felt::from_hex_unchecked("0x7B3E05F48F0C69E4A65CE5E076A66271A527AFF2C34CE1083EC6E1526997A69");
 

crates/starknet-devnet-core/contracts/accounts_artifacts/Argent/argent_multisig_0.2.0.sierra

@@ -60,10 +60,11 @@ use self::transaction_trace::create_trace;
 use crate::account::Account;
 use crate::blocks::{StarknetBlock, StarknetBlocks};
 use crate::constants::{
-    CHARGEABLE_ACCOUNT_ADDRESS, CHARGEABLE_ACCOUNT_PRIVATE_KEY, DEVNET_DEFAULT_CHAIN_ID,
-    DEVNET_DEFAULT_DATA_GAS_PRICE, DEVNET_DEFAULT_GAS_PRICE, DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
-    ETH_ERC20_CONTRACT_ADDRESS, ETH_ERC20_NAME, ETH_ERC20_SYMBOL, STRK_ERC20_CONTRACT_ADDRESS,
-    STRK_ERC20_NAME, STRK_ERC20_SYMBOL, USE_KZG_DA,
+    ARGENT_CONTRACT_CLASS_HASH, ARGENT_CONTRACT_SIERRA, ARGENT_MULTISIG_CONTRACT_CLASS_HASH,
+    ARGENT_MULTISIG_CONTRACT_SIERRA, CHARGEABLE_ACCOUNT_ADDRESS, CHARGEABLE_ACCOUNT_PRIVATE_KEY,
+    DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_DATA_GAS_PRICE, DEVNET_DEFAULT_GAS_PRICE,
+    DEVNET_DEFAULT_STARTING_BLOCK_NUMBER, ETH_ERC20_CONTRACT_ADDRESS, ETH_ERC20_NAME,
+    ETH_ERC20_SYMBOL, STRK_ERC20_CONTRACT_ADDRESS, STRK_ERC20_NAME, STRK_ERC20_SYMBOL, USE_KZG_DA,
 };
 use crate::contract_class_choice::AccountContractClassChoice;
 use crate::error::{DevnetResult, Error, TransactionValidationError};
@@ -151,7 +152,7 @@ impl Starknet {
         let rpc_contract_classes = Arc::new(RwLock::new(CommittedClassStorage::default()));
         let mut state = StarknetState::new(defaulter, rpc_contract_classes.clone());
 
-        // predeclare account classes
+        // predeclare account classes eligible for predeployment
         for account_class_choice in
             [AccountContractClassChoice::Cairo0, AccountContractClassChoice::Cairo1]
         {
@@ -162,6 +163,18 @@ impl Starknet {
             )?;
         }
 
+        // predeclare argent account classes (not predeployable)
+        if config.predeclare_argent {
+            for (class_hash, raw_sierra) in [
+                (ARGENT_CONTRACT_CLASS_HASH, ARGENT_CONTRACT_SIERRA),
+                (ARGENT_MULTISIG_CONTRACT_CLASS_HASH, ARGENT_MULTISIG_CONTRACT_SIERRA),
+            ] {
+                let contract_class =
+                    ContractClass::Cairo1(ContractClass::cairo_1_from_sierra_json_str(raw_sierra)?);
+                state.predeclare_contract_class(class_hash, contract_class)?;
+            }
+        }
+
         // deploy udc, eth erc20 and strk erc20 contracts
         let eth_erc20_fee_contract = predeployed::create_erc20_at_address_extended(
             ETH_ERC20_CONTRACT_ADDRESS,
@@ -1371,6 +1384,8 @@ mod tests {
     use crate::account::{Account, FeeToken};
     use crate::blocks::StarknetBlock;
     use crate::constants::{
+        ARGENT_CONTRACT_CLASS_HASH, ARGENT_MULTISIG_CONTRACT_CLASS_HASH,
+        CAIRO_0_ACCOUNT_CONTRACT_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH,
         DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_INITIAL_BALANCE,
         DEVNET_DEFAULT_STARTING_BLOCK_NUMBER, ETH_ERC20_CONTRACT_ADDRESS,
         STRK_ERC20_CONTRACT_ADDRESS,
@@ -1636,6 +1651,21 @@ mod tests {
         }
     }
 
+    #[test]
+    fn assert_expected_predeclared_account_classes() {
+        let config = StarknetConfig { predeclare_argent: true, ..Default::default() };
+        let starknet = Starknet::new(&config).unwrap();
+        for class_hash in [
+            ARGENT_CONTRACT_CLASS_HASH,
+            ARGENT_MULTISIG_CONTRACT_CLASS_HASH,
+            Felt::from_hex_unchecked(CAIRO_0_ACCOUNT_CONTRACT_HASH),
+            Felt::from_hex_unchecked(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH),
+        ] {
+            let contract = starknet.get_class(&BlockId::Tag(BlockTag::Latest), class_hash).unwrap();
+            assert_eq!(contract.generate_hash().unwrap(), class_hash);
+        }
+    }
+
     #[test]
     fn calling_method_of_undeployed_contract() {
         let config = StarknetConfig::default();

crates/starknet-devnet-core/src/constants.rs

@@ -123,6 +123,8 @@ pub struct StarknetConfig {
     pub eth_erc20_contract_class: String,
     #[serde(skip_serializing)]
     pub strk_erc20_contract_class: String,
+    #[serde(skip_serializing)]
+    pub predeclare_argent: bool,
 }
 
 #[allow(clippy::unwrap_used)]
@@ -156,6 +158,7 @@ impl Default for StarknetConfig {
             strk_erc20_class_hash: CAIRO_1_ERC20_CONTRACT_CLASS_HASH,
             eth_erc20_contract_class: CAIRO_1_ERC20_CONTRACT.to_string(),
             strk_erc20_contract_class: CAIRO_1_ERC20_CONTRACT.to_string(),
+            predeclare_argent: false,
         }
     }
 }

crates/starknet-devnet-core/src/starknet/mod.rs

@@ -7,8 +7,9 @@ use server::restrictive_mode::DEFAULT_RESTRICTED_JSON_RPC_METHODS;
 use server::server::HTTP_API_ROUTES_WITHOUT_LEADING_SLASH;
 use server::ServerConfig;
 use starknet_core::constants::{
-    DEVNET_DEFAULT_DATA_GAS_PRICE, DEVNET_DEFAULT_GAS_PRICE, DEVNET_DEFAULT_PORT,
-    DEVNET_DEFAULT_REQUEST_BODY_SIZE_LIMIT, DEVNET_DEFAULT_TIMEOUT, DEVNET_DEFAULT_TOTAL_ACCOUNTS,
+    ARGENT_CONTRACT_VERSION, ARGENT_MULTISIG_CONTRACT_VERSION, DEVNET_DEFAULT_DATA_GAS_PRICE,
+    DEVNET_DEFAULT_GAS_PRICE, DEVNET_DEFAULT_PORT, DEVNET_DEFAULT_REQUEST_BODY_SIZE_LIMIT,
+    DEVNET_DEFAULT_TIMEOUT, DEVNET_DEFAULT_TOTAL_ACCOUNTS,
 };
 use starknet_core::contract_class_choice::{AccountClassWrapper, AccountContractClassChoice};
 use starknet_core::random_number_generator::generate_u32_random_number;
@@ -55,6 +56,14 @@ pub(crate) struct Args {
     #[arg(help = "Specify the path to a Cairo Sierra artifact to be used by predeployed accounts;")]
     account_class_custom: Option<AccountClassWrapper>,
 
+    #[arg(long = "predeclare-argent")]
+    #[arg(env = "PREDECLARE_ARGENT")]
+    #[arg(help = format!(
+        "If set, predeclares Argent account contract classes: regular ({ARGENT_CONTRACT_VERSION}) \
+        and multisig ({ARGENT_MULTISIG_CONTRACT_VERSION}); does not affect account predeployment;"
+    ))]
+    predeclare_argent: bool,
+
     /// Initial balance of predeployed accounts
     #[arg(long = "initial-balance")]
     #[arg(env = "INITIAL_BALANCE")]
@@ -245,6 +254,7 @@ impl Args {
                 block_number: self.fork_block,
                 block_hash: None,
             },
+            predeclare_argent: self.predeclare_argent,
             ..Default::default()
         };
 
@@ -613,7 +623,8 @@ mod tests {
     #[test]
     #[serial_test::serial]
     fn test_boolean_param_specification_via_env_vars() {
-        let config_source = [("--lite-mode", "LITE_MODE")];
+        let config_source =
+            [("--lite-mode", "LITE_MODE"), ("--predeclare-argent", "PREDECLARE_ARGENT")];
 
         let mut cli_args = vec!["--"];
         for (cli_param, _) in config_source {

crates/starknet-devnet-core/src/starknet/starknet_config.rs

@@ -15,8 +15,8 @@ use server::rpc_core::request::{Id, RequestParams, Version};
 use server::server::serve_http_api_json_rpc;
 use starknet_core::account::Account;
 use starknet_core::constants::{
-    ETH_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS, UDC_CONTRACT_ADDRESS,
-    UDC_CONTRACT_CLASS_HASH,
+    ARGENT_CONTRACT_CLASS_HASH, ARGENT_MULTISIG_CONTRACT_CLASS_HASH, ETH_ERC20_CONTRACT_ADDRESS,
+    STRK_ERC20_CONTRACT_ADDRESS, UDC_CONTRACT_ADDRESS, UDC_CONTRACT_CLASS_HASH,
 };
 use starknet_core::starknet::starknet_config::{
     BlockGenerationOn, DumpOn, ForkConfig, StarknetConfig,
@@ -116,6 +116,15 @@ fn log_predeployed_contracts(config: &StarknetConfig) {
     println!();
 }
 
+fn log_other_predeclared_contracts(config: &StarknetConfig) {
+    if config.predeclare_argent {
+        println!("Predeclared Argent account classes");
+        println!("Regular class hash: 0x{:X}", ARGENT_CONTRACT_CLASS_HASH);
+        println!("Multisig class hash: 0x{:X}", ARGENT_MULTISIG_CONTRACT_CLASS_HASH);
+        println!();
+    }
+}
+
 fn log_chain_id(chain_id: &ChainId) {
     println!("Chain ID: {} ({})", chain_id, chain_id.to_felt().to_hex_string());
 }
@@ -286,6 +295,7 @@ async fn main() -> Result<(), anyhow::Error> {
     };
 
     log_predeployed_contracts(&starknet_config);
+    log_other_predeclared_contracts(&starknet_config);
     log_chain_id(&starknet_config.chain_id);
 
     let predeployed_accounts = api.starknet.lock().await.get_predeployed_accounts();

crates/starknet-devnet/src/cli.rs

@@ -78,7 +78,7 @@ pub const INVALID_ACCOUNT_SIERRA_PATH: &str =
 
 /// Argent v0.4.0
 pub const ARGENT_ACCOUNT_CLASS_HASH: &str =
-    "0x36078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f";
+    "0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f";
 
 // Forking
 pub const INTEGRATION_SEPOLIA_HTTP_URL: &str =

crates/starknet-devnet/src/main.rs

@@ -22,9 +22,7 @@ use starknet_rs_providers::{JsonRpcClient, Provider};
 use starknet_rs_signers::LocalWallet;
 
 use super::background_devnet::BackgroundDevnet;
-use super::constants::{
-    ARGENT_ACCOUNT_CLASS_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CAIRO_1_CONTRACT_PATH,
-};
+use super::constants::{CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CAIRO_1_CONTRACT_PATH};
 use super::safe_child::SafeChild;
 
 pub enum ImpersonationAction {
@@ -285,11 +283,12 @@ pub async fn deploy_oz_account(
 /// Assumes the Argent account contract is declared in the target network.
 pub async fn deploy_argent_account(
     devnet: &BackgroundDevnet,
+    class_hash: Felt,
 ) -> Result<(DeployAccountTransactionResult, LocalWallet), anyhow::Error> {
     let signer = get_deployable_account_signer();
     let salt = Felt::THREE;
     let factory = ArgentAccountFactory::new(
-        Felt::from_hex(ARGENT_ACCOUNT_CLASS_HASH)?,
+        class_hash,
         devnet.json_rpc_client.chain_id().await?,
         None,
         signer.clone(),
@@ -301,7 +300,8 @@ pub async fn deploy_argent_account(
 
     let account_address = deployment.address();
     devnet.mint(account_address, 1e18 as u128).await;
-    let deployment_result = deployment.send().await?;
+    let deployment_result =
+        deployment.send().await.map_err(|e| anyhow::Error::msg(format!("{e:?}")))?;
 
     Ok((deployment_result, signer))
 }

tests/integration/common/constants.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use serde_json::json;
+use server::test_utils::assert_contains;
 use starknet_core::utils::exported_test_utils::dummy_cairo_0_contract_class;
 use starknet_rs_accounts::{Account, ExecutionEncoding, SingleOwnerAccount};
 use starknet_rs_contract::ContractFactory;
@@ -12,7 +13,8 @@ use starknet_rs_signers::LocalWallet;
 
 use crate::common::background_devnet::BackgroundDevnet;
 use crate::common::constants::{
-    CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH, MAINNET_URL,
+    ARGENT_ACCOUNT_CLASS_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH,
+    CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH, MAINNET_URL,
 };
 use crate::common::reqwest_client::GetReqwestSender;
 use crate::common::utils::{
@@ -112,13 +114,39 @@ async fn can_deploy_new_custom_oz_account() {
     can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
 }
 
+#[tokio::test]
+async fn argent_account_undeployable_by_default() {
+    let devnet = BackgroundDevnet::spawn().await.unwrap();
+
+    let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
+    let error = deploy_argent_account(&devnet, account_hash).await.unwrap_err();
+    assert_contains(
+        &error.to_string(),
+        &format!("Class with hash {ARGENT_ACCOUNT_CLASS_HASH} is not declared"),
+    );
+}
+
 #[tokio::test]
 /// Relying on forking: the origin network is expected to have the account class declared.
-async fn can_deploy_new_argent_account() {
+async fn can_deploy_instance_of_argent_account_via_fork() {
     let cli_args = ["--fork-network", MAINNET_URL];
     let devnet = BackgroundDevnet::spawn_with_additional_args(&cli_args).await.unwrap();
 
-    let (account_deployment, signer) = deploy_argent_account(&devnet).await.unwrap();
+    let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
+    let (account_deployment, signer) = deploy_argent_account(&devnet, account_hash).await.unwrap();
+    assert_tx_successful(&account_deployment.transaction_hash, &devnet.json_rpc_client).await;
+
+    let account_address = account_deployment.contract_address;
+    can_declare_deploy_invoke_cairo1_using_account(&devnet, &signer, account_address).await;
+}
+
+#[tokio::test]
+async fn can_deploy_new_argent_account_from_predeclared_class() {
+    let devnet_args = ["--predeclare-argent"];
+    let devnet = BackgroundDevnet::spawn_with_additional_args(&devnet_args).await.unwrap();
+
+    let account_hash = Felt::from_hex_unchecked(ARGENT_ACCOUNT_CLASS_HASH);
+    let (account_deployment, signer) = deploy_argent_account(&devnet, account_hash).await.unwrap();
     assert_tx_successful(&account_deployment.transaction_hash, &devnet.json_rpc_client).await;
 
     let account_address = account_deployment.contract_address;