braidpool · mcelrath · Apr 17, 2025 · Apr 12, 2025 · Apr 12, 2025 · Apr 12, 2025
@@ -1,4 +1,3 @@
-
 ![Build status](https://github.com/wholooks/braidpool/actions/workflows/rust-node.yml/badge.svg)
 
 # Proposal
@@ -20,6 +19,7 @@ The goals of the pool are:
 Braidpool nodes need to connect to a bitcoin RPC node. The bitcoin node also needs to have the `hashblock` [ZMQ notification](https://github.com/bitcoin/bitcoin/blob/master/doc/zmq.md) enabled.
 
 Let's assume there is a `bitcoind` running on `0.0.0.0:8332` with username `xxxx`, password `yyyy`, and `zmqpubhashblock` enabled on port `28332`:
+
 ```
 $ bitcoind -rpcport=8332 -rpcuser=xxxx -rpcpassword=yyyy -zmqpubhashblock=tcp://localhost:28332
 ```
@@ -37,15 +37,17 @@ cargo run -- --bind=localhost:8989 --bitcoin=0.0.0.0 --rpcport=8332 --rpcuser=xx
 # run other nodes pointing to the seeding node and specify their own port as 9899
 cargo run -- --bind=localhost:9899 --addnode=localhost:8989 --bitcoin=0.0.0.0 --rpcport=8332 --rpcuser=xxxx --rpcpass=yyyy --zmqhashblockport=28332
 ```
+
 # Running the CPUnet testing node using nix-script
 
-Setting up `nix` locally for utilizing it from the specific releases check - [Nix setup](https://github.com/DeterminateSystems/nix-installer/releases) 
+Setting up `nix` locally for utilizing it from the specific releases check - [Nix setup](https://github.com/DeterminateSystems/nix-installer/releases)
+
 ```
 curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | \
   sh -s -- install
 ```
 
-The `.nix` script present in the root directory `/braidpool/cpunet_node.nix` contains the CPUnet patched 
+The `.nix` script present in the root directory `/braidpool/cpunet_node.nix` contains the CPUnet patched
 bitcoin-node , can be set up locally as testnet for Braidpool.
 
 ```
@@ -55,25 +57,24 @@ cd /braidpool
 # Run the nix-script
 nix-build cpunet_node.nix
 
-# Path to the result directory created after successful build 
+# Path to the result directory created after successful build
 cd result
 
 # Running the CPUnet node
 ./bin/bitcoind -cpunet -zmqpubsequence=tcp://127.0.0.1:28338
 
-# Creating/loading a corresponding wallet 
+# Creating/loading a corresponding wallet
 ./bin/bitcoin-cli -cpunet createwallet cpunet
 
 # Load an  wallet created previously
 ./bin/bitcoin-cli -cpunet loadwallet cpunet
 
-# Generate blocks     
+# Generate blocks
 ./contrib/cpunet/miner --cli=./bin/bitcoin-cli --ongoing --address `./bin/bitcoin-cli -cpunet getnewaddress` --grind-cmd="./bin/bitcoin-util -cpunet -ntasks=1 grind"
 
 
 ```
 
-
 # Documentation
 
 The documentation is in the `docs/` directory and contains a bunch of math. To
@@ -88,6 +89,39 @@ xdg-open http://localhost:8000
 
 Or you can just click on the docs directory in the code and Github will render the math in these markdown docs.
 
+# Braidpool Dashboard
+
+A visualization dashboard for the Braidpool decentralized mining pool, and Bitcoin related data.
+
+## How to Run
+
+```bash
+# Navigate to the dashboard directory 
+cd dashboard
+
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+```
+
+The dashboard will open automatically at [http://localhost:3000](http://localhost:3000).
+
+## Build for Production
+
+```bash
+# Navigate to the dashboard directory 
+cd dashboard
+
+# Create optimized build
+npm run build
+
+# Preview production build locally
+npm run preview
+```
+For more details on the Dashboard, [checkout its readme file](./dashboard/README.md).
+
 # Progress
 
 A list with TODO's:
@@ -103,6 +137,4 @@ A list with TODO's:
 - [ ] Single script installer (limited to Linux variants, potentially using
       docker).
 
-
 [Discord chat](https://discord.gg/pZYUDwkpPv)
-
@@ -8,8 +8,11 @@ hex = "0.4.3"
 num-bigint = "0.4.6"
 ordered-float = "5.0.0"
 transitive = "1.1.0"
-bitcoin = { git = "https://github.com/braidpool/rust-bitcoin.git" }
+bitcoin = { git = "https://github.com/braidpool/rust-bitcoin.git" ,features=["serde"]}
+serde = {version = "1.0.219", features=["derive"]}
+serde_json = "1.0.140"
+secp256k1 = "0.30.0"
 
 [lib]
 name = "braidpool_primitives"
-path = "src/lib.rs"
+path = "src/lib.rs"
@@ -1,60 +1,55 @@
+#![allow(unused)]
 // Standard Imports
+use ::serde::{Deserialize, Serialize};
 use std::collections::HashSet;
+use std::net::SocketAddr;
 
 // Bitcoin primitives
+use bitcoin::Address;
 use bitcoin::absolute::Time;
+use bitcoin::ecdsa::Signature;
+use bitcoin::p2p::Address as P2P_Address;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::transaction::TransactionExt;
-use bitcoin::{BlockHeader, CompactTarget, Transaction};
-
+use bitcoin::{BlockHeader, Transaction};
 // Custom Imports
 use crate::utils::BeadHash;
-use crate::utils::bitcoin::MerklePathProof;
-
-// Type Aliases
-type TransactionWithMerklePath = (Transaction, MerklePathProof);
-
-pub struct Bead {
-    pub block_header: BlockHeader,
-    pub bead_hash: BeadHash,
-    pub coinbase_transaction: TransactionWithMerklePath,
-    pub payout_update_transaction: TransactionWithMerklePath,
+#[derive(Clone, Debug, Serialize)]
 
+pub struct CommittedMetadata {
     // Committed Braidpool Metadata,
-    pub lesser_difficulty_target: CompactTarget,
-    pub parents: HashSet<(BeadHash, Time)>,
+    pub transaction_cnt: u32,
     pub transactions: Vec<Transaction>,
-
+    pub parents: HashSet<BeadHash>,
+    pub payout_address: Address,
+    //timestamp when the bead was created
     pub observed_time_at_node: Time,
+    pub comm_pub_key: PublicKey,
+    pub miner_ip: SocketAddr,
 }
+#[derive(Clone, Debug, Serialize)]
 
-impl Bead {
-    // All public definitions go in here!
-    #[inline]
-    pub fn is_transaction_included_in_block(
-        &self,
-        transaction_with_proof: &TransactionWithMerklePath,
-    ) -> bool {
-        transaction_with_proof
-            .1
-            .calculate_corresponding_merkle_root()
-            == self.block_header.merkle_root
-    }
+pub struct UnCommittedMetadata {
+    //Uncomitted Metadata
+    //timestamp when the bead was broadcasted
+    pub extra_nonce: i32,
+    pub broadcast_timestamp: Time,
+    pub signature: Signature,
+    pub parent_bead_timestamps: HashSet<Time>,
+}
+#[derive(Clone, Debug, Serialize)]
 
+pub struct Bead {
+    pub block_header: BlockHeader,
+    pub committed_metadata: CommittedMetadata,
+    pub uncommitted_metadata: UnCommittedMetadata,
+}
+
+impl Bead {
     pub fn is_valid_bead(&self) -> bool {
-        // Check whether the transactions are included in the block!
-        if self.is_transaction_included_in_block(&self.coinbase_transaction) == false {
-            false
-        } else if self.is_transaction_included_in_block(&self.payout_update_transaction) == false {
-            false
-        } else if self.coinbase_transaction.0.is_coinbase() == false {
-            false
-        } else if self.bead_hash != self.block_header.block_hash() {
-            false
-        } else {
-            true
-        }
+        // Check whether the transactions are included in the block
+        true
     }
-
     pub fn get_coinbase_transaction(&self) -> Transaction {
         // TODO: Implement this function.
         unimplemented!()
@@ -67,7 +62,13 @@ impl Bead {
 }
 
 impl Bead {
-    // All private function definitions go here!
+    // All private function definitions go here
+    //TODO : To implement a reverse mapping since we will be including the
+    //consensus determining attribute in the committed portion and those which
+    //will be used afterward such as in retargeting algorithms such as the parentbead_timestamps they shall be
+    //included inside the uncommitted portion but the order must be same as that of the hashset of parents_bead_hashes present
+    //inside the committed metadata
+    pub fn reverse_mapping_parentbead_with_timestamp() {}
 }
 
 #[cfg(test)]

@@ -1 +1,79 @@
+use ::bitcoin::BlockHash;
+use ::bitcoin::Network;
+use bitcoin::BlockTime;
+use bitcoin::BlockVersion;
+use bitcoin::CompactTarget;
+use bitcoin::EcdsaSighashType;
+use bitcoin::absolute::Time;
+use bitcoin::address::NetworkChecked;
+use bitcoin::base58::Error;
+use bitcoin::ecdsa::Signature;
+use bitcoin::hashes::sha256t::Hash;
+use bitcoin::secp256k1::PublicKey;
+use bitcoin::transaction::TransactionExt;
+use bitcoin::{Address, Block, TxMerkleNode};
+use bitcoin::{BlockHeader, Transaction};
+use core::net::SocketAddr;
+use secp256k1::Message;
+use secp256k1::{Secp256k1, SecretKey};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::json;
+use std::collections::HashSet;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::str::FromStr;
 
+use super::Bead;
+use super::CommittedMetadata;
+use super::UnCommittedMetadata;
+#[test]
+
+fn test_serialized_bead() {
+    let _address: Address = Address::from_str("32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf")
+        .unwrap()
+        .require_network(Network::Bitcoin)
+        .unwrap();
+    let secp = Secp256k1::new();
+    let secret_key = SecretKey::from_byte_array(&[0xcd; 32]).expect("32 bytes, within curve order");
+    let public_key = PublicKey::from_secret_key(&secp, &secret_key);
+    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+
+    let test_committed_metadata = CommittedMetadata {
+        transaction_cnt: 0,
+        parents: HashSet::new(),
+        transactions: vec![],
+        payout_address: _address,
+        comm_pub_key: public_key,
+        observed_time_at_node: Time::from_consensus(1653195600).unwrap(),
+        miner_ip: socket,
+    };
+    let hex = "3046022100839c1fbc5304de944f697c9f4b1d01d1faeba32d751c0f7acb21ac8a0f436a72022100e89bd46bb3a5a62adc679f659b7ce876d83ee297c7a5587b2011c4fcc72eab45";
+    let sig = Signature {
+        signature: secp256k1::ecdsa::Signature::from_str(hex).unwrap(),
+        sighash_type: EcdsaSighashType::All,
+    };
+
+    let test_uncommittedmetadata: UnCommittedMetadata = UnCommittedMetadata {
+        extra_nonce: 12,
+        broadcast_timestamp: Time::from_consensus(1653195600).unwrap(),
+        signature: sig,
+        parent_bead_timestamps: HashSet::new(),
+    };
+    let test_bytes = [0u8; 32];
+    let test_bead = Bead {
+        block_header: BlockHeader {
+            version: BlockVersion::TWO,
+            prev_blockhash: BlockHash::from_byte_array(test_bytes),
+            bits: CompactTarget::from_consensus(32),
+            nonce: 1,
+            time: BlockTime::from_u32(8328429),
+            merkle_root: TxMerkleNode::from_byte_array(test_bytes),
+        },
+        committed_metadata: test_committed_metadata,
+        uncommitted_metadata: test_uncommittedmetadata,
+    };
+    let serialized_str = serde_json::to_string(&test_bead).unwrap();
+    assert_eq!(
+        serialized_str,
+        r#"{"block_header":{"version":2,"prev_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","merkle_root":"0000000000000000000000000000000000000000000000000000000000000000","time":8328429,"bits":32,"nonce":1},"committed_metadata":{"transaction_cnt":0,"transactions":[],"parents":[],"payout_address":"32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf","observed_time_at_node":1653195600,"comm_pub_key":"02b98a7fb8cc007048625b6446ad49a1b3a722df8c1ca975b87160023e14d19097","miner_ip":"127.0.0.1:8080"},"uncommitted_metadata":{"extra_nonce":12,"broadcast_timestamp":1653195600,"signature":{"signature":"3046022100839c1fbc5304de944f697c9f4b1d01d1faeba32d751c0f7acb21ac8a0f436a72022100e89bd46bb3a5a62adc679f659b7ce876d83ee297c7a5587b2011c4fcc72eab45","sighash_type":"SIGHASH_ALL"},"parent_bead_timestamps":[]}}"#
+    );
+}