milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Support unsized `R` and `W` in consensus encode/decode

This commit is contained in:
Dawid Ciężarkiewicz 2022-06-28 18:22:12 -07:00
parent a24a3b0194
commit 1fea098dfb
20 changed files with 112 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/blockdata/script.rs
View File

@ -1091,14 +1091,14 @@ impl serde::Serialize for Script {
impl Encodable for Script { impl Encodable for Script {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
self.0.consensus_encode(w) self.0.consensus_encode(w)
} }
} }
impl Decodable for Script { impl Decodable for Script {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(Script(Decodable::consensus_decode_from_finite_reader(r)?)) Ok(Script(Decodable::consensus_decode_from_finite_reader(r)?))
} }
} }

25
src/blockdata/transaction.rs
View File

@ -652,13 +652,13 @@ impl Transaction {
impl_consensus_encoding!(TxOut, value, script_pubkey); impl_consensus_encoding!(TxOut, value, script_pubkey);
impl Encodable for OutPoint { impl Encodable for OutPoint {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let len = self.txid.consensus_encode(w)?; let len = self.txid.consensus_encode(w)?;
Ok(len + self.vout.consensus_encode(w)?) Ok(len + self.vout.consensus_encode(w)?)
} }
} }
impl Decodable for OutPoint { impl Decodable for OutPoint {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(OutPoint { Ok(OutPoint {
txid: Decodable::consensus_decode(r)?, txid: Decodable::consensus_decode(r)?,
vout: Decodable::consensus_decode(r)?, vout: Decodable::consensus_decode(r)?,
@ -667,7 +667,7 @@ impl Decodable for OutPoint {
} }
impl Encodable for TxIn { impl Encodable for TxIn {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += self.previous_output.consensus_encode(w)?; len += self.previous_output.consensus_encode(w)?;
len += self.script_sig.consensus_encode(w)?; len += self.script_sig.consensus_encode(w)?;
@ -677,7 +677,7 @@ impl Encodable for TxIn {
} }
impl Decodable for TxIn { impl Decodable for TxIn {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(TxIn { Ok(TxIn {
previous_output: Decodable::consensus_decode_from_finite_reader(r)?, previous_output: Decodable::consensus_decode_from_finite_reader(r)?,
script_sig: Decodable::consensus_decode_from_finite_reader(r)?, script_sig: Decodable::consensus_decode_from_finite_reader(r)?,
@ -688,7 +688,7 @@ impl Decodable for TxIn {
} }
impl Encodable for Transaction { impl Encodable for Transaction {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += self.version.consensus_encode(w)?; len += self.version.consensus_encode(w)?;
// To avoid serialization ambiguity, no inputs means we use BIP141 serialization (see // To avoid serialization ambiguity, no inputs means we use BIP141 serialization (see
@ -718,7 +718,7 @@ impl Encodable for Transaction {
} }
impl Decodable for Transaction { impl Decodable for Transaction {
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let version = i32::consensus_decode_from_finite_reader(r)?; let version = i32::consensus_decode_from_finite_reader(r)?;
let input = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?; let input = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
// segwit // segwit
@ -953,6 +953,19 @@ mod tests {
use super::EcdsaSighashType; use super::EcdsaSighashType;
use crate::util::sighash::SighashCache; use crate::util::sighash::SighashCache;
const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
#[test]
fn encode_to_unsized_writer() {
let mut buf = [0u8; 1024];
let raw_tx = Vec::from_hex(SOME_TX).unwrap();
let tx: Transaction = Decodable::consensus_decode(&mut raw_tx.as_slice()).unwrap();
let size = tx.consensus_encode(&mut &mut buf[..]).unwrap();
assert_eq!(size, SOME_TX.len() / 2);
assert_eq!(raw_tx, &buf[..size]);
}
#[test] #[test]
fn test_outpoint() { fn test_outpoint() {
assert_eq!(OutPoint::from_str("i don't care"), assert_eq!(OutPoint::from_str("i don't care"),

4
src/blockdata/witness.rs
View File

@ -49,7 +49,7 @@ pub struct Iter<'a> {
} }
impl Decodable for Witness { impl Decodable for Witness {
fn consensus_decode<R: Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let witness_elements = VarInt::consensus_decode(r)?.0 as usize; let witness_elements = VarInt::consensus_decode(r)?.0 as usize;
if witness_elements == 0 { if witness_elements == 0 {
Ok(Witness::default()) Ok(Witness::default())
@ -116,7 +116,7 @@ fn resize_if_needed(vec: &mut Vec<u8>, required_len: usize) {
} }
impl Encodable for Witness { impl Encodable for Witness {
fn consensus_encode<W: Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let len = VarInt(self.witness_elements as u64); let len = VarInt(self.witness_elements as u64);
len.consensus_encode(w)?; len.consensus_encode(w)?;
w.emit_slice(&self.content[..])?; w.emit_slice(&self.content[..])?;

82
src/consensus/encode.rs
View File

@ -176,7 +176,7 @@ pub fn deserialize_partial<T: Decodable>(data: &[u8]) -> Result<(T, usize), Erro
/// Extensions of `Write` to encode data as per Bitcoin consensus /// Extensions of `Write` to encode data as per Bitcoin consensus
pub trait WriteExt { pub trait WriteExt : io::Write {
/// Output a 64-bit uint /// Output a 64-bit uint
fn emit_u64(&mut self, v: u64) -> Result<(), io::Error>; fn emit_u64(&mut self, v: u64) -> Result<(), io::Error>;
/// Output a 32-bit uint /// Output a 32-bit uint
@ -203,7 +203,7 @@ pub trait WriteExt {
} }
/// Extensions of `Read` to decode data as per Bitcoin consensus /// Extensions of `Read` to decode data as per Bitcoin consensus
pub trait ReadExt { pub trait ReadExt : io::Read {
/// Read a 64-bit uint /// Read a 64-bit uint
fn read_u64(&mut self) -> Result<u64, Error>; fn read_u64(&mut self) -> Result<u64, Error>;
/// Read a 32-bit uint /// Read a 32-bit uint
@ -250,7 +250,7 @@ macro_rules! decoder_fn {
} }
} }
impl<W: io::Write> WriteExt for W { impl<W: io::Write + ?Sized> WriteExt for W {
encoder_fn!(emit_u64, u64, u64_to_array_le); encoder_fn!(emit_u64, u64, u64_to_array_le);
encoder_fn!(emit_u32, u32, u32_to_array_le); encoder_fn!(emit_u32, u32, u32_to_array_le);
encoder_fn!(emit_u16, u16, u16_to_array_le); encoder_fn!(emit_u16, u16, u16_to_array_le);
@ -276,7 +276,7 @@ impl<W: io::Write> WriteExt for W {
} }
} }
impl<R: Read> ReadExt for R { impl<R: Read + ?Sized> ReadExt for R {
decoder_fn!(read_u64, u64, slice_to_u64_le, 8); decoder_fn!(read_u64, u64, slice_to_u64_le, 8);
decoder_fn!(read_u32, u32, slice_to_u32_le, 4); decoder_fn!(read_u32, u32, slice_to_u32_le, 4);
decoder_fn!(read_u16, u16, slice_to_u16_le, 2); decoder_fn!(read_u16, u16, slice_to_u16_le, 2);
@ -315,7 +315,7 @@ pub trait Encodable {
/// Returns the number of bytes written on success. /// Returns the number of bytes written on success.
/// ///
/// The only errors returned are errors propagated from the writer. /// The only errors returned are errors propagated from the writer.
fn consensus_encode<W: io::Write>(&self, writer: &mut W) -> Result<usize, io::Error>; fn consensus_encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error>;
} }
/// Data which can be encoded in a consensus-consistent way /// Data which can be encoded in a consensus-consistent way
@ -354,7 +354,7 @@ pub trait Decodable: Sized {
/// `consensus_decode_from_finite_reader` on all members, to avoid creating redundant /// `consensus_decode_from_finite_reader` on all members, to avoid creating redundant
/// `Take` wrappers. Failure to do so might result only in a tiny performance hit. /// `Take` wrappers. Failure to do so might result only in a tiny performance hit.
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(reader: &mut R) -> Result<Self, Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {
// This method is always strictly less general than, `consensus_decode`, // This method is always strictly less general than, `consensus_decode`,
// so it's safe and make sense to default to just calling it. // so it's safe and make sense to default to just calling it.
// This way most types, that don't care about protecting against // This way most types, that don't care about protecting against
@ -371,7 +371,7 @@ pub trait Decodable: Sized {
/// for types that override [`Self::consensus_decode_from_finite_reader`] /// for types that override [`Self::consensus_decode_from_finite_reader`]
/// instead. /// instead.
#[inline] #[inline]
fn consensus_decode<R: io::Read>(reader: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {
Self::consensus_decode_from_finite_reader(reader.take(MAX_VEC_SIZE as u64).by_ref()) Self::consensus_decode_from_finite_reader(reader.take(MAX_VEC_SIZE as u64).by_ref())
} }
} }
@ -389,13 +389,13 @@ macro_rules! impl_int_encodable {
($ty:ident, $meth_dec:ident, $meth_enc:ident) => { ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
impl Decodable for $ty { impl Decodable for $ty {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
ReadExt::$meth_dec(r) ReadExt::$meth_dec(r)
} }
} }
impl Encodable for $ty { impl Encodable for $ty {
#[inline] #[inline]
fn consensus_encode<W: WriteExt>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
w.$meth_enc(*self)?; w.$meth_enc(*self)?;
Ok(mem::size_of::<$ty>()) Ok(mem::size_of::<$ty>())
} }
@ -430,7 +430,7 @@ impl VarInt {
impl Encodable for VarInt { impl Encodable for VarInt {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
match self.0 { match self.0 {
0..=0xFC => { 0..=0xFC => {
(self.0 as u8).consensus_encode(w)?; (self.0 as u8).consensus_encode(w)?;
@ -457,7 +457,7 @@ impl Encodable for VarInt {
impl Decodable for VarInt { impl Decodable for VarInt {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let n = ReadExt::read_u8(r)?; let n = ReadExt::read_u8(r)?;
match n { match n {
0xFF => { 0xFF => {
@ -492,7 +492,7 @@ impl Decodable for VarInt {
// Booleans // Booleans
impl Encodable for bool { impl Encodable for bool {
#[inline] #[inline]
fn consensus_encode<W: WriteExt>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
w.emit_bool(*self)?; w.emit_bool(*self)?;
Ok(1) Ok(1)
} }
@ -500,7 +500,7 @@ impl Encodable for bool {
impl Decodable for bool { impl Decodable for bool {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<bool, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<bool, Error> {
ReadExt::read_bool(r) ReadExt::read_bool(r)
} }
} }
@ -508,7 +508,7 @@ impl Decodable for bool {
// Strings // Strings
impl Encodable for String { impl Encodable for String {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let b = self.as_bytes(); let b = self.as_bytes();
let vi_len = VarInt(b.len() as u64).consensus_encode(w)?; let vi_len = VarInt(b.len() as u64).consensus_encode(w)?;
w.emit_slice(b)?; w.emit_slice(b)?;
@ -518,7 +518,7 @@ impl Encodable for String {
impl Decodable for String { impl Decodable for String {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<String, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<String, Error> {
String::from_utf8(Decodable::consensus_decode(r)?) String::from_utf8(Decodable::consensus_decode(r)?)
.map_err(|_| self::Error::ParseFailed("String was not valid UTF8")) .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
} }
@ -527,7 +527,7 @@ impl Decodable for String {
// Cow<'static, str> // Cow<'static, str>
impl Encodable for Cow<'static, str> { impl Encodable for Cow<'static, str> {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let b = self.as_bytes(); let b = self.as_bytes();
let vi_len = VarInt(b.len() as u64).consensus_encode(w)?; let vi_len = VarInt(b.len() as u64).consensus_encode(w)?;
w.emit_slice(b)?; w.emit_slice(b)?;
@ -537,7 +537,7 @@ impl Encodable for Cow<'static, str> {
impl Decodable for Cow<'static, str> { impl Decodable for Cow<'static, str> {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Cow<'static, str>, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Cow<'static, str>, Error> {
String::from_utf8(Decodable::consensus_decode(r)?) String::from_utf8(Decodable::consensus_decode(r)?)
.map_err(|_| self::Error::ParseFailed("String was not valid UTF8")) .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
.map(Cow::Owned) .map(Cow::Owned)
@ -550,7 +550,7 @@ macro_rules! impl_array {
( $size:expr ) => { ( $size:expr ) => {
impl Encodable for [u8; $size] { impl Encodable for [u8; $size] {
#[inline] #[inline]
fn consensus_encode<W: WriteExt>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: WriteExt + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
w.emit_slice(&self[..])?; w.emit_slice(&self[..])?;
Ok(self.len()) Ok(self.len())
} }
@ -558,7 +558,7 @@ macro_rules! impl_array {
impl Decodable for [u8; $size] { impl Decodable for [u8; $size] {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let mut ret = [0; $size]; let mut ret = [0; $size];
r.read_slice(&mut ret)?; r.read_slice(&mut ret)?;
Ok(ret) Ok(ret)
@ -578,7 +578,7 @@ impl_array!(33);
impl Decodable for [u16; 8] { impl Decodable for [u16; 8] {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let mut res = [0; 8]; let mut res = [0; 8];
for item in &mut res { for item in &mut res {
*item = Decodable::consensus_decode(r)?; *item = Decodable::consensus_decode(r)?;
@ -589,7 +589,7 @@ impl Decodable for [u16; 8] {
impl Encodable for [u16; 8] { impl Encodable for [u16; 8] {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
for c in self.iter() { c.consensus_encode(w)?; } for c in self.iter() { c.consensus_encode(w)?; }
Ok(16) Ok(16)
} }
@ -600,7 +600,7 @@ macro_rules! impl_vec {
($type: ty) => { ($type: ty) => {
impl Encodable for Vec<$type> { impl Encodable for Vec<$type> {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += VarInt(self.len() as u64).consensus_encode(w)?; len += VarInt(self.len() as u64).consensus_encode(w)?;
for c in self.iter() { for c in self.iter() {
@ -612,7 +612,7 @@ macro_rules! impl_vec {
impl Decodable for Vec<$type> { impl Decodable for Vec<$type> {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let len = VarInt::consensus_decode_from_finite_reader(r)?.0; let len = VarInt::consensus_decode_from_finite_reader(r)?.0;
// Do not allocate upfront more items than if the sequnce of type // Do not allocate upfront more items than if the sequnce of type
// occupied roughly quarter a block. This should never be the case // occupied roughly quarter a block. This should never be the case
@ -681,14 +681,14 @@ fn read_bytes_from_finite_reader<D: io::Read>(mut d: D, mut opts: ReadBytesFromF
impl Encodable for Vec<u8> { impl Encodable for Vec<u8> {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
consensus_encode_with_size(self, w) consensus_encode_with_size(self, w)
} }
} }
impl Decodable for Vec<u8> { impl Decodable for Vec<u8> {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let len = VarInt::consensus_decode(r)?.0 as usize; let len = VarInt::consensus_decode(r)?.0 as usize;
// most real-world vec of bytes data, wouldn't be larger than 128KiB // most real-world vec of bytes data, wouldn't be larger than 128KiB
read_bytes_from_finite_reader(r, ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 }) read_bytes_from_finite_reader(r, ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 })
@ -697,14 +697,14 @@ impl Decodable for Vec<u8> {
impl Encodable for Box<[u8]> { impl Encodable for Box<[u8]> {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
consensus_encode_with_size(self, w) consensus_encode_with_size(self, w)
} }
} }
impl Decodable for Box<[u8]> { impl Decodable for Box<[u8]> {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
<Vec<u8>>::consensus_decode_from_finite_reader(r).map(From::from) <Vec<u8>>::consensus_decode_from_finite_reader(r).map(From::from)
} }
} }
@ -719,7 +719,7 @@ fn sha2_checksum(data: &[u8]) -> [u8; 4] {
// Checked data // Checked data
impl Encodable for CheckedData { impl Encodable for CheckedData {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
(self.0.len() as u32).consensus_encode(w)?; (self.0.len() as u32).consensus_encode(w)?;
sha2_checksum(&self.0).consensus_encode(w)?; sha2_checksum(&self.0).consensus_encode(w)?;
w.emit_slice(&self.0)?; w.emit_slice(&self.0)?;
@ -729,7 +729,7 @@ impl Encodable for CheckedData {
impl Decodable for CheckedData { impl Decodable for CheckedData {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
let len = u32::consensus_decode_from_finite_reader(r)? as usize; let len = u32::consensus_decode_from_finite_reader(r)? as usize;
let checksum = <[u8; 4]>::consensus_decode_from_finite_reader(r)?; let checksum = <[u8; 4]>::consensus_decode_from_finite_reader(r)?;
@ -748,25 +748,25 @@ impl Decodable for CheckedData {
// References // References
impl<'a, T: Encodable> Encodable for &'a T { impl<'a, T: Encodable> Encodable for &'a T {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
(&**self).consensus_encode(w) (&**self).consensus_encode(w)
} }
} }
impl<'a, T: Encodable> Encodable for &'a mut T { impl<'a, T: Encodable> Encodable for &'a mut T {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
(&**self).consensus_encode(w) (&**self).consensus_encode(w)
} }
} }
impl<T: Encodable> Encodable for rc::Rc<T> { impl<T: Encodable> Encodable for rc::Rc<T> {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
(&**self).consensus_encode(w) (&**self).consensus_encode(w)
} }
} }
impl<T: Encodable> Encodable for sync::Arc<T> { impl<T: Encodable> Encodable for sync::Arc<T> {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
(&**self).consensus_encode(w) (&**self).consensus_encode(w)
} }
} }
@ -777,7 +777,7 @@ macro_rules! tuple_encode {
impl <$($x: Encodable),*> Encodable for ($($x),*) { impl <$($x: Encodable),*> Encodable for ($($x),*) {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn consensus_encode<W: io::Write>( fn consensus_encode<W: io::Write + ?Sized>(
&self, &self,
w: &mut W, w: &mut W,
) -> Result<usize, io::Error> { ) -> Result<usize, io::Error> {
@ -791,7 +791,7 @@ macro_rules! tuple_encode {
impl<$($x: Decodable),*> Decodable for ($($x),*) { impl<$($x: Decodable),*> Decodable for ($($x),*) {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
Ok(($({let $x = Decodable::consensus_decode(r)?; $x }),*)) Ok(($({let $x = Decodable::consensus_decode(r)?; $x }),*))
} }
} }
@ -807,37 +807,37 @@ tuple_encode!(T0, T1, T2, T3, T4, T5, T6);
tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7); tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
impl Encodable for sha256d::Hash { impl Encodable for sha256d::Hash {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
self.into_inner().consensus_encode(w) self.into_inner().consensus_encode(w)
} }
} }
impl Decodable for sha256d::Hash { impl Decodable for sha256d::Hash {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?)) Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?))
} }
} }
impl Encodable for sha256::Hash { impl Encodable for sha256::Hash {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
self.into_inner().consensus_encode(w) self.into_inner().consensus_encode(w)
} }
} }
impl Decodable for sha256::Hash { impl Decodable for sha256::Hash {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?)) Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?))
} }
} }
impl Encodable for TapLeafHash { impl Encodable for TapLeafHash {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
self.into_inner().consensus_encode(w) self.into_inner().consensus_encode(w)
} }
} }
impl Decodable for TapLeafHash { impl Decodable for TapLeafHash {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?)) Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(r)?))
} }
} }

4
src/hash_types.rs
View File

@ -25,13 +25,13 @@ use crate::hashes::{Hash, sha256, sha256d, hash160, hash_newtype};
macro_rules! impl_hashencode { macro_rules! impl_hashencode {
($hashtype:ident) => { ($hashtype:ident) => {
impl $crate::consensus::Encodable for $hashtype { impl $crate::consensus::Encodable for $hashtype {
fn consensus_encode<W: $crate::io::Write>(&self, w: &mut W) -> Result<usize, $crate::io::Error> { fn consensus_encode<W: $crate::io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, $crate::io::Error> {
self.0.consensus_encode(w) self.0.consensus_encode(w)
} }
} }
impl $crate::consensus::Decodable for $hashtype { impl $crate::consensus::Decodable for $hashtype {
fn consensus_decode<R: $crate::io::Read>(r: &mut R) -> Result<Self, $crate::consensus::encode::Error> { fn consensus_decode<R: $crate::io::Read + ?Sized>(r: &mut R) -> Result<Self, $crate::consensus::encode::Error> {
use $crate::hashes::Hash; use $crate::hashes::Hash;
Ok(Self::from_inner(<<$hashtype as $crate::hashes::Hash>::Inner>::consensus_decode(r)?)) Ok(Self::from_inner(<<$hashtype as $crate::hashes::Hash>::Inner>::consensus_decode(r)?))
} }

6
src/internal_macros.rs
View File

@ -21,7 +21,7 @@ macro_rules! impl_consensus_encoding {
($thing:ident, $($field:ident),+) => ( ($thing:ident, $($field:ident),+) => (
impl $crate::consensus::Encodable for $thing { impl $crate::consensus::Encodable for $thing {
#[inline] #[inline]
fn consensus_encode<R: $crate::io::Write>( fn consensus_encode<R: $crate::io::Write + ?Sized>(
&self, &self,
r: &mut R, r: &mut R,
) -> Result<usize, $crate::io::Error> { ) -> Result<usize, $crate::io::Error> {
@ -34,7 +34,7 @@ macro_rules! impl_consensus_encoding {
impl $crate::consensus::Decodable for $thing { impl $crate::consensus::Decodable for $thing {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: $crate::io::Read>( fn consensus_decode_from_finite_reader<R: $crate::io::Read + ?Sized>(
r: &mut R, r: &mut R,
) -> Result<$thing, $crate::consensus::encode::Error> { ) -> Result<$thing, $crate::consensus::encode::Error> {
Ok($thing { Ok($thing {
@ -43,7 +43,7 @@ macro_rules! impl_consensus_encoding {
} }
#[inline] #[inline]
fn consensus_decode<R: $crate::io::Read>( fn consensus_decode<R: $crate::io::Read + ?Sized>(
r: &mut R, r: &mut R,
) -> Result<$thing, $crate::consensus::encode::Error> { ) -> Result<$thing, $crate::consensus::encode::Error> {
use crate::io::Read as _; use crate::io::Read as _;

16
src/network/address.rs
View File

@ -69,7 +69,7 @@ impl Address {
impl Encodable for Address { impl Encodable for Address {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = self.services.consensus_encode(w)?; let mut len = self.services.consensus_encode(w)?;
for word in &self.address { for word in &self.address {
@ -86,7 +86,7 @@ impl Encodable for Address {
impl Decodable for Address { impl Decodable for Address {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(Address { Ok(Address {
services: Decodable::consensus_decode(r)?, services: Decodable::consensus_decode(r)?,
address: read_be_address(r)?, address: read_be_address(r)?,
@ -96,7 +96,7 @@ impl Decodable for Address {
} }
/// Read a big-endian address from reader. /// Read a big-endian address from reader.
fn read_be_address<R: io::Read>(r: &mut R) -> Result<[u16; 8], encode::Error> { fn read_be_address<R: io::Read + ?Sized>(r: &mut R) -> Result<[u16; 8], encode::Error> {
let mut address = [0u16; 8]; let mut address = [0u16; 8];
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
@ -147,8 +147,8 @@ pub enum AddrV2 {
} }
impl Encodable for AddrV2 { impl Encodable for AddrV2 {
fn consensus_encode<W: io::Write>(&self, e: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, e: &mut W) -> Result<usize, io::Error> {
fn encode_addr<W: io::Write>(w: &mut W, network: u8, bytes: &[u8]) -> Result<usize, io::Error> { fn encode_addr<W: io::Write + ?Sized>(w: &mut W, network: u8, bytes: &[u8]) -> Result<usize, io::Error> {
let len = network.consensus_encode(w)? let len = network.consensus_encode(w)?
+ VarInt(bytes.len() as u64).consensus_encode(w)? + VarInt(bytes.len() as u64).consensus_encode(w)?
+ bytes.len(); + bytes.len();
@ -168,7 +168,7 @@ impl Encodable for AddrV2 {
} }
impl Decodable for AddrV2 { impl Decodable for AddrV2 {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let network_id = u8::consensus_decode(r)?; let network_id = u8::consensus_decode(r)?;
let len = VarInt::consensus_decode(r)?.0; let len = VarInt::consensus_decode(r)?.0;
if len > 512 { if len > 512 {
@ -264,7 +264,7 @@ impl AddrV2Message {
} }
impl Encodable for AddrV2Message { impl Encodable for AddrV2Message {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += self.time.consensus_encode(w)?; len += self.time.consensus_encode(w)?;
len += VarInt(self.services.to_u64()).consensus_encode(w)?; len += VarInt(self.services.to_u64()).consensus_encode(w)?;
@ -278,7 +278,7 @@ impl Encodable for AddrV2Message {
} }
impl Decodable for AddrV2Message { impl Decodable for AddrV2Message {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(AddrV2Message { Ok(AddrV2Message {
time: Decodable::consensus_decode(r)?, time: Decodable::consensus_decode(r)?,
services: ServiceFlags::from(VarInt::consensus_decode(r)?.0), services: ServiceFlags::from(VarInt::consensus_decode(r)?.0),

4
src/network/constants.rs
View File

@ -280,14 +280,14 @@ impl ops::BitXorAssign for ServiceFlags {
impl Encodable for ServiceFlags { impl Encodable for ServiceFlags {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
self.0.consensus_encode(w) self.0.consensus_encode(w)
} }
} }
impl Decodable for ServiceFlags { impl Decodable for ServiceFlags {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(ServiceFlags(Decodable::consensus_decode(r)?)) Ok(ServiceFlags(Decodable::consensus_decode(r)?))
} }
} }

16
src/network/message.rs
View File

@ -80,7 +80,7 @@ impl AsRef<str> for CommandString {
impl Encodable for CommandString { impl Encodable for CommandString {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut rawbytes = [0u8; 12]; let mut rawbytes = [0u8; 12];
let strbytes = self.0.as_bytes(); let strbytes = self.0.as_bytes();
debug_assert!(strbytes.len() <= 12); debug_assert!(strbytes.len() <= 12);
@ -91,7 +91,7 @@ impl Encodable for CommandString {
impl Decodable for CommandString { impl Decodable for CommandString {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let rawbytes: [u8; 12] = Decodable::consensus_decode(r)?; let rawbytes: [u8; 12] = Decodable::consensus_decode(r)?;
let rv = iter::FromIterator::from_iter( let rv = iter::FromIterator::from_iter(
rawbytes rawbytes
@ -287,7 +287,7 @@ struct HeaderSerializationWrapper<'a>(&'a Vec<block::BlockHeader>);
impl<'a> Encodable for HeaderSerializationWrapper<'a> { impl<'a> Encodable for HeaderSerializationWrapper<'a> {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += VarInt(self.0.len() as u64).consensus_encode(w)?; len += VarInt(self.0.len() as u64).consensus_encode(w)?;
for header in self.0.iter() { for header in self.0.iter() {
@ -299,7 +299,7 @@ impl<'a> Encodable for HeaderSerializationWrapper<'a> {
} }
impl Encodable for RawNetworkMessage { impl Encodable for RawNetworkMessage {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += self.magic.consensus_encode(w)?; len += self.magic.consensus_encode(w)?;
len += self.command().consensus_encode(w)?; len += self.command().consensus_encode(w)?;
@ -346,7 +346,7 @@ struct HeaderDeserializationWrapper(Vec<block::BlockHeader>);
impl Decodable for HeaderDeserializationWrapper { impl Decodable for HeaderDeserializationWrapper {
#[inline] #[inline]
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let len = VarInt::consensus_decode(r)?.0; let len = VarInt::consensus_decode(r)?.0;
// should be above usual number of items to avoid // should be above usual number of items to avoid
// allocation // allocation
@ -361,13 +361,13 @@ impl Decodable for HeaderDeserializationWrapper {
} }
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref()) Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref())
} }
} }
impl Decodable for RawNetworkMessage { impl Decodable for RawNetworkMessage {
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let magic = Decodable::consensus_decode_from_finite_reader(r)?; let magic = Decodable::consensus_decode_from_finite_reader(r)?;
let cmd = CommandString::consensus_decode_from_finite_reader(r)?; let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
let raw_payload = CheckedData::consensus_decode_from_finite_reader(r)?.0; let raw_payload = CheckedData::consensus_decode_from_finite_reader(r)?.0;
@ -420,7 +420,7 @@ impl Decodable for RawNetworkMessage {
} }
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref()) Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref())
} }
} }

4
src/network/message_blockdata.rs
View File

@ -54,7 +54,7 @@ pub enum Inventory {
impl Encodable for Inventory { impl Encodable for Inventory {
#[inline] #[inline]
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
macro_rules! encode_inv { macro_rules! encode_inv {
($code:expr, $item:expr) => { ($code:expr, $item:expr) => {
u32::consensus_encode(&$code, w)? + $item.consensus_encode(w)? u32::consensus_encode(&$code, w)? + $item.consensus_encode(w)?
@ -74,7 +74,7 @@ impl Encodable for Inventory {
impl Decodable for Inventory { impl Decodable for Inventory {
#[inline] #[inline]
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let inv_type: u32 = Decodable::consensus_decode(r)?; let inv_type: u32 = Decodable::consensus_decode(r)?;
Ok(match inv_type { Ok(match inv_type {
0 => Inventory::Error, 0 => Inventory::Error,

4
src/network/message_bloom.rs
View File

@ -34,7 +34,7 @@ pub enum BloomFlags {
} }
impl Encodable for BloomFlags { impl Encodable for BloomFlags {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
w.write_all(&[match self { w.write_all(&[match self {
BloomFlags::None => 0, BloomFlags::None => 0,
BloomFlags::All => 1, BloomFlags::All => 1,
@ -45,7 +45,7 @@ impl Encodable for BloomFlags {
} }
impl Decodable for BloomFlags { impl Decodable for BloomFlags {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(match r.read_u8()? { Ok(match r.read_u8()? {
0 => BloomFlags::None, 0 => BloomFlags::None,
1 => BloomFlags::All, 1 => BloomFlags::All,

4
src/network/message_network.rs
View File

@ -106,14 +106,14 @@ pub enum RejectReason {
} }
impl Encodable for RejectReason { impl Encodable for RejectReason {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
w.write_all(&[*self as u8])?; w.write_all(&[*self as u8])?;
Ok(1) Ok(1)
} }
} }
impl Decodable for RejectReason { impl Decodable for RejectReason {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(match r.read_u8()? { Ok(match r.read_u8()? {
0x01 => RejectReason::Malformed, 0x01 => RejectReason::Malformed,
0x10 => RejectReason::Invalid, 0x10 => RejectReason::Invalid,

8
src/util/merkleblock.rs
View File

@ -355,7 +355,7 @@ impl PartialMerkleTree {
} }
impl Encodable for PartialMerkleTree { impl Encodable for PartialMerkleTree {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let ret = self.num_transactions.consensus_encode(w)? let ret = self.num_transactions.consensus_encode(w)?
+ self.hashes.consensus_encode(w)?; + self.hashes.consensus_encode(w)?;
let mut bytes: Vec<u8> = vec![0; (self.bits.len() + 7) / 8]; let mut bytes: Vec<u8> = vec![0; (self.bits.len() + 7) / 8];
@ -367,7 +367,7 @@ impl Encodable for PartialMerkleTree {
} }
impl Decodable for PartialMerkleTree { impl Decodable for PartialMerkleTree {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let num_transactions: u32 = Decodable::consensus_decode(r)?; let num_transactions: u32 = Decodable::consensus_decode(r)?;
let hashes: Vec<TxMerkleNode> = Decodable::consensus_decode(r)?; let hashes: Vec<TxMerkleNode> = Decodable::consensus_decode(r)?;
@ -506,7 +506,7 @@ impl MerkleBlock {
} }
impl Encodable for MerkleBlock { impl Encodable for MerkleBlock {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let len = self.header.consensus_encode(w)? let len = self.header.consensus_encode(w)?
+ self.txn.consensus_encode(w)?; + self.txn.consensus_encode(w)?;
Ok(len) Ok(len)
@ -514,7 +514,7 @@ impl Encodable for MerkleBlock {
} }
impl Decodable for MerkleBlock { impl Decodable for MerkleBlock {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(MerkleBlock { Ok(MerkleBlock {
header: Decodable::consensus_decode(r)?, header: Decodable::consensus_decode(r)?,
txn: Decodable::consensus_decode(r)?, txn: Decodable::consensus_decode(r)?,

4
src/util/psbt/macros.rs
View File

@ -55,7 +55,7 @@ macro_rules! impl_psbt_serialize {
macro_rules! impl_psbtmap_consensus_encoding { macro_rules! impl_psbtmap_consensus_encoding {
($thing:ty) => { ($thing:ty) => {
impl $crate::consensus::Encodable for $thing { impl $crate::consensus::Encodable for $thing {
fn consensus_encode<W: $crate::io::Write>( fn consensus_encode<W: $crate::io::Write + ?Sized>(
&self, &self,
w: &mut W, w: &mut W,
) -> Result<usize, $crate::io::Error> { ) -> Result<usize, $crate::io::Error> {
@ -68,7 +68,7 @@ macro_rules! impl_psbtmap_consensus_encoding {
macro_rules! impl_psbtmap_consensus_decoding { macro_rules! impl_psbtmap_consensus_decoding {
($thing:ty) => { ($thing:ty) => {
impl $crate::consensus::Decodable for $thing { impl $crate::consensus::Decodable for $thing {
fn consensus_decode<R: $crate::io::Read>( fn consensus_decode<R: $crate::io::Read + ?Sized>(
r: &mut R, r: &mut R,
) -> Result<Self, $crate::consensus::encode::Error> { ) -> Result<Self, $crate::consensus::encode::Error> {
let mut rv: Self = ::core::default::Default::default(); let mut rv: Self = ::core::default::Default::default();

2
src/util/psbt/map/global.rs
View File

@ -100,7 +100,7 @@ impl Map for PartiallySignedTransaction {
} }
impl PartiallySignedTransaction { impl PartiallySignedTransaction {
pub(crate) fn consensus_decode_global<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { pub(crate) fn consensus_decode_global<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let mut r = r.take(MAX_VEC_SIZE as u64); let mut r = r.take(MAX_VEC_SIZE as u64);
let mut tx: Option<Transaction> = None; let mut tx: Option<Transaction> = None;
let mut version: Option<u32> = None; let mut version: Option<u32> = None;

2
src/util/psbt/map/mod.rs
View File

@ -32,7 +32,7 @@ pub(super) trait Map {
fn get_pairs(&self) -> Result<Vec<raw::Pair>, io::Error>; fn get_pairs(&self) -> Result<Vec<raw::Pair>, io::Error>;
/// Encodes map data with bitcoin consensus encoding. /// Encodes map data with bitcoin consensus encoding.
fn consensus_encode_map<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode_map<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
for pair in Map::get_pairs(self)? { for pair in Map::get_pairs(self)? {
len += encode::Encodable::consensus_encode(&pair, w)?; len += encode::Encodable::consensus_encode(&pair, w)?;

4
src/util/psbt/mod.rs
View File

@ -277,7 +277,7 @@ mod display_from_str {
pub use self::display_from_str::PsbtParseError; pub use self::display_from_str::PsbtParseError;
impl Encodable for PartiallySignedTransaction { impl Encodable for PartiallySignedTransaction {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += b"psbt".consensus_encode(w)?; len += b"psbt".consensus_encode(w)?;
@ -298,7 +298,7 @@ impl Encodable for PartiallySignedTransaction {
} }
impl Decodable for PartiallySignedTransaction { impl Decodable for PartiallySignedTransaction {
fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let magic: [u8; 4] = Decodable::consensus_decode(r)?; let magic: [u8; 4] = Decodable::consensus_decode(r)?;
if *b"psbt" != magic { if *b"psbt" != magic {

12
src/util/psbt/raw.rs
View File

@ -79,7 +79,7 @@ impl fmt::Display for Key {
} }
impl Decodable for Key { impl Decodable for Key {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let VarInt(byte_size): VarInt = Decodable::consensus_decode(r)?; let VarInt(byte_size): VarInt = Decodable::consensus_decode(r)?;
if byte_size == 0 { if byte_size == 0 {
@ -107,7 +107,7 @@ impl Decodable for Key {
} }
impl Encodable for Key { impl Encodable for Key {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = 0; let mut len = 0;
len += VarInt((self.key.len() + 1) as u64).consensus_encode(w)?; len += VarInt((self.key.len() + 1) as u64).consensus_encode(w)?;
@ -122,14 +122,14 @@ impl Encodable for Key {
} }
impl Encodable for Pair { impl Encodable for Pair {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let len = self.key.consensus_encode(w)?; let len = self.key.consensus_encode(w)?;
Ok(len + self.value.consensus_encode(w)?) Ok(len + self.value.consensus_encode(w)?)
} }
} }
impl Decodable for Pair { impl Decodable for Pair {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
Ok(Pair { Ok(Pair {
key: Decodable::consensus_decode(r)?, key: Decodable::consensus_decode(r)?,
value: Decodable::consensus_decode(r)?, value: Decodable::consensus_decode(r)?,
@ -138,7 +138,7 @@ impl Decodable for Pair {
} }
impl<Subtype> Encodable for ProprietaryKey<Subtype> where Subtype: Copy + From<u8> + Into<u8> { impl<Subtype> Encodable for ProprietaryKey<Subtype> where Subtype: Copy + From<u8> + Into<u8> {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
let mut len = self.prefix.consensus_encode(w)? + 1; let mut len = self.prefix.consensus_encode(w)? + 1;
w.emit_u8(self.subtype.into())?; w.emit_u8(self.subtype.into())?;
w.write_all(&self.key)?; w.write_all(&self.key)?;
@ -148,7 +148,7 @@ impl<Subtype> Encodable for ProprietaryKey<Subtype> where Subtype: Copy + From<u
} }
impl<Subtype> Decodable for ProprietaryKey<Subtype> where Subtype: Copy + From<u8> + Into<u8> { impl<Subtype> Decodable for ProprietaryKey<Subtype> where Subtype: Copy + From<u8> + Into<u8> {
fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> { fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
let prefix = Vec::<u8>::consensus_decode(r)?; let prefix = Vec::<u8>::consensus_decode(r)?;
let subtype = Subtype::from(r.read_u8()?); let subtype = Subtype::from(r.read_u8()?);
let key = read_to_end(r)?; let key = read_to_end(r)?;

2
src/util/sighash.rs
View File

@ -794,7 +794,7 @@ impl<'a> Annex<'a> {
} }
impl<'a> Encodable for Annex<'a> { impl<'a> Encodable for Annex<'a> {
fn consensus_encode<W: io::Write>(&self, w: &mut W) -> Result<usize, io::Error> { fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
encode::consensus_encode_with_size(self.0, w) encode::consensus_encode_with_size(self.0, w)
} }
} }

4
src/util/uint.rs
View File

@ -419,7 +419,7 @@ macro_rules! construct_uint {
impl $crate::consensus::Encodable for $name { impl $crate::consensus::Encodable for $name {
#[inline] #[inline]
fn consensus_encode<W: $crate::io::Write>( fn consensus_encode<W: $crate::io::Write + ?Sized>(
&self, &self,
w: &mut W, w: &mut W,
) -> Result<usize, $crate::io::Error> { ) -> Result<usize, $crate::io::Error> {
@ -433,7 +433,7 @@ macro_rules! construct_uint {
} }
impl $crate::consensus::Decodable for $name { impl $crate::consensus::Decodable for $name {
fn consensus_decode<R: $crate::io::Read>( fn consensus_decode<R: $crate::io::Read + ?Sized>(
r: &mut R, r: &mut R,
) -> Result<$name, $crate::consensus::encode::Error> { ) -> Result<$name, $crate::consensus::encode::Error> {
use $crate::consensus::Decodable; use $crate::consensus::Decodable;