Skip to main content

hns_p2p_wire/
lib.rs

1#![doc = "Bounded, runtime-independent codecs for standard Handshake P2P traffic."]
2
3use std::collections::{HashMap, HashSet};
4use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
5
6use blake2::Blake2bVar;
7use blake2::digest::{Update, VariableOutput};
8use hns_encoding::{DecodeError, Decoder, Encoder};
9use hns_header_consensus::{HEADER_SIZE, Header};
10use hns_mining::{Block, validate_block_body};
11use hns_primitives::{BlockHash, NameHash, TreeRoot};
12use hns_transaction::Transaction;
13use hns_urkel_proof::{HsdUrkelProof, UrkelError};
14use thiserror::Error;
15
16pub const PROTOCOL_VERSION: u32 = 3;
17pub const MIN_PROTOCOL_VERSION: u32 = 1;
18pub const SERVICE_NETWORK: u64 = 1;
19pub const SERVICE_BLOOM: u64 = 1 << 1;
20pub const FRAME_HEADER_SIZE: usize = 9;
21pub const MAX_FRAME_PAYLOAD_SIZE: usize = 8_000_000;
22pub const MAX_INVENTORY_ITEMS: usize = 50_000;
23pub const MAX_LOCATOR_HASHES: usize = MAX_INVENTORY_ITEMS;
24pub const MAX_HEADERS: usize = 2_000;
25pub const MAX_ADDR_ITEMS: usize = 1_000;
26pub const MAX_USER_AGENT_SIZE: usize = u8::MAX as usize;
27pub const MAX_REJECT_REASON_SIZE: usize = u8::MAX as usize;
28pub const MAX_COMPACT_BLOCK_TRANSACTIONS: usize = 16_662;
29pub const NET_ADDRESS_SIZE: usize = 88;
30pub const MAX_STREAM_BUFFER_SIZE: usize = 2 * (FRAME_HEADER_SIZE + MAX_FRAME_PAYLOAD_SIZE);
31
32#[derive(Debug, Eq, Error, PartialEq)]
33pub enum WireError {
34    #[error(transparent)]
35    Decode(#[from] DecodeError),
36    #[error("network magic mismatch: expected {expected:#010x}, got {actual:#010x}")]
37    NetworkMagicMismatch { expected: u32, actual: u32 },
38    #[error("payload length {actual} exceeds the {maximum}-byte wire limit")]
39    PayloadTooLarge { actual: usize, maximum: usize },
40    #[error("{context} count {actual} exceeds the limit {maximum}")]
41    CountTooLarge {
42        context: &'static str,
43        actual: usize,
44        maximum: usize,
45    },
46    #[error("incomplete frame: need {needed} more byte(s)")]
47    IncompleteFrame { needed: usize },
48    #[error("invalid {context}: {reason}")]
49    InvalidPacket {
50        context: &'static str,
51        reason: &'static str,
52    },
53    #[error("invalid transaction packet: {0}")]
54    InvalidTransaction(String),
55    #[error(transparent)]
56    Urkel(#[from] UrkelError),
57    #[error(transparent)]
58    CompactBlock(#[from] CompactBlockError),
59}
60
61#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
62pub enum NetworkMagic {
63    Mainnet,
64    Testnet,
65    Regtest,
66    Simnet,
67}
68
69impl NetworkMagic {
70    pub const fn as_u32(self) -> u32 {
71        match self {
72            Self::Mainnet => 0x5b6e_f2d3,
73            Self::Testnet => 0xb152_0dd2,
74            Self::Regtest => 0xae38_95cf,
75            Self::Simnet => 0x0e64_8edc,
76        }
77    }
78}
79
80#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
81pub enum PacketType {
82    Version,
83    Verack,
84    Ping,
85    Pong,
86    GetAddr,
87    Addr,
88    Inv,
89    GetData,
90    NotFound,
91    GetBlocks,
92    GetHeaders,
93    Headers,
94    SendHeaders,
95    Block,
96    Tx,
97    Reject,
98    Mempool,
99    FilterLoad,
100    FilterAdd,
101    FilterClear,
102    MerkleBlock,
103    FeeFilter,
104    SendCmpct,
105    CmpctBlock,
106    GetBlockTxn,
107    BlockTxn,
108    GetProof,
109    Proof,
110    Claim,
111    Airdrop,
112    Unknown(u8),
113}
114
115impl PacketType {
116    pub const fn as_u8(self) -> u8 {
117        match self {
118            Self::Version => 0,
119            Self::Verack => 1,
120            Self::Ping => 2,
121            Self::Pong => 3,
122            Self::GetAddr => 4,
123            Self::Addr => 5,
124            Self::Inv => 6,
125            Self::GetData => 7,
126            Self::NotFound => 8,
127            Self::GetBlocks => 9,
128            Self::GetHeaders => 10,
129            Self::Headers => 11,
130            Self::SendHeaders => 12,
131            Self::Block => 13,
132            Self::Tx => 14,
133            Self::Reject => 15,
134            Self::Mempool => 16,
135            Self::FilterLoad => 17,
136            Self::FilterAdd => 18,
137            Self::FilterClear => 19,
138            Self::MerkleBlock => 20,
139            Self::FeeFilter => 21,
140            Self::SendCmpct => 22,
141            Self::CmpctBlock => 23,
142            Self::GetBlockTxn => 24,
143            Self::BlockTxn => 25,
144            Self::GetProof => 26,
145            Self::Proof => 27,
146            Self::Claim => 28,
147            Self::Airdrop => 29,
148            Self::Unknown(value) => value,
149        }
150    }
151
152    pub const fn from_u8(value: u8) -> Self {
153        match value {
154            0 => Self::Version,
155            1 => Self::Verack,
156            2 => Self::Ping,
157            3 => Self::Pong,
158            4 => Self::GetAddr,
159            5 => Self::Addr,
160            6 => Self::Inv,
161            7 => Self::GetData,
162            8 => Self::NotFound,
163            9 => Self::GetBlocks,
164            10 => Self::GetHeaders,
165            11 => Self::Headers,
166            12 => Self::SendHeaders,
167            13 => Self::Block,
168            14 => Self::Tx,
169            15 => Self::Reject,
170            16 => Self::Mempool,
171            17 => Self::FilterLoad,
172            18 => Self::FilterAdd,
173            19 => Self::FilterClear,
174            20 => Self::MerkleBlock,
175            21 => Self::FeeFilter,
176            22 => Self::SendCmpct,
177            23 => Self::CmpctBlock,
178            24 => Self::GetBlockTxn,
179            25 => Self::BlockTxn,
180            26 => Self::GetProof,
181            27 => Self::Proof,
182            28 => Self::Claim,
183            29 => Self::Airdrop,
184            other => Self::Unknown(other),
185        }
186    }
187
188    pub const fn carries_reject_hash(self) -> bool {
189        matches!(self, Self::Block | Self::Tx | Self::Claim | Self::Airdrop)
190    }
191}
192
193#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
194pub enum InventoryKind {
195    Transaction,
196    Block,
197    FilteredBlock,
198    CompactBlock,
199    Claim,
200    Airdrop,
201    Unknown(u32),
202}
203
204impl InventoryKind {
205    pub const fn as_u32(self) -> u32 {
206        match self {
207            Self::Transaction => 1,
208            Self::Block => 2,
209            Self::FilteredBlock => 3,
210            Self::CompactBlock => 4,
211            Self::Claim => 5,
212            Self::Airdrop => 6,
213            Self::Unknown(value) => value,
214        }
215    }
216
217    pub const fn from_u32(value: u32) -> Self {
218        match value {
219            1 => Self::Transaction,
220            2 => Self::Block,
221            3 => Self::FilteredBlock,
222            4 => Self::CompactBlock,
223            5 => Self::Claim,
224            6 => Self::Airdrop,
225            other => Self::Unknown(other),
226        }
227    }
228}
229
230#[derive(Clone, Debug, Eq, Hash, PartialEq)]
231pub struct Inventory {
232    pub kind: InventoryKind,
233    pub hash: [u8; 32],
234}
235
236#[derive(Clone, Debug, Eq, PartialEq)]
237pub struct NetAddress {
238    pub time: u64,
239    pub services: u64,
240    pub ip: [u8; 16],
241    pub port: u16,
242    pub key: [u8; 33],
243}
244
245impl NetAddress {
246    pub fn from_socket_addr(address: SocketAddr, time: u64, services: u64) -> Self {
247        let ip = match address.ip() {
248            IpAddr::V4(ip) => ip.to_ipv6_mapped().octets(),
249            IpAddr::V6(ip) => ip.octets(),
250        };
251        Self {
252            time,
253            services,
254            ip,
255            port: address.port(),
256            key: [0; 33],
257        }
258    }
259
260    pub fn socket_addr(&self) -> SocketAddr {
261        let ip = Ipv6Addr::from(self.ip);
262        let ip = ip
263            .to_ipv4_mapped()
264            .map(IpAddr::V4)
265            .unwrap_or(IpAddr::V6(ip));
266        SocketAddr::new(ip, self.port)
267    }
268
269    pub fn encode(&self) -> [u8; NET_ADDRESS_SIZE] {
270        let mut encoder = Encoder::with_capacity(NET_ADDRESS_SIZE);
271        self.encode_to(&mut encoder);
272        encoder
273            .into_bytes()
274            .try_into()
275            .expect("network address encoding is always 88 bytes")
276    }
277
278    pub fn decode(input: &[u8]) -> Result<Self, WireError> {
279        if input.len() != NET_ADDRESS_SIZE {
280            return Err(WireError::InvalidPacket {
281                context: "network address",
282                reason: "the encoding must be exactly 88 bytes",
283            });
284        }
285        let mut decoder = Decoder::new(input);
286        let address = Self::decode_from(&mut decoder)?;
287        decoder.finish()?;
288        Ok(address)
289    }
290
291    fn encode_to(&self, encoder: &mut Encoder) {
292        encoder.put_u64_le(self.time);
293        // HSD writes only the low service word and a reserved zero high word.
294        encoder.put_u32_le(self.services as u32);
295        encoder.put_u32_le(0);
296        encoder.put_u8(0);
297        encoder.put_bytes(&self.ip);
298        encoder.put_bytes(&[0; 20]);
299        encoder.put_u16_le(self.port);
300        encoder.put_bytes(&self.key);
301    }
302
303    fn decode_from(decoder: &mut Decoder<'_>) -> Result<Self, WireError> {
304        let time = decoder.read_u64_le()?;
305        let services = u64::from(decoder.read_u32_le()?);
306        let _reserved_service_word = decoder.read_u32_le()?;
307        let host_kind = decoder.read_u8()?;
308        let host = decoder.read_array::<36>()?;
309        let mut ip = [0; 16];
310        if host_kind == 0 {
311            ip.copy_from_slice(&host[..16]);
312        }
313        Ok(Self {
314            time,
315            services,
316            ip,
317            port: decoder.read_u16_le()?,
318            key: decoder.read_array()?,
319        })
320    }
321}
322
323impl Default for NetAddress {
324    fn default() -> Self {
325        Self::from_socket_addr(SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0), 0, 0)
326    }
327}
328
329#[derive(Clone, Debug, Eq, PartialEq)]
330pub struct VersionPacket {
331    pub version: u32,
332    pub services: u64,
333    pub time: u64,
334    pub remote: NetAddress,
335    pub nonce: [u8; 8],
336    pub agent: String,
337    pub height: u32,
338    pub no_relay: bool,
339}
340
341#[derive(Clone, Debug, Eq, PartialEq)]
342pub struct LocatorPacket {
343    pub locator: Vec<BlockHash>,
344    pub stop: BlockHash,
345}
346
347#[derive(Clone, Debug, Eq, PartialEq)]
348pub struct RejectPacket {
349    pub message: PacketType,
350    pub code: u8,
351    pub reason: String,
352    pub hash: Option<[u8; 32]>,
353}
354
355#[derive(Clone, Copy, Debug, Eq, PartialEq)]
356pub struct GetProofPacket {
357    pub root: TreeRoot,
358    pub key: NameHash,
359}
360
361#[derive(Clone, Debug, Eq, PartialEq)]
362pub struct ProofPacket {
363    pub root: TreeRoot,
364    pub key: NameHash,
365    pub proof: HsdUrkelProof,
366}
367
368#[derive(Clone, Debug, Eq, PartialEq)]
369pub struct PrefilledTransaction {
370    /// Differential index, matching HSD/BIP152 wire encoding.
371    pub index: usize,
372    pub transaction: Transaction,
373}
374
375#[derive(Clone, Debug, Eq, PartialEq)]
376pub struct CompactBlock {
377    pub header: Header,
378    pub key_nonce: [u8; 8],
379    pub short_ids: Vec<u64>,
380    pub prefilled: Vec<PrefilledTransaction>,
381}
382
383#[derive(Clone, Debug, Eq, PartialEq)]
384pub struct CompactBlockRequest {
385    pub block_hash: BlockHash,
386    /// Absolute transaction indexes. The wire codec converts them to and from
387    /// HSD/BIP152 differential indexes.
388    pub indexes: Vec<usize>,
389}
390
391#[derive(Clone, Debug, Eq, PartialEq)]
392pub struct CompactBlockResponse {
393    pub block_hash: BlockHash,
394    pub transactions: Vec<Transaction>,
395}
396
397#[derive(Clone, Debug)]
398pub struct CompactBlockReconstruction {
399    header: Header,
400    available: Vec<Option<usize>>,
401    transactions: Vec<Option<Transaction>>,
402    short_id_indexes: HashMap<u64, usize>,
403    filled: usize,
404}
405
406#[derive(Clone, Debug, Eq, Error, PartialEq)]
407pub enum CompactBlockError {
408    #[error("malformed compact block: {0}")]
409    Malformed(String),
410    #[error("compact block short-id collision: {0:#014x}")]
411    ShortIdCollision(u64),
412    #[error("compact block response hash does not match the pending block")]
413    ResponseHashMismatch,
414    #[error("compact block response has {actual} transactions; expected {expected}")]
415    ResponseCountMismatch { expected: usize, actual: usize },
416    #[error("compact block reconstruction is incomplete")]
417    Incomplete,
418    #[error("compact block transaction is malformed")]
419    InvalidTransaction,
420    #[error("compact block body does not match its committed roots or consensus shape")]
421    InvalidBlockBody,
422}
423
424impl ProofPacket {
425    pub fn verify(&self) -> Result<Option<Vec<u8>>, UrkelError> {
426        self.proof.verify(self.root, self.key)
427    }
428}
429
430impl CompactBlock {
431    pub fn from_block_with_nonce(
432        block: &Block,
433        key_nonce: [u8; 8],
434    ) -> Result<Self, CompactBlockError> {
435        validate_block_body(block).map_err(|_| CompactBlockError::InvalidBlockBody)?;
436        let mut compact = Self {
437            header: block.header.clone(),
438            key_nonce,
439            short_ids: Vec::with_capacity(block.transactions.len().saturating_sub(1)),
440            prefilled: Vec::with_capacity(usize::from(!block.transactions.is_empty())),
441        };
442        let siphash_key = compact.siphash_key();
443        compact.short_ids = block
444            .transactions
445            .iter()
446            .skip(1)
447            .map(|transaction| {
448                transaction
449                    .witness_hash()
450                    .map(|hash| Self::short_id_with_key(&hash, &siphash_key))
451                    .map_err(|_| CompactBlockError::InvalidTransaction)
452            })
453            .collect::<Result<Vec<_>, _>>()?;
454        if let Some(coinbase) = block.transactions.first() {
455            compact.prefilled.push(PrefilledTransaction {
456                index: 0,
457                transaction: coinbase.clone(),
458            });
459        }
460        compact.validate_layout()?;
461        Ok(compact)
462    }
463
464    pub fn hash(&self) -> BlockHash {
465        self.header.block_hash()
466    }
467
468    pub fn total_transactions(&self) -> usize {
469        self.short_ids.len().saturating_add(self.prefilled.len())
470    }
471
472    pub fn short_id(&self, witness_hash: &[u8; 32]) -> u64 {
473        Self::short_id_with_key(witness_hash, &self.siphash_key())
474    }
475
476    pub fn reconstruct(
477        &self,
478        mempool: &[Transaction],
479    ) -> Result<CompactBlockReconstruction, CompactBlockError> {
480        let total = self.validate_layout()?;
481        let mut reconstruction = CompactBlockReconstruction {
482            header: self.header.clone(),
483            available: vec![None; total],
484            transactions: Vec::with_capacity(total),
485            short_id_indexes: HashMap::with_capacity(self.short_ids.len()),
486            filled: 0,
487        };
488
489        let mut previous = None;
490        for prefilled in &self.prefilled {
491            let index = absolute_prefilled_index(previous, prefilled.index)?;
492            previous = Some(index);
493            reconstruction.insert(index, prefilled.transaction.clone())?;
494        }
495
496        let mut offset = 0_usize;
497        for (relative, short_id) in self.short_ids.iter().copied().enumerate() {
498            while reconstruction
499                .available
500                .get(relative.saturating_add(offset))
501                .is_some_and(Option::is_some)
502            {
503                offset = offset.saturating_add(1);
504            }
505            let index = relative.checked_add(offset).ok_or_else(|| {
506                CompactBlockError::Malformed("short-id index overflow".to_owned())
507            })?;
508            if index >= total {
509                return Err(CompactBlockError::Malformed(
510                    "short-id layout exceeds transaction count".to_owned(),
511                ));
512            }
513            if reconstruction
514                .short_id_indexes
515                .insert(short_id, index)
516                .is_some()
517            {
518                return Err(CompactBlockError::ShortIdCollision(short_id));
519            }
520        }
521        reconstruction.fill_mempool(self, mempool)?;
522        Ok(reconstruction)
523    }
524
525    fn siphash_key(&self) -> [u8; 16] {
526        let header = self.header.encode();
527        let hash = blake2b_256_many(&[header.as_slice(), self.key_nonce.as_slice()]);
528        let mut key = [0_u8; 16];
529        key.copy_from_slice(&hash[..16]);
530        key
531    }
532
533    fn short_id_with_key(witness_hash: &[u8; 32], key: &[u8; 16]) -> u64 {
534        siphash24(witness_hash, key) & 0x0000_ffff_ffff_ffff
535    }
536
537    fn validate_layout(&self) -> Result<usize, CompactBlockError> {
538        let total = self.total_transactions();
539        if total == 0 {
540            return Err(CompactBlockError::Malformed(
541                "empty short-id and prefilled vectors".to_owned(),
542            ));
543        }
544        if total > MAX_COMPACT_BLOCK_TRANSACTIONS {
545            return Err(CompactBlockError::Malformed(format!(
546                "transaction count {total} exceeds {MAX_COMPACT_BLOCK_TRANSACTIONS}"
547            )));
548        }
549        if self
550            .short_ids
551            .iter()
552            .any(|short_id| *short_id > 0x0000_ffff_ffff_ffff)
553        {
554            return Err(CompactBlockError::Malformed(
555                "short ID exceeds 48 bits".to_owned(),
556            ));
557        }
558
559        let mut previous = None;
560        for prefilled in &self.prefilled {
561            let index = absolute_prefilled_index(previous, prefilled.index)?;
562            if index >= total {
563                return Err(CompactBlockError::Malformed(format!(
564                    "prefilled index {index} exceeds transaction count {total}"
565                )));
566            }
567            previous = Some(index);
568        }
569        Ok(total)
570    }
571
572    fn encode_to(&self, encoder: &mut Encoder) -> Result<(), WireError> {
573        self.validate_layout()?;
574        encoder.put_bytes(&self.header.encode());
575        encoder.put_bytes(&self.key_nonce);
576        encoder.put_compact_size(self.short_ids.len() as u64);
577        for short_id in &self.short_ids {
578            encoder.put_u32_le(*short_id as u32);
579            encoder.put_u16_le((*short_id >> 32) as u16);
580        }
581        encoder.put_compact_size(self.prefilled.len() as u64);
582        for prefilled in &self.prefilled {
583            encoder.put_compact_size(prefilled.index as u64);
584            encoder.put_bytes(
585                &prefilled
586                    .transaction
587                    .encode()
588                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?,
589            );
590        }
591        Ok(())
592    }
593
594    fn decode_from(decoder: &mut Decoder<'_>) -> Result<Self, WireError> {
595        let header = Header::decode(decoder.read_slice(HEADER_SIZE)?).map_err(|_| {
596            WireError::InvalidPacket {
597                context: "compact block",
598                reason: "the nested header is malformed",
599            }
600        })?;
601        let key_nonce = decoder.read_array()?;
602        let short_id_count = read_count(
603            decoder,
604            "compact-block short IDs",
605            MAX_COMPACT_BLOCK_TRANSACTIONS,
606        )?;
607        let mut short_ids = Vec::with_capacity(short_id_count);
608        for _ in 0..short_id_count {
609            let low = u64::from(decoder.read_u32_le()?);
610            let high = u64::from(decoder.read_u16_le()?);
611            short_ids.push((high << 32) | low);
612        }
613        let maximum_prefilled = MAX_COMPACT_BLOCK_TRANSACTIONS.saturating_sub(short_id_count);
614        let prefilled_count = read_count(
615            decoder,
616            "compact-block prefilled transactions",
617            maximum_prefilled,
618        )?;
619        let total = short_id_count.saturating_add(prefilled_count);
620        let mut prefilled = Vec::with_capacity(prefilled_count);
621        let mut previous = None;
622        for _ in 0..prefilled_count {
623            let index = read_bounded_index(decoder, "compact-block prefilled index")?;
624            let absolute = absolute_prefilled_index(previous, index)?;
625            if absolute >= total {
626                return Err(CompactBlockError::Malformed(format!(
627                    "prefilled index {absolute} exceeds transaction count {total}"
628                ))
629                .into());
630            }
631            previous = Some(absolute);
632            prefilled.push(PrefilledTransaction {
633                index,
634                transaction: Transaction::decode_from(decoder)
635                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?,
636            });
637        }
638        let compact = Self {
639            header,
640            key_nonce,
641            short_ids,
642            prefilled,
643        };
644        compact.validate_layout()?;
645        Ok(compact)
646    }
647}
648
649impl CompactBlockReconstruction {
650    pub fn is_complete(&self) -> bool {
651        self.filled == self.available.len()
652    }
653
654    pub fn missing_request(&self) -> CompactBlockRequest {
655        CompactBlockRequest {
656            block_hash: self.header.block_hash(),
657            indexes: self
658                .available
659                .iter()
660                .enumerate()
661                .filter_map(|(index, transaction)| transaction.is_none().then_some(index))
662                .collect(),
663        }
664    }
665
666    pub fn fill_missing(
667        &mut self,
668        response: CompactBlockResponse,
669    ) -> Result<(), CompactBlockError> {
670        if response.block_hash != self.header.block_hash() {
671            return Err(CompactBlockError::ResponseHashMismatch);
672        }
673        let missing = self.available.iter().filter(|item| item.is_none()).count();
674        if response.transactions.len() != missing {
675            return Err(CompactBlockError::ResponseCountMismatch {
676                expected: missing,
677                actual: response.transactions.len(),
678            });
679        }
680        let indexes = self
681            .available
682            .iter()
683            .enumerate()
684            .filter_map(|(index, item)| item.is_none().then_some(index))
685            .collect::<Vec<_>>();
686        for (index, transaction) in indexes.into_iter().zip(response.transactions) {
687            self.insert(index, transaction)?;
688        }
689        Ok(())
690    }
691
692    pub fn into_block(self) -> Result<Block, CompactBlockError> {
693        if !self.is_complete() {
694            return Err(CompactBlockError::Incomplete);
695        }
696        let mut resolved = self.transactions;
697        let mut transactions = Vec::with_capacity(self.available.len());
698        for item in self.available {
699            let index = item.ok_or(CompactBlockError::Incomplete)?;
700            let transaction = resolved
701                .get_mut(index)
702                .and_then(Option::take)
703                .ok_or_else(|| {
704                    CompactBlockError::Malformed(
705                        "multiple compact-block slots reference one transaction".to_owned(),
706                    )
707                })?;
708            transactions.push(transaction);
709        }
710        let block = Block {
711            header: self.header,
712            transactions,
713        };
714        validate_block_body(&block).map_err(|_| CompactBlockError::InvalidBlockBody)?;
715        Ok(block)
716    }
717
718    fn fill_mempool(
719        &mut self,
720        compact: &CompactBlock,
721        mempool: &[Transaction],
722    ) -> Result<(), CompactBlockError> {
723        if self.is_complete() {
724            return Ok(());
725        }
726        let mut matched = HashSet::new();
727        let siphash_key = compact.siphash_key();
728        for transaction in mempool {
729            let witness_hash = transaction
730                .witness_hash()
731                .map_err(|_| CompactBlockError::InvalidTransaction)?;
732            let short_id = CompactBlock::short_id_with_key(&witness_hash, &siphash_key);
733            let Some(index) = self.short_id_indexes.get(&short_id).copied() else {
734                continue;
735            };
736            if !matched.insert(index) {
737                if self.available[index].take().is_some() {
738                    self.filled = self.filled.saturating_sub(1);
739                }
740                continue;
741            }
742            if self.available[index].is_none() {
743                self.insert(index, transaction.clone())?;
744            }
745            if self.is_complete() {
746                return Ok(());
747            }
748        }
749        Ok(())
750    }
751
752    fn insert(&mut self, index: usize, transaction: Transaction) -> Result<(), CompactBlockError> {
753        let slot = self.available.get_mut(index).ok_or_else(|| {
754            CompactBlockError::Malformed(format!("transaction index {index} is out of bounds"))
755        })?;
756        if slot.is_some() {
757            return Err(CompactBlockError::Malformed(format!(
758                "transaction index {index} is filled more than once"
759            )));
760        }
761        let resolved = self.transactions.len();
762        self.transactions.push(Some(transaction));
763        *slot = Some(resolved);
764        self.filled = self.filled.saturating_add(1);
765        Ok(())
766    }
767}
768
769impl CompactBlockRequest {
770    pub fn from_block(block: &Block, indexes: Vec<usize>) -> Self {
771        Self {
772            block_hash: block.header.block_hash(),
773            indexes,
774        }
775    }
776
777    fn encode_to(&self, encoder: &mut Encoder) -> Result<(), WireError> {
778        validate_absolute_indexes(&self.indexes)?;
779        encoder.put_bytes(self.block_hash.as_bytes());
780        encoder.put_compact_size(self.indexes.len() as u64);
781        for (position, index) in self.indexes.iter().copied().enumerate() {
782            let differential = if position == 0 {
783                index
784            } else {
785                index - self.indexes[position - 1] - 1
786            };
787            encoder.put_compact_size(differential as u64);
788        }
789        Ok(())
790    }
791
792    fn decode_from(decoder: &mut Decoder<'_>) -> Result<Self, WireError> {
793        let block_hash = BlockHash::new(decoder.read_array()?);
794        let count = read_count(
795            decoder,
796            "compact-block requested indexes",
797            MAX_COMPACT_BLOCK_TRANSACTIONS,
798        )?;
799        let mut indexes = Vec::with_capacity(count);
800        let mut previous = None;
801        for _ in 0..count {
802            let differential = read_bounded_index(decoder, "compact-block requested index")?;
803            let absolute = absolute_prefilled_index(previous, differential)?;
804            indexes.push(absolute);
805            previous = Some(absolute);
806        }
807        Ok(Self {
808            block_hash,
809            indexes,
810        })
811    }
812}
813
814impl CompactBlockResponse {
815    pub fn from_block(
816        block: &Block,
817        request: &CompactBlockRequest,
818    ) -> Result<Self, CompactBlockError> {
819        validate_absolute_indexes(&request.indexes)?;
820        if request.block_hash != block.header.block_hash() {
821            return Err(CompactBlockError::ResponseHashMismatch);
822        }
823        let transactions = request
824            .indexes
825            .iter()
826            .map(|index| {
827                block.transactions.get(*index).cloned().ok_or_else(|| {
828                    CompactBlockError::Malformed(format!(
829                        "requested transaction index {index} is out of bounds"
830                    ))
831                })
832            })
833            .collect::<Result<Vec<_>, _>>()?;
834        Ok(Self {
835            block_hash: request.block_hash,
836            transactions,
837        })
838    }
839
840    fn encode_to(&self, encoder: &mut Encoder) -> Result<(), WireError> {
841        check_count(
842            "compact-block response transactions",
843            self.transactions.len(),
844            MAX_COMPACT_BLOCK_TRANSACTIONS,
845        )?;
846        encoder.put_bytes(self.block_hash.as_bytes());
847        encoder.put_compact_size(self.transactions.len() as u64);
848        for transaction in &self.transactions {
849            encoder.put_bytes(
850                &transaction
851                    .encode()
852                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?,
853            );
854        }
855        Ok(())
856    }
857
858    fn decode_from(decoder: &mut Decoder<'_>) -> Result<Self, WireError> {
859        let block_hash = BlockHash::new(decoder.read_array()?);
860        let count = read_count(
861            decoder,
862            "compact-block response transactions",
863            MAX_COMPACT_BLOCK_TRANSACTIONS,
864        )?;
865        let mut transactions = Vec::with_capacity(count);
866        for _ in 0..count {
867            transactions.push(
868                Transaction::decode_from(decoder)
869                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?,
870            );
871        }
872        Ok(Self {
873            block_hash,
874            transactions,
875        })
876    }
877}
878
879#[derive(Clone, Debug, Eq, PartialEq)]
880pub enum Packet {
881    Version(VersionPacket),
882    Verack,
883    Ping([u8; 8]),
884    Pong([u8; 8]),
885    GetAddr,
886    Addr(Vec<NetAddress>),
887    Inv(Vec<Inventory>),
888    GetData(Vec<Inventory>),
889    NotFound(Vec<Inventory>),
890    GetBlocks(LocatorPacket),
891    GetHeaders(LocatorPacket),
892    Headers(Vec<Header>),
893    SendHeaders,
894    Block(Block),
895    Tx(Transaction),
896    Reject(RejectPacket),
897    Mempool,
898    FilterLoad(Vec<u8>),
899    FilterAdd(Vec<u8>),
900    FilterClear,
901    MerkleBlock(Vec<u8>),
902    FeeFilter(i64),
903    SendCmpct { mode: u8, version: u64 },
904    CmpctBlock(CompactBlock),
905    GetBlockTxn(CompactBlockRequest),
906    BlockTxn(CompactBlockResponse),
907    GetProof(GetProofPacket),
908    Proof(ProofPacket),
909    Claim(Vec<u8>),
910    Airdrop(Vec<u8>),
911    Unknown { packet_type: u8, payload: Vec<u8> },
912}
913
914impl Packet {
915    pub const fn packet_type(&self) -> PacketType {
916        match self {
917            Self::Version(_) => PacketType::Version,
918            Self::Verack => PacketType::Verack,
919            Self::Ping(_) => PacketType::Ping,
920            Self::Pong(_) => PacketType::Pong,
921            Self::GetAddr => PacketType::GetAddr,
922            Self::Addr(_) => PacketType::Addr,
923            Self::Inv(_) => PacketType::Inv,
924            Self::GetData(_) => PacketType::GetData,
925            Self::NotFound(_) => PacketType::NotFound,
926            Self::GetBlocks(_) => PacketType::GetBlocks,
927            Self::GetHeaders(_) => PacketType::GetHeaders,
928            Self::Headers(_) => PacketType::Headers,
929            Self::SendHeaders => PacketType::SendHeaders,
930            Self::Block(_) => PacketType::Block,
931            Self::Tx(_) => PacketType::Tx,
932            Self::Reject(_) => PacketType::Reject,
933            Self::Mempool => PacketType::Mempool,
934            Self::FilterLoad(_) => PacketType::FilterLoad,
935            Self::FilterAdd(_) => PacketType::FilterAdd,
936            Self::FilterClear => PacketType::FilterClear,
937            Self::MerkleBlock(_) => PacketType::MerkleBlock,
938            Self::FeeFilter(_) => PacketType::FeeFilter,
939            Self::SendCmpct { .. } => PacketType::SendCmpct,
940            Self::CmpctBlock(_) => PacketType::CmpctBlock,
941            Self::GetBlockTxn(_) => PacketType::GetBlockTxn,
942            Self::BlockTxn(_) => PacketType::BlockTxn,
943            Self::GetProof(_) => PacketType::GetProof,
944            Self::Proof(_) => PacketType::Proof,
945            Self::Claim(_) => PacketType::Claim,
946            Self::Airdrop(_) => PacketType::Airdrop,
947            Self::Unknown { packet_type, .. } => PacketType::Unknown(*packet_type),
948        }
949    }
950
951    pub fn encode_payload(&self) -> Result<Vec<u8>, WireError> {
952        let mut encoder = Encoder::new();
953        match self {
954            Self::Version(packet) => encode_version(packet, &mut encoder)?,
955            Self::Verack
956            | Self::GetAddr
957            | Self::SendHeaders
958            | Self::Mempool
959            | Self::FilterClear => {}
960            Self::Ping(nonce) | Self::Pong(nonce) => encoder.put_bytes(nonce),
961            Self::Addr(items) => {
962                check_count("address", items.len(), MAX_ADDR_ITEMS)?;
963                encoder.put_compact_size(items.len() as u64);
964                for item in items {
965                    item.encode_to(&mut encoder);
966                }
967            }
968            Self::Inv(items) | Self::GetData(items) | Self::NotFound(items) => {
969                encode_inventory(items, &mut encoder)?;
970            }
971            Self::GetBlocks(packet) | Self::GetHeaders(packet) => {
972                check_count("locator", packet.locator.len(), MAX_LOCATOR_HASHES)?;
973                encoder.put_compact_size(packet.locator.len() as u64);
974                for hash in &packet.locator {
975                    encoder.put_bytes(hash.as_bytes());
976                }
977                encoder.put_bytes(packet.stop.as_bytes());
978            }
979            Self::Headers(headers) => {
980                check_count("header", headers.len(), MAX_HEADERS)?;
981                encoder.put_compact_size(headers.len() as u64);
982                for header in headers {
983                    encoder.put_bytes(&header.encode());
984                }
985            }
986            Self::Tx(transaction) => encoder.put_bytes(
987                &transaction
988                    .encode()
989                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?,
990            ),
991            Self::Reject(packet) => encode_reject(packet, &mut encoder)?,
992            Self::FeeFilter(rate) => encoder.put_u64_le(*rate as u64),
993            Self::SendCmpct { mode, version } => {
994                encoder.put_u8(*mode);
995                encoder.put_u64_le(*version);
996            }
997            Self::GetProof(packet) => {
998                encoder.put_bytes(packet.root.as_bytes());
999                encoder.put_bytes(packet.key.as_bytes());
1000            }
1001            Self::Proof(packet) => {
1002                encoder.put_bytes(packet.root.as_bytes());
1003                encoder.put_bytes(packet.key.as_bytes());
1004                encoder.put_bytes(&packet.proof.encode()?);
1005            }
1006            Self::Block(block) => {
1007                encoder.put_bytes(&block.encode().map_err(|_| WireError::InvalidPacket {
1008                    context: "block",
1009                    reason: "the nested block is malformed",
1010                })?)
1011            }
1012            Self::CmpctBlock(block) => block.encode_to(&mut encoder)?,
1013            Self::GetBlockTxn(request) => request.encode_to(&mut encoder)?,
1014            Self::BlockTxn(response) => response.encode_to(&mut encoder)?,
1015            Self::FilterLoad(payload)
1016            | Self::FilterAdd(payload)
1017            | Self::MerkleBlock(payload)
1018            | Self::Claim(payload)
1019            | Self::Airdrop(payload)
1020            | Self::Unknown { payload, .. } => encoder.put_bytes(payload),
1021        }
1022        let payload = encoder.into_bytes();
1023        check_payload_size(payload.len())?;
1024        Ok(payload)
1025    }
1026
1027    pub fn decode(packet_type: PacketType, payload: &[u8]) -> Result<Self, WireError> {
1028        check_payload_size(payload.len())?;
1029        if let PacketType::Unknown(packet_type) = packet_type {
1030            return Ok(Self::Unknown {
1031                packet_type,
1032                payload: payload.to_vec(),
1033            });
1034        }
1035        let mut decoder = Decoder::new(payload);
1036        let packet = match packet_type {
1037            PacketType::Version => Self::Version(decode_version(&mut decoder)?),
1038            PacketType::Verack => Self::Verack,
1039            PacketType::Ping => Self::Ping(decoder.read_array()?),
1040            PacketType::Pong => Self::Pong(decoder.read_array()?),
1041            PacketType::GetAddr => Self::GetAddr,
1042            PacketType::Addr => {
1043                let count = read_count(&mut decoder, "address", MAX_ADDR_ITEMS)?;
1044                let mut items = Vec::with_capacity(count);
1045                for _ in 0..count {
1046                    items.push(NetAddress::decode_from(&mut decoder)?);
1047                }
1048                Self::Addr(items)
1049            }
1050            PacketType::Inv => Self::Inv(decode_inventory(&mut decoder)?),
1051            PacketType::GetData => Self::GetData(decode_inventory(&mut decoder)?),
1052            PacketType::NotFound => Self::NotFound(decode_inventory(&mut decoder)?),
1053            PacketType::GetBlocks | PacketType::GetHeaders => {
1054                let count = read_count(&mut decoder, "locator", MAX_LOCATOR_HASHES)?;
1055                let mut locator = Vec::with_capacity(count);
1056                for _ in 0..count {
1057                    locator.push(BlockHash::new(decoder.read_array()?));
1058                }
1059                let packet = LocatorPacket {
1060                    locator,
1061                    stop: BlockHash::new(decoder.read_array()?),
1062                };
1063                if packet_type == PacketType::GetBlocks {
1064                    Self::GetBlocks(packet)
1065                } else {
1066                    Self::GetHeaders(packet)
1067                }
1068            }
1069            PacketType::Headers => {
1070                let count = read_count(&mut decoder, "header", MAX_HEADERS)?;
1071                let mut headers = Vec::with_capacity(count);
1072                for _ in 0..count {
1073                    headers.push(Header::decode(decoder.read_slice(HEADER_SIZE)?).map_err(
1074                        |_| WireError::InvalidPacket {
1075                            context: "headers",
1076                            reason: "a nested header is malformed",
1077                        },
1078                    )?);
1079                }
1080                Self::Headers(headers)
1081            }
1082            PacketType::SendHeaders => Self::SendHeaders,
1083            PacketType::Block => {
1084                return Block::decode(payload).map(Self::Block).map_err(|_| {
1085                    WireError::InvalidPacket {
1086                        context: "block",
1087                        reason: "the nested block is malformed",
1088                    }
1089                });
1090            }
1091            PacketType::Tx => {
1092                let transaction = Transaction::decode(payload)
1093                    .map_err(|error| WireError::InvalidTransaction(error.to_string()))?;
1094                return Ok(Self::Tx(transaction));
1095            }
1096            PacketType::Reject => Self::Reject(decode_reject(&mut decoder)?),
1097            PacketType::Mempool => Self::Mempool,
1098            PacketType::FilterLoad => Self::FilterLoad(take_remaining(&mut decoder)?),
1099            PacketType::FilterAdd => Self::FilterAdd(take_remaining(&mut decoder)?),
1100            PacketType::FilterClear => Self::FilterClear,
1101            PacketType::MerkleBlock => Self::MerkleBlock(take_remaining(&mut decoder)?),
1102            PacketType::FeeFilter => Self::FeeFilter(decoder.read_u64_le()? as i64),
1103            PacketType::SendCmpct => Self::SendCmpct {
1104                mode: decoder.read_u8()?,
1105                version: decoder.read_u64_le()?,
1106            },
1107            PacketType::CmpctBlock => Self::CmpctBlock(CompactBlock::decode_from(&mut decoder)?),
1108            PacketType::GetBlockTxn => {
1109                Self::GetBlockTxn(CompactBlockRequest::decode_from(&mut decoder)?)
1110            }
1111            PacketType::BlockTxn => {
1112                Self::BlockTxn(CompactBlockResponse::decode_from(&mut decoder)?)
1113            }
1114            PacketType::GetProof => Self::GetProof(GetProofPacket {
1115                root: TreeRoot::new(decoder.read_array()?),
1116                key: NameHash::new(decoder.read_array()?),
1117            }),
1118            PacketType::Proof => {
1119                let root = TreeRoot::new(decoder.read_array()?);
1120                let key = NameHash::new(decoder.read_array()?);
1121                let raw = take_remaining(&mut decoder)?;
1122                Self::Proof(ProofPacket {
1123                    root,
1124                    key,
1125                    proof: HsdUrkelProof::decode_strict(&raw)?,
1126                })
1127            }
1128            PacketType::Claim => Self::Claim(take_remaining(&mut decoder)?),
1129            PacketType::Airdrop => Self::Airdrop(take_remaining(&mut decoder)?),
1130            PacketType::Unknown(_) => unreachable!("handled before decoder construction"),
1131        };
1132        decoder.finish()?;
1133        Ok(packet)
1134    }
1135}
1136
1137#[derive(Clone, Debug, Eq, PartialEq)]
1138pub struct Frame {
1139    pub packet_type: PacketType,
1140    pub payload: Vec<u8>,
1141}
1142
1143impl Frame {
1144    pub fn new(packet_type: PacketType, payload: Vec<u8>) -> Result<Self, WireError> {
1145        check_payload_size(payload.len())?;
1146        Ok(Self {
1147            packet_type,
1148            payload,
1149        })
1150    }
1151
1152    pub fn from_packet(packet: &Packet) -> Result<Self, WireError> {
1153        Self::new(packet.packet_type(), packet.encode_payload()?)
1154    }
1155
1156    pub fn decode_packet(&self) -> Result<Packet, WireError> {
1157        Packet::decode(self.packet_type, &self.payload)
1158    }
1159
1160    pub fn encode(&self, network: NetworkMagic) -> Result<Vec<u8>, WireError> {
1161        check_payload_size(self.payload.len())?;
1162        let length = u32::try_from(self.payload.len()).map_err(|_| WireError::PayloadTooLarge {
1163            actual: self.payload.len(),
1164            maximum: MAX_FRAME_PAYLOAD_SIZE,
1165        })?;
1166        let mut encoder =
1167            Encoder::with_capacity(FRAME_HEADER_SIZE.saturating_add(self.payload.len()));
1168        encoder.put_u32_le(network.as_u32());
1169        encoder.put_u8(self.packet_type.as_u8());
1170        encoder.put_u32_le(length);
1171        encoder.put_bytes(&self.payload);
1172        Ok(encoder.into_bytes())
1173    }
1174
1175    pub fn decode_exact(network: NetworkMagic, input: &[u8]) -> Result<Self, WireError> {
1176        match decode_frame_prefix(network, input)? {
1177            Some((frame, consumed)) => {
1178                if consumed != input.len() {
1179                    return Err(DecodeError::TrailingBytes {
1180                        remaining: input.len() - consumed,
1181                    }
1182                    .into());
1183                }
1184                Ok(frame)
1185            }
1186            None => Err(WireError::IncompleteFrame {
1187                needed: bytes_needed_for_frame(input),
1188            }),
1189        }
1190    }
1191}
1192
1193pub fn decode_frame_prefix(
1194    network: NetworkMagic,
1195    input: &[u8],
1196) -> Result<Option<(Frame, usize)>, WireError> {
1197    if input.len() < FRAME_HEADER_SIZE {
1198        return Ok(None);
1199    }
1200    let mut decoder = Decoder::new(&input[..FRAME_HEADER_SIZE]);
1201    let actual_magic = decoder.read_u32_le()?;
1202    if actual_magic != network.as_u32() {
1203        return Err(WireError::NetworkMagicMismatch {
1204            expected: network.as_u32(),
1205            actual: actual_magic,
1206        });
1207    }
1208    let packet_type = PacketType::from_u8(decoder.read_u8()?);
1209    let payload_length = decoder.read_u32_le()? as usize;
1210    decoder.finish()?;
1211    check_payload_size(payload_length)?;
1212    let frame_length = FRAME_HEADER_SIZE + payload_length;
1213    if input.len() < frame_length {
1214        return Ok(None);
1215    }
1216    Ok(Some((
1217        Frame {
1218            packet_type,
1219            payload: input[FRAME_HEADER_SIZE..frame_length].to_vec(),
1220        },
1221        frame_length,
1222    )))
1223}
1224
1225#[derive(Clone, Debug)]
1226pub struct FrameDecoder {
1227    network: NetworkMagic,
1228    buffered: Vec<u8>,
1229}
1230
1231impl FrameDecoder {
1232    pub const fn new(network: NetworkMagic) -> Self {
1233        Self {
1234            network,
1235            buffered: Vec::new(),
1236        }
1237    }
1238
1239    pub fn buffered_len(&self) -> usize {
1240        self.buffered.len()
1241    }
1242
1243    pub fn push(&mut self, input: &[u8]) -> Result<Vec<Frame>, WireError> {
1244        let total =
1245            self.buffered
1246                .len()
1247                .checked_add(input.len())
1248                .ok_or(WireError::PayloadTooLarge {
1249                    actual: usize::MAX,
1250                    maximum: MAX_STREAM_BUFFER_SIZE,
1251                })?;
1252        if total > MAX_STREAM_BUFFER_SIZE {
1253            return Err(WireError::PayloadTooLarge {
1254                actual: total,
1255                maximum: MAX_STREAM_BUFFER_SIZE,
1256            });
1257        }
1258        self.buffered.extend_from_slice(input);
1259        let mut consumed = 0;
1260        let mut frames = Vec::new();
1261        while let Some((frame, length)) =
1262            decode_frame_prefix(self.network, &self.buffered[consumed..])?
1263        {
1264            consumed += length;
1265            frames.push(frame);
1266            if consumed == self.buffered.len() {
1267                break;
1268            }
1269        }
1270        if consumed != 0 {
1271            self.buffered.drain(..consumed);
1272        }
1273        Ok(frames)
1274    }
1275}
1276
1277fn encode_version(packet: &VersionPacket, encoder: &mut Encoder) -> Result<(), WireError> {
1278    check_ascii_u8("version user agent", &packet.agent, MAX_USER_AGENT_SIZE)?;
1279    encoder.put_u32_le(packet.version);
1280    encoder.put_u32_le(packet.services as u32);
1281    encoder.put_u32_le(0);
1282    encoder.put_u64_le(packet.time);
1283    packet.remote.encode_to(encoder);
1284    encoder.put_bytes(&packet.nonce);
1285    encoder.put_u8(packet.agent.len() as u8);
1286    encoder.put_bytes(packet.agent.as_bytes());
1287    encoder.put_u32_le(packet.height);
1288    encoder.put_u8(u8::from(packet.no_relay));
1289    Ok(())
1290}
1291
1292fn decode_version(decoder: &mut Decoder<'_>) -> Result<VersionPacket, WireError> {
1293    let version = decoder.read_u32_le()?;
1294    let services = u64::from(decoder.read_u32_le()?);
1295    let _reserved_service_word = decoder.read_u32_le()?;
1296    let time = decoder.read_u64_le()?;
1297    let remote = NetAddress::decode_from(decoder)?;
1298    let nonce = decoder.read_array()?;
1299    let agent_length = usize::from(decoder.read_u8()?);
1300    let agent = decode_hsd_ascii(decoder.read_slice(agent_length)?);
1301    let height = decoder.read_u32_le()?;
1302    // HSD treats exactly one as true and every other value as false.
1303    let no_relay = decoder.read_u8()? == 1;
1304    Ok(VersionPacket {
1305        version,
1306        services,
1307        time,
1308        remote,
1309        nonce,
1310        agent,
1311        height,
1312        no_relay,
1313    })
1314}
1315
1316fn encode_inventory(items: &[Inventory], encoder: &mut Encoder) -> Result<(), WireError> {
1317    check_count("inventory", items.len(), MAX_INVENTORY_ITEMS)?;
1318    encoder.put_compact_size(items.len() as u64);
1319    for item in items {
1320        encoder.put_u32_le(item.kind.as_u32());
1321        encoder.put_bytes(&item.hash);
1322    }
1323    Ok(())
1324}
1325
1326fn decode_inventory(decoder: &mut Decoder<'_>) -> Result<Vec<Inventory>, WireError> {
1327    let count = read_count(decoder, "inventory", MAX_INVENTORY_ITEMS)?;
1328    let mut items = Vec::with_capacity(count);
1329    for _ in 0..count {
1330        items.push(Inventory {
1331            kind: InventoryKind::from_u32(decoder.read_u32_le()?),
1332            hash: decoder.read_array()?,
1333        });
1334    }
1335    Ok(items)
1336}
1337
1338fn encode_reject(packet: &RejectPacket, encoder: &mut Encoder) -> Result<(), WireError> {
1339    check_ascii_u8("reject reason", &packet.reason, MAX_REJECT_REASON_SIZE)?;
1340    if packet.message.carries_reject_hash() != packet.hash.is_some() {
1341        return Err(WireError::InvalidPacket {
1342            context: "reject packet",
1343            reason: "hash presence does not match the rejected packet type",
1344        });
1345    }
1346    encoder.put_u8(packet.message.as_u8());
1347    encoder.put_u8(packet.code);
1348    encoder.put_u8(packet.reason.len() as u8);
1349    encoder.put_bytes(packet.reason.as_bytes());
1350    if let Some(hash) = packet.hash {
1351        encoder.put_bytes(&hash);
1352    }
1353    Ok(())
1354}
1355
1356fn decode_reject(decoder: &mut Decoder<'_>) -> Result<RejectPacket, WireError> {
1357    let message = PacketType::from_u8(decoder.read_u8()?);
1358    let code = decoder.read_u8()?;
1359    let reason_length = usize::from(decoder.read_u8()?);
1360    let reason = decode_hsd_ascii(decoder.read_slice(reason_length)?);
1361    let hash = if message.carries_reject_hash() {
1362        Some(decoder.read_array()?)
1363    } else {
1364        None
1365    };
1366    Ok(RejectPacket {
1367        message,
1368        code,
1369        reason,
1370        hash,
1371    })
1372}
1373
1374fn read_count(
1375    decoder: &mut Decoder<'_>,
1376    context: &'static str,
1377    maximum: usize,
1378) -> Result<usize, WireError> {
1379    let value = decoder.read_compact_size()?;
1380    let actual = usize::try_from(value).unwrap_or(usize::MAX);
1381    check_count(context, actual, maximum)?;
1382    Ok(actual)
1383}
1384
1385fn read_bounded_index(
1386    decoder: &mut Decoder<'_>,
1387    context: &'static str,
1388) -> Result<usize, WireError> {
1389    let value = decoder.read_compact_size()?;
1390    let actual = usize::try_from(value).unwrap_or(usize::MAX);
1391    check_count(context, actual, u16::MAX as usize)?;
1392    Ok(actual)
1393}
1394
1395fn absolute_prefilled_index(
1396    previous: Option<usize>,
1397    differential: usize,
1398) -> Result<usize, CompactBlockError> {
1399    match previous {
1400        Some(previous) => previous
1401            .checked_add(differential)
1402            .and_then(|index| index.checked_add(1))
1403            .filter(|index| *index <= u16::MAX as usize)
1404            .ok_or_else(|| CompactBlockError::Malformed("differential index overflow".to_owned())),
1405        None if differential <= u16::MAX as usize => Ok(differential),
1406        None => Err(CompactBlockError::Malformed(
1407            "first differential index exceeds u16".to_owned(),
1408        )),
1409    }
1410}
1411
1412fn validate_absolute_indexes(indexes: &[usize]) -> Result<(), CompactBlockError> {
1413    if indexes.len() > MAX_COMPACT_BLOCK_TRANSACTIONS {
1414        return Err(CompactBlockError::Malformed(format!(
1415            "index count {} exceeds {MAX_COMPACT_BLOCK_TRANSACTIONS}",
1416            indexes.len()
1417        )));
1418    }
1419    let mut previous = None;
1420    for index in indexes.iter().copied() {
1421        if index > u16::MAX as usize {
1422            return Err(CompactBlockError::Malformed(format!(
1423                "transaction index {index} exceeds u16"
1424            )));
1425        }
1426        if previous.is_some_and(|previous| previous >= index) {
1427            return Err(CompactBlockError::Malformed(
1428                "absolute transaction indexes are not strictly increasing".to_owned(),
1429            ));
1430        }
1431        previous = Some(index);
1432    }
1433    Ok(())
1434}
1435
1436fn check_count(context: &'static str, actual: usize, maximum: usize) -> Result<(), WireError> {
1437    if actual > maximum {
1438        return Err(WireError::CountTooLarge {
1439            context,
1440            actual,
1441            maximum,
1442        });
1443    }
1444    Ok(())
1445}
1446
1447fn check_payload_size(actual: usize) -> Result<(), WireError> {
1448    if actual > MAX_FRAME_PAYLOAD_SIZE {
1449        return Err(WireError::PayloadTooLarge {
1450            actual,
1451            maximum: MAX_FRAME_PAYLOAD_SIZE,
1452        });
1453    }
1454    Ok(())
1455}
1456
1457fn check_ascii_u8(context: &'static str, value: &str, maximum: usize) -> Result<(), WireError> {
1458    if value.len() > maximum {
1459        return Err(WireError::CountTooLarge {
1460            context,
1461            actual: value.len(),
1462            maximum,
1463        });
1464    }
1465    if !value.is_ascii() {
1466        return Err(WireError::InvalidPacket {
1467            context,
1468            reason: "outbound text must be ASCII",
1469        });
1470    }
1471    Ok(())
1472}
1473
1474fn decode_hsd_ascii(input: &[u8]) -> String {
1475    input.iter().map(|byte| char::from(byte & 0x7f)).collect()
1476}
1477
1478fn take_remaining(decoder: &mut Decoder<'_>) -> Result<Vec<u8>, WireError> {
1479    Ok(decoder.read_slice(decoder.remaining())?.to_vec())
1480}
1481
1482fn blake2b_256_many(parts: &[&[u8]]) -> [u8; 32] {
1483    let mut hasher = Blake2bVar::new(32).expect("valid BLAKE2b output size");
1484    for part in parts {
1485        hasher.update(part);
1486    }
1487    let mut output = [0_u8; 32];
1488    hasher
1489        .finalize_variable(&mut output)
1490        .expect("output buffer has the requested size");
1491    output
1492}
1493
1494fn siphash24(input: &[u8], key: &[u8; 16]) -> u64 {
1495    let key0 = u64::from_le_bytes(key[..8].try_into().expect("eight-byte key half"));
1496    let key1 = u64::from_le_bytes(key[8..].try_into().expect("eight-byte key half"));
1497    let mut state = [
1498        key0 ^ 0x736f_6d65_7073_6575,
1499        key1 ^ 0x646f_7261_6e64_6f6d,
1500        key0 ^ 0x6c79_6765_6e65_7261,
1501        key1 ^ 0x7465_6462_7974_6573,
1502    ];
1503
1504    let mut chunks = input.chunks_exact(8);
1505    for chunk in &mut chunks {
1506        let message = u64::from_le_bytes(chunk.try_into().expect("eight-byte chunk"));
1507        state[3] ^= message;
1508        siphash_round(&mut state);
1509        siphash_round(&mut state);
1510        state[0] ^= message;
1511    }
1512
1513    let mut tail = (input.len() as u64) << 56;
1514    for (offset, byte) in chunks.remainder().iter().copied().enumerate() {
1515        tail |= u64::from(byte) << (8 * offset);
1516    }
1517    state[3] ^= tail;
1518    siphash_round(&mut state);
1519    siphash_round(&mut state);
1520    state[0] ^= tail;
1521    state[2] ^= 0xff;
1522    for _ in 0..4 {
1523        siphash_round(&mut state);
1524    }
1525    state[0] ^ state[1] ^ state[2] ^ state[3]
1526}
1527
1528fn siphash_round(state: &mut [u64; 4]) {
1529    state[0] = state[0].wrapping_add(state[1]);
1530    state[1] = state[1].rotate_left(13);
1531    state[1] ^= state[0];
1532    state[0] = state[0].rotate_left(32);
1533    state[2] = state[2].wrapping_add(state[3]);
1534    state[3] = state[3].rotate_left(16);
1535    state[3] ^= state[2];
1536    state[0] = state[0].wrapping_add(state[3]);
1537    state[3] = state[3].rotate_left(21);
1538    state[3] ^= state[0];
1539    state[2] = state[2].wrapping_add(state[1]);
1540    state[1] = state[1].rotate_left(17);
1541    state[1] ^= state[2];
1542    state[2] = state[2].rotate_left(32);
1543}
1544
1545fn bytes_needed_for_frame(input: &[u8]) -> usize {
1546    if input.len() < FRAME_HEADER_SIZE {
1547        return FRAME_HEADER_SIZE - input.len();
1548    }
1549    let payload_length =
1550        u32::from_le_bytes(input[5..9].try_into().expect("frame length field")) as usize;
1551    FRAME_HEADER_SIZE
1552        .saturating_add(payload_length)
1553        .saturating_sub(input.len())
1554}
1555
1556#[cfg(test)]
1557mod tests {
1558    use hns_transaction::{Address, Input, Outpoint, Output, Witness};
1559
1560    use super::*;
1561
1562    const VERSION_PAYLOAD: &str = "03000000010000000000000006050403020100000403020100000000efcdab89000000000000000000000000000000ffff000000000000000000000000000000000000000000000000d6360211111111111111111111111111111111111111111111111111111111111111110102030405060708132f687372642d6f7261636c653a302e312e302f40e2010001";
1563    const VERSION_FRAME: &str = "d3f26e5b008d00000003000000010000000000000006050403020100000403020100000000efcdab89000000000000000000000000000000ffff000000000000000000000000000000000000000000000000d6360211111111111111111111111111111111111111111111111111111111111111110102030405060708132f687372642d6f7261636c653a302e312e302f40e2010001";
1564    const HEADER_PAYLOAD: &str = "017856341206050403020100000101010101010101010101010101010101010101010101010101010101010101040404040404040404040404040404040404040404040404040404040404040406060606060606060606060606060606060606060606060605050505050505050505050505050505050505050505050505050505050505050303030303030303030303030303030303030303030303030303030303030303020202020202020202020202020202020202020202020202020202020202020207000000ffff001d0707070707070707070707070707070707070707070707070707070707070707";
1565    const CMPCTBLOCK_PAYLOAD: &str = "7856341206050403020100000101010101010101010101010101010101010101010101010101010101010101040404040404040404040404040404040404040404040404040404040404040406060606060606060606060606060606060606060606060605050505050505050505050505050505050505050505050505050505050505050303030303030303030303030303030303030303030303030303030303030303020202020202020202020202020202020202020202020202020202020202020207000000ffff001d0707070707070707070707070707070707070707070707070707070707070707010203040506070802d8451ace6e01662b3c2ef01b0100010000000101010101010101010101010101010101010101010101010101010101010101010100000001ffffff01e9030000000000000014000000000000000000000000000000000000000000000100000001020102";
1566    const GETBLOCKTXN_PAYLOAD: &str =
1567        "e6c0e40f86adaaa4c2cf6e1be9525a8bb440fd5d4caad2e28f0cec6368d5a879020100";
1568    const BLOCKTXN_PAYLOAD: &str = "e6c0e40f86adaaa4c2cf6e1be9525a8bb440fd5d4caad2e28f0cec6368d5a87902020000000102020202020202020202020202020202020202020202020202020202020202020200000002ffffff01ea030000000000000014000000000000000000000000000000000000000000000200000001020203030000000103030303030303030303030303030303030303030303030303030303030303030300000003ffffff01eb030000000000000014000000000000000000000000000000000000000000000300000001020304";
1569
1570    fn decode_hex(value: &str) -> Vec<u8> {
1571        hex::decode(value).expect("valid fixture hex")
1572    }
1573
1574    fn valid_compact_source() -> Block {
1575        let coinbase = Transaction {
1576            version: 0,
1577            inputs: vec![Input {
1578                previous_output: Outpoint::NULL,
1579                sequence: 1,
1580                witness: Witness {
1581                    items: vec![b"hns-rs".to_vec(), vec![0; 8], vec![0; 8]],
1582                },
1583            }],
1584            outputs: vec![Output {
1585                value: 1_000_u64.into(),
1586                address: Address::new(0, vec![1; 20]).unwrap(),
1587                covenant: Default::default(),
1588            }],
1589            locktime: 1,
1590        };
1591        let coinbase_hash = coinbase.transaction_hash().unwrap();
1592        let spend = |index: u32| Transaction {
1593            version: 0,
1594            inputs: vec![Input {
1595                previous_output: Outpoint {
1596                    transaction_hash: coinbase_hash,
1597                    index,
1598                },
1599                sequence: u32::MAX,
1600                witness: Witness::default(),
1601            }],
1602            outputs: vec![Output {
1603                value: u64::from(900 - index).into(),
1604                address: Address::new(0, vec![index as u8 + 2; 20]).unwrap(),
1605                covenant: Default::default(),
1606            }],
1607            locktime: 0,
1608        };
1609        let transactions = vec![coinbase, spend(0), spend(1)];
1610        let header = Header {
1611            merkle_root: hns_mining::block_merkle_root(&transactions).unwrap(),
1612            witness_root: hns_mining::block_witness_root(&transactions).unwrap(),
1613            ..Header::default()
1614        };
1615        let block = Block {
1616            header,
1617            transactions,
1618        };
1619        validate_block_body(&block).unwrap();
1620        block
1621    }
1622
1623    #[test]
1624    fn packet_type_assignments_match_hsd() {
1625        let expected = [
1626            PacketType::Version,
1627            PacketType::Verack,
1628            PacketType::Ping,
1629            PacketType::Pong,
1630            PacketType::GetAddr,
1631            PacketType::Addr,
1632            PacketType::Inv,
1633            PacketType::GetData,
1634            PacketType::NotFound,
1635            PacketType::GetBlocks,
1636            PacketType::GetHeaders,
1637            PacketType::Headers,
1638            PacketType::SendHeaders,
1639            PacketType::Block,
1640            PacketType::Tx,
1641            PacketType::Reject,
1642            PacketType::Mempool,
1643            PacketType::FilterLoad,
1644            PacketType::FilterAdd,
1645            PacketType::FilterClear,
1646            PacketType::MerkleBlock,
1647            PacketType::FeeFilter,
1648            PacketType::SendCmpct,
1649            PacketType::CmpctBlock,
1650            PacketType::GetBlockTxn,
1651            PacketType::BlockTxn,
1652            PacketType::GetProof,
1653            PacketType::Proof,
1654            PacketType::Claim,
1655            PacketType::Airdrop,
1656        ];
1657        for (value, packet_type) in expected.into_iter().enumerate() {
1658            assert_eq!(packet_type.as_u8(), value as u8);
1659            assert_eq!(PacketType::from_u8(value as u8), packet_type);
1660        }
1661        assert_eq!(PacketType::from_u8(254), PacketType::Unknown(254));
1662    }
1663
1664    #[test]
1665    fn all_network_ping_frames_match_hsd() {
1666        let fixtures = [
1667            (
1668                NetworkMagic::Mainnet,
1669                "0102030405060708",
1670                "d3f26e5b02080000000102030405060708",
1671            ),
1672            (
1673                NetworkMagic::Testnet,
1674                "4242424242424242",
1675                "d20d52b102080000004242424242424242",
1676            ),
1677            (
1678                NetworkMagic::Regtest,
1679                "4343434343434343",
1680                "cf9538ae02080000004343434343434343",
1681            ),
1682            (
1683                NetworkMagic::Simnet,
1684                "4444444444444444",
1685                "dc8e640e02080000004444444444444444",
1686            ),
1687        ];
1688        for (network, payload, encoded) in fixtures {
1689            let frame = Frame::new(PacketType::Ping, decode_hex(payload)).unwrap();
1690            assert_eq!(frame.encode(network).unwrap(), decode_hex(encoded));
1691            assert_eq!(
1692                Frame::decode_exact(network, &decode_hex(encoded)).unwrap(),
1693                frame
1694            );
1695        }
1696    }
1697
1698    #[test]
1699    fn version_packet_matches_hsd_and_preserves_decode_quirks() {
1700        let frame = Frame::decode_exact(NetworkMagic::Mainnet, &decode_hex(VERSION_FRAME)).unwrap();
1701        assert_eq!(frame.payload, decode_hex(VERSION_PAYLOAD));
1702        let Packet::Version(version) = frame.decode_packet().unwrap() else {
1703            panic!("expected version packet");
1704        };
1705        assert_eq!(version.version, 3);
1706        assert_eq!(version.services, 1);
1707        assert_eq!(version.time, 0x0000_0102_0304_0506);
1708        assert_eq!(version.remote.time, 0x0102_0304);
1709        assert_eq!(version.remote.services, 0x89ab_cdef);
1710        assert_eq!(version.remote.port, 14_038);
1711        assert_eq!(version.agent, "/hsrd-oracle:0.1.0/");
1712        assert_eq!(version.height, 123_456);
1713        assert!(version.no_relay);
1714        assert_eq!(
1715            Frame::from_packet(&Packet::Version(version))
1716                .unwrap()
1717                .encode(NetworkMagic::Mainnet)
1718                .unwrap(),
1719            decode_hex(VERSION_FRAME)
1720        );
1721
1722        let mut noncanonical = decode_hex(VERSION_PAYLOAD);
1723        *noncanonical.last_mut().unwrap() = 2;
1724        let Packet::Version(version) = Packet::decode(PacketType::Version, &noncanonical).unwrap()
1725        else {
1726            panic!("expected version packet");
1727        };
1728        assert!(!version.no_relay);
1729
1730        let agent_offset = noncanonical.len() - 1 - 4 - 19;
1731        noncanonical[agent_offset] = 0x80;
1732        noncanonical[agent_offset + 1] = 0xff;
1733        let Packet::Version(version) = Packet::decode(PacketType::Version, &noncanonical).unwrap()
1734        else {
1735            panic!("expected version packet");
1736        };
1737        assert_eq!(version.agent.as_bytes()[..2], [0, 0x7f]);
1738    }
1739
1740    #[test]
1741    fn address_normalization_and_inventory_match_hsd() {
1742        let unsupported = decode_hex(concat!(
1743            "7b0000000000000007000000ddccbbaa09",
1744            "555555555555555555555555555555555555555555555555555555555555555555555555",
1745            "d636222222222222222222222222222222222222222222222222222222222222222222"
1746        ));
1747        let address = NetAddress::decode(&unsupported).unwrap();
1748        assert_eq!(address.ip, [0; 16]);
1749        assert_eq!(address.services, 7);
1750        let canonical = decode_hex(concat!(
1751            "7b00000000000000070000000000000000",
1752            "000000000000000000000000000000000000000000000000000000000000000000000000",
1753            "d636222222222222222222222222222222222222222222222222222222222222222222"
1754        ));
1755        assert_eq!(address.encode(), canonical.as_slice());
1756
1757        let payload = decode_hex(
1758            "02020000002121212121212121212121212121212121212121212121212121212121212121efbeedfe2222222222222222222222222222222222222222222222222222222222222222",
1759        );
1760        let Packet::Inv(items) = Packet::decode(PacketType::Inv, &payload).unwrap() else {
1761            panic!("expected inventory packet");
1762        };
1763        assert_eq!(items[0].kind, InventoryKind::Block);
1764        assert_eq!(items[1].kind, InventoryKind::Unknown(0xfeed_beef));
1765        assert_eq!(Packet::Inv(items).encode_payload().unwrap(), payload);
1766    }
1767
1768    #[test]
1769    fn locators_headers_reject_and_filters_match_hsd() {
1770        let locator = decode_hex(
1771            "02313131313131313131313131313131313131313131313131313131313131313132323232323232323232323232323232323232323232323232323232323232323333333333333333333333333333333333333333333333333333333333333333",
1772        );
1773        let packet = Packet::decode(PacketType::GetHeaders, &locator).unwrap();
1774        assert_eq!(packet.encode_payload().unwrap(), locator);
1775
1776        let headers = decode_hex(HEADER_PAYLOAD);
1777        let packet = Packet::decode(PacketType::Headers, &headers).unwrap();
1778        assert_eq!(packet.encode_payload().unwrap(), headers);
1779
1780        let reject = decode_hex(concat!(
1781            "0d10096261642d626c6f636b",
1782            "5151515151515151515151515151515151515151515151515151515151515151"
1783        ));
1784        let packet = Packet::decode(PacketType::Reject, &reject).unwrap();
1785        assert_eq!(packet.encode_payload().unwrap(), reject);
1786
1787        let fee = decode_hex("7929edffffffffff");
1788        assert_eq!(
1789            Packet::decode(PacketType::FeeFilter, &fee).unwrap(),
1790            Packet::FeeFilter(-1_234_567)
1791        );
1792        let compact = decode_hex("010200000000000000");
1793        assert_eq!(
1794            Packet::decode(PacketType::SendCmpct, &compact)
1795                .unwrap()
1796                .encode_payload()
1797                .unwrap(),
1798            compact
1799        );
1800    }
1801
1802    #[test]
1803    fn syntactic_block_packet_matches_hsd_fixture() {
1804        let payload = vec![0; HEADER_SIZE + 1];
1805        let packet = Packet::decode(PacketType::Block, &payload).unwrap();
1806        assert_eq!(packet.encode_payload().unwrap(), payload);
1807        let Packet::Block(block) = packet else {
1808            panic!("expected block packet");
1809        };
1810        assert!(block.transactions.is_empty());
1811    }
1812
1813    #[test]
1814    fn compact_block_packets_match_hsd_and_reconstruct() {
1815        let compact_payload = decode_hex(CMPCTBLOCK_PAYLOAD);
1816        let Packet::CmpctBlock(compact) =
1817            Packet::decode(PacketType::CmpctBlock, &compact_payload).unwrap()
1818        else {
1819            panic!("expected compact block");
1820        };
1821        assert_eq!(compact.total_transactions(), 3);
1822        assert_eq!(
1823            Packet::CmpctBlock(compact.clone())
1824                .encode_payload()
1825                .unwrap(),
1826            compact_payload
1827        );
1828
1829        let request_payload = decode_hex(GETBLOCKTXN_PAYLOAD);
1830        let Packet::GetBlockTxn(request) =
1831            Packet::decode(PacketType::GetBlockTxn, &request_payload).unwrap()
1832        else {
1833            panic!("expected compact-block request");
1834        };
1835        assert_eq!(request.block_hash, compact.hash());
1836        assert_eq!(request.indexes, [1, 2]);
1837        assert_eq!(
1838            Packet::GetBlockTxn(request.clone())
1839                .encode_payload()
1840                .unwrap(),
1841            request_payload
1842        );
1843
1844        let response_payload = decode_hex(BLOCKTXN_PAYLOAD);
1845        let Packet::BlockTxn(response) =
1846            Packet::decode(PacketType::BlockTxn, &response_payload).unwrap()
1847        else {
1848            panic!("expected compact-block response");
1849        };
1850        assert_eq!(response.block_hash, compact.hash());
1851        assert_eq!(response.transactions.len(), 2);
1852        assert_eq!(
1853            Packet::BlockTxn(response.clone()).encode_payload().unwrap(),
1854            response_payload
1855        );
1856
1857        let mut reconstruction = compact.reconstruct(&[]).unwrap();
1858        assert!(!reconstruction.is_complete());
1859        assert_eq!(reconstruction.missing_request(), request);
1860        reconstruction.fill_missing(response).unwrap();
1861        assert!(reconstruction.is_complete());
1862        assert!(matches!(
1863            reconstruction.into_block(),
1864            Err(CompactBlockError::InvalidBlockBody)
1865        ));
1866    }
1867
1868    #[test]
1869    fn compact_block_codecs_reject_ambiguous_or_malformed_data() {
1870        let Packet::CmpctBlock(mut compact) =
1871            Packet::decode(PacketType::CmpctBlock, &decode_hex(CMPCTBLOCK_PAYLOAD)).unwrap()
1872        else {
1873            panic!("expected compact block");
1874        };
1875        compact.short_ids[1] = compact.short_ids[0];
1876        assert!(matches!(
1877            compact.reconstruct(&[]),
1878            Err(CompactBlockError::ShortIdCollision(_))
1879        ));
1880
1881        let request = CompactBlockRequest {
1882            block_hash: compact.hash(),
1883            indexes: vec![2, 2],
1884        };
1885        assert!(matches!(
1886            Packet::GetBlockTxn(request).encode_payload(),
1887            Err(WireError::CompactBlock(CompactBlockError::Malformed(_)))
1888        ));
1889
1890        let block = valid_compact_source();
1891        let valid_compact =
1892            CompactBlock::from_block_with_nonce(&block, [1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
1893        let mut reconstruction = valid_compact.reconstruct(&[]).unwrap();
1894        let request = reconstruction.missing_request();
1895        let mut response = CompactBlockResponse::from_block(&block, &request).unwrap();
1896        response.transactions[0].outputs[0].value = 0_u64.into();
1897        reconstruction.fill_missing(response).unwrap();
1898        assert!(matches!(
1899            reconstruction.into_block(),
1900            Err(CompactBlockError::InvalidBlockBody)
1901        ));
1902
1903        let mut wrong_request = request;
1904        wrong_request.block_hash = BlockHash::new([0xff; 32]);
1905        assert!(matches!(
1906            CompactBlockResponse::from_block(&block, &wrong_request),
1907            Err(CompactBlockError::ResponseHashMismatch)
1908        ));
1909
1910        let mut trailing = decode_hex(GETBLOCKTXN_PAYLOAD);
1911        trailing.push(0);
1912        assert!(matches!(
1913            Packet::decode(PacketType::GetBlockTxn, &trailing),
1914            Err(WireError::Decode(DecodeError::TrailingBytes {
1915                remaining: 1
1916            }))
1917        ));
1918    }
1919
1920    #[test]
1921    fn compact_block_reconstruction_validates_the_final_body() {
1922        let block = valid_compact_source();
1923        let compact =
1924            CompactBlock::from_block_with_nonce(&block, [8, 7, 6, 5, 4, 3, 2, 1]).unwrap();
1925        let mut reconstruction = compact
1926            .reconstruct(std::slice::from_ref(&block.transactions[1]))
1927            .unwrap();
1928        assert_eq!(reconstruction.missing_request().indexes, [2]);
1929        let response =
1930            CompactBlockResponse::from_block(&block, &reconstruction.missing_request()).unwrap();
1931        reconstruction.fill_missing(response).unwrap();
1932        assert_eq!(reconstruction.into_block().unwrap(), block);
1933    }
1934
1935    #[test]
1936    fn proof_transport_verifies_and_rejects_trailing_bytes() {
1937        let proof = HsdUrkelProof::decode_strict(&[0, 0, 0, 0]).unwrap();
1938        let packet = Packet::Proof(ProofPacket {
1939            root: TreeRoot::new([0; 32]),
1940            key: NameHash::new([7; 32]),
1941            proof,
1942        });
1943        let payload = packet.encode_payload().unwrap();
1944        let decoded = Packet::decode(PacketType::Proof, &payload).unwrap();
1945        assert_eq!(decoded, packet);
1946        let Packet::Proof(proof) = decoded else {
1947            panic!("expected proof packet");
1948        };
1949        assert_eq!(proof.verify().unwrap(), None);
1950
1951        let mut trailing = payload;
1952        trailing.push(0);
1953        assert!(matches!(
1954            Packet::decode(PacketType::Proof, &trailing),
1955            Err(WireError::Urkel(UrkelError::TrailingBytes(1)))
1956        ));
1957    }
1958
1959    #[test]
1960    fn framing_is_incremental_and_bounded() {
1961        let first = decode_hex("cf9538ae02080000004343434343434343");
1962        let second = decode_hex("cf9538ae02080000004444444444444444");
1963        let mut decoder = FrameDecoder::new(NetworkMagic::Regtest);
1964        assert!(decoder.push(&first[..5]).unwrap().is_empty());
1965        assert_eq!(decoder.buffered_len(), 5);
1966        let mut remainder = first[5..].to_vec();
1967        remainder.extend_from_slice(&second);
1968        let frames = decoder.push(&remainder).unwrap();
1969        assert_eq!(frames.len(), 2);
1970        assert_eq!(decoder.buffered_len(), 0);
1971
1972        let mut wrong_magic = first;
1973        wrong_magic[..4].copy_from_slice(&0_u32.to_le_bytes());
1974        assert!(matches!(
1975            Frame::decode_exact(NetworkMagic::Regtest, &wrong_magic),
1976            Err(WireError::NetworkMagicMismatch { .. })
1977        ));
1978
1979        let oversized = [
1980            &NetworkMagic::Regtest.as_u32().to_le_bytes()[..],
1981            &[PacketType::Ping.as_u8()],
1982            &(MAX_FRAME_PAYLOAD_SIZE as u32 + 1).to_le_bytes(),
1983        ]
1984        .concat();
1985        assert!(matches!(
1986            Frame::decode_exact(NetworkMagic::Regtest, &oversized),
1987            Err(WireError::PayloadTooLarge { .. })
1988        ));
1989    }
1990
1991    #[test]
1992    fn strict_packet_decoders_reject_trailing_and_noncanonical_counts() {
1993        assert!(matches!(
1994            Packet::decode(PacketType::Ping, &[0; 9]),
1995            Err(WireError::Decode(DecodeError::TrailingBytes {
1996                remaining: 1
1997            }))
1998        ));
1999        assert!(matches!(
2000            Packet::decode(PacketType::Inv, &[0xfd, 1, 0]),
2001            Err(WireError::Decode(DecodeError::InvalidValue { .. }))
2002        ));
2003        let oversized_count = [0xfd, 0x51, 0xc3];
2004        assert!(matches!(
2005            Packet::decode(PacketType::Headers, &oversized_count),
2006            Err(WireError::CountTooLarge { .. })
2007        ));
2008    }
2009}