2 use std::fmt::{Display, Formatter};
3 use bech32::{ToBase32, u5, WriteBase32, Base32Len};
5 use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
6 PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawInvoice, RawDataPart};
8 /// Converts a stream of bytes written to it to base32. On finalization the according padding will
9 /// be applied. That means the results of writing two data blocks with one or two `BytesToBase32`
10 /// converters will differ.
11 struct BytesToBase32<'a, W: WriteBase32 + 'a> {
12 /// Target for writing the resulting `u5`s resulting from the written bytes
14 /// Holds all unwritten bits left over from last round. The bits are stored beginning from
15 /// the most significant bit. E.g. if buffer_bits=3, then the byte with bits a, b and c will
16 /// look as follows: [a, b, c, 0, 0, 0, 0, 0]
18 /// Amount of bits left over from last round, stored in buffer.
22 impl<'a, W: WriteBase32> BytesToBase32<'a, W> {
23 /// Create a new bytes-to-base32 converter with `writer` as a sink for the resulting base32
25 pub fn new(writer: &'a mut W) -> BytesToBase32<'a, W> {
33 /// Add more bytes to the current conversion unit
34 pub fn append(&mut self, bytes: &[u8]) -> Result<(), W::Err> {
41 pub fn append_u8(&mut self, byte: u8) -> Result<(), W::Err> {
42 // Write first u5 if we have to write two u5s this round. That only happens if the
43 // buffer holds too many bits, so we don't have to combine buffer bits with new bits
44 // from this rounds byte.
45 if self.buffer_bits >= 5 {
47 u5::try_from_u8((self.buffer & 0b11111000) >> 3 ).expect("<32")
49 self.buffer = self.buffer << 5;
50 self.buffer_bits -= 5;
53 // Combine all bits from buffer with enough bits from this rounds byte so that they fill
54 // a u5. Save reamining bits from byte to buffer.
55 let from_buffer = self.buffer >> 3;
56 let from_byte = byte >> (3 + self.buffer_bits); // buffer_bits <= 4
58 self.writer.write_u5(u5::try_from_u8(from_buffer | from_byte).expect("<32"))?;
59 self.buffer = byte << (5 - self.buffer_bits);
60 self.buffer_bits = 3 + self.buffer_bits;
65 pub fn finalize(mut self) -> Result<(), W::Err> {
66 self.inner_finalize()?;
67 std::mem::forget(self);
71 fn inner_finalize(&mut self) -> Result<(), W::Err>{
72 // There can be at most two u5s left in the buffer after processing all bytes, write them.
73 if self.buffer_bits >= 5 {
75 u5::try_from_u8((self.buffer & 0b11111000) >> 3).expect("<32")
77 self.buffer = self.buffer << 5;
78 self.buffer_bits -= 5;
81 if self.buffer_bits != 0 {
82 self.writer.write_u5(u5::try_from_u8(self.buffer >> 3).expect("<32"))?;
89 impl<'a, W: WriteBase32> Drop for BytesToBase32<'a, W> {
92 .expect("Unhandled error when finalizing conversion on drop. User finalize to handle.")
96 /// Calculates the base32 encoded size of a byte slice
97 fn bytes_size_to_base32_size(byte_size: usize) -> usize {
98 let bits = byte_size * 8;
100 // without padding bits
108 impl Display for Invoice {
109 fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
110 self.signed_invoice.fmt(f)
114 impl Display for SignedRawInvoice {
115 fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
116 let hrp = self.raw_invoice.hrp.to_string();
117 let mut data = self.raw_invoice.data.to_base32();
118 data.extend_from_slice(&self.signature.to_base32());
120 bech32::encode_to_fmt(f, &hrp, data, bech32::Variant::Bech32).expect("HRP is valid")?;
127 impl Display for RawHrp {
128 fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
129 let amount = match self.raw_amount {
130 Some(ref amt) => amt.to_string(),
131 None => String::new(),
134 let si_prefix = match self.si_prefix {
135 Some(ref si) => si.to_string(),
136 None => String::new(),
149 impl Display for Currency {
150 fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
151 let currency_code = match *self {
152 Currency::Bitcoin => "bc",
153 Currency::BitcoinTestnet => "tb",
154 Currency::Regtest => "bcrt",
155 Currency::Simnet => "sb",
156 Currency::Signet => "tbs",
158 write!(f, "{}", currency_code)
162 impl Display for SiPrefix {
163 fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
166 SiPrefix::Milli => "m",
167 SiPrefix::Micro => "u",
168 SiPrefix::Nano => "n",
169 SiPrefix::Pico => "p",
175 fn encode_int_be_base32(int: u64) -> Vec<u5> {
178 let mut out_vec = Vec::<u5>::new();
180 let mut rem_int = int;
182 out_vec.push(u5::try_from_u8((rem_int % base) as u8).expect("always <32"));
190 fn encoded_int_be_base32_size(int: u64) -> usize {
191 for pos in (0..13).rev() {
192 if int & (0x1f << (5 * pos)) != 0 {
193 return (pos + 1) as usize;
199 fn encode_int_be_base256<T: Into<u64>>(int: T) -> Vec<u8> {
202 let mut out_vec = Vec::<u8>::new();
204 let mut rem_int: u64 = int.into();
206 out_vec.push((rem_int % base) as u8);
214 /// Appends the default value of `T` to the front of the `in_vec` till it reaches the length
215 /// `target_length`. If `in_vec` already is too lang `None` is returned.
216 fn try_stretch<T>(mut in_vec: Vec<T>, target_len: usize) -> Option<Vec<T>>
217 where T: Default + Copy
219 if in_vec.len() > target_len {
221 } else if in_vec.len() == target_len {
224 let mut out_vec = Vec::<T>::with_capacity(target_len);
225 out_vec.append(&mut vec![T::default(); target_len - in_vec.len()]);
226 out_vec.append(&mut in_vec);
231 impl ToBase32 for RawDataPart {
232 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
234 self.timestamp.write_base32(writer)?;
236 // encode tagged fields
237 for tagged_field in self.tagged_fields.iter() {
238 tagged_field.write_base32(writer)?;
245 impl ToBase32 for PositiveTimestamp {
246 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
247 // FIXME: use writer for int encoding
249 &try_stretch(encode_int_be_base32(self.as_unix_timestamp()), 7)
250 .expect("Can't be longer due than 7 u5s due to timestamp bounds")
255 impl ToBase32 for RawTaggedField {
256 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
258 RawTaggedField::UnknownSemantics(ref content) => {
259 writer.write(content)
261 RawTaggedField::KnownSemantics(ref tagged_field) => {
262 tagged_field.write_base32(writer)
268 impl ToBase32 for Sha256 {
269 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
270 (&self.0[..]).write_base32(writer)
273 impl Base32Len for Sha256 {
274 fn base32_len(&self) -> usize {
275 (&self.0[..]).base32_len()
279 impl ToBase32 for Description {
280 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
281 self.as_bytes().write_base32(writer)
285 impl Base32Len for Description {
286 fn base32_len(&self) -> usize {
287 self.0.as_bytes().base32_len()
291 impl ToBase32 for PayeePubKey {
292 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
293 (&self.serialize()[..]).write_base32(writer)
297 impl Base32Len for PayeePubKey {
298 fn base32_len(&self) -> usize {
299 bytes_size_to_base32_size(secp256k1::constants::PUBLIC_KEY_SIZE)
303 impl ToBase32 for ExpiryTime {
304 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
305 writer.write(&encode_int_be_base32(self.as_seconds()))
309 impl Base32Len for ExpiryTime {
310 fn base32_len(&self) -> usize {
311 encoded_int_be_base32_size(self.0.as_secs())
315 impl ToBase32 for MinFinalCltvExpiry {
316 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
317 writer.write(&encode_int_be_base32(self.0))
321 impl Base32Len for MinFinalCltvExpiry {
322 fn base32_len(&self) -> usize {
323 encoded_int_be_base32_size(self.0)
327 impl ToBase32 for Fallback {
328 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
330 Fallback::SegWitProgram {version: v, program: ref p} => {
332 p.write_base32(writer)
334 Fallback::PubKeyHash(ref hash) => {
335 writer.write_u5(u5::try_from_u8(17).expect("17 < 32"))?;
336 (&hash[..]).write_base32(writer)
338 Fallback::ScriptHash(ref hash) => {
339 writer.write_u5(u5::try_from_u8(18).expect("18 < 32"))?;
340 (&hash[..]).write_base32(writer)
346 impl Base32Len for Fallback {
347 fn base32_len(&self) -> usize {
349 Fallback::SegWitProgram {program: ref p, ..} => {
350 bytes_size_to_base32_size(p.len()) + 1
352 Fallback::PubKeyHash(_) | Fallback::ScriptHash(_) => {
359 impl ToBase32 for PrivateRoute {
360 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
361 let mut converter = BytesToBase32::new(writer);
363 for hop in (self.0).0.iter() {
364 converter.append(&hop.src_node_id.serialize()[..])?;
365 let short_channel_id = try_stretch(
366 encode_int_be_base256(hop.short_channel_id),
368 ).expect("sizeof(u64) == 8");
369 converter.append(&short_channel_id)?;
371 let fee_base_msat = try_stretch(
372 encode_int_be_base256(hop.fees.base_msat),
374 ).expect("sizeof(u32) == 4");
375 converter.append(&fee_base_msat)?;
377 let fee_proportional_millionths = try_stretch(
378 encode_int_be_base256(hop.fees.proportional_millionths),
380 ).expect("sizeof(u32) == 4");
381 converter.append(&fee_proportional_millionths)?;
383 let cltv_expiry_delta = try_stretch(
384 encode_int_be_base256(hop.cltv_expiry_delta),
386 ).expect("sizeof(u16) == 2");
387 converter.append(&cltv_expiry_delta)?;
390 converter.finalize()?;
395 impl Base32Len for PrivateRoute {
396 fn base32_len(&self) -> usize {
397 bytes_size_to_base32_size((self.0).0.len() * 51)
401 impl ToBase32 for TaggedField {
402 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
403 /// Writes a tagged field: tag, length and data. `tag` should be in `0..32` otherwise the
404 /// function will panic.
405 fn write_tagged_field<W, P>(writer: &mut W, tag: u8, payload: &P) -> Result<(), W::Err>
406 where W: WriteBase32,
407 P: ToBase32 + Base32Len,
409 let len = payload.base32_len();
410 assert!(len < 1024, "Every tagged field data can be at most 1023 bytes long.");
412 writer.write_u5(u5::try_from_u8(tag).expect("invalid tag, not in 0..32"))?;
413 writer.write(&try_stretch(
414 encode_int_be_base32(len as u64),
416 ).expect("Can't be longer than 2, see assert above."))?;
417 payload.write_base32(writer)
421 TaggedField::PaymentHash(ref hash) => {
422 write_tagged_field(writer, constants::TAG_PAYMENT_HASH, hash)
424 TaggedField::Description(ref description) => {
425 write_tagged_field(writer, constants::TAG_DESCRIPTION, description)
427 TaggedField::PayeePubKey(ref pub_key) => {
428 write_tagged_field(writer, constants::TAG_PAYEE_PUB_KEY, pub_key)
430 TaggedField::DescriptionHash(ref hash) => {
431 write_tagged_field(writer, constants::TAG_DESCRIPTION_HASH, hash)
433 TaggedField::ExpiryTime(ref duration) => {
434 write_tagged_field(writer, constants::TAG_EXPIRY_TIME, duration)
436 TaggedField::MinFinalCltvExpiry(ref expiry) => {
437 write_tagged_field(writer, constants::TAG_MIN_FINAL_CLTV_EXPIRY, expiry)
439 TaggedField::Fallback(ref fallback_address) => {
440 write_tagged_field(writer, constants::TAG_FALLBACK, fallback_address)
442 TaggedField::PrivateRoute(ref route_hops) => {
443 write_tagged_field(writer, constants::TAG_PRIVATE_ROUTE, route_hops)
445 TaggedField::PaymentSecret(ref payment_secret) => {
446 write_tagged_field(writer, constants::TAG_PAYMENT_SECRET, payment_secret)
448 TaggedField::Features(ref features) => {
449 write_tagged_field(writer, constants::TAG_FEATURES, features)
455 impl ToBase32 for InvoiceSignature {
456 fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
457 let mut converter = BytesToBase32::new(writer);
458 let (recovery_id, signature) = self.0.serialize_compact();
459 converter.append(&signature[..])?;
460 converter.append_u8(recovery_id.to_i32() as u8)?;
467 use bech32::CheckBase32;
470 fn test_currency_code() {
473 assert_eq!("bc", Currency::Bitcoin.to_string());
474 assert_eq!("tb", Currency::BitcoinTestnet.to_string());
475 assert_eq!("bcrt", Currency::Regtest.to_string());
476 assert_eq!("sb", Currency::Simnet.to_string());
477 assert_eq!("tbs", Currency::Signet.to_string());
482 use ::{Currency, RawHrp, SiPrefix};
485 currency: Currency::Bitcoin,
486 raw_amount: Some(100),
487 si_prefix: Some(SiPrefix::Micro),
490 assert_eq!(hrp.to_string(), "lnbc100u");
494 fn test_encode_int_be_base32() {
495 use ser::encode_int_be_base32;
497 let input: u64 = 33764;
498 let expected_out = CheckBase32::check_base32(&[1, 0, 31, 4]).unwrap();
500 assert_eq!(expected_out, encode_int_be_base32(input));
504 fn test_encode_int_be_base256() {
505 use ser::encode_int_be_base256;
507 let input: u64 = 16842530;
508 let expected_out = vec![1, 0, 255, 34];
510 assert_eq!(expected_out, encode_int_be_base256(input));