-// Prefix these with `rustdoc::` when we update our MSRV to be >= 1.52 to remove warnings.
-#![deny(broken_intra_doc_links)]
-#![deny(private_intra_doc_links)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(rustdoc::private_intra_doc_links)]
#![deny(missing_docs)]
#![deny(non_upper_case_globals)]
pub mod payment;
pub mod utils;
-pub(crate) mod time_utils;
-
extern crate bech32;
-extern crate bitcoin_hashes;
#[macro_use] extern crate lightning;
extern crate num_traits;
extern crate secp256k1;
use bech32::u5;
use bitcoin::{Address, Network, PubkeyHash, ScriptHash};
-use bitcoin::util::address::{Payload, WitnessVersion};
-use bitcoin_hashes::{Hash, sha256};
-use lightning::ln::PaymentSecret;
+use bitcoin::address::{Payload, WitnessProgram, WitnessVersion};
+use bitcoin::hashes::{Hash, sha256};
use lightning::ln::features::Bolt11InvoiceFeatures;
-#[cfg(any(doc, test))]
-use lightning::routing::gossip::RoutingFees;
-use lightning::routing::router::RouteHint;
use lightning::util::invoice::construct_invoice_preimage;
use secp256k1::PublicKey;
#[cfg(feature = "serde")]
use serde::{Deserialize, Deserializer,Serialize, Serializer, de::Error};
+#[doc(no_inline)]
+pub use lightning::ln::PaymentSecret;
+#[doc(no_inline)]
+pub use lightning::routing::router::{RouteHint, RouteHintHop};
+#[doc(no_inline)]
+pub use lightning::routing::gossip::RoutingFees;
+use lightning::util::string::UntrustedString;
+
mod de;
mod ser;
mod tb;
+#[allow(unused_imports)]
mod prelude {
- #[cfg(feature = "hashbrown")]
- extern crate hashbrown;
-
- pub use alloc::{vec, vec::Vec, string::String, collections::VecDeque, boxed::Box};
- #[cfg(not(feature = "hashbrown"))]
- pub use std::collections::{HashMap, HashSet, hash_map};
- #[cfg(feature = "hashbrown")]
- pub use self::hashbrown::{HashMap, HashSet, hash_map};
+ pub use alloc::{vec, vec::Vec, string::String};
pub use alloc::string::ToString;
}
use crate::prelude::*;
-/// Sync compat for std/no_std
-#[cfg(feature = "std")]
-mod sync {
- pub use ::std::sync::{Mutex, MutexGuard};
-}
-
-/// Sync compat for std/no_std
-#[cfg(not(feature = "std"))]
-mod sync;
-
/// Errors that indicate what is wrong with the invoice. They have some granularity for debug
/// reasons, but should generally result in an "invalid BOLT11 invoice" message for the user.
#[allow(missing_docs)]
/// extern crate secp256k1;
/// extern crate lightning;
/// extern crate lightning_invoice;
-/// extern crate bitcoin_hashes;
+/// extern crate bitcoin;
///
-/// use bitcoin_hashes::Hash;
-/// use bitcoin_hashes::sha256;
+/// use bitcoin::hashes::Hash;
+/// use bitcoin::hashes::sha256;
///
/// use secp256k1::Secp256k1;
/// use secp256k1::SecretKey;
/// This is not exported to bindings users as we don't have a good way to map the reference lifetimes making this
/// practically impossible to use safely in languages like C.
#[derive(Eq, PartialEq, Debug, Clone, Ord, PartialOrd)]
-pub enum InvoiceDescription<'f> {
+pub enum Bolt11InvoiceDescription<'f> {
/// Reference to the directly supplied description in the invoice
Direct(&'f Description),
Hash(&'f Sha256),
}
+impl<'f> Display for Bolt11InvoiceDescription<'f> {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ match self {
+ Bolt11InvoiceDescription::Direct(desc) => write!(f, "{}", desc.0),
+ Bolt11InvoiceDescription::Hash(hash) => write!(f, "{}", hash.0),
+ }
+ }
+}
+
/// Represents a signed [`RawBolt11Invoice`] with cached hash. The signature is not checked and may be
/// invalid.
///
hash: [u8; 32],
/// signature of the payment request
- signature: InvoiceSignature,
+ signature: Bolt11InvoiceSignature,
}
/// Represents an syntactically correct [`Bolt11Invoice`] for a payment on the lightning network,
Network::Testnet => Currency::BitcoinTestnet,
Network::Regtest => Currency::Regtest,
Network::Signet => Currency::Signet,
+ _ => {
+ debug_assert!(false, "Need to handle new rust-bitcoin network type");
+ Currency::Regtest
+ },
}
}
}
///
/// # Invariants
/// The description can be at most 639 __bytes__ long
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
-pub struct Description(String);
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Default)]
+pub struct Description(UntrustedString);
/// Payee public key
#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
/// Recoverable signature
#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-pub struct InvoiceSignature(pub RecoverableSignature);
+pub struct Bolt11InvoiceSignature(pub RecoverableSignature);
-impl PartialOrd for InvoiceSignature {
+impl PartialOrd for Bolt11InvoiceSignature {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
- self.0.serialize_compact().1.partial_cmp(&other.0.serialize_compact().1)
+ Some(self.cmp(other))
}
}
-impl Ord for InvoiceSignature {
+impl Ord for Bolt11InvoiceSignature {
fn cmp(&self, other: &Self) -> Ordering {
self.0.serialize_compact().1.cmp(&other.0.serialize_compact().1)
}
amount: None,
si_prefix: None,
timestamp: None,
- tagged_fields: Vec::new(),
+ tagged_fields: Vec::with_capacity(8),
error: None,
phantom_d: core::marker::PhantomData,
}
/// Set the description or description hash. This function is only available if no description (hash) was set.
- pub fn invoice_description(self, description: InvoiceDescription) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
+ pub fn invoice_description(self, description: Bolt11InvoiceDescription) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
match description {
- InvoiceDescription::Direct(desc) => {
- self.description(desc.clone().into_inner())
+ Bolt11InvoiceDescription::Direct(desc) => {
+ self.description(desc.clone().into_inner().0)
}
- InvoiceDescription::Hash(hash) => {
+ Bolt11InvoiceDescription::Hash(hash) => {
self.description_hash(hash.0)
}
}
/// 1. raw invoice
/// 2. hash of the raw invoice
/// 3. signature
- pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], InvoiceSignature) {
+ pub fn into_parts(self) -> (RawBolt11Invoice, [u8; 32], Bolt11InvoiceSignature) {
(self.raw_invoice, self.hash, self.signature)
}
}
/// Signature for the invoice.
- pub fn signature(&self) -> &InvoiceSignature {
+ pub fn signature(&self) -> &Bolt11InvoiceSignature {
&self.signature
}
Ok(SignedRawBolt11Invoice {
raw_invoice: self,
hash: raw_hash,
- signature: InvoiceSignature(signature),
+ signature: Bolt11InvoiceSignature(signature),
})
}
}
}
+impl From<PositiveTimestamp> for Duration {
+ fn from(val: PositiveTimestamp) -> Self {
+ val.0
+ }
+}
+
#[cfg(feature = "std")]
impl From<PositiveTimestamp> for SystemTime {
fn from(val: PositiveTimestamp) -> Self {
/// Return the description or a hash of it for longer ones
///
- /// This is not exported to bindings users because we don't yet export InvoiceDescription
- pub fn description(&self) -> InvoiceDescription {
+ /// This is not exported to bindings users because we don't yet export Bolt11InvoiceDescription
+ pub fn description(&self) -> Bolt11InvoiceDescription {
if let Some(direct) = self.signed_invoice.description() {
- return InvoiceDescription::Direct(direct);
+ return Bolt11InvoiceDescription::Direct(direct);
} else if let Some(hash) = self.signed_invoice.description_hash() {
- return InvoiceDescription::Hash(hash);
+ return Bolt11InvoiceDescription::Hash(hash);
}
unreachable!("ensured by constructor");
}
self.signed_invoice.recover_payee_pub_key().expect("was checked by constructor").0
}
+ /// Recover the payee's public key if one was included in the invoice, otherwise return the
+ /// recovered public key from the signature
+ pub fn get_payee_pub_key(&self) -> PublicKey {
+ match self.payee_pub_key() {
+ Some(pk) => *pk,
+ None => self.recover_payee_pub_key()
+ }
+ }
+
/// Returns the Duration since the Unix epoch at which the invoice expires.
/// Returning None if overflow occurred.
pub fn expires_at(&self) -> Option<Duration> {
/// Returns a list of all fallback addresses as [`Address`]es
pub fn fallback_addresses(&self) -> Vec<Address> {
- self.fallbacks().iter().map(|fallback| {
+ self.fallbacks().iter().filter_map(|fallback| {
let payload = match fallback {
Fallback::SegWitProgram { version, program } => {
- Payload::WitnessProgram { version: *version, program: program.to_vec() }
+ match WitnessProgram::new(*version, program.clone()) {
+ Ok(witness_program) => Payload::WitnessProgram(witness_program),
+ Err(_) => return None,
+ }
}
Fallback::PubKeyHash(pkh) => {
Payload::PubkeyHash(*pkh)
}
};
- Address { payload, network: self.network() }
+ Some(Address::new(self.network(), payload))
}).collect()
}
if description.len() > 639 {
Err(CreationError::DescriptionTooLong)
} else {
- Ok(Description(description))
+ Ok(Description(UntrustedString(description)))
}
}
- /// Returns the underlying description [`String`]
- pub fn into_inner(self) -> String {
+ /// Returns the underlying description [`UntrustedString`]
+ pub fn into_inner(self) -> UntrustedString {
self.0
}
}
-impl From<Description> for String {
- fn from(val: Description) -> Self {
- val.into_inner()
- }
-}
-
-impl Deref for Description {
- type Target = str;
-
- fn deref(&self) -> &str {
- &self.0
+impl Display for Description {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.0)
}
}
}
}
-impl Deref for InvoiceSignature {
+impl Deref for Bolt11InvoiceSignature {
type Target = RecoverableSignature;
fn deref(&self) -> &RecoverableSignature {
#[cfg(test)]
mod test {
- use bitcoin::Script;
- use bitcoin_hashes::hex::FromHex;
- use bitcoin_hashes::sha256;
+ use bitcoin::ScriptBuf;
+ use bitcoin::hashes::sha256;
+ use std::str::FromStr;
#[test]
fn test_system_time_bounds_assumptions() {
data: RawDataPart {
timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
tagged_fields: vec![
- PaymentHash(crate::Sha256(sha256::Hash::from_hex(
+ PaymentHash(crate::Sha256(sha256::Hash::from_str(
"0001020304050607080900010203040506070809000102030405060708090102"
).unwrap())).into(),
Description(crate::Description::new(
use secp256k1::Secp256k1;
use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
use secp256k1::{SecretKey, PublicKey};
- use crate::{SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256,
+ use crate::{SignedRawBolt11Invoice, Bolt11InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256,
PositiveTimestamp};
let invoice = SignedRawBolt11Invoice {
data: RawDataPart {
timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
tagged_fields: vec ! [
- PaymentHash(Sha256(sha256::Hash::from_hex(
+ PaymentHash(Sha256(sha256::Hash::from_str(
"0001020304050607080900010203040506070809000102030405060708090102"
).unwrap())).into(),
Description(
0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7,
0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9
],
- signature: InvoiceSignature(RecoverableSignature::from_compact(
+ signature: Bolt11InvoiceSignature(RecoverableSignature::from_compact(
& [
0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a,
0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,
use lightning::ln::features::Bolt11InvoiceFeatures;
use secp256k1::Secp256k1;
use secp256k1::SecretKey;
- use crate::{Bolt11Invoice, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp,
+ use crate::{Bolt11Invoice, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp,
Bolt11SemanticError};
let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
data: RawDataPart {
timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
tagged_fields: vec ! [
- PaymentHash(Sha256(sha256::Hash::from_hex(
+ PaymentHash(Sha256(sha256::Hash::from_str(
"0001020304050607080900010203040506070809000102030405060708090102"
).unwrap())).into(),
Description(
use lightning::routing::router::RouteHintHop;
use secp256k1::Secp256k1;
use secp256k1::{SecretKey, PublicKey};
- use std::time::{UNIX_EPOCH, Duration};
+ use std::time::Duration;
let secp_ctx = Secp256k1::new();
assert_eq!(invoice.currency(), Currency::BitcoinTestnet);
#[cfg(feature = "std")]
assert_eq!(
- invoice.timestamp().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+ invoice.timestamp().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs(),
1234567
);
assert_eq!(invoice.payee_pub_key(), Some(&public_key));
assert_eq!(invoice.expiry_time(), Duration::from_secs(54321));
assert_eq!(invoice.min_final_cltv_expiry_delta(), 144);
assert_eq!(invoice.fallbacks(), vec![&Fallback::PubKeyHash(PubkeyHash::from_slice(&[0;20]).unwrap())]);
- let address = Address::from_script(&Script::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
+ let address = Address::from_script(&ScriptBuf::new_p2pkh(&PubkeyHash::from_slice(&[0;20]).unwrap()), Network::Testnet).unwrap();
assert_eq!(invoice.fallback_addresses(), vec![address]);
assert_eq!(invoice.private_routes(), vec![&PrivateRoute(route_1), &PrivateRoute(route_2)]);
assert_eq!(
invoice.description(),
- InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))
+ Bolt11InvoiceDescription::Hash(&Sha256(sha256::Hash::from_slice(&[3;32][..]).unwrap()))
);
assert_eq!(invoice.payment_hash(), &sha256::Hash::from_slice(&[21;32][..]).unwrap());
assert_eq!(invoice.payment_secret(), &PaymentSecret([42; 32]));
projects / rust-lightning / blobdiff