← Watch feed
Add DecoderStatus return value to the Decoder trait
Public commit record
65/100 · Adequate
What the developer wrote
Authored by Nick Johnson
Add DecoderStatus return value to the Decoder trait
Same reasoning as the EncoderStatus, the type makes things a little
easier to reason about than a naked bool.
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
What changed, and why it matters
This commit is a straightforward internal refactoring of the rust-bitcoin library's decoding machinery. It replaces a plain true/false return value from decoder methods with a new named DecoderStatus enum (NeedsMore / Ready). The change is purely about making the code easier to read and maintain; it does not alter what data is accepted, rejected, or how it is parsed. There is no indication this fixes a security bug or introduces a vulnerability.
Recommended action
No security action required. Treat as a normal API/refactoring change. Reviewers may optionally verify that all call sites correctly map the old boolean polarity to the new enum variants, but the diff shows consistent conversion.
Security signals we found
01
No security-relevant behavioral change: boolean semantics are preserved under a new enum type.
02
No new validation, no relaxation of existing checks, and no change to read limits or allocation behavior.
03
All updates are mechanical rewrites of conditionals (e.g., `if needs_more` becomes `if status.needs_more()`).
04
No vendor disclosure, CVE, or researcher attribution present in the commit or supplied references.
Evidence from the diff
The patch changes the Decoder trait’s push_bytes signature from Result
Changed components
consensus_encoding/src/decode/mod.rsconsensus_encoding/src/decode/decoders.rsconsensus_encoding/src/compact_size.rsconsensus_encoding/src/lib.rsio/src/lib.rsp2p/src/message.rsp2p/src/message_network.rsprimitives/src/transaction.rsprimitives/src/witness.rsinclude/decoder_newtype.rsInspect captured patch +314 / −271
diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index f1cca3bc..31103bbe 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -75,6 +75,7 @@ exclude_re = [
"consensus_encoding/.* <impl Decoder for .*>::push_bytes", # Mutations cause an infinite loop
"consensus_encoding/.* <impl Encoder for .*>::advance", # Replacing the return with true causes an infinite loop.
"consensus_encoding/.* EncoderStatus::has_more", # Replacing with true causes an infinite loop
+ "consensus_encoding/.* DecoderStatus::is_ready", # Replacing with true causes an infinite loop
"consensus_encoding/.* delete ! in drain_to_vec", # Causes an infinite loop.
"consensus_encoding/.* delete ! in drain_to_writer", # Causes an infinite loop.
]
diff --git a/consensus_encoding/src/compact_size.rs b/consensus_encoding/src/compact_size.rs
index 9076afdb..4e44ea95 100644
--- a/consensus_encoding/src/compact_size.rs
+++ b/consensus_encoding/src/compact_size.rs
@@ -13,6 +13,7 @@ use crate::encode::{Encoder, EncoderStatus, ExactSizeEncoder};
use crate::error::{
CompactSizeDecoderError, CompactSizeDecoderErrorInner, LengthPrefixExceedsMaxError,
};
+use crate::DecoderStatus;
/// Default maximum size of a decoded object in bytes.
///
@@ -163,7 +164,7 @@ impl Decoder for CompactSizeDecoder {
type Output = usize;
type Error = CompactSizeDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
Ok(compact_size_push_bytes(&mut self.buf, bytes))
}
@@ -232,7 +233,7 @@ impl Decoder for CompactSizeU64Decoder {
type Output = u64;
type Error = CompactSizeDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
Ok(compact_size_push_bytes(&mut self.buf, bytes))
}
@@ -241,10 +242,10 @@ impl Decoder for CompactSizeU64Decoder {
fn read_limit(&self) -> usize { compact_size_read_limit(&self.buf) }
}
-/// Pushes bytes into a compact size buffer, returning true if more bytes are needed.
-fn compact_size_push_bytes(buf: &mut ArrayVec<u8, 9>, bytes: &mut &[u8]) -> bool {
+/// Pushes bytes into a compact size buffer, returning the decoder status.
+fn compact_size_push_bytes(buf: &mut ArrayVec<u8, 9>, bytes: &mut &[u8]) -> DecoderStatus {
if bytes.is_empty() {
- return true;
+ return DecoderStatus::NeedsMore;
}
if buf.is_empty() {
@@ -261,7 +262,7 @@ fn compact_size_push_bytes(buf: &mut ArrayVec<u8, 9>, bytes: &mut &[u8]) -> bool
buf.extend_from_slice(&bytes[..to_copy]);
*bytes = &bytes[to_copy..];
- buf.len() != len
+ if buf.len() == len { DecoderStatus::Ready } else { DecoderStatus::NeedsMore }
}
/// Returns the number of bytes the compact size decoder still needs to read.
@@ -380,14 +381,14 @@ mod tests {
// MAX_COMPACT_SIZE should succeed for `new` constructor
// 0x0200_0000 as minimal 5-byte compact size: 0xFE + u32 little-endian
let mut decoder = CompactSizeDecoder::new();
- decoder.push_bytes(&mut [0xFE, 0x00, 0x00, 0x00, 0x02].as_slice()).unwrap();
+ let _ = decoder.push_bytes(&mut [0xFE, 0x00, 0x00, 0x00, 0x02].as_slice()).unwrap();
let got = decoder.end().unwrap();
assert_eq!(got, MAX_COMPACT_SIZE);
// MAX_COMPACT_SIZE + 1 should fail for `new` constructor
// 0x0200_0001 as minimal 5-byte compact size: 0xFE + u32 little-endian
let mut decoder = CompactSizeDecoder::new();
- decoder.push_bytes(&mut [0xFE, 0x01, 0x00, 0x00, 0x02].as_slice()).unwrap();
+ let _ = decoder.push_bytes(&mut [0xFE, 0x01, 0x00, 0x00, 0x02].as_slice()).unwrap();
let got = decoder.end().unwrap_err();
assert!(matches!(
got,
@@ -404,13 +405,13 @@ mod tests {
// 240 should succeed for `new_with_limit` constructor
let mut decoder = CompactSizeDecoder::new_with_limit(240);
- decoder.push_bytes(&mut [0xf0].as_slice()).unwrap();
+ let _ = decoder.push_bytes(&mut [0xf0].as_slice()).unwrap();
let got = decoder.end().unwrap();
assert_eq!(got, 240);
// 241 should fail for `new_with_limit` constructor
let mut decoder = CompactSizeDecoder::new_with_limit(240);
- decoder.push_bytes(&mut [0xf1].as_slice()).unwrap();
+ let _ = decoder.push_bytes(&mut [0xf1].as_slice()).unwrap();
let got = decoder.end().unwrap_err();
assert!(matches!(
got,
diff --git a/consensus_encoding/src/decode/decoders.rs b/consensus_encoding/src/decode/decoders.rs
index 0499c89a..3cf6962e 100644
--- a/consensus_encoding/src/decode/decoders.rs
+++ b/consensus_encoding/src/decode/decoders.rs
@@ -8,7 +8,7 @@ use core::{fmt, mem};
#[cfg(feature = "alloc")]
use super::Decode;
-use super::Decoder;
+use super::{Decoder, DecoderStatus};
#[cfg(feature = "alloc")]
use crate::compact_size::CompactSizeDecoder;
#[cfg(feature = "alloc")]
@@ -86,14 +86,14 @@ impl Decoder for ByteVecDecoder {
type Output = Vec<u8>;
type Error = ByteVecDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
use ByteVecDecoderError as E;
use ByteVecDecoderErrorInner as Inner;
if let Some(mut decoder) = self.prefix_decoder.take() {
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))? {
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))?.needs_more() {
self.prefix_decoder = Some(decoder);
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
self.bytes_expected = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
self.prefix_decoder = None;
@@ -111,8 +111,11 @@ impl Decoder for ByteVecDecoder {
self.bytes_written += copy_len;
*bytes = &bytes[copy_len..];
- // Return true if we still need more data.
- Ok(self.bytes_written < self.bytes_expected)
+ if self.bytes_written < self.bytes_expected {
+ Ok(DecoderStatus::NeedsMore)
+ } else {
+ Ok(DecoderStatus::Ready)
+ }
}
fn end(self) -> Result<Self::Output, Self::Error> {
@@ -232,18 +235,18 @@ impl<T: Decode> Decoder for VecDecoder<T> {
type Output = Vec<T>;
type Error = VecDecoderError<<<T as Decode>::Decoder as Decoder>::Error>;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
use VecDecoderError as E;
use VecDecoderErrorInner as Inner;
if let Some(mut decoder) = self.prefix_decoder.take() {
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))? {
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::LengthPrefixDecode(e)))?.needs_more() {
self.prefix_decoder = Some(decoder);
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
self.length = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
if self.length == 0 {
- return Ok(false);
+ return Ok(DecoderStatus::Ready);
}
self.prefix_decoder = None;
@@ -256,22 +259,22 @@ impl<T: Decode> Decoder for VecDecoder<T> {
let mut decoder = self.decoder.take().unwrap_or_else(T::decoder);
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::Item(e)))? {
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::Item(e)))?.needs_more() {
self.decoder = Some(decoder);
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
let item = decoder.end().map_err(|e| E(Inner::Item(e)))?;
self.buffer.push(item);
if self.buffer.len() == self.length {
- return Ok(false);
+ return Ok(DecoderStatus::Ready);
}
}
if self.buffer.len() == self.length {
- Ok(false)
+ Ok(DecoderStatus::Ready)
} else {
- Ok(true)
+ Ok(DecoderStatus::NeedsMore)
}
}
@@ -328,7 +331,7 @@ impl<const N: usize> Decoder for ArrayDecoder<N> {
type Output = [u8; N];
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
let remaining_space = N - self.bytes_written;
let copy_len = bytes.len().min(remaining_space);
@@ -340,8 +343,11 @@ impl<const N: usize> Decoder for ArrayDecoder<N> {
*bytes = &bytes[copy_len..];
}
- // Return true if we still need more data.
- Ok(self.bytes_written < N)
+ if self.bytes_written < N {
+ Ok(DecoderStatus::NeedsMore)
+ } else {
+ Ok(DecoderStatus::Ready)
+ }
}
#[inline]
@@ -431,13 +437,13 @@ where
type Output = (A::Output, B::Output);
type Error = Decoder2Error<A::Error, B::Error>;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
loop {
match &mut self.state {
Decoder2State::First(first_decoder, _) => {
- if first_decoder.push_bytes(bytes).map_err(Decoder2Error::First)? {
+ if first_decoder.push_bytes(bytes).map_err(Decoder2Error::First)?.needs_more() {
// First decoder wants more data.
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
// First decoder is complete, transition to second.
@@ -551,7 +557,7 @@ where
type Error = Decoder3Error<A::Error, B::Error, C::Error>;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(|error| match error {
Decoder2Error::First(Decoder2Error::First(a)) => Decoder3Error::First(a),
Decoder2Error::First(Decoder2Error::Second(b)) => Decoder3Error::Second(b),
@@ -637,7 +643,7 @@ where
type Error = Decoder4Error<A::Error, B::Error, C::Error, D::Error>;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(|error| match error {
Decoder2Error::First(Decoder2Error::First(a)) => Decoder4Error::First(a),
Decoder2Error::First(Decoder2Error::Second(b)) => Decoder4Error::Second(b),
@@ -745,7 +751,7 @@ where
type Error = Decoder6Error<A::Error, B::Error, C::Error, D::Error, E::Error, F::Error>;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(|error| match error {
Decoder2Error::First(Decoder3Error::First(a)) => Decoder6Error::First(a),
Decoder2Error::First(Decoder3Error::Second(b)) => Decoder6Error::Second(b),
@@ -905,7 +911,7 @@ mod tests {
type Output = Inner;
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -936,7 +942,7 @@ mod tests {
type Output = Test;
type Error = VecDecoderError<UnexpectedEofError>;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -961,7 +967,7 @@ mod tests {
let mut slice = encoded.as_slice();
let mut decoder = Test::decoder();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let got = decoder.end().unwrap();
let want = Test(vec![]);
@@ -978,7 +984,7 @@ mod tests {
let mut slice = encoded.as_slice();
let mut decoder = Test::decoder();
// Should want more bytes since we've provided nothing
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
assert!(matches!(
decoder.end().unwrap_err(),
diff --git a/consensus_encoding/src/decode/mod.rs b/consensus_encoding/src/decode/mod.rs
index 61215220..65b662f3 100644
--- a/consensus_encoding/src/decode/mod.rs
+++ b/consensus_encoding/src/decode/mod.rs
@@ -16,7 +16,7 @@ use crate::{DecodeError, UnconsumedError};
/// # Examples
///
/// ```
-/// use bitcoin_consensus_encoding::{decode_from_slice, Decode, Decoder, ArrayDecoder, UnexpectedEofError};
+/// use bitcoin_consensus_encoding::{decode_from_slice, Decode, Decoder, DecoderStatus, ArrayDecoder, UnexpectedEofError};
///
/// struct Foo([u8; 4]);
///
@@ -27,7 +27,7 @@ use crate::{DecodeError, UnconsumedError};
/// type Output = Foo;
/// type Error = UnexpectedEofError;
///
-/// fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+/// fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
/// self.0.push_bytes(bytes)
/// }
/// fn end(self) -> Result<Self::Output, Self::Error> { self.0.end().map(Foo) }
@@ -58,15 +58,15 @@ pub trait Decoder: Sized {
/// Pushes bytes into the decoder, consuming as much as possible.
///
- /// The slice reference will be advanced to point to the unconsumed portion. Returns `Ok(true)`
- /// if more bytes are needed to complete decoding, `Ok(false)` if the decoder is ready to
+ /// The slice reference will be advanced to point to the unconsumed portion. Returns `Ok(DecoderStatus::NeedsMore)`
+ /// if more bytes are needed to complete decoding, `Ok(DecoderStatus::Ready)` if the decoder is ready to
/// finalize with [`Self::end`], or `Err(error)` if parsing failed.
///
/// # Errors
///
/// Returns an error if the provided bytes are invalid or malformed according to the decoder's
/// validation rules. Insufficient data (needing more bytes) is *not* an error for this method,
- /// the decoder will simply consume what it can and return `true` to indicate more data is
+ /// the decoder will simply consume what it can and return `DecoderStatus::NeedsMore` to indicate more data is
/// needed.
///
/// # Panics
@@ -74,7 +74,7 @@ pub trait Decoder: Sized {
/// May panic if called after a previous call to [`Self::push_bytes`] errored.
#[must_use = "must check result to avoid panics on subsequent calls"]
#[track_caller]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error>;
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error>;
/// Completes the decoding process and return the final result.
///
@@ -100,6 +100,35 @@ pub trait Decoder: Sized {
fn read_limit(&self) -> usize;
}
+/// Indicates whether a decoder needs more data or is ready to finalize.
+///
+/// This is returned from the [`Decoder::push_bytes`] method to indicate whether the decoder
+/// should continue accumulating data or is ready to produce the decoded value with [`Decoder::end`].
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum DecoderStatus {
+ /// The decoder needs more data to complete decoding.
+ ///
+ /// Continue pushing byte slices with [`Decoder::push_bytes`] until this status changes to [`Ready`](DecoderStatus::Ready).
+ NeedsMore,
+
+ /// The decoder has accumulated sufficient data and is ready to finalize.
+ ///
+ /// Call [`Decoder::end`] to complete the decoding process and obtain the final result.
+ Ready,
+}
+
+impl DecoderStatus {
+ /// Returns `true` if the decoder needs more data to continue.
+ pub fn needs_more(&self) -> bool {
+ matches!(self, Self::NeedsMore)
+ }
+
+ /// Returns `true` if ready to produce decoded value with [`Decoder::end`].
+ pub fn is_ready(&self) -> bool {
+ matches!(self, Self::Ready)
+ }
+}
+
/// Decodes an object from a byte slice.
///
/// # Errors
@@ -139,7 +168,7 @@ where
let mut decoder = T::decoder();
while !bytes.is_empty() {
- if !decoder.push_bytes(bytes)? {
+ if decoder.push_bytes(bytes)?.is_ready() {
break;
}
}
@@ -181,11 +210,11 @@ where
}
let original_len = buffer.len();
- let need_more = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
+ let status = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
let consumed = original_len - buffer.len();
reader.consume(consumed);
- if !need_more {
+ if status.is_ready() {
return decoder.end().map_err(ReadError::Decode);
}
}
@@ -255,9 +284,10 @@ where
return decoder.end().map_err(ReadError::Decode);
}
Ok(bytes_read) => {
- if !decoder
+ if decoder
.push_bytes(&mut &clamped_buffer[..bytes_read])
.map_err(ReadError::Decode)?
+ .is_ready()
{
return decoder.end().map_err(ReadError::Decode);
}
diff --git a/consensus_encoding/src/lib.rs b/consensus_encoding/src/lib.rs
index 90ff151a..485cb565 100644
--- a/consensus_encoding/src/lib.rs
+++ b/consensus_encoding/src/lib.rs
@@ -83,7 +83,7 @@ pub use self::decode::{
decode_from_read, decode_from_read_unbuffered, decode_from_read_unbuffered_with,
};
#[doc(inline)]
-pub use self::decode::{decode_from_slice, decode_from_slice_unbounded, Decode, Decoder};
+pub use self::decode::{decode_from_slice, decode_from_slice_unbounded, Decode, Decoder, DecoderStatus};
#[doc(inline)]
pub use self::encode::encoders::{
ArrayEncoder, ArrayRefEncoder, BytesEncoder, Encoder2, Encoder3, Encoder4, Encoder6,
diff --git a/consensus_encoding/tests/api.rs b/consensus_encoding/tests/api.rs
index 434f419d..ce2cce6f 100644
--- a/consensus_encoding/tests/api.rs
+++ b/consensus_encoding/tests/api.rs
@@ -82,7 +82,7 @@ impl Decoder for FooDecoder {
type Output = Foo;
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
fn end(self) -> Result<Self::Output, Self::Error> { self.0.end().map(Foo) }
diff --git a/consensus_encoding/tests/compact_size.rs b/consensus_encoding/tests/compact_size.rs
index 13b0f9e6..65dbf149 100644
--- a/consensus_encoding/tests/compact_size.rs
+++ b/consensus_encoding/tests/compact_size.rs
@@ -27,7 +27,7 @@ impl Decoder for CompactSizeUsizeDecoderWrapper {
type Output = CompactSizeUsize;
type Error = CompactSizeDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -59,7 +59,7 @@ impl Decoder for CompactSizeU64DecoderWrapper {
type Output = CompactSizeU64;
type Error = CompactSizeDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -189,20 +189,20 @@ fn decoder_compact_size_read_limit_transitions() {
assert_eq!(decoder.read_limit(), 1);
let mut data = &[0xFD][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "should need more data after seeing 0xFD");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "should need more data after seeing 0xFD");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 2);
let mut data = &[0x00][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "should still need one more byte");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "should still need one more byte");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 1);
let mut data = &[0x01][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "should not need more data");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "should not need more data");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 0);
@@ -217,8 +217,8 @@ fn decoder_compact_size_single_byte_read_limit() {
assert_eq!(decoder.read_limit(), 1);
let mut data = &[0x42][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "single-byte value should be complete");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "single-byte value should be complete");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 0);
let result = decoder.end().unwrap();
@@ -235,11 +235,11 @@ fn decoder_compact_size_0xF0F0_F0F0_F0E0() {
for (i, _) in array.iter().enumerate() {
if i < array.len() - 1 {
let mut p = &array[i..=i];
- assert!(decoder.push_bytes(&mut p).unwrap());
+ assert!(decoder.push_bytes(&mut p).unwrap().needs_more());
} else {
// last byte: `push_bytes` should return false since no more bytes required.
let mut p = &array[i..];
- assert!(!decoder.push_bytes(&mut p).unwrap());
+ assert!(decoder.push_bytes(&mut p).unwrap().is_ready());
}
}
@@ -254,7 +254,7 @@ fn decoder_compact_size_zero() {
let mut slice = &encoded[..];
let mut decoder = CompactSizeDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let got = decoder.end().unwrap();
assert_eq!(got, 0);
@@ -266,7 +266,7 @@ fn decoder_compact_size_end_incomplete_one_byte() {
let mut slice = &encoded[..];
let mut decoder = CompactSizeDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::CompactSizeDecoderError { .. }));
@@ -278,7 +278,7 @@ fn decoder_compact_size_end_incomplete_three_byte() {
let mut slice = &encoded[..];
let mut decoder = CompactSizeDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::CompactSizeDecoderError { .. }));
@@ -290,7 +290,7 @@ fn decoder_compact_size_end_incomplete_five_byte() {
let mut slice = &encoded[..];
let mut decoder = CompactSizeDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::CompactSizeDecoderError { .. }));
@@ -302,7 +302,7 @@ fn decoder_compact_size_end_incomplete_nine_byte() {
let mut slice = &encoded[..];
let mut decoder = CompactSizeDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::CompactSizeDecoderError { .. }));
diff --git a/consensus_encoding/tests/composition.rs b/consensus_encoding/tests/composition.rs
index f9a7087f..4a054e2e 100644
--- a/consensus_encoding/tests/composition.rs
+++ b/consensus_encoding/tests/composition.rs
@@ -3,8 +3,8 @@
//! Test composition of encoders and decoders.
use bitcoin_consensus_encoding::{
- ArrayDecoder, BytesEncoder, check_encoder, Decoder, Decoder2, Decoder2Error, Decoder6, Encoder3,
- UnexpectedEofError,
+ ArrayDecoder, BytesEncoder, check_encoder, Decoder, Decoder2, Decoder2Error, DecoderStatus, Decoder6,
+ Encoder3, UnexpectedEofError,
};
#[cfg(feature = "alloc")]
use bitcoin_consensus_encoding::{
@@ -68,7 +68,7 @@ impl Decoder for CompositeDataDecoder {
type Output = CompositeData;
type Error = CompositeError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(|error| match error {
Decoder2Error::First(e) | Decoder2Error::Second(e) => CompositeError::Eof(e),
})
@@ -98,8 +98,8 @@ fn composition_chain() {
// Decode using the push decoder.
let mut decoder = CompositeData::decoder();
let mut bytes = &encoded_bytes[..];
- let needs_more = decoder.push_bytes(&mut bytes).unwrap();
- assert!(!needs_more, "CompositeData decoder should be ready to end");
+ let status = decoder.push_bytes(&mut bytes).unwrap();
+ assert!(status.is_ready(), "CompositeData decoder should be ready to end");
assert_eq!(bytes, EMPTY);
let decoded = decoder.end().unwrap();
assert_eq!(original, decoded);
@@ -131,8 +131,8 @@ fn composition_nested() {
ArrayDecoder::<1>::new(),
);
let mut bytes = &encoded_bytes[..];
- let needs_more = decoder6.push_bytes(&mut bytes).unwrap();
- assert!(!needs_more, "Decoder6 should be ready to end");
+ let status = decoder6.push_bytes(&mut bytes).unwrap();
+ assert!(status.is_ready(), "Decoder6 should be ready to end");
assert_eq!(bytes, EMPTY);
let (first, second, third, fourth, fifth, sixth) = decoder6.end().unwrap();
assert_eq!(first, [data[0]]);
@@ -151,8 +151,8 @@ fn composition_extra_bytes() {
let mut bytes = &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08][..];
let original_len = bytes.len();
- let needs_more = decoder2.push_bytes(&mut bytes).unwrap();
- assert!(!needs_more, "Decoder2 should be ready to end after consuming all needed bytes");
+ let status = decoder2.push_bytes(&mut bytes).unwrap();
+ assert!(status.is_ready(), "Decoder2 should be ready to end after consuming all needed bytes");
let consumed = original_len - bytes.len();
assert_eq!(consumed, 5, "Decoder2 should consume exactly 5 bytes");
@@ -216,7 +216,7 @@ fn composition_error_unification() {
type Output = ([u8; 1], [u8; 1]);
type Error = NestedError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(|error| match error {
Decoder2Error::First(e) | Decoder2Error::Second(e) => NestedError::from(e),
})
@@ -245,7 +245,7 @@ fn composition_error_unification() {
type Output = [u8; 4];
type Error = TopLevelError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
Ok(self.inner.push_bytes(bytes)?)
}
@@ -271,7 +271,7 @@ fn composition_error_unification() {
type Output = [u8; 1];
type Error = NestedError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(NestedError::from)
}
diff --git a/consensus_encoding/tests/decode.rs b/consensus_encoding/tests/decode.rs
index 2bc27c38..119471a7 100644
--- a/consensus_encoding/tests/decode.rs
+++ b/consensus_encoding/tests/decode.rs
@@ -20,8 +20,8 @@ const EMPTY: &[u8] = &[];
fn decode_array_excess_data_ignored() {
let mut decoder = ArrayDecoder::<4>::new();
let mut data = &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "ArrayDecoder should be complete after consuming all needed bytes");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "ArrayDecoder should be complete after consuming all needed bytes");
assert_eq!(data, &[0x05, 0x06]);
let result = decoder.end().unwrap();
assert_eq!(result, [0x01, 0x02, 0x03, 0x04]);
@@ -32,18 +32,18 @@ fn decode_array_streaming_behavior() {
let mut decoder = ArrayDecoder::<4>::new();
let mut data = &[0x01][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "ArrayDecoder should need more data after 1 byte");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "ArrayDecoder should need more data after 1 byte");
assert_eq!(data, EMPTY);
let mut data = &[0x02, 0x03][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "ArrayDecoder should need more data after 3 bytes");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "ArrayDecoder should need more data after 3 bytes");
assert_eq!(data, EMPTY);
let mut data = &[0x04, 0x05, 0x06][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "ArrayDecoder should be complete after 4 bytes");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "ArrayDecoder should be complete after 4 bytes");
assert_eq!(data, &[0x05, 0x06]);
let result = decoder.end().unwrap();
@@ -55,8 +55,8 @@ fn decode_array_insufficient_data_error() {
let mut decoder = ArrayDecoder::<5>::new();
let mut data = &[0xAA, 0xBB][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "ArrayDecoder should need more data after 2 bytes for 5-byte array");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "ArrayDecoder should need more data after 2 bytes for 5-byte array");
assert_eq!(data, EMPTY);
let err = decoder.end().unwrap_err();
@@ -69,8 +69,8 @@ fn decode_array_zero_size() {
let mut decoder = ArrayDecoder::<0>::new();
let mut data = &[0x01, 0x02, 0x03][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "zero-sized ArrayDecoder should not need data");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "zero-sized ArrayDecoder should not need data");
assert_eq!(data, &[0x01, 0x02, 0x03]);
let result = decoder.end().unwrap();
assert_eq!(result, [0u8; 0]);
@@ -86,8 +86,8 @@ fn decode_array_empty_slice_push() {
let mut decoder = ArrayDecoder::<3>::new();
let mut empty_data = &[][..];
- let needs_more = decoder.push_bytes(&mut empty_data).unwrap();
- assert!(needs_more, "decoder should still need data after empty push");
+ let status = decoder.push_bytes(&mut empty_data).unwrap();
+ assert!(status.needs_more(), "decoder should still need data after empty push");
assert_eq!(empty_data, &[0u8; 0]);
assert_eq!(decoder.read_limit(), 3);
}
@@ -100,14 +100,14 @@ fn decode_decoder2_state_transitions() {
assert_eq!(decoder.read_limit(), 5);
let mut data = &[0x01, 0x02][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more, "should need more data for second decoder");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "should need more data for second decoder");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 3);
let mut more_data = &[0x03, 0x04, 0x05][..];
- let needs_more = decoder.push_bytes(&mut more_data).unwrap();
- assert!(!needs_more, "should not need more data after completing both decoders");
+ let status = decoder.push_bytes(&mut more_data).unwrap();
+ assert!(status.is_ready(), "should not need more data after completing both decoders");
assert_eq!(more_data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 0);
@@ -126,8 +126,8 @@ fn decode_decoder2_read_limit_with_exhausted() {
let mut decoder2: Decoder2<ArrayDecoder<2>, ArrayDecoder<3>> =
Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
let mut data = &[0x01, 0x02][..];
- let needs_more = decoder2.push_bytes(&mut data).unwrap();
- assert!(needs_more, "should need more data for second decoder");
+ let status = decoder2.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more(), "should need more data for second decoder");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder2.read_limit(), 3);
}
@@ -185,8 +185,8 @@ fn decode_byte_vec_decoder_empty() {
let mut decoder = ByteVecDecoder::new();
let mut data = &[0x00][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(!needs_more, "decoder should not need more data for empty vector");
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.is_ready(), "decoder should not need more data for empty vector");
assert_eq!(data.len(), 0, "all data should be consumed");
assert_eq!(decoder.read_limit(), 0);
let result = decoder.end().unwrap();
@@ -200,7 +200,7 @@ fn decode_byte_vec_decoder_does_not_overconsume() {
let mut decoder = ByteVecDecoder::new();
let mut data = &[0x02, 0xAA, 0xBB, 0xCC, 0xDD][..];
- assert!(!decoder.push_bytes(&mut data).unwrap());
+ assert!(decoder.push_bytes(&mut data).unwrap().is_ready());
assert_eq!(data, &[0xCC, 0xDD][..]);
assert_eq!(decoder.end().unwrap(), vec![0xAA, 0xBB]);
}
@@ -217,11 +217,11 @@ fn decode_byte_vec_decoder_does_not_overconsume_on_second_chunk() {
let mut decoder = ByteVecDecoder::new();
- assert!(decoder.push_bytes(&mut first_chunk).unwrap());
+ assert!(decoder.push_bytes(&mut first_chunk).unwrap().needs_more());
assert!(first_chunk.is_empty());
- let needs_more = decoder.push_bytes(&mut second_chunk).unwrap();
- assert!(!needs_more);
+ let status = decoder.push_bytes(&mut second_chunk).unwrap();
+ assert!(status.is_ready());
assert_eq!(second_chunk, &[0x11, 0x22][..]);
let decoded_vec = decoder.end().unwrap();
@@ -244,7 +244,7 @@ impl Decoder for TestArrayDecoder {
type Output = TestArray;
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes)
}
@@ -401,7 +401,7 @@ impl Decoder for InnerDecoder {
type Output = Inner;
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -431,7 +431,7 @@ impl Decoder for TestDecoder {
type Output = Test;
type Error = VecDecoderError<UnexpectedEofError>;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -460,11 +460,11 @@ macro_rules! check_decode_one_byte_at_a_time {
for (i, _) in $array.iter().enumerate() {
if i < $array.len() - 1 {
let mut p = &$array[i..i+1];
- assert!(decoder.push_bytes(&mut p).unwrap());
+ assert!(decoder.push_bytes(&mut p).unwrap().needs_more());
} else {
- // last byte: `push_bytes` should return false since no more bytes required.
+ // last byte: `push_bytes` should return Ready since no more bytes required.
let mut p = &$array[i..];
- assert!(!decoder.push_bytes(&mut p).unwrap());
+ assert!(decoder.push_bytes(&mut p).unwrap().is_ready());
}
}
@@ -512,7 +512,7 @@ fn vec_decoder_empty() {
let mut slice = encoded.as_slice();
let mut decoder = Test::decoder();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let got = decoder.end().unwrap();
let want = Test(vec![]);
@@ -631,8 +631,8 @@ fn decode_vec_from_read_unbuffered_success() {
fn decode_byte_vec_decoder_end_incomplete_length_prefix() {
let mut decoder = ByteVecDecoder::new();
let mut data = &[0xFD, 0x05][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::ByteVecDecoderError { .. }));
@@ -644,8 +644,8 @@ fn decode_byte_vec_decoder_end_incomplete_data() {
// Length=5 but only 2 bytes of data.
let mut decoder = ByteVecDecoder::new();
let mut data = &[0x05, 0xAA, 0xBB][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::ByteVecDecoderError { .. }));
@@ -656,8 +656,8 @@ fn decode_byte_vec_decoder_end_incomplete_data() {
fn decode_vec_decoder_end_incomplete_length_prefix() {
let mut decoder = VecDecoder::<Inner>::new();
let mut data = &[0xFD, 0x05][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::VecDecoderError { .. }));
@@ -669,8 +669,8 @@ fn decode_vec_decoder_end_incomplete_item() {
// Length=3 but only 2 bytes of data.
let mut decoder = VecDecoder::<Inner>::new();
let mut data = &[0x03, 0xAA, 0xBB][..];
- let needs_more = decoder.push_bytes(&mut data).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut data).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, bitcoin_consensus_encoding::VecDecoderError { .. }));
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_array.rs b/fuzz/fuzz_targets/consensus_encoding/decode_array.rs
index 30e94b78..ecac0f47 100644
--- a/fuzz/fuzz_targets/consensus_encoding/decode_array.rs
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_array.rs
@@ -25,8 +25,8 @@ fn test_array_decoder<const N: usize>(data: &[u8]) {
Err(_) => {
// Expected for invalid data or other parsing errors.
}
- Ok(needs_more) => {
- if needs_more {
+ Ok(status) => {
+ if status.needs_more() {
// Decoder needs more data, but we've given it all we have
// This should result in an error when we call end().
let end_result = decoder.end();
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs b/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs
index cf0d2e0c..7616d6e7 100644
--- a/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_byte_vec.rs
@@ -16,8 +16,8 @@ fn do_test(data: &[u8]) {
Err(_) => {
// Expected for invalid data or allocation limits.
}
- Ok(needs_more) => {
- if needs_more {
+ Ok(status) => {
+ if status.needs_more() {
// Decoder needs more data, but we've given it all we have
// This should result in an error when we call end().
let end_result = decoder.end();
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs b/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs
index 8e5b0abf..3f68cd71 100644
--- a/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_compact_size.rs
@@ -16,8 +16,8 @@ fn do_test(data: &[u8]) {
Err(_) => {
// Expected for invalid compact size encodings.
}
- Ok(needs_more) => {
- if needs_more {
+ Ok(status) => {
+ if status.needs_more() {
// Decoder needs more data, but we've given it all we have
// This should result in an error when we call end().
let end_result = decoder.end();
diff --git a/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs b/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs
index 542f54ca..5d6d1b65 100644
--- a/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs
+++ b/fuzz/fuzz_targets/consensus_encoding/decode_decoder2.rs
@@ -17,8 +17,8 @@ fn do_test(data: &[u8]) {
Err(_) => {
// Expected for invalid data
}
- Ok(needs_more) => {
- if needs_more {
+ Ok(status) => {
+ if status.needs_more() {
let end_result = decoder.end();
assert!(
end_result.is_err(),
diff --git a/fuzz/src/lib.rs b/fuzz/src/lib.rs
index 745293cb..8e7ac745 100644
--- a/fuzz/src/lib.rs
+++ b/fuzz/src/lib.rs
@@ -47,7 +47,7 @@ where
let mut decoder = D::decoder();
loop {
let mut chunk = encoder.current_chunk();
- while !chunk.is_empty() && decoder.push_bytes(&mut chunk).unwrap() {}
+ while !chunk.is_empty() && decoder.push_bytes(&mut chunk).unwrap().needs_more() {}
if !chunk.is_empty() || encoder.advance().has_finished() {
break;
}
diff --git a/include/decoder_newtype.rs b/include/decoder_newtype.rs
index 93d70e4e..96a12e83 100644
--- a/include/decoder_newtype.rs
+++ b/include/decoder_newtype.rs
@@ -206,7 +206,7 @@ macro_rules! _decoder_newtype_internal {
type Error = $err;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(Self::push_bytes_map_err)
}
diff --git a/io/src/lib.rs b/io/src/lib.rs
index 633416aa..72f1d41c 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -523,11 +523,11 @@ where
}
let original_len = buffer.len();
- let need_more = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
+ let status = decoder.push_bytes(&mut buffer).map_err(ReadError::Decode)?;
let consumed = original_len - buffer.len();
reader.consume(consumed);
- if !need_more {
+ if status.is_ready() {
return decoder.end().map_err(ReadError::Decode);
}
}
@@ -597,9 +597,10 @@ where
return decoder.end().map_err(ReadError::Decode);
}
Ok(bytes_read) => {
- if !decoder
+ if decoder
.push_bytes(&mut &clamped_buffer[..bytes_read])
.map_err(ReadError::Decode)?
+ .is_ready()
{
return decoder.end().map_err(ReadError::Decode);
}
@@ -817,7 +818,7 @@ mod tests {
type Output = TestArray;
type Error = UnexpectedEofError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<encoding::DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes)
}
diff --git a/p2p/src/address.rs b/p2p/src/address.rs
index d899a9ad..6372987b 100644
--- a/p2p/src/address.rs
+++ b/p2p/src/address.rs
@@ -167,7 +167,7 @@ impl encoding::Decoder for AddressDecoder {
type Error = AddressDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddressDecoderError)
}
@@ -223,7 +223,7 @@ impl encoding::Decoder for AddrV1MessageDecoder {
type Error = AddrV1MessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddrV1MessageDecoderError)
}
@@ -528,7 +528,7 @@ impl encoding::Decoder for AddrV2Decoder {
type Error = AddrV2DecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddrV2DecoderError::Decoder)
}
@@ -656,7 +656,7 @@ impl encoding::Decoder for AddrV2MessageDecoder {
type Error = AddrV2MessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddrV2MessageDecoderError)
}
diff --git a/p2p/src/bip152.rs b/p2p/src/bip152.rs
index 570a404b..8b212cbf 100644
--- a/p2p/src/bip152.rs
+++ b/p2p/src/bip152.rs
@@ -11,7 +11,7 @@ use core::convert;
use arbitrary::{Arbitrary, Unstructured};
use encoding::{
ArrayDecoder, ArrayEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder2, Decoder4,
- Encoder2, Encoder4, SliceEncoder, VecDecoder,
+ Encoder2, Encoder4, SliceEncoder, VecDecoder, DecoderStatus,
};
use hashes::{sha256, siphash24, HashEngine};
use internals::array::ArrayExt as _;
@@ -91,7 +91,7 @@ impl encoding::Decoder for PrefilledTransactionDecoder {
type Error = PrefilledTransactionDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(Self::err_from_inner)
}
@@ -213,7 +213,7 @@ impl encoding::Decoder for ShortIdDecoder {
type Error = ShortIdDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(ShortIdDecoderError)
}
@@ -307,7 +307,7 @@ impl encoding::Decoder for HeaderAndShortIdsDecoder {
type Error = HeaderAndShortIdsDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(Self::err_from_inner)
}
@@ -435,7 +435,7 @@ impl encoding::Decoder for OffsetDecoder {
type Error = <CompactSizeDecoder as encoding::Decoder>::Error;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes)
}
@@ -546,7 +546,7 @@ impl encoding::Decoder for BlockTransactionsRequestDecoder {
type Error = BlockTransactionsRequestDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(BlockTransactionsRequestDecoderError)
}
@@ -613,7 +613,7 @@ impl encoding::Decoder for BlockTransactionsDecoder {
type Error = BlockTransactionsDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(BlockTransactionsDecoderError)
}
diff --git a/p2p/src/lib.rs b/p2p/src/lib.rs
index baa64b8e..e45f45f6 100644
--- a/p2p/src/lib.rs
+++ b/p2p/src/lib.rs
@@ -146,7 +146,7 @@ impl encoding::Decoder for ProtocolVersionDecoder {
type Error = ProtocolVersionDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(ProtocolVersionDecoderError)
}
@@ -340,7 +340,7 @@ impl encoding::Decoder for ServiceFlagsDecoder {
type Error = ServiceFlagsDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(ServiceFlagsDecoderError)
}
@@ -470,7 +470,7 @@ impl encoding::Decoder for MagicDecoder {
type Error = MagicDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(MagicDecoderError)
}
diff --git a/p2p/src/merkle_tree.rs b/p2p/src/merkle_tree.rs
index 628257cf..76a5eff4 100644
--- a/p2p/src/merkle_tree.rs
+++ b/p2p/src/merkle_tree.rs
@@ -152,7 +152,7 @@ impl encoding::Decoder for MerkleBlockDecoder {
type Error = MerkleBlockDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(MerkleBlockDecoderError)
}
@@ -520,7 +520,7 @@ impl encoding::Decoder for PartialMerkleTreeDecoder {
type Error = PartialMerkleTreeDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(PartialMerkleTreeDecoderError)
}
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
index 986c4915..7497da0c 100644
--- a/p2p/src/message.rs
+++ b/p2p/src/message.rs
@@ -168,7 +168,7 @@ impl encoding::Decoder for CommandStringDecoder {
type Output = CommandString;
type Error = CommandStringDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.inner.push_bytes(bytes).map_err(CommandStringDecoderError::UnexpectedEof)
}
@@ -278,7 +278,7 @@ impl encoding::Decoder for V1MessageHeaderDecoder {
type Error = V1MessageHeaderDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(V1MessageHeaderDecoderError)
}
@@ -343,7 +343,7 @@ impl encoding::Decoder for InventoryPayloadDecoder {
type Error = InventoryPayloadDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(InventoryPayloadDecoderError)
}
@@ -392,7 +392,7 @@ impl encoding::Decoder for AddrPayloadDecoder {
type Error = AddrPayloadDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddrPayloadDecoderError)
}
@@ -444,7 +444,7 @@ impl encoding::Decoder for AddrV2PayloadDecoder {
type Error = AddrV2PayloadDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AddrV2PayloadDecoderError)
}
@@ -519,7 +519,7 @@ impl encoding::Decoder for FeeFilterDecoder {
type Output = FeeFilter;
type Error = FeeFilterDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(FeeFilterDecoderError::UnexpectedEof)
}
@@ -599,7 +599,7 @@ impl encoding::Decoder for PingDecoder {
type Error = PingDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(PingDecoderError)
}
@@ -655,7 +655,7 @@ impl encoding::Decoder for PongDecoder {
type Error = PongDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(PongDecoderError)
}
@@ -1197,7 +1197,7 @@ impl encoding::Decoder for NetworkMessageDecoderInner {
type Error = V1NetworkMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
let err = V1NetworkMessageDecoderError(V1NetworkMessageDecoderErrorInner::Payload);
match self {
Self::Version(d) => d.push_bytes(bytes).map_err(|_| err),
@@ -1229,14 +1229,14 @@ impl encoding::Decoder for NetworkMessageDecoderInner {
Self::FeeFilter(d) => d.push_bytes(bytes).map_err(|_| err),
Self::AddrV2(d) => d.push_bytes(bytes).map_err(|_| err),
Self::SendTxRcnCl(d) => d.push_bytes(bytes).map_err(|_| err),
- Self::Empty(_) => Ok(false),
+ Self::Empty(_) => Ok(encoding::DecoderStatus::Ready),
Self::Unknown { remaining, buffer, .. } => {
let copy_len = bytes.len().min(*remaining);
let (to_copy, rest) = bytes.split_at(copy_len);
buffer.extend_from_slice(to_copy);
*bytes = rest;
*remaining -= copy_len;
- Ok(*remaining > 0)
+ Ok(if *remaining > 0 { encoding::DecoderStatus::NeedsMore } else { encoding::DecoderStatus::Ready })
}
}
}
@@ -1357,7 +1357,7 @@ impl encoding::Decoder for NetworkMessageDecoder {
type Error = V1NetworkMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
let before = bytes.len();
let result = self.inner.push_bytes(bytes)?;
self.bytes_consumed += before - bytes.len();
@@ -1424,14 +1424,14 @@ impl encoding::Decoder for V1NetworkMessageDecoder {
type Output = V1NetworkMessage;
type Error = V1NetworkMessageDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
match &mut self.state {
DecoderState::ReadingHeader { header_decoder } => {
- let need_more = header_decoder.push_bytes(bytes).map_err(|e| {
+ let status = header_decoder.push_bytes(bytes).map_err(|e| {
V1NetworkMessageDecoderError(V1NetworkMessageDecoderErrorInner::Header(e))
})?;
- if !need_more {
+ if status.is_ready() {
// Header complete, extract values and transition to payload state.
let old_state = core::mem::replace(
&mut self.state,
@@ -1468,7 +1468,7 @@ impl encoding::Decoder for V1NetworkMessageDecoder {
return self.push_bytes(bytes);
}
- Ok(need_more)
+ Ok(status)
}
DecoderState::ReadingPayload { payload_decoder, checksum_engine, .. } => {
let original_bytes = *bytes;
@@ -1663,7 +1663,7 @@ impl encoding::Decoder for NetworkHeaderDecoder {
type Error = NetworkHeaderDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(NetworkHeaderDecoderError)
}
@@ -1728,7 +1728,7 @@ impl encoding::Decoder for HeadersMessageDecoder {
type Error = HeadersMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(HeadersMessageDecoderError)
}
@@ -1846,15 +1846,16 @@ impl encoding::Decoder for V2NetworkMessageDecoder {
type Output = V2NetworkMessage;
type Error = V2NetworkMessageDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
loop {
match &mut self.state {
V2NetworkMessageDecoderState::ShortId(short_id_decoder) => {
- if short_id_decoder
+ if !short_id_decoder
.push_bytes(bytes)
.map_err(|_| V2NetworkMessageDecoderError::ShortId)?
+ .is_ready()
{
- return Ok(true);
+ return Ok(encoding::DecoderStatus::NeedsMore);
}
match mem::replace(&mut self.state, V2NetworkMessageDecoderState::Errored) {
@@ -1878,11 +1879,12 @@ impl encoding::Decoder for V2NetworkMessageDecoder {
}
}
V2NetworkMessageDecoderState::CommandString(command_string_decoder) => {
- if command_string_decoder
+ if !command_string_decoder
.push_bytes(bytes)
.map_err(V2NetworkMessageDecoderError::Command)?
+ .is_ready()
{
- return Ok(true);
+ return Ok(encoding::DecoderStatus::NeedsMore);
}
match mem::replace(&mut self.state, V2NetworkMessageDecoderState::Errored) {
V2NetworkMessageDecoderState::CommandString(command_string) => {
diff --git a/p2p/src/message_blockdata.rs b/p2p/src/message_blockdata.rs
index e22da6ff..267688cb 100644
--- a/p2p/src/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -109,7 +109,7 @@ impl encoding::Decoder for InventoryDecoder {
type Error = InventoryDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(InventoryDecoderError)
}
@@ -228,7 +228,7 @@ impl encoding::Decoder for BlockLocatorDecoder {
type Error = BlockLocatorDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(BlockLocatorDecoderError)
}
@@ -330,7 +330,7 @@ impl encoding::Decoder for GetHeadersMessageDecoder {
type Error = GetHeadersMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(GetHeadersMessageDecoderError)
}
@@ -350,7 +350,7 @@ impl encoding::Decoder for GetBlocksMessageDecoder {
type Error = GetBlocksMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(GetBlocksMessageDecoderError)
}
diff --git a/p2p/src/message_bloom.rs b/p2p/src/message_bloom.rs
index a7998354..3145604c 100644
--- a/p2p/src/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -75,7 +75,7 @@ impl encoding::Decoder for FilterLoadDecoder {
type Error = FilterLoadDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(FilterLoadDecoderError)
}
@@ -146,7 +146,7 @@ impl encoding::Decoder for BloomFlagsDecoder {
type Error = BloomFlagsDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(Self::err_from_inner)
}
@@ -205,7 +205,7 @@ impl encoding::Decoder for FilterAddDecoder {
type Error = FilterAddDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(FilterAddDecoderError)
}
diff --git a/p2p/src/message_compact_blocks.rs b/p2p/src/message_compact_blocks.rs
index a6136087..1bc4ccde 100644
--- a/p2p/src/message_compact_blocks.rs
+++ b/p2p/src/message_compact_blocks.rs
@@ -48,7 +48,7 @@ impl encoding::Decoder for SendCmpctDecoder {
type Error = SendCmpctDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(SendCmpctDecoderError)
}
diff --git a/p2p/src/message_erlay.rs b/p2p/src/message_erlay.rs
index b3972282..de53691f 100644
--- a/p2p/src/message_erlay.rs
+++ b/p2p/src/message_erlay.rs
@@ -64,7 +64,7 @@ impl encoding::Decoder for SendTxRcnClDecoder {
type Error = SendTxRcnClDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(SendTxRcnClDecoderError)
}
diff --git a/p2p/src/message_filter.rs b/p2p/src/message_filter.rs
index 94c5f3f1..b7281e20 100644
--- a/p2p/src/message_filter.rs
+++ b/p2p/src/message_filter.rs
@@ -86,7 +86,7 @@ impl encoding::Decoder for FilterHashDecoder {
type Error = FilterHashDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(FilterHashDecoderError)
}
@@ -113,7 +113,7 @@ impl encoding::Decoder for FilterHeaderDecoder {
type Error = FilterHeaderDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(FilterHeaderDecoderError)
}
@@ -185,7 +185,7 @@ impl encoding::Decoder for GetCFiltersDecoder {
type Error = GetCFiltersDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(GetCFiltersDecoderError)
}
@@ -255,7 +255,7 @@ impl encoding::Decoder for CFilterDecoder {
type Error = CFilterDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(CFilterDecoderError)
}
@@ -313,7 +313,7 @@ impl encoding::Decoder for GetCFHeadersDecoder {
type Error = GetCFHeadersDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(GetCFHeadersDecoderError)
}
@@ -385,7 +385,7 @@ impl encoding::Decoder for CFHeadersDecoder {
type Error = CFHeadersDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(CFHeadersDecoderError)
}
@@ -446,7 +446,7 @@ impl encoding::Decoder for GetCFCheckptDecoder {
type Error = GetCFCheckptDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(GetCFCheckptDecoderError)
}
@@ -516,7 +516,7 @@ impl encoding::Decoder for CFCheckptDecoder {
type Error = CFCheckptDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(CFCheckptDecoderError)
}
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
index 8d31a488..5d243fbc 100644
--- a/p2p/src/message_network.rs
+++ b/p2p/src/message_network.rs
@@ -146,7 +146,7 @@ impl encoding::Decoder for VersionMessageDecoder {
type Error = VersionMessageDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(VersionMessageDecoderError)
}
@@ -232,7 +232,7 @@ impl encoding::Decoder for UserAgentDecoder {
type Error = UserAgentDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(UserAgentDecoderError::Decoder)
}
@@ -441,7 +441,7 @@ impl encoding::Decoder for RejectReasonDecoder {
type Error = RejectReasonDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(RejectReasonDecoderError::Decoder)
}
@@ -529,7 +529,7 @@ impl encoding::Decoder for RejectDecoder {
type Error = RejectDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(RejectDecoderError::Decoder)
}
@@ -614,7 +614,7 @@ impl encoding::Decoder for AlertDecoder {
type Error = AlertDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(AlertDecoderError)
}
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 40a2b395..d800e9c9 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -1245,8 +1245,8 @@ mod tests {
let mut decoder = Block::decoder();
assert!(decoder.read_limit() > 0);
- let needs_more = decoder.push_bytes(&mut view).unwrap();
- assert!(!needs_more);
+ let status = decoder.push_bytes(&mut view).unwrap();
+ assert!(status.is_ready());
assert_eq!(decoder.read_limit(), 0);
assert_eq!(decoder.end().unwrap(), block);
}
@@ -1274,8 +1274,8 @@ mod tests {
let mut decoder = Header::decoder();
assert!(decoder.read_limit() > 0);
- let needs_more = decoder.push_bytes(&mut view).unwrap();
- assert!(!needs_more);
+ let status = decoder.push_bytes(&mut view).unwrap();
+ assert!(status.is_ready());
assert_eq!(decoder.read_limit(), 0);
assert_eq!(decoder.end().unwrap(), header);
}
@@ -1837,8 +1837,8 @@ mod tests {
assert!(decoder.read_limit() > 0);
- let needs_more = decoder.push_bytes(&mut bytes).unwrap();
- assert!(!needs_more);
+ let status = decoder.push_bytes(&mut bytes).unwrap();
+ assert!(status.is_ready());
assert!(bytes.is_empty());
assert_eq!(decoder.read_limit(), 0);
@@ -1895,7 +1895,7 @@ mod tests {
let mut view = bytes.as_slice();
let mut decoder = Block::decoder();
- assert!(decoder.push_bytes(&mut view).unwrap());
+ assert!(decoder.push_bytes(&mut view).unwrap().needs_more());
assert!(view.is_empty());
let err_second = decoder.end().unwrap_err();
diff --git a/primitives/src/hash_types/block_hash.rs b/primitives/src/hash_types/block_hash.rs
index 50a5f3a0..ae002ce7 100644
--- a/primitives/src/hash_types/block_hash.rs
+++ b/primitives/src/hash_types/block_hash.rs
@@ -104,7 +104,7 @@ mod tests {
let mut decoder = BlockHashDecoder::new();
let mut bytes = &[0u8; 31][..];
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = decoder.end().unwrap_err();
diff --git a/primitives/src/hash_types/transaction_merkle_node.rs b/primitives/src/hash_types/transaction_merkle_node.rs
index 62b43f3a..df3bcd4b 100644
--- a/primitives/src/hash_types/transaction_merkle_node.rs
+++ b/primitives/src/hash_types/transaction_merkle_node.rs
@@ -125,7 +125,7 @@ mod tests {
let mut decoder = TxMerkleNodeDecoder::new();
let mut bytes = &[0u8; NODE_LEN - 1][..];
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(!err.to_string().is_empty());
diff --git a/primitives/src/hash_types/witness_merkle_node.rs b/primitives/src/hash_types/witness_merkle_node.rs
index b3dc1c23..aca02be6 100644
--- a/primitives/src/hash_types/witness_merkle_node.rs
+++ b/primitives/src/hash_types/witness_merkle_node.rs
@@ -145,7 +145,7 @@ mod tests {
let mut decoder = WitnessMerkleNodeDecoder::new();
let mut bytes = &[0u8; 31][..];
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(!err.to_string().is_empty());
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 6388f45c..a9fc9c8f 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -5,7 +5,7 @@ use core::ops::{Deref, DerefMut};
#[cfg(feature = "arbitrary")]
use arbitrary::{Arbitrary, Unstructured};
-use encoding::ByteVecDecoder;
+use encoding::{ByteVecDecoder, DecoderStatus};
#[cfg(feature = "hex")]
use super::error::FromHexError;
@@ -198,7 +198,7 @@ impl<T> encoding::Decoder for ScriptBufDecoder<T> {
type Error = ScriptBufDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
self.0.push_bytes(bytes).map_err(ScriptBufDecoderError)
}
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 2ad2f8ea..8bc93ce9 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -19,7 +19,7 @@ use arbitrary::{Arbitrary, Unstructured};
use encoding::{ArrayEncoder, BytesEncoder, Encoder2};
#[cfg(feature = "alloc")]
use encoding::{
- CompactSizeEncoder, Decoder2, Decoder3, Encode as _, Encoder3, Encoder6, EncoderStatus, SliceEncoder,
+ CompactSizeEncoder, Decoder2, Decoder3, DecoderStatus, Encode as _, Encoder3, Encoder6, EncoderStatus, SliceEncoder,
VecDecoder,
};
#[cfg(feature = "alloc")]
@@ -449,7 +449,7 @@ impl encoding::Decoder for TransactionDecoder {
type Error = TransactionDecoderError;
#[inline]
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
use TransactionDecoderError as E;
use TransactionDecoderErrorInner as Inner;
use TransactionDecoderState as State;
@@ -458,32 +458,32 @@ impl encoding::Decoder for TransactionDecoder {
// Attempt to push to the currently-active decoder and return early on success.
match &mut self.state {
State::Version(decoder) => {
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::Version(e)))? {
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::Version(e)))?.needs_more() {
// Still more bytes required.
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
}
State::Inputs(_, _, decoder) =>
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::Inputs(e)))? {
- return Ok(true);
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::Inputs(e)))?.needs_more() {
+ return Ok(DecoderStatus::NeedsMore);
},
State::SegwitFlag(_) =>
if bytes.is_empty() {
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
},
State::Outputs(_, _, _, decoder) =>
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::Outputs(e)))? {
- return Ok(true);
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::Outputs(e)))?.needs_more() {
+ return Ok(DecoderStatus::NeedsMore);
},
State::Witnesses(_, _, _, _, decoder) =>
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::Witness(e)))? {
- return Ok(true);
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::Witness(e)))?.needs_more() {
+ return Ok(DecoderStatus::NeedsMore);
},
State::LockTime(_, _, _, decoder) =>
- if decoder.push_bytes(bytes).map_err(|e| E(Inner::LockTime(e)))? {
- return Ok(true);
+ if decoder.push_bytes(bytes).map_err(|e| E(Inner::LockTime(e)))?.needs_more() {
+ return Ok(DecoderStatus::NeedsMore);
},
- State::Done(..) => return Ok(false),
+ State::Done(..) => return Ok(DecoderStatus::Ready),
State::Errored => panic!("call to push_bytes() after decoder errored"),
}
@@ -565,9 +565,9 @@ impl encoding::Decoder for TransactionDecoder {
State::LockTime(version, inputs, outputs, decoder) => {
let lock_time = decoder.end().map_err(|e| E(Inner::LockTime(e)))?;
self.state = State::Done(Transaction { version, lock_time, inputs, outputs });
- return Ok(false);
+ return Ok(DecoderStatus::Ready);
}
- State::Done(..) => return Ok(false),
+ State::Done(..) => return Ok(DecoderStatus::Ready),
State::Errored => unreachable!("checked above"),
}
}
@@ -2258,10 +2258,10 @@ mod tests {
let mut decoder = TransactionDecoder::new();
let mut bytes = tx_bytes.as_slice();
- assert!(!decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().is_ready());
let mut empty = [].as_slice();
- assert!(!decoder.push_bytes(&mut empty).unwrap());
+ assert!(decoder.push_bytes(&mut empty).unwrap().is_ready());
}
#[test]
@@ -2272,7 +2272,7 @@ mod tests {
state: S::Inputs(Version::ONE, Attempt::First, VecDecoder::new()),
};
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2290,7 +2290,7 @@ mod tests {
};
let mut bytes = [0u8, 0, 0, 0].as_slice();
- assert!(!decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().is_ready());
assert!(bytes.is_empty());
let tx = decoder.end().unwrap();
@@ -2312,7 +2312,7 @@ mod tests {
),
};
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2323,7 +2323,7 @@ mod tests {
state: S::Outputs(Version::ONE, vec![], IsSegwit::No, VecDecoder::new()),
};
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2332,7 +2332,7 @@ mod tests {
use TransactionDecoderState as S;
let mut decoder = TransactionDecoder { state: S::SegwitFlag(Version::ONE) };
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2340,7 +2340,7 @@ mod tests {
fn transaction_decoder_push_bytes_version_needs_more() {
let mut decoder = TransactionDecoder::new();
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2358,7 +2358,7 @@ mod tests {
),
};
let mut bytes = [].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
}
#[test]
@@ -2600,8 +2600,8 @@ mod tests {
let mut decoder = OutPoint::decoder();
let mut slice = &[][..];
- let needs_more = decoder.push_bytes(&mut slice).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut slice).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, OutPointDecoderError(_)));
@@ -2682,8 +2682,8 @@ mod tests {
let mut decoder = Version::decoder();
let mut slice = &[][..];
- let needs_more = decoder.push_bytes(&mut slice).unwrap();
- assert!(needs_more);
+ let status = decoder.push_bytes(&mut slice).unwrap();
+ assert!(status.needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, VersionDecoderError(_)));
@@ -2698,7 +2698,7 @@ mod tests {
fn transaction_decoder_version_error() {
let mut decoder = VersionDecoder::new();
let mut bytes = [0u8, 0, 0].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = TransactionDecoderError(TransactionDecoderErrorInner::Version(
decoder.end().unwrap_err(),
));
@@ -2727,7 +2727,7 @@ mod tests {
fn transaction_decoder_inputs_error() {
let mut decoder = VecDecoder::<TxIn>::new();
let mut bytes = [1u8].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = TransactionDecoderError(TransactionDecoderErrorInner::Inputs(
decoder.end().unwrap_err(),
));
@@ -2743,7 +2743,7 @@ mod tests {
fn transaction_decoder_outputs_error() {
let mut decoder = VecDecoder::<TxOut>::new();
let mut bytes = [1u8].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = TransactionDecoderError(TransactionDecoderErrorInner::Outputs(
decoder.end().unwrap_err(),
));
@@ -2759,7 +2759,7 @@ mod tests {
fn transaction_decoder_witness_error() {
let mut decoder = WitnessDecoder::new();
let mut bytes = [1u8].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = TransactionDecoderError(TransactionDecoderErrorInner::Witness(
decoder.end().unwrap_err(),
));
@@ -2803,7 +2803,7 @@ mod tests {
fn transaction_decoder_lock_time_error() {
let mut decoder = LockTimeDecoder::new();
let mut bytes = [0u8, 0, 0].as_slice();
- assert!(decoder.push_bytes(&mut bytes).unwrap());
+ assert!(decoder.push_bytes(&mut bytes).unwrap().needs_more());
let err = TransactionDecoderError(TransactionDecoderErrorInner::LockTime(
decoder.end().unwrap_err(),
));
@@ -3086,7 +3086,7 @@ mod tests {
fn txin_decoder_first_error() {
let mut decoder = TxIn::decoder();
let mut slice = [].as_slice();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err.0, encoding::Decoder3Error::First(_)));
@@ -3107,7 +3107,7 @@ mod tests {
let mut decoder = TxIn::decoder();
let mut slice = bytes.as_slice();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err.0, encoding::Decoder3Error::Second(_)));
@@ -3128,7 +3128,7 @@ mod tests {
let mut decoder = TxIn::decoder();
let mut slice = bytes.as_slice();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err.0, encoding::Decoder3Error::Third(_)));
@@ -3143,7 +3143,7 @@ mod tests {
fn txout_decoder_first_error() {
let mut decoder = TxOut::decoder();
let mut slice = [].as_slice();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err.0, encoding::Decoder2Error::First(_)));
@@ -3161,7 +3161,7 @@ mod tests {
let mut decoder = TxOut::decoder();
let mut slice = bytes.as_slice();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err.0, encoding::Decoder2Error::Second(_)));
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index ad349468..9323172b 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -12,7 +12,7 @@ use arbitrary::{Arbitrary, Unstructured};
#[cfg(doc)]
use encoding::Decoder4;
use encoding::{
- self, BytesEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder as _, EncoderStatus, Encoder2,
+ self, BytesEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder as _, DecoderStatus, EncoderStatus, Encoder2,
};
#[cfg(feature = "hex")]
use hex::DecodeVariableLengthBytesError;
@@ -370,7 +370,7 @@ impl encoding::Decoder for WitnessDecoder {
type Output = Witness;
type Error = WitnessDecoderError;
- fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+ fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
use WitnessDecoderError as E;
use WitnessDecoderErrorInner as Inner;
@@ -380,8 +380,9 @@ impl encoding::Decoder for WitnessDecoder {
.witness_count_decoder
.push_bytes(bytes)
.map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+ .needs_more()
{
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
// Take ownership of the decoder in order to consume it.
let decoder = core::mem::take(&mut self.witness_count_decoder);
@@ -390,7 +391,7 @@ impl encoding::Decoder for WitnessDecoder {
// Short circuit for zero witness elements.
if witness_elements == 0 {
- return Ok(false);
+ return Ok(DecoderStatus::Ready);
}
// Allocate space for the index and buffer. The buffer
@@ -413,11 +414,11 @@ impl encoding::Decoder for WitnessDecoder {
loop {
// Check if we're done processing all elements.
if self.element_idx >= witness_elements {
- return Ok(false);
+ return Ok(DecoderStatus::Ready);
}
if bytes.is_empty() {
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
// If we have some bytes to read, then reading element data.
@@ -447,8 +448,9 @@ impl encoding::Decoder for WitnessDecoder {
.element_length_decoder
.push_bytes(bytes)
.map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+ .needs_more()
{
- return Ok(true);
+ return Ok(DecoderStatus::NeedsMore);
}
// Take ownership of the decoder so we can consume it.
@@ -1485,7 +1487,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let witness = decoder.end().unwrap();
assert_eq!(witness.len(), 0);
@@ -1500,7 +1502,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let witness = decoder.end().unwrap();
assert_eq!(witness.len(), 1);
@@ -1515,7 +1517,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let witness = decoder.end().unwrap();
assert_eq!(witness.len(), 1);
@@ -1530,7 +1532,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let witness = decoder.end().unwrap();
assert_eq!(witness.len(), 3);
@@ -1547,7 +1549,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
@@ -1561,7 +1563,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
@@ -1575,7 +1577,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
@@ -1631,7 +1633,7 @@ mod test {
fn decoder_unexpected_eof_error() {
let mut decoder = WitnessDecoder::new();
let mut slice = [0x01].as_slice(); // witness element count = 1.
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let inner = match decoder.end().unwrap_err() {
WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(inner)) => inner,
@@ -1674,7 +1676,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut decoder = WitnessDecoder::new();
- assert!(!decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
let witness = decoder.end().unwrap();
assert_eq!(witness.len(), 2);
@@ -1798,7 +1800,7 @@ mod test {
let mut slice = encoded.as_slice();
let mut dec = WitnessDecoder::new();
- assert!(dec.push_bytes(&mut slice).unwrap());
+ assert!(dec.push_bytes(&mut slice).unwrap().needs_more());
let allocated = dec.content.len();
diff --git a/units/src/block.rs b/units/src/block.rs
index cc17f79b..4d86d10a 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -879,7 +879,7 @@ mod tests {
let bytes = [0xff, 0xff, 0xff]; // 3 bytes is an EOF error
let mut decoder = BlockHeightDecoder::default();
- assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap());
+ assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap().needs_more());
let error = decoder.end().unwrap_err();
assert!(matches!(error, BlockHeightDecoderError(UnexpectedEofError { .. })));
diff --git a/units/src/pow.rs b/units/src/pow.rs
index ea378282..646fdc8a 100644
--- a/units/src/pow.rs
+++ b/units/src/pow.rs
@@ -1550,7 +1550,7 @@ mod tests {
let mut slice = [0u8; 3].as_slice();
let mut decoder = CompactTargetDecoder::new();
- assert!(decoder.push_bytes(&mut slice).unwrap());
+ assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
let err = decoder.end().unwrap_err();
assert!(!err.to_string().is_empty());
diff --git a/units/src/sequence.rs b/units/src/sequence.rs
index c33e3e93..326764f5 100644
--- a/units/src/sequence.rs
+++ b/units/src/sequence.rs
@@ -554,7 +554,7 @@ mod tests {
let bytes = [0xff, 0xff, 0xff]; // 3 bytes is an EOF error
let mut decoder = SequenceDecoder::default();
- assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap());
+ assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap().needs_more());
let error = decoder.end().unwrap_err();
assert!(matches!(error, SequenceDecoderError(UnexpectedEofError { .. })));
diff --git a/units/src/time.rs b/units/src/time.rs
index 672a0705..c38fb2da 100644
--- a/units/src/time.rs
+++ b/units/src/time.rs
@@ -241,7 +241,7 @@ mod tests {
let bytes = [0xb0, 0x52, 0x39]; // 3 bytes is an EOF error
let mut decoder = BlockTimeDecoder::default();
- assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap());
+ assert!(decoder.push_bytes(&mut bytes.as_slice()).unwrap().needs_more());
let error = decoder.end().unwrap_err();
assert!(matches!(error, BlockTimeDecoderError(UnexpectedEofError { .. })));
diff --git a/units/tests/encoding.rs b/units/tests/encoding.rs
index 9d467a03..216e7393 100644
--- a/units/tests/encoding.rs
+++ b/units/tests/encoding.rs
@@ -63,8 +63,8 @@ macro_rules! test_hardcoded_decoding {
let mut decoder = <$decoder>::new();
assert_eq!(decoder.read_limit(), $read_limit);
- let needs_more = decoder.push_bytes(&mut bytes.as_slice()).unwrap();
- assert!(!needs_more);
+ let status = decoder.push_bytes(&mut bytes.as_slice()).unwrap();
+ assert!(status.is_ready());
assert_eq!(decoder.read_limit(), 0);
let decoded = decoder.end().unwrap();
@@ -88,9 +88,9 @@ macro_rules! test_incremental_decoding {
// Feed bytes one at a time
for (i, byte) in bytes.iter().enumerate() {
let slice = &[*byte];
- let needs_more = decoder.push_bytes(&mut slice.as_slice()).unwrap();
+ let status = decoder.push_bytes(&mut slice.as_slice()).unwrap();
assert_eq!(decoder.read_limit(), $read_limit - 1 - i);
- assert_eq!(needs_more, i < $read_limit - 1); // true until the last loop
+ assert_eq!(status.needs_more(), i < $read_limit - 1); // true until the last loop
}
let decoded = decoder.end().unwrap();
Risk score
Our methodology →Why this scored 18/100
Human-validated context
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
No validated notes yet.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.