Add new pre-mine for test

- Added new esmeralda pre-mine for test
- Added a console wallet command to get the spend status of all pre-mine outputs in the genesis block

applications/minotari_console_wallet/src/automation/commands.rs

@@ -32,7 +32,7 @@ use std::{
 };
 
 use chrono::{DateTime, Utc};
-use digest::{crypto_common::rand_core::OsRng, Digest};
+use digest::Digest;
 use futures::FutureExt;
 use log::*;
 use minotari_app_grpc::tls::certs::{generate_self_signed_certs, print_warning, write_cert_to_disk};
@@ -70,6 +70,7 @@ use tari_comms::{
 };
 use tari_comms_dht::{envelope::NodeDestination, DhtDiscoveryRequester};
 use tari_core::{
+    blocks::pre_mine::get_pre_mine_items,
     covenants::Covenant,
     transactions::{
         key_manager::TransactionKeyManagerInterface,
@@ -87,13 +88,10 @@ use tari_core::{
         },
     },
 };
-use tari_crypto::{
-    keys::SecretKey,
-    ristretto::{pedersen::PedersenCommitment, RistrettoSecretKey},
-};
+use tari_crypto::ristretto::{pedersen::PedersenCommitment, RistrettoSecretKey};
 use tari_key_manager::key_manager_service::{KeyId, KeyManagerInterface};
 use tari_script::{script, CheckSigSchnorrSignature};
-use tari_utilities::{encoding::Base58, hex::Hex, ByteArray};
+use tari_utilities::{hex::Hex, ByteArray};
 use tokio::{
     sync::{broadcast, mpsc},
     time::{sleep, timeout},
@@ -103,6 +101,7 @@ use super::error::CommandError;
 use crate::{
     automation::{
         utils::{
+            create_pre_mine_output_dir,
             get_file_name,
             move_session_file_to_session_dir,
             out_dir,
@@ -765,6 +764,58 @@ pub async fn command_runner(
                     Err(e) => eprintln!("BurnMinotari error! {}", e),
                 }
             },
+            PreMineSpendGetOutputStatus => {
+                let pre_mine_outputs = get_all_embedded_pre_mine_outputs()?;
+                let output_hashes: Vec<HashOutput> = pre_mine_outputs.iter().map(|v| v.hash()).collect();
+                let unspent_outputs = transaction_service.fetch_unspent_outputs(output_hashes).await?;
+
+                let pre_mine_items = match get_pre_mine_items(Network::get_current_or_user_setting_or_default()).await {
+                    Ok(items) => items,
+                    Err(e) => {
+                        eprintln!("\nError: {}\n", e);
+                        return Ok(());
+                    },
+                };
+
+                let (_session_id, out_dir) = match create_pre_mine_output_dir(Some("pre_mine_status")) {
+                    Ok(values) => values,
+                    Err(e) => {
+                        eprintln!("\nError: {}\n", e);
+                        return Ok(());
+                    },
+                };
+                let csv_file_name = "pre_mine_items_with_status.csv";
+                let csv_out_file = out_dir.join(csv_file_name);
+                let mut file_stream =
+                    File::create(&csv_out_file).expect("Could not create 'pre_mine_items_with_status.csv'");
+                if let Err(e) =
+                    file_stream.write_all("index,value,maturity,fail_safe_height,beneficiary,spent_status\n".as_bytes())
+                {
+                    eprintln!("\nError: Could not write pre-mine header ({})\n", e);
+                    return Ok(());
+                }
+
+                for (index, item) in pre_mine_items.iter().enumerate() {
+                    let unspent = unspent_outputs
+                        .iter()
+                        .any(|u| u.commitment() == &pre_mine_outputs[index].commitment);
+                    if let Err(e) = file_stream.write_all(
+                        format!(
+                            "{},{},{},{},{},{}\n",
+                            index,
+                            item.value,
+                            item.maturity,
+                            item.maturity + item.fail_safe_height,
+                            item.beneficiary,
+                            unspent
+                        )
+                        .as_bytes(),
+                    ) {
+                        eprintln!("\nError: Could not write pre-mine item ({})\n", e);
+                        return Ok(());
+                    }
+                }
+            },
             PreMineSpendSessionInfo(args) => {
                 match key_manager_service.get_wallet_type().await {
                     WalletType::Ledger(_) => {},
@@ -803,8 +854,13 @@ pub async fn command_runner(
                     }
                 }
 
-                let mut session_id = PrivateKey::random(&mut OsRng).to_base58();
-                session_id.truncate(16);
+                let (session_id, out_dir) = match create_pre_mine_output_dir(None) {
+                    Ok(values) => values,
+                    Err(e) => {
+                        eprintln!("\nError: {}\n", e);
+                        return Ok(());
+                    },
+                };
                 let session_info = PreMineSpendStep1SessionInfo {
                     session_id: session_id.clone(),
                     commitment_to_spend: commitment.to_hex(),
@@ -813,7 +869,7 @@ pub async fn command_runner(
                     fee_per_gram: args.fee_per_gram,
                     output_index: args.output_index,
                 };
-                let out_dir = out_dir(&session_info.session_id)?;
+
                 let out_file = out_dir.join(get_file_name(SPEND_SESSION_INFO, None));
                 write_to_json_file(&out_file, true, session_info)?;
                 println!();
@@ -1794,6 +1850,23 @@ pub async fn command_runner(
 }
 
 fn get_embedded_pre_mine_outputs(output_indexes: Vec<usize>) -> Result<Vec<TransactionOutput>, CommandError> {
+    let utxos = get_all_embedded_pre_mine_outputs()?;
+
+    let mut fetched_outputs = Vec::with_capacity(output_indexes.len());
+    for index in output_indexes {
+        if index >= utxos.len() {
+            return Err(CommandError::PreMine(format!(
+                "Error: Invalid 'output_index' {} provided pre-mine outputs only number {}!",
+                index,
+                utxos.len()
+            )));
+        }
+        fetched_outputs.push(utxos[index].clone());
+    }
+    Ok(fetched_outputs)
+}
+
+fn get_all_embedded_pre_mine_outputs() -> Result<Vec<TransactionOutput>, CommandError> {
     let pre_mine_contents = match Network::get_current_or_user_setting_or_default() {
         Network::MainNet => {
             include_str!("../../../../base_layer/core/src/blocks/pre_mine/mainnet_pre_mine.json")
@@ -1828,18 +1901,7 @@ fn get_embedded_pre_mine_outputs(output_indexes: Vec<usize>) -> Result<Vec<Trans
         counter += 1;
     }
 
-    let mut fetched_outputs = Vec::with_capacity(output_indexes.len());
-    for index in output_indexes {
-        if index >= utxos.len() {
-            return Err(CommandError::PreMine(format!(
-                "Error: Invalid 'output_index' {} provided pre-mine outputs only number {}!",
-                index,
-                utxos.len()
-            )));
-        }
-        fetched_outputs.push(utxos[index].clone());
-    }
-    Ok(fetched_outputs)
+    Ok(utxos)
 }
 
 fn write_utxos_to_csv_file(

applications/minotari_console_wallet/src/automation/utils.rs

@@ -27,7 +27,11 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use digest::crypto_common::rand_core::OsRng;
 use serde::{de::DeserializeOwned, Serialize};
+use tari_common_types::types::PrivateKey;
+use tari_crypto::keys::SecretKey;
+use tari_utilities::encoding::Base58;
 
 use crate::automation::{
     commands::{FILE_EXTENSION, SPEND_SESSION_INFO},
@@ -127,6 +131,20 @@ fn append_to_json_file<P: AsRef<Path>, T: Serialize>(file: P, data: T) -> Result
     Ok(())
 }
 
+/// Create a unique session-based output directory
+pub(crate) fn create_pre_mine_output_dir(alias: Option<&str>) -> Result<(String, PathBuf), CommandError> {
+    let mut session_id = PrivateKey::random(&mut OsRng).to_base58();
+    session_id.truncate(if alias.is_some() { 8 } else { 16 });
+    if let Some(alias) = alias {
+        session_id.push('_');
+        session_id.push_str(alias);
+    }
+    let out_dir = out_dir(&session_id)?;
+    fs::create_dir_all(out_dir.clone())
+        .map_err(|e| CommandError::JsonFile(format!("{} ({})", e, out_dir.display())))?;
+    Ok((session_id, out_dir))
+}
+
 /// Return the output directory for the session
 pub(crate) fn out_dir(session_id: &str) -> Result<PathBuf, CommandError> {
     let base_dir = dirs_next::document_dir().ok_or(CommandError::InvalidArgument(

applications/minotari_console_wallet/src/cli.rs

@@ -121,6 +121,7 @@ pub enum CliCommands {
     GetBalance,
     SendMinotari(SendMinotariArgs),
     BurnMinotari(BurnMinotariArgs),
+    PreMineSpendGetOutputStatus,
     PreMineSpendSessionInfo(PreMineSpendSessionInfoArgs),
     PreMineSpendPartyDetails(PreMineSpendPartyDetailsArgs),
     PreMineSpendEncumberAggregateUtxo(PreMineSpendEncumberAggregateUtxoArgs),

applications/minotari_console_wallet/src/wallet_modes.rs

@@ -173,7 +173,8 @@ fn force_exit_for_pre_mine_commands(command: &CliCommands) -> (bool, bool) {
     (
         matches!(
             command,
-            CliCommands::PreMineSpendSessionInfo(_) |
+            CliCommands::PreMineSpendGetOutputStatus |
+                CliCommands::PreMineSpendSessionInfo(_) |
                 CliCommands::PreMineSpendEncumberAggregateUtxo(_) |
                 CliCommands::PreMineSpendPartyDetails(_) |
                 CliCommands::PreMineSpendInputOutputSigs(_) |
@@ -549,6 +550,8 @@ mod test {
             
             burn-minotari --message Ups_these_funds_will_be_burned! 100T
 
+            pre-mine-spend-get-output-status
+
             pre-mine-spend-session-info --fee-per-gram 2 --output-index 123 --recipient-address \
              f4LR9f6WwwcPiKJjK5ciTkU1ocNhANa3FPw1wkyVUwbuKpgiihawCXy6PFszunUWQ4Te8KVFnyWVHHwsk9x5Cg7ZQiA \
              --verify-unspent-outputs
@@ -584,6 +587,7 @@ mod test {
         let mut get_balance = false;
         let mut send_tari = false;
         let mut burn_tari = false;
+        let mut pre_mine_spend_get_output_status = false;
         let mut pre_mine_spend_session_info = false;
         let mut pre_mine_spend_encumber_aggregate_utxo = false;
         let mut pre_mine_spend_aggregate_transaction = false;
@@ -600,6 +604,7 @@ mod test {
                 CliCommands::GetBalance => get_balance = true,
                 CliCommands::SendMinotari(_) => send_tari = true,
                 CliCommands::BurnMinotari(_) => burn_tari = true,
+                CliCommands::PreMineSpendGetOutputStatus => pre_mine_spend_get_output_status = true,
                 CliCommands::PreMineSpendSessionInfo(_) => pre_mine_spend_session_info = true,
                 CliCommands::PreMineSpendPartyDetails(_) => pre_mine_spend_party_details = true,
                 CliCommands::PreMineSpendEncumberAggregateUtxo(_) => pre_mine_spend_encumber_aggregate_utxo = true,
@@ -641,6 +646,7 @@ mod test {
             get_balance &&
                 send_tari &&
                 burn_tari &&
+                pre_mine_spend_get_output_status &&
                 pre_mine_spend_session_info &&
                 pre_mine_spend_encumber_aggregate_utxo &&
                 pre_mine_spend_aggregate_transaction &&

base_layer/core/src/blocks/genesis_block.rs

@@ -326,9 +326,9 @@ pub fn get_esmeralda_genesis_block() -> ChainBlock {
 
         // Hardcode the Merkle roots once they've been computed above
         block.header.kernel_mr =
-            FixedHash::from_hex("c3b93616d0e6289e8faff111d9d7b009fc45a04f3a5c31a5ad22610bc37f9dd7").unwrap();
+            FixedHash::from_hex("7db4197b169ee6c2ec3ffb04481c41ef6e900e41cbd96b35c4c0a77badfe4fbe").unwrap();
         block.header.output_mr =
-            FixedHash::from_hex("002a2ca5084105b8f0a165a40b6e707fd6cbae5ae14ca590735e21dd14ddb00a").unwrap();
+            FixedHash::from_hex("d75c2b76fb3da80bacb1b00f75a0fa4ea4002e79a2691085f4edb18f2de79ae0").unwrap();
         block.header.validator_node_mr =
             FixedHash::from_hex("277da65c40b2cf99db86baedb903a3f0a38540f3a94d40c826eecac7e27d5dfc").unwrap();
     }
@@ -347,7 +347,7 @@ pub fn get_esmeralda_genesis_block() -> ChainBlock {
 
 fn get_esmeralda_genesis_block_raw() -> Block {
     // Set genesis timestamp
-    let genesis_timestamp = DateTime::parse_from_rfc2822("06 Aug 2024 08:00:00 +0200").expect("parse may not fail");
+    let genesis_timestamp = DateTime::parse_from_rfc2822("08 Aug 2024 08:00:00 +0200").expect("parse may not fail");
     // Let us add a "not before" proof to the genesis block
     let not_before_proof =
         b"as I sip my drink, thoughts of esmeralda consume my mind, like a refreshing nourishing draught \