feat: check block filter hashes

Cargo.toml

@@ -22,6 +22,7 @@ ckb-traits        = "0.108.0"
 ckb-resource      = "0.108.0"
 ckb-verification  = "0.108.0"
 ckb-systemtime    = "0.108.0"
+ckb-hash          = "0.108.0"
 ckb-merkle-mountain-range = "0.5.1"
 golomb-coded-set = "0.2.0"
 rocksdb = { package = "ckb-rocksdb", version ="=0.19.0", features = ["snappy"], default-features = false }

src/main.rs

@@ -14,6 +14,9 @@ mod types;
 mod utils;
 mod verify;
 
+// TODO Remove the patches if the code was merged into CKB.
+mod patches;
+
 use config::AppConfig;
 
 fn main() -> anyhow::Result<()> {

src/patches.rs

@@ -0,0 +1,73 @@
+use std::io::{Cursor, Write};
+
+#[cfg(not(test))]
+use ckb_hash::blake2b_256;
+use golomb_coded_set::{GCSFilterWriter, SipHasher24Builder, M, P};
+
+use ckb_types::{core::TransactionView, packed, prelude::*};
+
+/// Provides data for building block filter data.
+pub trait FilterDataProvider {
+    /// Finds the cell through its out point.
+    fn cell(&self, out_point: &packed::OutPoint) -> Option<packed::CellOutput>;
+}
+
+/// Builds filter data for transactions.
+pub fn build_filter_data<P: FilterDataProvider>(
+    provider: P,
+    transactions: &[TransactionView],
+) -> (Vec<u8>, Vec<packed::OutPoint>) {
+    let mut filter_writer = Cursor::new(Vec::new());
+    let mut filter = build_gcs_filter(&mut filter_writer);
+    let mut missing_out_points = Vec::new();
+    for tx in transactions {
+        if !tx.is_cellbase() {
+            for out_point in tx.input_pts_iter() {
+                if let Some(input_cell) = provider.cell(&out_point) {
+                    filter.add_element(input_cell.calc_lock_hash().as_slice());
+                    if let Some(type_script) = input_cell.type_().to_opt() {
+                        filter.add_element(type_script.calc_script_hash().as_slice());
+                    }
+                } else {
+                    missing_out_points.push(out_point);
+                }
+            }
+        }
+        for output_cell in tx.outputs() {
+            filter.add_element(output_cell.calc_lock_hash().as_slice());
+            if let Some(type_script) = output_cell.type_().to_opt() {
+                filter.add_element(type_script.calc_script_hash().as_slice());
+            }
+        }
+    }
+    filter
+        .finish()
+        .expect("flush to memory writer should be OK");
+    let filter_data = filter_writer.into_inner();
+    (filter_data, missing_out_points)
+}
+
+/// Calculates a block filter hash.
+#[cfg(not(test))]
+pub fn calc_filter_hash(
+    parent_block_filter_hash: &packed::Byte32,
+    filter_data: &packed::Bytes,
+) -> [u8; 32] {
+    blake2b_256(
+        [
+            parent_block_filter_hash.as_slice(),
+            filter_data.calc_raw_data_hash().as_slice(),
+        ]
+        .concat(),
+    )
+}
+
+// TODO Use real block filter hashes in unit tests.
+#[cfg(test)]
+pub fn calc_filter_hash(_: &packed::Byte32, _: &packed::Bytes) -> [u8; 32] {
+    Default::default()
+}
+
+fn build_gcs_filter(out: &mut dyn Write) -> GCSFilterWriter<SipHasher24Builder> {
+    GCSFilterWriter::new(out, SipHasher24Builder::new(0, 0), M, P)
+}