X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Fser.rs;h=dc5dba45da0fe46c24bbf6f8b664dbef76f175b5;hb=34f8dd9a49060676da0cf4157613cfb5fd58cf1e;hp=8811926782348a263735b55824ea74fb65d662cb;hpb=c60543c0ed9f1c469fb8b1836ef7796c696642f3;p=rust-lightning diff --git a/lightning-invoice/src/ser.rs b/lightning-invoice/src/ser.rs index 88119267..dc5dba45 100644 --- a/lightning-invoice/src/ser.rs +++ b/lightning-invoice/src/ser.rs @@ -1,9 +1,10 @@ -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, - RouteHint, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart}; +use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, Bolt11InvoiceSignature, PositiveTimestamp, + PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawBolt11Invoice, RawDataPart}; /// Converts a stream of bytes written to it to base32. On finalization the according padding will /// be applied. That means the results of writing two data blocks with one or two `BytesToBase32` @@ -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; } @@ -105,25 +106,25 @@ fn bytes_size_to_base32_size(byte_size: usize) -> usize { } } -impl Display for Invoice { +impl Display for Bolt11Invoice { fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { self.signed_invoice.fmt(f) } } -impl Display for SignedRawInvoice { +impl Display for SignedRawBolt11Invoice { fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { let hrp = self.raw_invoice.hrp.to_string(); 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 { @@ -153,6 +154,7 @@ impl Display for Currency { Currency::BitcoinTestnet => "tb", Currency::Regtest => "bcrt", Currency::Simnet => "sb", + Currency::Signet => "tbs", }; write!(f, "{}", currency_code) } @@ -311,13 +313,13 @@ impl Base32Len for ExpiryTime { } } -impl ToBase32 for MinFinalCltvExpiry { +impl ToBase32 for MinFinalCltvExpiryDelta { fn write_base32(&self, writer: &mut W) -> Result<(), ::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) } @@ -327,7 +329,7 @@ impl ToBase32 for Fallback { fn write_base32(&self, writer: &mut W) -> Result<(), ::Err> { match *self { Fallback::SegWitProgram {version: v, program: ref p} => { - writer.write_u5(v)?; + writer.write_u5(Into::::into(v))?; p.write_base32(writer) }, Fallback::PubKeyHash(ref hash) => { @@ -355,11 +357,11 @@ impl Base32Len for Fallback { } } -impl ToBase32 for RouteHint { +impl ToBase32 for PrivateRoute { fn write_base32(&self, writer: &mut W) -> Result<(), ::Err> { let mut converter = BytesToBase32::new(writer); - for hop in self.iter() { + for hop in (self.0).0.iter() { converter.append(&hop.src_node_id.serialize()[..])?; let short_channel_id = try_stretch( encode_int_be_base256(hop.short_channel_id), @@ -391,9 +393,9 @@ impl ToBase32 for RouteHint { } } -impl Base32Len for RouteHint { +impl Base32Len for PrivateRoute { fn base32_len(&self) -> usize { - bytes_size_to_base32_size(self.0.len() * 51) + bytes_size_to_base32_size((self.0).0.len() * 51) } } @@ -432,18 +434,21 @@ 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) }, - TaggedField::Route(ref route_hops) => { - write_tagged_field(writer, constants::TAG_ROUTE, route_hops) + TaggedField::PrivateRoute(ref route_hops) => { + write_tagged_field(writer, constants::TAG_PRIVATE_ROUTE, route_hops) }, TaggedField::PaymentSecret(ref payment_secret) => { write_tagged_field(writer, constants::TAG_PAYMENT_SECRET, payment_secret) }, + TaggedField::PaymentMetadata(ref payment_metadata) => { + write_tagged_field(writer, constants::TAG_PAYMENT_METADATA, payment_metadata) + }, TaggedField::Features(ref features) => { write_tagged_field(writer, constants::TAG_FEATURES, features) }, @@ -451,7 +456,7 @@ impl ToBase32 for TaggedField { } } -impl ToBase32 for InvoiceSignature { +impl ToBase32 for Bolt11InvoiceSignature { fn write_base32(&self, writer: &mut W) -> Result<(), ::Err> { let mut converter = BytesToBase32::new(writer); let (recovery_id, signature) = self.0.serialize_compact(); @@ -467,17 +472,18 @@ 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()); assert_eq!("bcrt", Currency::Regtest.to_string()); assert_eq!("sb", Currency::Simnet.to_string()); + assert_eq!("tbs", Currency::Signet.to_string()); } #[test] fn test_raw_hrp() { - use ::{Currency, RawHrp, SiPrefix}; + use crate::{Currency, RawHrp, SiPrefix}; let hrp = RawHrp { currency: Currency::Bitcoin, @@ -490,7 +496,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(); @@ -500,7 +506,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];