Merge pull request #119 from nervosnetwork/quake/tx_filter

feat: add transaction filter
nervosnetwork · Dec 28, 2018 · 41eadc5 · 41eadc5
2 parents 36f1ec0 + ec8f3b7
commit 41eadc5
Show file tree

Hide file tree

Showing 21 changed files with 1,044 additions and 125 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/core/src/transaction.rs b/core/src/transaction.rs
@@ -106,6 +106,12 @@ pub struct Transaction {
     outputs: Vec<CellOutput>,
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct IndexTransaction {
+    pub index: usize,
+    pub transaction: Transaction,
+}
+
 impl CellOutput {
     pub fn bytes_len(&self) -> usize {
         mem::size_of::<Capacity>()

diff --git a/protocol/src/builder.rs b/protocol/src/builder.rs
@@ -2,13 +2,13 @@ use crate::protocol_generated::ckb::protocol::{
     Block as FbsBlock, BlockBuilder, BlockProposalBuilder, BlockTransactionsBuilder,
     Bytes as FbsBytes, BytesBuilder, CellInput as FbsCellInput, CellInputBuilder,
     CellOutput as FbsCellOutput, CellOutputBuilder, CompactBlock, CompactBlockBuilder,
-    GetBlockProposalBuilder, GetBlockTransactionsBuilder, GetBlocks as FbsGetBlocks,
-    GetBlocksBuilder, GetHeaders as FbsGetHeaders, GetHeadersBuilder, Header as FbsHeader,
-    HeaderBuilder, Headers as FbsHeaders, HeadersBuilder, OutPoint as FbsOutPoint, OutPointBuilder,
-    PrefilledTransactionBuilder, RelayMessage, RelayMessageBuilder, RelayPayload,
-    Script as FbsScript, ScriptBuilder, SyncMessage, SyncMessageBuilder, SyncPayload,
-    Transaction as FbsTransaction, TransactionBuilder, UncleBlock as FbsUncleBlock,
-    UncleBlockBuilder,
+    FilteredBlock, FilteredBlockBuilder, GetBlockProposalBuilder, GetBlockTransactionsBuilder,
+    GetBlocks as FbsGetBlocks, GetBlocksBuilder, GetHeaders as FbsGetHeaders, GetHeadersBuilder,
+    Header as FbsHeader, HeaderBuilder, Headers as FbsHeaders, HeadersBuilder,
+    IndexTransactionBuilder, OutPoint as FbsOutPoint, OutPointBuilder, RelayMessage,
+    RelayMessageBuilder, RelayPayload, Script as FbsScript, ScriptBuilder, SyncMessage,
+    SyncMessageBuilder, SyncPayload, Transaction as FbsTransaction, TransactionBuilder,
+    UncleBlock as FbsUncleBlock, UncleBlockBuilder,
 };
 use crate::{short_transaction_id, short_transaction_id_keys};
 use ckb_core::block::Block;
@@ -337,6 +337,47 @@ impl<'a> SyncMessage<'a> {
         builder.add_payload(fbs_block.as_union_value());
         builder.finish()
     }
+
+    pub fn build_filtered_block<'b>(
+        fbb: &mut FlatBufferBuilder<'b>,
+        block: &Block,
+        transactions_index: &[usize],
+    ) -> WIPOffset<SyncMessage<'b>> {
+        let filtered_block = FilteredBlock::build(fbb, &block, transactions_index);
+        let mut builder = SyncMessageBuilder::new(fbb);
+        builder.add_payload_type(SyncPayload::FilteredBlock);
+        builder.add_payload(filtered_block.as_union_value());
+        builder.finish()
+    }
+}
+
+impl<'a> FilteredBlock<'a> {
+    pub fn build<'b>(
+        fbb: &mut FlatBufferBuilder<'b>,
+        block: &Block,
+        transactions_index: &[usize],
+    ) -> WIPOffset<FilteredBlock<'b>> {
+        let transactions = transactions_index
+            .iter()
+            .map(|ti| {
+                let fbs_transaction = FbsTransaction::build(fbb, &block.commit_transactions()[*ti]);
+                let mut builder = IndexTransactionBuilder::new(fbb);
+                builder.add_index(*ti as u32);
+                builder.add_transaction(fbs_transaction);
+                builder.finish()
+            })
+            .collect::<Vec<_>>();
+
+        let header = FbsHeader::build(fbb, &block.header());
+        let fbs_transactions = fbb.create_vector(&transactions);
+
+        let mut builder = FilteredBlockBuilder::new(fbb);
+        builder.add_header(header);
+        builder.add_transactions(fbs_transactions);
+        // TODO waiting for merkle tree proof generation function
+        // builder.add_hashes(...);
+        builder.finish()
+    }
 }
 
 impl<'a> CompactBlock<'a> {
@@ -362,7 +403,7 @@ impl<'a> CompactBlock<'a> {
                 || transaction.is_cellbase()
             {
                 let fbs_transaction = FbsTransaction::build(fbb, transaction);
-                let mut builder = PrefilledTransactionBuilder::new(fbb);
+                let mut builder = IndexTransactionBuilder::new(fbb);
                 builder.add_index(transaction_index as u32);
                 builder.add_transaction(fbs_transaction);
                 prefilled_transactions.push(builder.finish());

diff --git a/protocol/src/convert.rs b/protocol/src/convert.rs
@@ -158,3 +158,12 @@ impl<'a> From<ckb_protocol::CellOutput<'a>> for ckb_core::transaction::CellOutpu
         }
     }
 }
+
+impl<'a> From<ckb_protocol::IndexTransaction<'a>> for ckb_core::transaction::IndexTransaction {
+    fn from(it: ckb_protocol::IndexTransaction<'a>) -> Self {
+        ckb_core::transaction::IndexTransaction {
+            index: it.index() as usize,
+            transaction: it.transaction().unwrap().into(),
+        }
+    }
+}
diff --git a/protocol/src/protocol.fbs b/protocol/src/protocol.fbs
@@ -5,6 +5,10 @@ union SyncPayload {
     Headers,
     GetBlocks,
     Block,
+    SetFilter,
+    AddFilter,
+    ClearFilter,
+    FilteredBlock,
 }
 
 table SyncMessage {
@@ -109,12 +113,12 @@ table CompactBlock {
     header:                     Header;
     nonce:                      uint64;
     short_ids:                  [Bytes];
-    prefilled_transactions:     [PrefilledTransaction];
+    prefilled_transactions:     [IndexTransaction];
     uncles:                     [UncleBlock];
     proposal_transactions:      [Bytes];
 }
 
-table PrefilledTransaction {
+table IndexTransaction {
     index:                      uint32;
     transaction:                Transaction;
 }
@@ -137,3 +141,57 @@ table GetBlockProposal {
 table BlockProposal {
     transactions:              [Transaction];
 }
+
+struct H256 {
+    u0: uint8;
+    u1: uint8;
+    u2: uint8;
+    u3: uint8;
+    u4: uint8;
+    u5: uint8;
+    u6: uint8;
+    u7: uint8;
+    u8: uint8;
+    u9: uint8;
+    u10: uint8;
+    u11: uint8;
+    u12: uint8;
+    u13: uint8;
+    u14: uint8;
+    u15: uint8;
+    u16: uint8;
+    u17: uint8;
+    u18: uint8;
+    u19: uint8;
+    u20: uint8;
+    u21: uint8;
+    u22: uint8;
+    u23: uint8;
+    u24: uint8;
+    u25: uint8;
+    u26: uint8;
+    u27: uint8;
+    u28: uint8;
+    u29: uint8;
+    u30: uint8;
+    u31: uint8;
+}
+
+table SetFilter {
+    filter: [uint8];
+    num_hashes: uint8;
+    hash_seed: uint32;
+}
+
+table AddFilter {
+    filter: [uint8];
+}
+
+table ClearFilter {
+}
+
+table FilteredBlock {
+    header: Header;
+    transactions: [IndexTransaction];
+    hashes: [H256];
+}