-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`
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;
}
// Combine all bits from buffer with enough bits from this rounds byte so that they fill
- // a u5. Save reamining bits from byte to buffer.
+ // a u5. Save remaining bits from byte to buffer.
let from_buffer = self.buffer >> 3;
let from_byte = byte >> (3 + self.buffer_bits); // buffer_bits <= 4
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(())
}
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;
}
}
}
-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 {
impl ToBase32 for Description {
fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
- self.as_bytes().write_base32(writer)
+ self.0.0.as_bytes().write_base32(writer)
}
}
impl Base32Len for Description {
fn base32_len(&self) -> usize {
- self.0.as_bytes().base32_len()
+ self.0.0.as_bytes().base32_len()
}
}
}
}
-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)
}
fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
match *self {
Fallback::SegWitProgram {version: v, program: ref p} => {
- writer.write_u5(v)?;
+ writer.write_u5(Into::<u5>::into(v))?;
p.write_base32(writer)
},
Fallback::PubKeyHash(ref hash) => {
}
}
-impl ToBase32 for RouteHint {
+impl ToBase32 for PrivateRoute {
fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::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),
}
}
-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)
}
}
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)
},
}
}
-impl ToBase32 for InvoiceSignature {
+impl ToBase32 for Bolt11InvoiceSignature {
fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
let mut converter = BytesToBase32::new(writer);
let (recovery_id, signature) = self.0.serialize_compact();
#[test]
fn test_currency_code() {
- use Currency;
+ use crate::Currency;
assert_eq!("bc", Currency::Bitcoin.to_string());
assert_eq!("tb", Currency::BitcoinTestnet.to_string());
#[test]
fn test_raw_hrp() {
- use ::{Currency, RawHrp, SiPrefix};
+ use crate::{Currency, RawHrp, SiPrefix};
let hrp = RawHrp {
currency: Currency::Bitcoin,
#[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();
#[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];
projects / rust-lightning / blobdiff