feat: include transactions in block

Author: 0xLucqs

src/blob.rs

@@ -18,20 +18,21 @@ impl Default for Blob {
 }
 
 impl Blob {
-    pub fn new(data: [u8; BLOB_SIZE]) -> Self {
-        Self {
-            data: Bytes::from_iter(data.iter().copied()),
+    pub fn new(data: Bytes) -> Self {
+        if data.len() > BLOB_SIZE {
+            panic!("Data is too large");
         }
+        Self { data }
     }
     pub fn data(&self) -> &[u8] {
         self.data.as_ref()
     }
     pub fn random() -> Self {
         let mut rng = thread_rng();
 
-        let mut blob = [0; BLOB_SIZE];
+        let mut blob = vec![0; BLOB_SIZE];
         rng.fill_bytes(&mut blob);
 
-        Self::new(blob)
+        Self::new(Bytes::from(blob))
     }
 }

src/block.rs

@@ -6,19 +6,19 @@ use eyre::Ok;
 use frieda::api::commit;
 use rand::{thread_rng, RngCore};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use rs_merkle::{algorithms::Sha256, Hasher, MerkleTree};
+use rs_merkle::{algorithms::Sha256, MerkleTree};
 use tracing::{error, info};
 
-use crate::blob::BLOB_SIZE;
 use crate::malachite_types::{address::Address, signing::PrivateKey};
+use crate::transactions::Transaction;
 use crate::{blob::Blob, error::BlockError, header::Header};
 
 #[derive(Debug, Encode, Decode, Default)]
 pub struct Block {
     /// Block Header.
     header: Header,
     /// list of blobs in this block.
-    blobs: [Blob; 4],
+    transactions: Vec<Transaction>,
 }
 
 impl Block {
@@ -28,50 +28,54 @@ impl Block {
         timestamp: u64,
         parent_hash: [u8; 32],
         proposer_address: Address,
-        blobs: [Blob; 4],
+        transactions: Vec<Transaction>,
     ) -> Self {
-        let leaves: Vec<[u8; 32]> = blobs.iter().map(|blob| Sha256::hash(blob.data())).collect();
+        let tx_commitment = if transactions.is_empty() {
+            [0; 32]
+        } else if transactions.len() == 1 {
+            transactions[0].hash()
+        } else {
+            let leaves: Vec<[u8; 32]> = transactions.iter().map(|tx| tx.hash()).collect();
 
-        let merkle_tree = MerkleTree::<Sha256>::from_leaves(&leaves);
+            let merkle_tree = MerkleTree::<Sha256>::from_leaves(&leaves);
 
-        let data_hash = merkle_tree.root().unwrap();
-        let da_commitment = blobs
+            merkle_tree.root().unwrap()
+        };
+
+        let da_commitment = transactions
             .par_iter()
-            .map(|blob| commit(blob.data(), 4))
-            .collect::<Vec<[u8; 32]>>()
-            .try_into()
-            .unwrap();
+            .flat_map(|tx| tx.data())
+            .map(|data| commit(data.data(), 4))
+            .collect::<Vec<[u8; 32]>>();
         let header = Header::new(
             block_number,
             timestamp,
-            data_hash,
+            tx_commitment,
             proposer_address,
-            da_commitment,
+            da_commitment.try_into().unwrap_or_default(),
             parent_hash,
         );
-        Self { header, blobs }
+        Self {
+            header,
+            transactions,
+        }
     }
     pub fn parent_hash(&self) -> [u8; 32] {
         self.header.parent_hash()
     }
+    pub fn blobs(&self) -> Vec<Blob> {
+        self.transactions
+            .iter()
+            .flat_map(|tx| tx.data().clone())
+            .collect::<Vec<_>>()
+    }
 
     pub fn hash(&self) -> [u8; 32] {
         self.header.block_hash()
     }
 
     pub fn genesis() -> Self {
-        Self::new(
-            0,
-            69420,
-            [0; 32],
-            Address::default(),
-            [
-                Blob::new([0; BLOB_SIZE]),
-                Blob::new([0; BLOB_SIZE]),
-                Blob::new([0; BLOB_SIZE]),
-                Blob::new([0; BLOB_SIZE]),
-            ],
-        )
+        Self::new(0, 69420, [0; 32], Address::default(), vec![])
     }
     pub fn to_bytes(&self) -> eyre::Result<Bytes> {
         let bytes = bincode::encode_to_vec(self, standard())?;
@@ -111,17 +115,17 @@ impl Block {
             );
             return Ok(false);
         }
-        let expected = self.blob_tree_root()?;
-        let actual = self.header.data_hash;
+        let expected = self.tx_tree_root()?;
+        let actual = self.header.tx_commitment;
         if expected != actual {
             error!(
-                "Data hash mismatch: expected {:?}, got {:?}",
+                "tx commitment mismatch: expected {:?}, got {:?}",
                 expected, actual
             );
             return Ok(false);
         }
         let expected_commitments = self
-            .blobs
+            .blobs()
             .par_iter()
             .map(|blob| commit(blob.data(), 4))
             .collect::<Vec<[u8; 32]>>();
@@ -147,32 +151,19 @@ impl Block {
         Ok(true)
     }
 
-    /// populate the empty fields in `Header`
-    pub fn populate(&mut self) -> eyre::Result<()> {
-        // Set the `data_hash` if not present
-        let blob_tree_root = self.blob_tree_root()?;
-        if self.header.data_hash.is_empty() {
-            self.header.data_hash = blob_tree_root;
-        } else if self.header.data_hash != blob_tree_root {
-            return Err(BlockError::DataHashMismatch(blob_tree_root, self.header.data_hash).into());
-        }
-
-        println!("Header population success!");
-
-        Ok(())
-    }
-
     /// Merklize the raw blob data
-    pub fn blob_tree_root(&self) -> eyre::Result<[u8; 32]> {
-        let leaves: Vec<[u8; 32]> = self
-            .blobs
-            .iter()
-            .map(|blob| Sha256::hash(blob.data()))
-            .collect();
+    pub fn tx_tree_root(&self) -> eyre::Result<[u8; 32]> {
+        if self.transactions.is_empty() {
+            Ok([0; 32])
+        } else if self.transactions.len() == 1 {
+            Ok(self.transactions[0].hash())
+        } else {
+            let leaves: Vec<[u8; 32]> = self.transactions.iter().map(|tx| tx.hash()).collect();
 
-        let merkle_tree = MerkleTree::<Sha256>::from_leaves(&leaves);
+            let merkle_tree = MerkleTree::<Sha256>::from_leaves(&leaves);
 
-        merkle_tree.root().ok_or(BlockError::MerkleTreeError.into())
+            merkle_tree.root().ok_or(BlockError::MerkleTreeError.into())
+        }
     }
 }
 
@@ -196,12 +187,7 @@ mod tests {
             Utc::now().timestamp() as u64,
             prev_block.hash(),
             mock_make_validator(),
-            [
-                Blob::random(),
-                Blob::random(),
-                Blob::random(),
-                Blob::random(),
-            ],
+            vec![Transaction::random()],
         );
         assert!(block.is_valid(1, &prev_block).unwrap());
     }

src/header.rs

@@ -18,7 +18,7 @@ pub struct Header {
     pub parent_hash: [u8; 32],
     /// Merkle root of the data in the current block.
     /// Leaves of this tree will be the raw bytes of each blob
-    pub data_hash: [u8; 32],
+    pub tx_commitment: [u8; 32],
     /// address of proposer of this block.
     #[bincode(with_serde)]
     pub proposer_address: Address,
@@ -31,7 +31,7 @@ impl Default for Header {
             block_hash: [0; 32],
             da_commitment: [[0; 32]; 4],
             parent_hash: [0; 32],
-            data_hash: [0; 32],
+            tx_commitment: [0; 32],
             proposer_address: mock_make_validator(),
         }
     }
@@ -43,7 +43,7 @@ impl Header {
     pub fn new(
         block_number: u64,
         timestamp: u64,
-        data_hash: [u8; 32],
+        tx_commitment: [u8; 32],
         proposer_address: Address,
         da_commitment: [[u8; 32]; 4],
         parent_hash: [u8; 32],
@@ -52,7 +52,7 @@ impl Header {
             block_number,
             timestamp,
             da_commitment,
-            data_hash,
+            tx_commitment,
             proposer_address,
             parent_hash,
             block_hash: [0; 32],
@@ -81,7 +81,7 @@ impl Header {
 
         hasher.update(self.block_number.to_le_bytes());
         hasher.update(self.parent_hash);
-        hasher.update(self.data_hash);
+        hasher.update(self.tx_commitment);
         hasher.update(self.proposer_address.into_inner());
 
         hasher.finalize().into()
@@ -100,7 +100,7 @@ pub struct HeaderBuilder {
     pub parent_hash: Option<[u8; 32]>,
     /// Merkle root of the data in the current block.
     /// Leaves of this tree will be the raw bytes of each blob
-    pub data_hash: Option<[u8; 32]>,
+    pub tx_commitment: Option<[u8; 32]>,
     /// address of proposer of this block.
     pub proposer_address: Option<Address>,
 }
@@ -133,8 +133,8 @@ impl HeaderBuilder {
         self
     }
 
-    pub fn data_hash(mut self, data_hash: [u8; 32]) -> Self {
-        self.data_hash = Some(data_hash);
+    pub fn tx_commitment(mut self, tx_commitment: [u8; 32]) -> Self {
+        self.tx_commitment = Some(tx_commitment);
         self
     }
     pub fn proposer_address(mut self, proposer_address: Address) -> Self {
@@ -146,7 +146,7 @@ impl HeaderBuilder {
         Header::new(
             self.block_number.unwrap(),
             self.timestamp.unwrap(),
-            self.data_hash.unwrap_or_default(),
+            self.tx_commitment.unwrap_or_default(),
             self.proposer_address.unwrap(),
             self.da_commitment.unwrap(),
             self.parent_hash.unwrap(),

src/state.rs

@@ -162,7 +162,7 @@ impl State {
             Utc::now().timestamp() as u64,
             prev_block.hash(),
             self.address,
-            tx.data().clone(),
+            vec![tx],
         );
 
         let block_data = bincode::encode_to_vec(&block, standard())?;

src/transactions/mod.rs

@@ -1,14 +1,18 @@
 use crate::blob::Blob;
+use bincode::{Decode, Encode};
 use malachitebft_test::{PrivateKey, PublicKey, Signature};
 use rand::{thread_rng, Rng};
 use sha3::Digest;
 use std::cmp::Ordering;
 
 pub mod pool;
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
 pub struct Transaction {
+    #[bincode(with_serde)]
     signature: Signature,
+    #[bincode(with_serde)]
     from: PublicKey,
+    #[bincode(with_serde)]
     to: PublicKey,
     value: u64,
     data: [Blob; 4],