Merge pull request #2828 from TheBlueMatt/2024-01-crypto-module

[rust-lightning] / lightning-invoice / src / de.rs

diff --git a/lightning-invoice/src/de.rs b/lightning-invoice/src/de.rs
index 3f0548efb751799ecfbad44c0edf133dbe0dc571..c75373ea9dac3d127575b95d78954400164d1dc9 100644 (file)
--- a/lightning-invoice/src/de.rs
+++ b/lightning-invoice/src/de.rs
@@ -10,9 +10,9 @@ use core::str::FromStr;
 use bech32::{u5, FromBase32};
 
 use bitcoin::{PubkeyHash, ScriptHash};
-use bitcoin::util::address::WitnessVersion;
-use bitcoin_hashes::Hash;
-use bitcoin_hashes::sha256;
+use bitcoin::address::WitnessVersion;
+use bitcoin::hashes::Hash;
+use bitcoin::hashes::sha256;
 use crate::prelude::*;
 use lightning::ln::PaymentSecret;
 use lightning::routing::gossip::RoutingFees;
@@ -23,9 +23,9 @@ use num_traits::{CheckedAdd, CheckedMul};
 use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
 use secp256k1::PublicKey;
 
-use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
+use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, Bolt11InvoiceSignature, PositiveTimestamp,
        Bolt11SemanticError, PrivateRoute, Bolt11ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawBolt11Invoice,
-       constants, SignedRawBolt11Invoice, RawDataPart, InvoiceFeatures};
+       constants, SignedRawBolt11Invoice, RawDataPart, Bolt11InvoiceFeatures};
 
 use self::hrp_sm::parse_hrp;
 
@@ -292,7 +292,7 @@ impl FromStr for SignedRawBolt11Invoice {
                                hrp.as_bytes(),
                                &data[..data.len()-104]
                        ),
-                       signature: InvoiceSignature::from_base32(&data[data.len()-104..])?,
+                       signature: Bolt11InvoiceSignature::from_base32(&data[data.len()-104..])?,
                })
        }
 }
@@ -365,17 +365,17 @@ impl FromBase32 for PositiveTimestamp {
        }
 }
 
-impl FromBase32 for InvoiceSignature {
+impl FromBase32 for Bolt11InvoiceSignature {
        type Err = Bolt11ParseError;
        fn from_base32(signature: &[u5]) -> Result<Self, Self::Err> {
                if signature.len() != 104 {
-                       return Err(Bolt11ParseError::InvalidSliceLength("InvoiceSignature::from_base32()".into()));
+                       return Err(Bolt11ParseError::InvalidSliceLength("Bolt11InvoiceSignature::from_base32()".into()));
                }
                let recoverable_signature_bytes = Vec::<u8>::from_base32(signature)?;
                let signature = &recoverable_signature_bytes[0..64];
                let recovery_id = RecoveryId::from_i32(recoverable_signature_bytes[64] as i32)?;
 
-               Ok(InvoiceSignature(RecoverableSignature::from_compact(
+               Ok(Bolt11InvoiceSignature(RecoverableSignature::from_compact(
                        signature,
                        recovery_id
                )?))
@@ -463,7 +463,7 @@ impl FromBase32 for TaggedField {
                        constants::TAG_PAYMENT_METADATA =>
                                Ok(TaggedField::PaymentMetadata(Vec::<u8>::from_base32(field_data)?)),
                        constants::TAG_FEATURES =>
-                               Ok(TaggedField::Features(InvoiceFeatures::from_base32(field_data)?)),
+                               Ok(TaggedField::Features(Bolt11InvoiceFeatures::from_base32(field_data)?)),
                        _ => {
                                // "A reader MUST skip over unknown fields"
                                Err(Bolt11ParseError::Skip)
@@ -564,14 +564,14 @@ impl FromBase32 for Fallback {
                        17 => {
                                let pkh = match PubkeyHash::from_slice(&bytes) {
                                        Ok(pkh) => pkh,
-                                       Err(bitcoin_hashes::Error::InvalidLength(_, _)) => return Err(Bolt11ParseError::InvalidPubKeyHashLength),
+                                       Err(bitcoin::hashes::Error::InvalidLength(_, _)) => return Err(Bolt11ParseError::InvalidPubKeyHashLength),
                                };
                                Ok(Fallback::PubKeyHash(pkh))
                        }
                        18 => {
                                let sh = match ScriptHash::from_slice(&bytes) {
                                        Ok(sh) => sh,
-                                       Err(bitcoin_hashes::Error::InvalidLength(_, _)) => return Err(Bolt11ParseError::InvalidScriptHashLength),
+                                       Err(bitcoin::hashes::Error::InvalidLength(_, _)) => return Err(Bolt11ParseError::InvalidScriptHashLength),
                                };
                                Ok(Fallback::ScriptHash(sh))
                        }
@@ -726,8 +726,8 @@ mod test {
        use crate::de::Bolt11ParseError;
        use secp256k1::PublicKey;
        use bech32::u5;
-       use bitcoin_hashes::hex::FromHex;
-       use bitcoin_hashes::sha256;
+       use bitcoin::hashes::sha256;
+       use std::str::FromStr;
 
        const CHARSET_REV: [i8; 128] = [
                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
@@ -778,7 +778,7 @@ mod test {
                        "qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypq".as_bytes()
                );
 
-               let hash = sha256::Hash::from_hex(
+               let hash = sha256::Hash::from_str(
                        "0001020304050607080900010203040506070809000102030405060708090102"
                ).unwrap();
                let expected = Ok(Sha256(hash));
@@ -855,8 +855,8 @@ mod test {
                use crate::Fallback;
                use bech32::FromBase32;
                use bitcoin::{PubkeyHash, ScriptHash};
-               use bitcoin::util::address::WitnessVersion;
-               use bitcoin_hashes::Hash;
+               use bitcoin::address::WitnessVersion;
+               use bitcoin::hashes::Hash;
 
                let cases = vec![
                        (
@@ -969,14 +969,14 @@ mod test {
 
        #[test]
        fn test_payment_secret_and_features_de_and_ser() {
-               use lightning::ln::features::InvoiceFeatures;
+               use lightning::ln::features::Bolt11InvoiceFeatures;
                use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
                use crate::TaggedField::*;
-               use crate::{SiPrefix, SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart,
+               use crate::{SiPrefix, SignedRawBolt11Invoice, Bolt11InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart,
                                 Currency, Sha256, PositiveTimestamp};
 
                // Feature bits 9, 15, and 99 are set.
-               let expected_features = InvoiceFeatures::from_le_bytes(vec![0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]);
+               let expected_features = Bolt11InvoiceFeatures::from_le_bytes(vec![0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]);
                let invoice_str = "lnbc25m1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdq5vdhkven9v5sxyetpdeessp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygs9q5sqqqqqqqqqqqqqqqpqsq67gye39hfg3zd8rgc80k32tvy9xk2xunwm5lzexnvpx6fd77en8qaq424dxgt56cag2dpt359k3ssyhetktkpqh24jqnjyw6uqd08sgptq44qu";
                let invoice = SignedRawBolt11Invoice {
                                        raw_invoice: RawBolt11Invoice {
@@ -988,7 +988,7 @@ mod test {
                                                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(crate::Description::new("coffee beans".to_owned()).unwrap()).into(),
@@ -998,7 +998,7 @@ mod test {
                                        hash: [0xb1, 0x96, 0x46, 0xc3, 0xbc, 0x56, 0x76, 0x1d, 0x20, 0x65, 0x6e, 0x0e, 0x32,
                                                                        0xec, 0xd2, 0x69, 0x27, 0xb7, 0x62, 0x6e, 0x2a, 0x8b, 0xe6, 0x97, 0x71, 0x9f,
                                                                        0xf8, 0x7e, 0x44, 0x54, 0x55, 0xb9],
-                                       signature: InvoiceSignature(RecoverableSignature::from_compact(
+                                       signature: Bolt11InvoiceSignature(RecoverableSignature::from_compact(
                                                                                &[0xd7, 0x90, 0x4c, 0xc4, 0xb7, 0x4a, 0x22, 0x26, 0x9c, 0x68, 0xc1, 0xdf, 0x68,
                                                                                        0xa9, 0x6c, 0x21, 0x4d, 0x65, 0x1b, 0x93, 0x76, 0xe9, 0xf1, 0x64, 0xd3, 0x60,
                                                                                        0x4d, 0xa4, 0xb7, 0xde, 0xcc, 0xce, 0x0e, 0x82, 0xaa, 0xab, 0x4c, 0x85, 0xd3,
@@ -1018,7 +1018,7 @@ mod test {
        fn test_raw_signed_invoice_deserialization() {
                use crate::TaggedField::*;
                use secp256k1::ecdsa::{RecoveryId, RecoverableSignature};
-               use crate::{SignedRawBolt11Invoice, InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256,
+               use crate::{SignedRawBolt11Invoice, Bolt11InvoiceSignature, RawBolt11Invoice, RawHrp, RawDataPart, Currency, Sha256,
                         PositiveTimestamp};
 
                assert_eq!(
@@ -1035,7 +1035,7 @@ mod test {
                                        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(
@@ -1051,7 +1051,7 @@ mod test {
                                        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,