Merge pull request #2133 from tnull/2023-03-pin-syn

[rust-lightning] / lightning-invoice / src / ser.rs

diff --git a/lightning-invoice/src/ser.rs b/lightning-invoice/src/ser.rs
index 5c7b4aa8978456aebda20014a43c4ea165a2effb..c9fca01f11f48fa9923e7d748ec824f43622b7f6 100644 (file)
--- a/lightning-invoice/src/ser.rs
+++ b/lightning-invoice/src/ser.rs
@@ -1,8 +1,9 @@
-use std::fmt;
-use std::fmt::{Display, Formatter};
+use core::fmt;
+use core::fmt::{Display, Formatter};
 use bech32::{ToBase32, u5, WriteBase32, Base32Len};
+use crate::prelude::*;
 
-use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
+use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
        PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart};
 
 /// Converts a stream of bytes written to it to base32. On finalization the according padding will
@@ -46,7 +47,7 @@ impl<'a, W: WriteBase32> BytesToBase32<'a, W> {
                        self.writer.write_u5(
                                u5::try_from_u8((self.buffer & 0b11111000) >> 3 ).expect("<32")
                        )?;
-                       self.buffer = self.buffer << 5;
+                       self.buffer <<= 5;
                        self.buffer_bits -= 5;
                }
 
@@ -57,14 +58,14 @@ impl<'a, W: WriteBase32> BytesToBase32<'a, W> {
 
                self.writer.write_u5(u5::try_from_u8(from_buffer | from_byte).expect("<32"))?;
                self.buffer = byte << (5 - self.buffer_bits);
-               self.buffer_bits = 3 + self.buffer_bits;
+               self.buffer_bits += 3;
 
                Ok(())
        }
 
        pub fn finalize(mut self) ->  Result<(), W::Err> {
                self.inner_finalize()?;
-               std::mem::forget(self);
+               core::mem::forget(self);
                Ok(())
        }
 
@@ -74,7 +75,7 @@ impl<'a, W: WriteBase32> BytesToBase32<'a, W> {
                        self.writer.write_u5(
                                u5::try_from_u8((self.buffer & 0b11111000) >> 3).expect("<32")
                        )?;
-                       self.buffer = self.buffer << 5;
+                       self.buffer <<= 5;
                        self.buffer_bits -= 5;
                }
 
@@ -117,13 +118,13 @@ impl Display for SignedRawInvoice {
                let mut data  = self.raw_invoice.data.to_base32();
                data.extend_from_slice(&self.signature.to_base32());
 
-               bech32::encode_to_fmt(f, &hrp, data).expect("HRP is valid")?;
+               bech32::encode_to_fmt(f, &hrp, data, bech32::Variant::Bech32).expect("HRP is valid")?;
 
                Ok(())
        }
 }
 
-/// (C-not exported)
+/// This is not exported to bindings users
 impl Display for RawHrp {
        fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
                let amount = match self.raw_amount {
@@ -312,13 +313,13 @@ impl Base32Len for ExpiryTime {
        }
 }
 
-impl ToBase32 for MinFinalCltvExpiry {
+impl ToBase32 for MinFinalCltvExpiryDelta {
        fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
                writer.write(&encode_int_be_base32(self.0))
        }
 }
 
-impl Base32Len for MinFinalCltvExpiry {
+impl Base32Len for MinFinalCltvExpiryDelta {
        fn base32_len(&self) -> usize {
                encoded_int_be_base32_size(self.0)
        }
@@ -433,8 +434,8 @@ impl ToBase32 for TaggedField {
                        TaggedField::ExpiryTime(ref duration) => {
                                write_tagged_field(writer, constants::TAG_EXPIRY_TIME, duration)
                        },
-                       TaggedField::MinFinalCltvExpiry(ref expiry) => {
-                               write_tagged_field(writer, constants::TAG_MIN_FINAL_CLTV_EXPIRY, expiry)
+                       TaggedField::MinFinalCltvExpiryDelta(ref expiry) => {
+                               write_tagged_field(writer, constants::TAG_MIN_FINAL_CLTV_EXPIRY_DELTA, expiry)
                        },
                        TaggedField::Fallback(ref fallback_address) => {
                                write_tagged_field(writer, constants::TAG_FALLBACK, fallback_address)
@@ -468,7 +469,7 @@ mod test {
 
        #[test]
        fn test_currency_code() {
-               use Currency;
+               use crate::Currency;
 
                assert_eq!("bc", Currency::Bitcoin.to_string());
                assert_eq!("tb", Currency::BitcoinTestnet.to_string());
@@ -479,7 +480,7 @@ mod test {
 
        #[test]
        fn test_raw_hrp() {
-               use ::{Currency, RawHrp, SiPrefix};
+               use crate::{Currency, RawHrp, SiPrefix};
 
                let hrp = RawHrp {
                        currency: Currency::Bitcoin,
@@ -492,7 +493,7 @@ mod test {
 
        #[test]
        fn test_encode_int_be_base32() {
-               use ser::encode_int_be_base32;
+               use crate::ser::encode_int_be_base32;
 
                let input: u64 = 33764;
                let expected_out = CheckBase32::check_base32(&[1, 0, 31, 4]).unwrap();
@@ -502,7 +503,7 @@ mod test {
 
        #[test]
        fn test_encode_int_be_base256() {
-               use ser::encode_int_be_base256;
+               use crate::ser::encode_int_be_base256;
 
                let input: u64 = 16842530;
                let expected_out = vec![1, 0, 255, 34];