pub mod payment;
pub mod utils;
-pub(crate) mod time_utils;
-
extern crate bech32;
extern crate bitcoin_hashes;
#[macro_use] extern crate lightning;
use bech32::u5;
use bitcoin::{Address, Network, PubkeyHash, ScriptHash};
-use bitcoin::util::address::{Payload, WitnessVersion};
+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::util::invoice::construct_invoice_preimage;
use secp256k1::PublicKey;
#[doc(no_inline)]
pub use lightning::ln::PaymentSecret;
#[doc(no_inline)]
-pub use lightning::routing::router::RouteHint;
+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;
#[cfg(feature = "hashbrown")]
extern crate hashbrown;
- pub use alloc::{vec, vec::Vec, string::String, collections::VecDeque, boxed::Box};
+ pub use alloc::{vec, vec::Vec, string::String};
#[cfg(not(feature = "hashbrown"))]
- pub use std::collections::{HashMap, HashSet, hash_map};
+ pub use std::collections::{HashMap, hash_map};
#[cfg(feature = "hashbrown")]
pub use self::hashbrown::{HashMap, HashSet, hash_map};
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;
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.
///
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)]
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))
}
}
/// The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
///
#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
-pub struct PrivateRoute(RouteHint);
+pub struct PrivateRoute(pub RouteHint);
/// Tag constants as specified in BOLT11
#[allow(missing_docs)]
pub fn invoice_description(self, description: Bolt11InvoiceDescription) -> InvoiceBuilder<tb::True, H, T, C, S, M> {
match description {
Bolt11InvoiceDescription::Direct(desc) => {
- self.description(desc.clone().into_inner())
+ self.description(desc.clone().into_inner().0)
}
Bolt11InvoiceDescription::Hash(hash) => {
self.description_hash(hash.0)
}
}
+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 {
/// 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)
}
}
#[cfg(test)]
mod test {
- use bitcoin::Script;
- use bitcoin_hashes::hex::FromHex;
+ 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(
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::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(
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!(