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 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 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 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 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}