Sulkta-Coop/pallas
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

chore: fix lint warnings (#330)

Browse source
This commit is contained in:
Santiago Carmuega 2023-11-13 17:00:00 -03:00 • committed by GitHub
parent c772da69ec
commit f26b9bd591
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 139 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

14
pallas-applying/tests/byron.rs
View file

@ -273,7 +273,8 @@ mod byron_tests {
} }
#[test] #[test]
// The input to the transaction has an associated witness, but the signature is wrong. // The input to the transaction has an associated witness, but the signature is
// wrong.
fn wrong_signature() { fn wrong_signature() {
let cbor_bytes: Vec<u8> = cbor_to_bytes(include_str!("../../test_data/byron1.tx")); let cbor_bytes: Vec<u8> = cbor_to_bytes(include_str!("../../test_data/byron1.tx"));
let mut mtxp: MintedTxPayload = mainnet_tx_from_bytes_cbor(&cbor_bytes); let mut mtxp: MintedTxPayload = mainnet_tx_from_bytes_cbor(&cbor_bytes);
@ -319,9 +320,10 @@ fn add_to_utxo<'a>(utxos: &mut UTxOs<'a>, tx_in: TxIn, tx_out: TxOut) {
utxos.insert(multi_era_in, multi_era_out); utxos.insert(multi_era_in, multi_era_out);
} }
// pallas_applying::validate takes a MultiEraTx, not a Tx and a Witnesses. To be able to build a // pallas_applying::validate takes a MultiEraTx, not a Tx and a Witnesses. To be
// MultiEraTx from a Tx and a Witnesses, we need to encode each of them and then decode them into // able to build a MultiEraTx from a Tx and a Witnesses, we need to encode each
// KeepRaw<Tx> and KeepRaw<Witnesses> values, respectively, to be able to make the MultiEraTx value. // of them and then decode them into KeepRaw<Tx> and KeepRaw<Witnesses> values,
// respectively, to be able to make the MultiEraTx value.
fn mk_byron_tx_and_validate( fn mk_byron_tx_and_validate(
tx: &Tx, tx: &Tx,
wits: &Witnesses, wits: &Witnesses,
@ -333,7 +335,7 @@ fn mk_byron_tx_and_validate(
Ok(_) => (), Ok(_) => (),
Err(err) => assert!(false, "Unable to encode Tx ({:?}).", err), Err(err) => assert!(false, "Unable to encode Tx ({:?}).", err),
}; };
let kptx: KeepRaw<Tx> = match Decode::decode(&mut Decoder::new(&tx_buf.as_slice()), &mut ()) { let kptx: KeepRaw<Tx> = match Decode::decode(&mut Decoder::new(tx_buf.as_slice()), &mut ()) {
Ok(kp) => kp, Ok(kp) => kp,
Err(err) => panic!("Unable to decode Tx ({:?}).", err), Err(err) => panic!("Unable to decode Tx ({:?}).", err),
}; };
@ -344,7 +346,7 @@ fn mk_byron_tx_and_validate(
Err(err) => assert!(false, "Unable to encode Witnesses ({:?}).", err), Err(err) => assert!(false, "Unable to encode Witnesses ({:?}).", err),
}; };
let kpwit: KeepRaw<Witnesses> = let kpwit: KeepRaw<Witnesses> =
match Decode::decode(&mut Decoder::new(&wit_buf.as_slice()), &mut ()) { match Decode::decode(&mut Decoder::new(wit_buf.as_slice()), &mut ()) {
Ok(kp) => kp, Ok(kp) => kp,
Err(err) => panic!("Unable to decode Witnesses ({:?}).", err), Err(err) => panic!("Unable to decode Witnesses ({:?}).", err),
}; };

94
pallas-codec/src/flat/decode/decoder.rs
View file

@ -27,11 +27,13 @@ impl<'b> Decoder<'b> {
/// Decode an integer of any size. /// Decode an integer of any size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we decode the next 8 bits of the buffer. /// First we decode the next 8 bits of the buffer.
/// We take the 7 least significant bits as the 7 least significant bits of the current unsigned integer. /// We take the 7 least significant bits as the 7 least significant bits of
/// If the most significant bit of the 8 bits is 1 then we take the next 8 and repeat the process above, /// the current unsigned integer. If the most significant bit of the 8
/// filling in the next 7 least significant bits of the unsigned integer and so on. /// bits is 1 then we take the next 8 and repeat the process above,
/// If the most significant bit was instead 0 we stop decoding any more bits. /// filling in the next 7 least significant bits of the unsigned integer and
/// Finally we use zigzag to convert the unsigned integer back to a signed integer. /// so on. If the most significant bit was instead 0 we stop decoding
/// any more bits. Finally we use zigzag to convert the unsigned integer
/// back to a signed integer.
pub fn integer(&mut self) -> Result<isize, Error> { pub fn integer(&mut self) -> Result<isize, Error> {
Ok(zigzag::to_isize(self.word()?)) Ok(zigzag::to_isize(self.word()?))
} }
@ -39,11 +41,13 @@ impl<'b> Decoder<'b> {
/// Decode an integer of 128 bits size. /// Decode an integer of 128 bits size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we decode the next 8 bits of the buffer. /// First we decode the next 8 bits of the buffer.
/// We take the 7 least significant bits as the 7 least significant bits of the current unsigned integer. /// We take the 7 least significant bits as the 7 least significant bits of
/// If the most significant bit of the 8 bits is 1 then we take the next 8 and repeat the process above, /// the current unsigned integer. If the most significant bit of the 8
/// filling in the next 7 least significant bits of the unsigned integer and so on. /// bits is 1 then we take the next 8 and repeat the process above,
/// If the most significant bit was instead 0 we stop decoding any more bits. /// filling in the next 7 least significant bits of the unsigned integer and
/// Finally we use zigzag to convert the unsigned integer back to a signed integer. /// so on. If the most significant bit was instead 0 we stop decoding
/// any more bits. Finally we use zigzag to convert the unsigned integer
/// back to a signed integer.
pub fn big_integer(&mut self) -> Result<i128, Error> { pub fn big_integer(&mut self) -> Result<i128, Error> {
Ok(zigzag::to_i128(self.big_word()?)) Ok(zigzag::to_i128(self.big_word()?))
} }
@ -70,9 +74,10 @@ impl<'b> Decoder<'b> {
/// Decodes a filler to byte align the buffer, /// Decodes a filler to byte align the buffer,
/// then decodes the next byte to get the array length up to a max of 255. /// then decodes the next byte to get the array length up to a max of 255.
/// We decode bytes equal to the array length to form the byte array. /// We decode bytes equal to the array length to form the byte array.
/// If the following byte for array length is not 0 we decode it and repeat above to continue decoding the byte array. /// If the following byte for array length is not 0 we decode it and repeat
/// We stop once we hit a byte array length of 0. /// above to continue decoding the byte array. We stop once we hit a
/// If array length is 0 for first byte array length the we return a empty array. /// byte array length of 0. If array length is 0 for first byte array
/// length the we return a empty array.
pub fn bytes(&mut self) -> Result<Vec<u8>, Error> { pub fn bytes(&mut self) -> Result<Vec<u8>, Error> {
self.filler()?; self.filler()?;
self.byte_array() self.byte_array()
@ -81,10 +86,12 @@ impl<'b> Decoder<'b> {
/// Decode a 32 bit char. /// Decode a 32 bit char.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we decode the next 8 bits of the buffer. /// First we decode the next 8 bits of the buffer.
/// We take the 7 least significant bits as the 7 least significant bits of the current unsigned integer. /// We take the 7 least significant bits as the 7 least significant bits of
/// If the most significant bit of the 8 bits is 1 then we take the next 8 and repeat the process above, /// the current unsigned integer. If the most significant bit of the 8
/// filling in the next 7 least significant bits of the unsigned integer and so on. /// bits is 1 then we take the next 8 and repeat the process above,
/// If the most significant bit was instead 0 we stop decoding any more bits. /// filling in the next 7 least significant bits of the unsigned integer and
/// so on. If the most significant bit was instead 0 we stop decoding
/// any more bits.
pub fn char(&mut self) -> Result<char, Error> { pub fn char(&mut self) -> Result<char, Error> {
let character = self.word()? as u32; let character = self.word()? as u32;
@ -105,9 +112,10 @@ impl<'b> Decoder<'b> {
/// Decodes a filler to byte align the buffer, /// Decodes a filler to byte align the buffer,
/// then decodes the next byte to get the array length up to a max of 255. /// then decodes the next byte to get the array length up to a max of 255.
/// We decode bytes equal to the array length to form the byte array. /// We decode bytes equal to the array length to form the byte array.
/// If the following byte for array length is not 0 we decode it and repeat above to continue decoding the byte array. /// If the following byte for array length is not 0 we decode it and repeat
/// We stop once we hit a byte array length of 0. /// above to continue decoding the byte array. We stop once we hit a
/// If array length is 0 for first byte array length the we return a empty array. /// byte array length of 0. If array length is 0 for first byte array
/// length the we return a empty array.
pub fn utf8(&mut self) -> Result<String, Error> { pub fn utf8(&mut self) -> Result<String, Error> {
// TODO: Better Error Handling // TODO: Better Error Handling
String::from_utf8(Vec::<u8>::decode(self)?).map_err(Error::from) String::from_utf8(Vec::<u8>::decode(self)?).map_err(Error::from)
@ -124,10 +132,12 @@ impl<'b> Decoder<'b> {
/// Decode a word of any size. /// Decode a word of any size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we decode the next 8 bits of the buffer. /// First we decode the next 8 bits of the buffer.
/// We take the 7 least significant bits as the 7 least significant bits of the current unsigned integer. /// We take the 7 least significant bits as the 7 least significant bits of
/// If the most significant bit of the 8 bits is 1 then we take the next 8 and repeat the process above, /// the current unsigned integer. If the most significant bit of the 8
/// filling in the next 7 least significant bits of the unsigned integer and so on. /// bits is 1 then we take the next 8 and repeat the process above,
/// If the most significant bit was instead 0 we stop decoding any more bits. /// filling in the next 7 least significant bits of the unsigned integer and
/// so on. If the most significant bit was instead 0 we stop decoding
/// any more bits.
pub fn word(&mut self) -> Result<usize, Error> { pub fn word(&mut self) -> Result<usize, Error> {
let mut leading_bit = 1; let mut leading_bit = 1;
let mut final_word: usize = 0; let mut final_word: usize = 0;
@ -146,10 +156,12 @@ impl<'b> Decoder<'b> {
/// Decode a word of 128 bits size. /// Decode a word of 128 bits size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we decode the next 8 bits of the buffer. /// First we decode the next 8 bits of the buffer.
/// We take the 7 least significant bits as the 7 least significant bits of the current unsigned integer. /// We take the 7 least significant bits as the 7 least significant bits of
/// If the most significant bit of the 8 bits is 1 then we take the next 8 and repeat the process above, /// the current unsigned integer. If the most significant bit of the 8
/// filling in the next 7 least significant bits of the unsigned integer and so on. /// bits is 1 then we take the next 8 and repeat the process above,
/// If the most significant bit was instead 0 we stop decoding any more bits. /// filling in the next 7 least significant bits of the unsigned integer and
/// so on. If the most significant bit was instead 0 we stop decoding
/// any more bits.
pub fn big_word(&mut self) -> Result<u128, Error> { pub fn big_word(&mut self) -> Result<u128, Error> {
let mut leading_bit = 1; let mut leading_bit = 1;
let mut final_word: u128 = 0; let mut final_word: u128 = 0;
@ -169,8 +181,8 @@ impl<'b> Decoder<'b> {
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// Decode a bit from the buffer. /// Decode a bit from the buffer.
/// If 0 then stop. /// If 0 then stop.
/// Otherwise we decode an item in the list with the decoder function passed in. /// Otherwise we decode an item in the list with the decoder function passed
/// Then decode the next bit in the buffer and repeat above. /// in. Then decode the next bit in the buffer and repeat above.
/// Returns a list of items decoded with the decoder function. /// Returns a list of items decoded with the decoder function.
pub fn decode_list_with<T, F>(&mut self, decoder_func: F) -> Result<Vec<T>, Error> pub fn decode_list_with<T, F>(&mut self, decoder_func: F) -> Result<Vec<T>, Error>
where where
@ -228,9 +240,10 @@ impl<'b> Decoder<'b> {
/// Throws a BufferNotByteAligned error if the buffer is not byte aligned /// Throws a BufferNotByteAligned error if the buffer is not byte aligned
/// Decodes the next byte to get the array length up to a max of 255. /// Decodes the next byte to get the array length up to a max of 255.
/// We decode bytes equal to the array length to form the byte array. /// We decode bytes equal to the array length to form the byte array.
/// If the following byte for array length is not 0 we decode it and repeat above to continue decoding the byte array. /// If the following byte for array length is not 0 we decode it and repeat
/// We stop once we hit a byte array length of 0. /// above to continue decoding the byte array. We stop once we hit a
/// If array length is 0 for first byte array length the we return a empty array. /// byte array length of 0. If array length is 0 for first byte array
/// length the we return a empty array.
fn byte_array(&mut self) -> Result<Vec<u8>, Error> { fn byte_array(&mut self) -> Result<Vec<u8>, Error> {
if self.used_bits != 0 { if self.used_bits != 0 {
return Err(Error::BufferNotByteAligned); return Err(Error::BufferNotByteAligned);
@ -265,10 +278,11 @@ impl<'b> Decoder<'b> {
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// If num_bits is greater than the 8 we throw an IncorrectNumBits error. /// If num_bits is greater than the 8 we throw an IncorrectNumBits error.
/// First we decode the next num_bits of bits in the buffer. /// First we decode the next num_bits of bits in the buffer.
/// If there are less unused bits in the current byte in the buffer than num_bits, /// If there are less unused bits in the current byte in the buffer than
/// then we decode the remaining bits from the most significant bits in the next byte in the buffer. /// num_bits, then we decode the remaining bits from the most
/// Otherwise we decode the unused bits from the current byte. /// significant bits in the next byte in the buffer. Otherwise we decode
/// Returns the decoded value up to a byte in size. /// the unused bits from the current byte. Returns the decoded value up
/// to a byte in size.
pub fn bits8(&mut self, num_bits: usize) -> Result<u8, Error> { pub fn bits8(&mut self, num_bits: usize) -> Result<u8, Error> {
if num_bits > 8 { if num_bits > 8 {
return Err(Error::IncorrectNumBits); return Err(Error::IncorrectNumBits);
@ -292,7 +306,8 @@ impl<'b> Decoder<'b> {
} }
/// Ensures the buffer has the required bytes passed in by required_bytes. /// Ensures the buffer has the required bytes passed in by required_bytes.
/// Throws a NotEnoughBytes error if there are less bytes remaining in the buffer than required_bytes. /// Throws a NotEnoughBytes error if there are less bytes remaining in the
/// buffer than required_bytes.
fn ensure_bytes(&mut self, required_bytes: usize) -> Result<(), Error> { fn ensure_bytes(&mut self, required_bytes: usize) -> Result<(), Error> {
if required_bytes as isize > self.buffer.len() as isize - self.pos as isize { if required_bytes as isize > self.buffer.len() as isize - self.pos as isize {
Err(Error::NotEnoughBytes(required_bytes)) Err(Error::NotEnoughBytes(required_bytes))
@ -302,7 +317,8 @@ impl<'b> Decoder<'b> {
} }
/// Ensures the buffer has the required bits passed in by required_bits. /// Ensures the buffer has the required bits passed in by required_bits.
/// Throws a NotEnoughBits error if there are less bits remaining in the buffer than required_bits. /// Throws a NotEnoughBits error if there are less bits remaining in the
/// buffer than required_bits.
fn ensure_bits(&mut self, required_bits: usize) -> Result<(), Error> { fn ensure_bits(&mut self, required_bits: usize) -> Result<(), Error> {
if required_bits as isize if required_bits as isize
> (self.buffer.len() as isize - self.pos as isize) * 8 - self.used_bits as isize > (self.buffer.len() as isize - self.pos as isize) * 8 - self.used_bits as isize

97
pallas-codec/src/flat/encode/encoder.rs
View file

@ -34,7 +34,8 @@ impl Encoder {
} }
/// Encode 1 unsigned byte. /// Encode 1 unsigned byte.
/// Uses the next 8 bits in the buffer, can be byte aligned or byte unaligned /// Uses the next 8 bits in the buffer, can be byte aligned or byte
/// unaligned
pub fn u8(&mut self, x: u8) -> Result<&mut Self, Error> { pub fn u8(&mut self, x: u8) -> Result<&mut Self, Error> {
if self.used_bits == 0 { if self.used_bits == 0 {
self.current_byte = x; self.current_byte = x;
@ -60,10 +61,11 @@ impl Encoder {
} }
/// Encode a byte array. /// Encode a byte array.
/// Uses filler to byte align the buffer, then writes byte array length up to 255. /// Uses filler to byte align the buffer, then writes byte array length up
/// Following that it writes the next 255 bytes from the array. /// to 255. Following that it writes the next 255 bytes from the array.
/// We repeat writing length up to 255 and the next 255 bytes until we reach the end of the byte array. /// We repeat writing length up to 255 and the next 255 bytes until we reach
/// After reaching the end of the byte array we write a 0 byte. Only write 0 byte if the byte array is empty. /// the end of the byte array. After reaching the end of the byte array
/// we write a 0 byte. Only write 0 byte if the byte array is empty.
pub fn bytes(&mut self, x: &[u8]) -> Result<&mut Self, Error> { pub fn bytes(&mut self, x: &[u8]) -> Result<&mut Self, Error> {
// use filler to write current buffer so bits used gets reset // use filler to write current buffer so bits used gets reset
self.filler(); self.filler();
@ -71,11 +73,12 @@ impl Encoder {
self.byte_array(x) self.byte_array(x)
} }
/// Encode a byte array in a byte aligned buffer. Throws exception if any bits for the current byte were used. /// Encode a byte array in a byte aligned buffer. Throws exception if any
/// Writes byte array length up to 255 /// bits for the current byte were used. Writes byte array length up to
/// Following that it writes the next 255 bytes from the array. /// 255 Following that it writes the next 255 bytes from the array.
/// We repeat writing length up to 255 and the next 255 bytes until we reach the end of the byte array. /// We repeat writing length up to 255 and the next 255 bytes until we reach
/// After reaching the end of the buffer we write a 0 byte. Only write 0 if the byte array is empty. /// the end of the byte array. After reaching the end of the buffer we
/// write a 0 byte. Only write 0 if the byte array is empty.
pub fn byte_array(&mut self, arr: &[u8]) -> Result<&mut Self, Error> { pub fn byte_array(&mut self, arr: &[u8]) -> Result<&mut Self, Error> {
if self.used_bits != 0 { if self.used_bits != 0 {
return Err(Error::BufferNotByteAligned); return Err(Error::BufferNotByteAligned);
@ -88,9 +91,11 @@ impl Encoder {
/// Encode an integer of any size. /// Encode an integer of any size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we use zigzag once to double the number and encode the negative sign as the least significant bit. /// First we use zigzag once to double the number and encode the negative
/// Next we encode the 7 least significant bits of the unsigned integer. If the number is greater than /// sign as the least significant bit. Next we encode the 7 least
/// 127 we encode a leading 1 followed by repeating the encoding above for the next 7 bits and so on. /// significant bits of the unsigned integer. If the number is greater than
/// 127 we encode a leading 1 followed by repeating the encoding above for
/// the next 7 bits and so on.
pub fn integer(&mut self, i: isize) -> &mut Self { pub fn integer(&mut self, i: isize) -> &mut Self {
let i = zigzag::to_usize(i); let i = zigzag::to_usize(i);
@ -101,9 +106,11 @@ impl Encoder {
/// Encode an integer of 128 bits size. /// Encode an integer of 128 bits size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// First we use zigzag once to double the number and encode the negative sign as the least significant bit. /// First we use zigzag once to double the number and encode the negative
/// Next we encode the 7 least significant bits of the unsigned integer. If the number is greater than /// sign as the least significant bit. Next we encode the 7 least
/// 127 we encode a leading 1 followed by repeating the encoding above for the next 7 bits and so on. /// significant bits of the unsigned integer. If the number is greater than
/// 127 we encode a leading 1 followed by repeating the encoding above for
/// the next 7 bits and so on.
pub fn big_integer(&mut self, i: i128) -> &mut Self { pub fn big_integer(&mut self, i: i128) -> &mut Self {
let i = zigzag::to_u128(i); let i = zigzag::to_u128(i);
@ -114,8 +121,9 @@ impl Encoder {
/// Encode a char of 32 bits. /// Encode a char of 32 bits.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// We encode the 7 least significant bits of the unsigned byte. If the char value is greater than /// We encode the 7 least significant bits of the unsigned byte. If the char
/// 127 we encode a leading 1 followed by repeating the above for the next 7 bits and so on. /// value is greater than 127 we encode a leading 1 followed by
/// repeating the above for the next 7 bits and so on.
pub fn char(&mut self, c: char) -> &mut Self { pub fn char(&mut self, c: char) -> &mut Self {
self.word(c as usize); self.word(c as usize);
@ -136,17 +144,19 @@ impl Encoder {
/// Encode a string. /// Encode a string.
/// Convert to byte array and then use byte array encoding. /// Convert to byte array and then use byte array encoding.
/// Uses filler to byte align the buffer, then writes byte array length up to 255. /// Uses filler to byte align the buffer, then writes byte array length up
/// Following that it writes the next 255 bytes from the array. /// to 255. Following that it writes the next 255 bytes from the array.
/// After reaching the end of the buffer we write a 0 byte. Only write 0 byte if the byte array is empty. /// After reaching the end of the buffer we write a 0 byte. Only write 0
/// byte if the byte array is empty.
pub fn utf8(&mut self, s: &str) -> Result<&mut Self, Error> { pub fn utf8(&mut self, s: &str) -> Result<&mut Self, Error> {
self.bytes(s.as_bytes()) self.bytes(s.as_bytes())
} }
/// Encode a unsigned integer of any size. /// Encode a unsigned integer of any size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// We encode the 7 least significant bits of the unsigned byte. If the char value is greater than /// We encode the 7 least significant bits of the unsigned byte. If the char
/// 127 we encode a leading 1 followed by repeating the above for the next 7 bits and so on. /// value is greater than 127 we encode a leading 1 followed by
/// repeating the above for the next 7 bits and so on.
pub fn word(&mut self, c: usize) -> &mut Self { pub fn word(&mut self, c: usize) -> &mut Self {
let mut d = c; let mut d = c;
loop { loop {
@ -168,8 +178,9 @@ impl Encoder {
/// Encode a unsigned integer of 128 bits size. /// Encode a unsigned integer of 128 bits size.
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// We encode the 7 least significant bits of the unsigned byte. If the char value is greater than /// We encode the 7 least significant bits of the unsigned byte. If the char
/// 127 we encode a leading 1 followed by repeating the above for the next 7 bits and so on. /// value is greater than 127 we encode a leading 1 followed by
/// repeating the above for the next 7 bits and so on.
pub fn big_word(&mut self, c: u128) -> &mut Self { pub fn big_word(&mut self, c: u128) -> &mut Self {
let mut d = c; let mut d = c;
loop { loop {
@ -191,8 +202,9 @@ impl Encoder {
/// Encode a list of bytes with a function /// Encode a list of bytes with a function
/// This is byte alignment agnostic. /// This is byte alignment agnostic.
/// If there are bytes in a list then write 1 bit followed by the functions encoding. /// If there are bytes in a list then write 1 bit followed by the functions
/// After the last item write a 0 bit. If the list is empty only encode a 0 bit. /// encoding. After the last item write a 0 bit. If the list is empty
/// only encode a 0 bit.
pub fn encode_list_with<T>( pub fn encode_list_with<T>(
&mut self, &mut self,
list: &[T], list: &[T],
@ -209,10 +221,11 @@ impl Encoder {
} }
/// Encodes up to 8 bits of information and is byte alignment agnostic. /// Encodes up to 8 bits of information and is byte alignment agnostic.
/// Uses unused bits in the current byte to write out the passed in byte value. /// Uses unused bits in the current byte to write out the passed in byte
/// Overflows to the most significant digits of the next byte if number of bits to use is greater than unused bits. /// value. Overflows to the most significant digits of the next byte if
/// Expects that number of bits to use is greater than or equal to required bits by the value. /// number of bits to use is greater than unused bits. Expects that
/// The param num_bits is i64 to match unused_bits type. /// number of bits to use is greater than or equal to required bits by the
/// value. The param num_bits is i64 to match unused_bits type.
pub fn bits(&mut self, num_bits: i64, val: u8) -> &mut Self { pub fn bits(&mut self, num_bits: i64, val: u8) -> &mut Self {
match (num_bits, val) { match (num_bits, val) {
(1, 0) => self.zero(), (1, 0) => self.zero(),
@ -237,13 +250,13 @@ impl Encoder {
self.used_bits += num_bits; self.used_bits += num_bits;
let unused_bits = 8 - self.used_bits; let unused_bits = 8 - self.used_bits;
match unused_bits { match unused_bits {
x if x > 0 => { 0 => {
self.current_byte |= val << x;
}
x if x == 0 => {
self.current_byte |= val; self.current_byte |= val;
self.next_word(); self.next_word();
} }
x if x > 0 => {
self.current_byte |= val << x;
}
x => { x => {
let used = -x; let used = -x;
self.current_byte |= val >> used; self.current_byte |= val >> used;
@ -289,8 +302,9 @@ impl Encoder {
} }
} }
/// Write out byte regardless of current buffer alignment. /// Write out byte regardless of current buffer alignment.
/// Write most significant bits in remaining unused bits for the current byte, /// Write most significant bits in remaining unused bits for the current
/// then write out the remaining bits at the beginning of the next byte. /// byte, then write out the remaining bits at the beginning of the next
/// byte.
fn byte_unaligned(&mut self, x: u8) { fn byte_unaligned(&mut self, x: u8) {
let x_shift = self.current_byte | (x >> self.used_bits); let x_shift = self.current_byte | (x >> self.used_bits);
self.buffer.push(x_shift); self.buffer.push(x_shift);
@ -298,8 +312,9 @@ impl Encoder {
self.current_byte = x << (8 - self.used_bits); self.current_byte = x << (8 - self.used_bits);
} }
/// Write the current byte out to the buffer and begin next byte to write out. /// Write the current byte out to the buffer and begin next byte to write
/// Add current byte to the buffer and set current byte and used bits to 0. /// out. Add current byte to the buffer and set current byte and used
/// bits to 0.
fn next_word(&mut self) { fn next_word(&mut self) {
self.buffer.push(self.current_byte); self.buffer.push(self.current_byte);
@ -309,8 +324,8 @@ impl Encoder {
/// Writes byte array length up to 255 /// Writes byte array length up to 255
/// Following that it writes the next 255 bytes from the array. /// Following that it writes the next 255 bytes from the array.
/// After reaching the end of the buffer we write a 0 byte. Only write 0 if the byte array is empty. /// After reaching the end of the buffer we write a 0 byte. Only write 0 if
/// This is byte alignment agnostic. /// the byte array is empty. This is byte alignment agnostic.
fn write_blk(&mut self, arr: &[u8]) { fn write_blk(&mut self, arr: &[u8]) {
let chunks = arr.chunks(255); let chunks = arr.chunks(255);

6
pallas-network/src/miniprotocols/localstate/server.rs
View file

@ -47,11 +47,7 @@ impl GenericServer {
} }
fn has_agency(&self) -> bool { fn has_agency(&self) -> bool {
match self.state() { matches!(self.state(), State::Acquiring | State::Querying)
State::Acquiring => true,
State::Querying => true,
_ => false,
}
} }
fn assert_agency_is_ours(&self) -> Result<(), Error> { fn assert_agency_is_ours(&self) -> Result<(), Error> {

7
pallas-network/tests/protocols.rs
View file

@ -6,17 +6,14 @@ use pallas_codec::utils::AnyCbor;
use pallas_network::facades::{NodeClient, PeerClient, PeerServer}; use pallas_network::facades::{NodeClient, PeerClient, PeerServer};
use pallas_network::miniprotocols::blockfetch::BlockRequest; use pallas_network::miniprotocols::blockfetch::BlockRequest;
use pallas_network::miniprotocols::chainsync::{ClientRequest, HeaderContent, Tip}; use pallas_network::miniprotocols::chainsync::{ClientRequest, HeaderContent, Tip};
use pallas_network::miniprotocols::handshake::n2c;
use pallas_network::miniprotocols::handshake::n2n::VersionData; use pallas_network::miniprotocols::handshake::n2n::VersionData;
use pallas_network::miniprotocols::localstate::{ClientAcquireRequest, ClientQueryRequest}; use pallas_network::miniprotocols::localstate::ClientQueryRequest;
use pallas_network::miniprotocols::{ use pallas_network::miniprotocols::{
blockfetch, blockfetch,
chainsync::{self, NextResponse}, chainsync::{self, NextResponse},
Point, Point,
}; };
use pallas_network::miniprotocols::{ use pallas_network::miniprotocols::{handshake, localstate};
handshake, localstate, PROTOCOL_N2C_HANDSHAKE, PROTOCOL_N2C_STATE_QUERY,
};
use pallas_network::multiplexer::{Bearer, Plexer}; use pallas_network::multiplexer::{Bearer, Plexer};
use std::path::Path; use std::path::Path;
use tokio::net::{TcpListener, UnixListener}; use tokio::net::{TcpListener, UnixListener};

13
pallas-primitives/src/conway/model.rs
View file

@ -841,7 +841,7 @@ impl<C> minicbor::Encode<C> for ProposalProcedure {
) -> Result<(), minicbor::encode::Error<W::Error>> { ) -> Result<(), minicbor::encode::Error<W::Error>> {
e.array(4)?; e.array(4)?;
e.encode_with(&self.deposit, ctx)?; e.encode_with(self.deposit, ctx)?;
e.encode_with(&self.reward_account, ctx)?; e.encode_with(&self.reward_account, ctx)?;
e.encode_with(&self.gov_action, ctx)?; e.encode_with(&self.gov_action, ctx)?;
e.encode_with(&self.anchor, ctx)?; e.encode_with(&self.anchor, ctx)?;
@ -852,7 +852,7 @@ impl<C> minicbor::Encode<C> for ProposalProcedure {
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum GovAction { pub enum GovAction {
ParameterChange(Option<GovActionId>, ProtocolParamUpdate), ParameterChange(Option<GovActionId>, Box<ProtocolParamUpdate>),
HardForkInitiation(Option<GovActionId>, Vec<ProtocolVersion>), HardForkInitiation(Option<GovActionId>, Vec<ProtocolVersion>),
TreasuryWithdrawals(KeyValuePairs<RewardAccount, Coin>), TreasuryWithdrawals(KeyValuePairs<RewardAccount, Coin>),
NoConfidence(Option<GovActionId>), NoConfidence(Option<GovActionId>),
@ -1080,7 +1080,7 @@ impl<C> minicbor::Encode<C> for Anchor {
e.array(2)?; e.array(2)?;
e.encode_with(&self.0, ctx)?; e.encode_with(&self.0, ctx)?;
e.encode_with(&self.1, ctx)?; e.encode_with(self.1, ctx)?;
Ok(()) Ok(())
} }
@ -1105,8 +1105,8 @@ impl<C> minicbor::Encode<C> for GovActionId {
) -> Result<(), minicbor::encode::Error<W::Error>> { ) -> Result<(), minicbor::encode::Error<W::Error>> {
e.array(2)?; e.array(2)?;
e.encode_with(&self.0, ctx)?; e.encode_with(self.0, ctx)?;
e.encode_with(&self.1, ctx)?; e.encode_with(self.1, ctx)?;
Ok(()) Ok(())
} }
@ -1570,7 +1570,8 @@ mod tests {
// fn fragments_decoding() { // fn fragments_decoding() {
// // peculiar array of outputs used in an hydra transaction // // peculiar array of outputs used in an hydra transaction
// let bytes = hex::decode(hex).unwrap(); // let bytes = hex::decode(hex).unwrap();
// let outputs = Vec::<TransactionOutput>::decode_fragment(&bytes).unwrap(); // let outputs =
// Vec::<TransactionOutput>::decode_fragment(&bytes).unwrap();
// //
// dbg!(outputs); // dbg!(outputs);
// //

4
pallas-rolldb/src/wal/store.rs
View file

@ -131,7 +131,7 @@ impl<'a> RollBatch<'a> {
fn stage_append(&mut self, log: Log) { fn stage_append(&mut self, log: Log) {
let new_seq = self.2 + 1; let new_seq = self.2 + 1;
WalKV::stage_upsert(&self.0, DBInt(new_seq), DBSerde(log), &mut self.1); WalKV::stage_upsert(self.0, DBInt(new_seq), DBSerde(log), &mut self.1);
self.2 = new_seq; self.2 = new_seq;
} }
@ -175,7 +175,7 @@ impl Store {
hash: BlockHash, hash: BlockHash,
body: BlockBody, body: BlockBody,
) -> Result<(), Error> { ) -> Result<(), Error> {
let mut batch = RollBatch::new(&mut self.db, self.wal_seq); let mut batch = RollBatch::new(&self.db, self.wal_seq);
batch.stage_append(Log::Apply(slot, hash, body)); batch.stage_append(Log::Apply(slot, hash, body));

13
pallas-traverse/src/tx.rs
View file

@ -9,8 +9,8 @@ use pallas_primitives::{
}; };
use crate::{ use crate::{
Era, MultiEraCert, MultiEraInput, MultiEraMeta, MultiEraOutput, MultiEraPolicyAssets, Era, Error, MultiEraCert, MultiEraInput, MultiEraMeta, MultiEraOutput, MultiEraPolicyAssets,
MultiEraSigners, MultiEraTx, MultiEraUpdate, MultiEraWithdrawals, OriginalHash, Error MultiEraSigners, MultiEraTx, MultiEraUpdate, MultiEraWithdrawals, OriginalHash,
}; };
impl<'b> MultiEraTx<'b> { impl<'b> MultiEraTx<'b> {
@ -66,16 +66,19 @@ impl<'b> MultiEraTx<'b> {
/// successful /// successful
pub fn decode(cbor: &'b [u8]) -> Result<Self, Error> { pub fn decode(cbor: &'b [u8]) -> Result<Self, Error> {
if let Ok(tx) = minicbor::decode(cbor) { if let Ok(tx) = minicbor::decode(cbor) {
return Ok(MultiEraTx::Conway(Box::new(Cow::Owned(tx)))) return Ok(MultiEraTx::Conway(Box::new(Cow::Owned(tx))));
} }
if let Ok(tx) = minicbor::decode(cbor) { if let Ok(tx) = minicbor::decode(cbor) {
return Ok(MultiEraTx::Babbage(Box::new(Cow::Owned(tx)))) return Ok(MultiEraTx::Babbage(Box::new(Cow::Owned(tx))));
} }
if let Ok(tx) = minicbor::decode(cbor) { if let Ok(tx) = minicbor::decode(cbor) {
// Shelley/Allegra/Mary/Alonzo will all decode to Alonzo // Shelley/Allegra/Mary/Alonzo will all decode to Alonzo
return Ok(MultiEraTx::AlonzoCompatible(Box::new(Cow::Owned(tx)), Era::Alonzo)) return Ok(MultiEraTx::AlonzoCompatible(
Box::new(Cow::Owned(tx)),
Era::Alonzo,
));
} }
if let Ok(tx) = minicbor::decode(cbor) { if let Ok(tx) = minicbor::decode(cbor) {