feat: bootstrap cmd supports evm networks

src/ansible/provisioning.rs

@@ -62,25 +62,25 @@ impl From<BootstrapOptions> for ProvisionOptions {
         ProvisionOptions {
             binary_option: bootstrap_options.binary_option,
             bootstrap_node_count: 0,
-            chunk_size: None,
+            chunk_size: bootstrap_options.chunk_size,
             downloaders_count: 0,
             env_variables: bootstrap_options.env_variables,
             evm_network: bootstrap_options.evm_network,
             funding_wallet_secret_key: None,
             log_format: bootstrap_options.log_format,
             logstash_details: None,
-            name: bootstrap_options.name,
-            nat_gateway: None,
             max_archived_log_files: bootstrap_options.max_archived_log_files,
             max_log_files: bootstrap_options.max_log_files,
+            name: bootstrap_options.name,
+            nat_gateway: None,
             node_count: bootstrap_options.node_count,
             output_inventory_dir_path: bootstrap_options.output_inventory_dir_path,
             private_node_count: bootstrap_options.private_node_count,
             private_node_vms: Vec::new(),
             public_rpc: false,
+            rewards_address: bootstrap_options.rewards_address,
             safe_version: None,
             uploaders_count: None,
-            rewards_address: String::new(),
         }
     }
 }

src/bootstrap.rs

@@ -10,17 +10,19 @@ use crate::{
     ansible::{inventory::AnsibleInventoryType, provisioning::ProvisionOptions},
     error::Result,
     write_environment_details, BinaryOption, DeploymentType, EnvironmentDetails, EnvironmentType,
-    EvmNetwork, InfraRunOptions, LogFormat, NodeType, TestnetDeployer,
+    EvmCustomTestnetData, EvmNetwork, InfraRunOptions, LogFormat, NodeType, TestnetDeployer,
 };
 use colored::Colorize;
 
 #[derive(Clone)]
 pub struct BootstrapOptions {
     pub binary_option: BinaryOption,
     pub bootstrap_peer: String,
+    pub chunk_size: Option<u64>,
     pub environment_type: EnvironmentType,
     pub env_variables: Option<Vec<(String, String)>>,
     pub evm_network: EvmNetwork,
+    pub evm_custom_testnet_data: Option<EvmCustomTestnetData>,
     pub log_format: Option<LogFormat>,
     pub max_archived_log_files: u16,
     pub max_log_files: u16,
@@ -31,6 +33,7 @@ pub struct BootstrapOptions {
     pub private_node_count: u16,
     pub private_node_vm_count: Option<u16>,
     pub rewards_address: String,
+    pub node_vm_size: Option<String>,
 }
 
 impl TestnetDeployer {
@@ -55,26 +58,26 @@ impl TestnetDeployer {
                 deployment_type: DeploymentType::Bootstrap,
                 environment_type: options.environment_type.clone(),
                 evm_network: options.evm_network.clone(),
-                evm_testnet_data: None,
+                evm_testnet_data: options.evm_custom_testnet_data.clone(),
                 funding_wallet_address: None,
                 rewards_address: options.rewards_address.clone(),
             },
         )
         .await?;
 
         self.create_or_update_infra(&InfraRunOptions {
-            bootstrap_node_vm_count: None,
+            bootstrap_node_vm_count: Some(0),
             bootstrap_node_vm_size: None,
             enable_build_vm: build_custom_binaries,
-            evm_node_count: None,
+            evm_node_count: Some(0),
             evm_node_vm_size: None,
-            genesis_vm_count: None,
+            genesis_vm_count: Some(0),
             name: options.name.clone(),
             node_vm_count: options.node_vm_count,
-            node_vm_size: None,
+            node_vm_size: options.node_vm_size.clone(),
             private_node_vm_count: options.private_node_vm_count,
             tfvars_filename: options.environment_type.get_tfvars_filename().to_string(),
-            uploader_vm_count: None,
+            uploader_vm_count: Some(0),
             uploader_vm_size: None,
         })
         .map_err(|err| {
@@ -109,7 +112,7 @@ impl TestnetDeployer {
             &provision_options,
             &options.bootstrap_peer,
             NodeType::Normal,
-            None,
+            options.evm_custom_testnet_data.clone(),
         ) {
             Ok(()) => {
                 println!("Provisioned normal nodes");
@@ -147,7 +150,7 @@ impl TestnetDeployer {
             match self.ansible_provisioner.provision_private_nodes(
                 &mut provision_options,
                 &options.bootstrap_peer,
-                None,
+                options.evm_custom_testnet_data.clone(),
             ) {
                 Ok(()) => {
                     println!("Provisioned private nodes");

src/inventory.rs

@@ -185,18 +185,22 @@ impl DeploymentInventoryService {
             .ansible_runner
             .get_inventory(AnsibleInventoryType::BootstrapNodes, false)?;
 
-        let uploader_and_sks = self.ansible_provisioner.get_uploader_secret_keys()?;
-        let uploader_vms = uploader_and_sks
-            .iter()
-            .map(|(vm, sks)| UploaderVirtualMachine {
-                vm: vm.clone(),
-                wallet_public_key: sks
-                    .iter()
-                    .enumerate()
-                    .map(|(user, sk)| (format!("safe{}", user + 1), sk.address().encode_hex()))
-                    .collect(),
-            })
-            .collect::<Vec<_>>();
+        let uploader_vms = if environment_details.deployment_type != DeploymentType::Bootstrap {
+            let uploader_and_sks = self.ansible_provisioner.get_uploader_secret_keys()?;
+            uploader_and_sks
+                .iter()
+                .map(|(vm, sks)| UploaderVirtualMachine {
+                    vm: vm.clone(),
+                    wallet_public_key: sks
+                        .iter()
+                        .enumerate()
+                        .map(|(user, sk)| (format!("safe{}", user + 1), sk.address().encode_hex()))
+                        .collect(),
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
 
         println!("Retrieving node registries from all VMs...");
         let mut failed_node_registry_vms = Vec::new();
@@ -273,24 +277,28 @@ impl DeploymentInventoryService {
                 )?
             };
 
-            let safe_version = {
+            let safe_version = if environment_details.deployment_type != DeploymentType::Bootstrap {
                 let random_uploader_vm = uploader_vms
                     .choose(&mut rand::thread_rng())
                     .ok_or_else(|| eyre!("No uploader VMs available to retrieve safe version"))?;
-                self.get_bin_version(
+                Some(self.get_bin_version(
                     &random_uploader_vm.vm,
                     "autonomi --version",
                     "autonomi-cli ",
-                )?
+                )?)
+            } else {
+                None
             };
 
             println!("Retrieved binary versions from previous deployment:");
             println!("  safenode: {}", safenode_version);
             println!("  safenode-manager: {}", safenode_manager_version);
-            println!("  autonomi: {}", safe_version);
+            if let Some(version) = &safe_version {
+                println!("  autonomi: {}", version);
+            }
 
             BinaryOption::Versioned {
-                safe_version: Some(safe_version),
+                safe_version,
                 safenode_version,
                 safenode_manager_version,
             }

src/lib.rs

@@ -804,6 +804,7 @@ impl TestnetDeployer {
                 uploader_vm_count.to_string(),
             ));
         }
+
         args.push((
             "use_custom_bin".to_string(),
             options.enable_build_vm.to_string(),

src/main.rs

@@ -27,8 +27,8 @@ use sn_testnet_deploy::{
     network_commands, notify_slack,
     setup::setup_dotenv_file,
     upscale::UpscaleOptions,
-    BinaryOption, CloudProvider, EnvironmentType, EvmNetwork, LogFormat, TestnetDeployBuilder,
-    UpgradeOptions,
+    BinaryOption, CloudProvider, EnvironmentType, EvmCustomTestnetData, EvmNetwork, LogFormat,
+    TestnetDeployBuilder, UpgradeOptions,
 };
 use std::{env, net::IpAddr};
 use std::{str::FromStr, time::Duration};
@@ -62,6 +62,11 @@ enum Commands {
         /// The peer from an existing network that we can bootstrap from.
         #[arg(long)]
         bootstrap_peer: String,
+        /// Specify the chunk size for the custom binaries using a 64-bit integer.
+        ///
+        /// This option only applies if the --branch and --repo-owner arguments are used.
+        #[clap(long, value_parser = parse_chunk_size)]
+        chunk_size: Option<u64>,
         /// The type of deployment.
         ///
         /// Possible values are 'development', 'production' or 'staging'. The value used will
@@ -80,6 +85,31 @@ enum Commands {
         /// Example: --env SN_LOG=all,RUST_LOG=libp2p=debug
         #[clap(name = "env", long, use_value_delimiter = true, value_parser = parse_environment_variables, verbatim_doc_comment)]
         env_variables: Option<Vec<(String, String)>>,
+        /// The address of the data payments contract.
+        ///
+        /// This argument only applies if the EVM network type is 'custom'.
+        #[arg(long)]
+        evm_data_payments_address: Option<String>,
+        /// The private key of the wallet that deployed the contracts.
+        ///
+        /// This argument only applies if the EVM network type is 'custom'.
+        #[arg(long)]
+        evm_deployer_wallet_private_key: Option<String>,
+        /// The EVM network to use.
+        ///
+        /// Valid values are "arbitrum-one", "arbitrum-sepolia", or "custom".
+        #[clap(long, default_value_t = EvmNetwork::ArbitrumOne, value_parser = parse_evm_network)]
+        evm_network_type: EvmNetwork,
+        /// The address of the payment token contract.
+        ///
+        /// This argument only applies if the EVM network type is 'custom'.
+        #[arg(long)]
+        evm_payment_token_address: Option<String>,
+        /// The RPC URL for the EVM network.
+        ///
+        /// This argument only applies if the EVM network type is 'custom'.
+        #[arg(long)]
+        evm_rpc_url: Option<String>,
         /// Override the maximum number of forks Ansible will use to execute tasks on target hosts.
         ///
         /// The default value from ansible.cfg is 50.
@@ -106,6 +136,12 @@ enum Commands {
         /// If the argument is not used, the default format will be applied.
         #[clap(long, value_parser = LogFormat::parse_from_str, verbatim_doc_comment)]
         log_format: Option<LogFormat>,
+        /// The maximum of archived log files to keep. After reaching this limit, the older files are deleted.
+        #[clap(long, default_value = "5")]
+        max_archived_log_files: u16,
+        /// The maximum number of log files to keep. After reaching this limit, the older files are archived.
+        #[clap(long, default_value = "10")]
+        max_log_files: u16,
         /// The name of the environment
         #[arg(short = 'n', long)]
         name: String,
@@ -130,12 +166,9 @@ enum Commands {
         /// argument.
         #[clap(long)]
         node_vm_count: Option<u16>,
-        /// The maximum of archived log files to keep. After reaching this limit, the older files are deleted.
-        #[clap(long, default_value = "5")]
-        max_archived_log_files: u16,
-        /// The maximum number of log files to keep. After reaching this limit, the older files are archived.
-        #[clap(long, default_value = "10")]
-        max_log_files: u16,
+        /// Override the size of the node VMs.
+        #[clap(long)]
+        node_vm_size: Option<String>,
         /// Optionally set the payment forward public key for a custom safenode binary.
         ///
         /// This argument only applies if the '--branch' and '--repo-owner' arguments are used.
@@ -1151,6 +1184,11 @@ async fn main() -> Result<()> {
             branch,
             environment_type,
             env_variables,
+            evm_data_payments_address,
+            evm_deployer_wallet_private_key,
+            evm_network_type,
+            evm_payment_token_address,
+            evm_rpc_url,
             forks,
             foundation_pk,
             genesis_pk,
@@ -1159,6 +1197,7 @@ async fn main() -> Result<()> {
             network_royalties_pk,
             node_count,
             node_vm_count,
+            node_vm_size,
             max_archived_log_files,
             max_log_files,
             payment_forward_pk,
@@ -1170,7 +1209,40 @@ async fn main() -> Result<()> {
             safenode_features,
             safenode_version,
             safenode_manager_version,
+            chunk_size,
         } => {
+            let evm_custom_testnet_data = match evm_network_type {
+                EvmNetwork::Custom => {
+                    if evm_data_payments_address.is_none()
+                        || evm_payment_token_address.is_none()
+                        || evm_rpc_url.is_none()
+                    {
+                        return Err(eyre!(
+                            "When using a custom EVM network, you must supply evm-data-payments-address, evm-payment-token-address, and evm-rpc-url"
+                        ));
+                    }
+                    Some(EvmCustomTestnetData {
+                        data_payments_address: evm_data_payments_address.unwrap(),
+                        deployer_wallet_private_key: evm_deployer_wallet_private_key
+                            .unwrap_or_default(),
+                        payment_token_address: evm_payment_token_address.unwrap(),
+                        rpc_url: evm_rpc_url.unwrap(),
+                    })
+                }
+                _ => {
+                    if evm_data_payments_address.is_some()
+                        || evm_payment_token_address.is_some()
+                        || evm_rpc_url.is_some()
+                        || evm_deployer_wallet_private_key.is_some()
+                    {
+                        return Err(eyre!(
+                            "EVM custom network parameters can only be used with evm-network-type=custom"
+                        ));
+                    }
+                    None
+                }
+            };
+
             let network_keys = validate_and_get_pks(
                 foundation_pk,
                 genesis_pk,
@@ -1233,13 +1305,14 @@ async fn main() -> Result<()> {
                     bootstrap_peer,
                     environment_type: environment_type.clone(),
                     env_variables,
-                    // TODO: Should come from the previous deployment.
-                    evm_network: EvmNetwork::ArbitrumOne,
+                    evm_network: evm_network_type,
+                    evm_custom_testnet_data,
                     log_format,
                     name: name.clone(),
                     node_count: node_count.unwrap_or(environment_type.get_default_node_count()),
                     max_archived_log_files,
                     max_log_files,
+                    node_vm_size,
                     output_inventory_dir_path: inventory_service
                         .working_directory_path
                         .join("ansible")
@@ -1249,6 +1322,7 @@ async fn main() -> Result<()> {
                         .unwrap_or(environment_type.get_default_private_node_count()),
                     node_vm_count,
                     rewards_address,
+                    chunk_size,
                 })
                 .await?;