Three Rust projects,
running in this page.

A block’s hash has to be reproducible byte for byte, on any machine, in any order — otherwise two honest nodes derive different hashes from the same block and the chain forks for no reason. So the fields are fed to SHA-256 through a canonical length-prefixed encoding rather than any formatting the language happens to offer.

hasher.update(index.to_be_bytes());
hasher.update(timestamp.to_be_bytes());
hasher.update((transactions.len() as u64).to_be_bytes());
for tx in transactions {
    tx.hash_into(&mut hasher);   // length-prefixed too
}
hasher.update((previous_hash.len() as u64).to_be_bytes());
hasher.update(previous_hash.as_bytes());
hasher.update(nonce.to_be_bytes());

// rendered as hex, so a difficulty target is
// a plain string prefix comparison
hex::encode(hasher.finalize())
// "0000b1d8ddf4f6cf3e27cb81…"

Length-prefixing is what makes it unambiguous: without it, ("ab", "c") and ("a", "bc") hash identically, and a transaction could be rewritten without disturbing the digest. Validation re-derives every hash from scratch rather than trusting the one stored in the block — which is why the tamper button above gets caught.

TCP has no message boundaries: one read may hand you half a reply, or three replies at once. So decoding is incremental — Ok(None) means “a valid prefix, send more bytes”, and success reports exactly how many bytes were consumed so the connection can drain one frame and keep the rest.

pub fn decode(input: &[u8])
    -> Result<Option<(Value, usize)>, ProtocolError>

// Ok(Some((value, n)))  one frame, n bytes consumed
// Ok(None)              incomplete, read more
// Err(..)               malformed or hostile

The test suite feeds every prefix of a multi-frame buffer through the decoder, so a split at any byte offset is proven to be handled. Try the partial preset above to see it.