feat(coinbase-extra): add coinbase extra field

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sha_p2pool"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 
 [dependencies]
@@ -10,7 +10,6 @@ tari_common_types = { git = "https://github.com/tari-project/tari.git" }
 tari_common = { git = "https://github.com/tari-project/tari.git" }
 tari_core = { git = "https://github.com/tari-project/tari.git" }
 tari_shutdown = { git = "https://github.com/tari-project/tari.git" }
-
 tari_crypto = "0.20.1"
 tari_utilities = { version = "0.7", features = ["borsh"] }
 

src/cli/args.rs

@@ -8,7 +8,7 @@ use tari_shutdown::ShutdownSignal;
 
 use crate::cli::{
     commands,
-    util::{cli_styles, validate_tribe},
+    util::{cli_styles, validate_squad},
 };
 
 #[allow(clippy::struct_excessive_bools)]
@@ -63,12 +63,12 @@ pub struct StartArgs {
     #[arg(long, value_name = "stable-peer", default_value_t = false)]
     pub stable_peer: bool,
 
-    /// Tribe to enter (a team of miners).
-    /// A tribe can have any name.
+    /// Squad to enter (a team of miners).
+    /// A squad can have any name.
     #[arg(
-        long, value_name = "tribe", default_value = "default", value_parser = validate_tribe
+        long, alias = "tribe", value_name = "squad", default_value = "default", value_parser = validate_squad
     )]
-    pub tribe: String,
+    pub squad: String,
 
     /// Private key folder.
     ///
@@ -110,10 +110,10 @@ pub struct StartArgs {
 }
 
 #[derive(Clone, Parser, Debug)]
-pub struct ListTribeArgs {
-    /// List tribe command timeout in seconds.
+pub struct ListSquadArgs {
+    /// List squad command timeout in seconds.
     ///
-    /// The list-tribes commands tries to look for all the currently available tribes
+    /// The list-squads commands tries to look for all the currently available squads
     /// for this amount of time maximum.
     #[arg(long, value_name = "timeout", default_value_t = 15)]
     pub timeout: u64,
@@ -130,13 +130,13 @@ pub enum Commands {
     /// Generating new identity.
     GenerateIdentity,
 
-    /// Listing all tribes that are present on the network.
-    ListTribes {
+    /// Listing all squads that are present on the network.
+    ListSquads {
         #[clap(flatten)]
         args: StartArgs,
 
         #[clap(flatten)]
-        list_tribe_args: ListTribeArgs,
+        list_squad_args: ListSquadArgs,
     },
 }
 
@@ -157,9 +157,9 @@ impl Cli {
                 .clone()
                 .unwrap_or_else(|| dirs::home_dir().unwrap().join(".tari/p2pool")),
             Commands::GenerateIdentity => dirs::home_dir().unwrap().join(".tari/p2pool"),
-            Commands::ListTribes {
+            Commands::ListSquads {
                 args,
-                list_tribe_args: _list_tribe_args,
+                list_squad_args: _list_squad_args,
             } => args
                 .base_dir
                 .clone()
@@ -180,8 +180,8 @@ impl Cli {
             Commands::GenerateIdentity => {
                 commands::handle_generate_identity().await?;
             },
-            Commands::ListTribes { args, list_tribe_args } => {
-                commands::handle_list_tribes(cli_ref.clone(), args, list_tribe_args, cli_shutdown.clone()).await?;
+            Commands::ListSquads { args, list_squad_args } => {
+                commands::handle_list_squads(cli_ref.clone(), args, list_squad_args, cli_shutdown.clone()).await?;
             },
         }
 

src/cli/commands/list_tribes.rs → src/cli/commands/list_squads.rs

@@ -10,16 +10,16 @@ use tokio::{select, sync::oneshot, task::JoinHandle, time};
 
 use crate::{
     cli::{
-        args::{Cli, ListTribeArgs, StartArgs},
+        args::{Cli, ListSquadArgs, StartArgs},
         commands::util,
     },
     server::p2p::peer_store::PeerStore,
 };
 
-pub async fn handle_list_tribes(
+pub async fn handle_list_squads(
     cli: Arc<Cli>,
     args: &StartArgs,
-    list_tribe_args: &ListTribeArgs,
+    list_squad_args: &ListSquadArgs,
     cli_shutdown_signal: ShutdownSignal,
 ) -> anyhow::Result<()> {
     // start server asynchronously
@@ -43,9 +43,9 @@ pub async fn handle_list_tribes(
     // wait for peer store from started server
     let peer_store = peer_store_channel_rx.await?;
 
-    // collect tribes for the given timeout
-    let mut tribes = vec![];
-    let timeout = time::sleep(Duration::from_secs(list_tribe_args.timeout));
+    // collect squads for the given timeout
+    let mut squads = vec![];
+    let timeout = time::sleep(Duration::from_secs(list_squad_args.timeout));
     tokio::pin!(timeout);
     tokio::pin!(cli_shutdown_signal);
     loop {
@@ -56,9 +56,9 @@ pub async fn handle_list_tribes(
             () = &mut timeout => {
                 break;
             }
-            current_tribes = peer_store.tribes() => {
-                tribes = current_tribes;
-                if tribes.len() > 1 {
+            current_squads = peer_store.squads() => {
+                squads = current_squads;
+                if squads.len() > 1 {
                     break;
                 }
             }
@@ -67,8 +67,8 @@ pub async fn handle_list_tribes(
     shutdown.trigger();
     handle.await??;
 
-    let tribes = tribes.iter().map(|tribe| tribe.to_string()).collect_vec();
-    print!("{}", serde_json::to_value(tribes)?);
+    let squads = squads.iter().map(|squad| squad.to_string()).collect_vec();
+    print!("{}", serde_json::to_value(squads)?);
 
     Ok(())
 }

src/cli/commands/mod.rs

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 pub use generate_identity::*;
-pub use list_tribes::*;
+pub use list_squads::*;
 pub use start::*;
 
 mod generate_identity;
-mod list_tribes;
+mod list_squads;
 mod start;
 mod util;

src/cli/commands/util.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 The Tari Project
 // SPDX-License-Identifier: BSD-3-Clause
 
-use std::{env, sync::Arc};
+use std::{collections::HashMap, env, sync::Arc};
 
 use libp2p::identity::Keypair;
 use log::info;
@@ -12,11 +12,12 @@ use tari_core::{
 };
 use tari_shutdown::ShutdownSignal;
 use tari_utilities::hex::Hex;
+use tokio::sync::RwLock;
 
 use crate::{
     cli::args::{Cli, StartArgs},
     server as main_server,
-    server::{p2p::Tribe, Server},
+    server::{p2p::Squad, Server},
     sharechain::{in_memory::InMemoryShareChain, BlockValidationParams, MAX_BLOCKS_COUNT},
 };
 
@@ -46,7 +47,7 @@ pub async fn server(
         config_builder.with_p2p_port(p2p_port);
     }
 
-    config_builder.with_tribe(Tribe::from(args.tribe.clone()));
+    config_builder.with_squad(Squad::from(args.squad.clone()));
 
     // set default tari network specific seed peer address
     let mut seed_peers = vec![];
@@ -99,14 +100,30 @@ genesis_block_hash.to_hex());
         consensus_manager.clone(),
         genesis_block_hash,
     ));
-    let share_chain_sha3x =
-        InMemoryShareChain::new(MAX_BLOCKS_COUNT, PowAlgorithm::Sha3x, None, consensus_manager.clone())?;
+    let coinbase_extras_sha3x = Arc::new(RwLock::new(HashMap::<String, Vec<u8>>::new()));
+    let share_chain_sha3x = InMemoryShareChain::new(
+        MAX_BLOCKS_COUNT,
+        PowAlgorithm::Sha3x,
+        None,
+        consensus_manager.clone(),
+        coinbase_extras_sha3x.clone(),
+    )?;
+    let coinbase_extras_random_x = Arc::new(RwLock::new(HashMap::<String, Vec<u8>>::new()));
     let share_chain_random_x = InMemoryShareChain::new(
         MAX_BLOCKS_COUNT,
         PowAlgorithm::RandomX,
         Some(block_validation_params.clone()),
         consensus_manager,
+        coinbase_extras_random_x.clone(),
     )?;
 
-    Ok(Server::new(config, share_chain_sha3x, share_chain_random_x, shutdown_signal).await?)
+    Ok(Server::new(
+        config,
+        share_chain_sha3x,
+        share_chain_random_x,
+        coinbase_extras_sha3x.clone(),
+        coinbase_extras_random_x.clone(),
+        shutdown_signal,
+    )
+    .await?)
 }

src/cli/util.rs

@@ -14,10 +14,10 @@ pub fn cli_styles() -> Styles {
         .valid(AnsiColor::BrightGreen.on_default())
 }
 
-pub fn validate_tribe(tribe: &str) -> Result<String, String> {
-    if tribe.trim().is_empty() {
-        return Err(String::from("tribe must be set"));
+pub fn validate_squad(squad: &str) -> Result<String, String> {
+    if squad.trim().is_empty() {
+        return Err(String::from("squad must be set"));
     }
 
-    Ok(String::from(tribe))
+    Ok(String::from(squad))
 }

src/server/config.rs

@@ -8,7 +8,7 @@ use libp2p::identity::Keypair;
 use crate::server::{
     http,
     p2p,
-    p2p::{peer_store::PeerStoreConfig, Tribe},
+    p2p::{peer_store::PeerStoreConfig, Squad},
 };
 
 /// Config is the server configuration struct.
@@ -68,8 +68,8 @@ impl ConfigBuilder {
         self
     }
 
-    pub fn with_tribe(&mut self, tribe: Tribe) -> &mut Self {
-        self.config.p2p_service.tribe = tribe;
+    pub fn with_squad(&mut self, squad: Squad) -> &mut Self {
+        self.config.p2p_service.squad = squad;
         self
     }
 

src/server/grpc/p2pool.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 The Tari Project
 // SPDX-License-Identifier: BSD-3-Clause
 
-use std::{collections::HashMap, sync::Arc, time::Instant};
+use std::{collections::HashMap, str::FromStr, sync::Arc, time::Instant};
 
 use log::{debug, error, info, warn};
 use minotari_app_grpc::tari_rpc::{
@@ -16,7 +16,7 @@ use minotari_app_grpc::tari_rpc::{
     SubmitBlockResponse,
 };
 use num_format::{Locale, ToFormattedString};
-use tari_common_types::types::FixedHash;
+use tari_common_types::{tari_address::TariAddress, types::FixedHash};
 use tari_core::{
     consensus::ConsensusManager,
     proof_of_work::{randomx_difficulty, randomx_factory::RandomXFactory, sha3x_difficulty, Difficulty, PowAlgorithm},
@@ -37,6 +37,7 @@ use crate::{
             P2POOL_STAT_REJECTED_BLOCKS_COUNT,
         },
         p2p,
+        p2p::Squad,
         stats_store::StatsStore,
     },
     sharechain::{block::Block, BlockValidationParams, ShareChain, SHARE_COUNT},
@@ -77,6 +78,9 @@ where S: ShareChain
     stats_max_difficulty_since_last_success: Arc<RwLock<Difficulty>>,
     consensus_manager: ConsensusManager,
     submit_block_semaphore: Arc<Semaphore>,
+    squad: Squad,
+    coinbase_extras_sha3x: Arc<RwLock<HashMap<String, Vec<u8>>>>,
+    coinbase_extras_random_x: Arc<RwLock<HashMap<String, Vec<u8>>>>,
 }
 
 impl<S> ShaP2PoolGrpc<S>
@@ -92,6 +96,9 @@ where S: ShareChain
         random_x_factory: RandomXFactory,
         consensus_manager: ConsensusManager,
         genesis_block_hash: FixedHash,
+        squad: Squad,
+        coinbase_extras_sha3x: Arc<RwLock<HashMap<String, Vec<u8>>>>,
+        coinbase_extras_random_x: Arc<RwLock<HashMap<String, Vec<u8>>>>,
     ) -> Result<Self, Error> {
         Ok(Self {
             client: Arc::new(RwLock::new(
@@ -111,6 +118,9 @@ where S: ShareChain
             stats_max_difficulty_since_last_success: Arc::new(RwLock::new(Difficulty::min())),
             consensus_manager,
             submit_block_semaphore: Arc::new(Semaphore::new(1)),
+            squad,
+            coinbase_extras_sha3x,
+            coinbase_extras_random_x,
         })
     }
 
@@ -153,16 +163,16 @@ where S: ShareChain
 {
     /// Returns a new block (that can be mined) which contains all the shares generated
     /// from the current share chain as coinbase transactions.
+    #[allow(clippy::too_many_lines)]
     async fn get_new_block(
         &self,
         request: Request<GetNewBlockRequest>,
     ) -> Result<Response<GetNewBlockResponse>, Status> {
         let timer = Instant::now();
+        let grpc_req = request.into_inner();
+
         // extract pow algo
-        let grpc_block_header_pow = request
-            .into_inner()
-            .pow
-            .ok_or(Status::invalid_argument("missing pow in request"))?;
+        let grpc_block_header_pow = grpc_req.pow.ok_or(Status::invalid_argument("missing pow in request"))?;
         let grpc_pow_algo = PowAlgos::from_i32(grpc_block_header_pow.pow_algo)
             .ok_or_else(|| Status::internal("invalid block header pow algo in request"))?;
         let pow_algo = match grpc_pow_algo {
@@ -187,12 +197,26 @@ where S: ShareChain
             .ok_or_else(|| Status::internal("missing miner data"))?;
         // let reward = miner_data.reward;
 
+        // update coinbase extras cache
+        let wallet_payment_address = TariAddress::from_str(grpc_req.wallet_payment_address.as_str())
+            .map_err(|error| Status::failed_precondition(format!("Invalid wallet payment address:  {}", error)))?;
+        let mut coinbase_extras_lock = match pow_algo {
+            PowAlgorithm::RandomX => self.coinbase_extras_random_x.write().await,
+            PowAlgorithm::Sha3x => self.coinbase_extras_sha3x.write().await,
+        };
+        coinbase_extras_lock.insert(
+            wallet_payment_address.to_base58(),
+            util::convert_coinbase_extra(self.squad.clone(), grpc_req.coinbase_extra)
+                .map_err(|error| Status::internal(format!("failed to convert coinbase extra {error:?}")))?,
+        );
+        drop(coinbase_extras_lock);
+
         // request new block template with shares as coinbases
         let share_chain = match pow_algo {
             PowAlgorithm::RandomX => self.share_chain_random_x.clone(),
             PowAlgorithm::Sha3x => self.share_chain_sha3x.clone(),
         };
-        let shares = share_chain.generate_shares().await;
+        let shares = share_chain.generate_shares(self.squad.clone()).await;
 
         let mut response = self
             .client
@@ -257,6 +281,7 @@ where S: ShareChain
         if timer.elapsed() > MAX_ACCEPTABLE_GRPC_TIMEOUT {
             warn!(target: LOG_TARGET, "get_new_block took {}ms", timer.elapsed().as_millis());
         }
+
         Ok(Response::new(GetNewBlockResponse {
             block: Some(response),
             target_difficulty: target_difficulty.as_u64(),
@@ -307,7 +332,7 @@ where S: ShareChain
             PowAlgorithm::Sha3x => self.share_chain_sha3x.clone(),
         };
         let mut block = share_chain
-            .new_block(grpc_block)
+            .new_block(grpc_block, self.squad.clone())
             .await
             .map_err(|error| Status::internal(error.to_string()))?;