/// Bitcoin regtest
Regtest,
- /// Bitcoin simnet/signet
+ /// Bitcoin simnet
Simnet,
+
+ /// Bitcoin signet
+ Signet,
}
/// Tagged field which may have an unknown tag
+///
+/// (C-not exported) as we don't currently support TaggedField
#[derive(Eq, PartialEq, Debug, Clone)]
pub enum RawTaggedField {
/// Parsed tagged field with known tag
/// Tagged field with known tag
///
/// For descriptions of the enum values please refer to the enclosed type's docs.
+///
+/// (C-not exported) As we don't yet support enum variants with the same name the struct contained
+/// in the variant.
#[allow(missing_docs)]
#[derive(Eq, PartialEq, Debug, Clone)]
pub enum TaggedField {
/// Finds the first element of an enum stream of a given variant and extracts one member of the
/// variant. If no element was found `None` gets returned.
///
-/// The following example would extract the first
+/// The following example would extract the first B.
/// ```
/// use Enum::*
///
/// assert_eq!(find_extract!(elements.iter(), Enum::B(ref x), x), Some(3u16))
/// ```
macro_rules! find_extract {
- ($iter:expr, $enm:pat, $enm_var:ident) => {
+ ($iter:expr, $enm:pat, $enm_var:ident) => {
+ find_all_extract!($iter, $enm, $enm_var).next()
+ };
+}
+
+/// Finds the all elements of an enum stream of a given variant and extracts one member of the
+/// variant through an iterator.
+///
+/// The following example would extract all A.
+/// ```
+/// use Enum::*
+///
+/// enum Enum {
+/// A(u8),
+/// B(u16)
+/// }
+///
+/// let elements = vec![A(1), A(2), B(3), A(4)]
+///
+/// assert_eq!(
+/// find_all_extract!(elements.iter(), Enum::A(ref x), x).collect::<Vec<u8>>(),
+/// vec![1u8, 2u8, 4u8])
+/// ```
+macro_rules! find_all_extract {
+ ($iter:expr, $enm:pat, $enm_var:ident) => {
$iter.filter_map(|tf| match *tf {
$enm => Some($enm_var),
_ => None,
- }).next()
+ })
};
}
/// (C-not exported) as we don't support Vec<&NonOpaqueType>
pub fn fallbacks(&self) -> Vec<&Fallback> {
- self.known_tagged_fields().filter_map(|tf| match tf {
- &TaggedField::Fallback(ref f) => Some(f),
- _ => None,
- }).collect::<Vec<&Fallback>>()
+ find_all_extract!(self.known_tagged_fields(), TaggedField::Fallback(ref x), x).collect()
}
pub fn routes(&self) -> Vec<&RouteHint> {
- self.known_tagged_fields().filter_map(|tf| match tf {
- &TaggedField::Route(ref r) => Some(r),
- _ => None,
- }).collect::<Vec<&RouteHint>>()
+ find_all_extract!(self.known_tagged_fields(), TaggedField::Route(ref x), x).collect()
}
pub fn amount_pico_btc(&self) -> Option<u64> {
/// When signing using a fallible method either an user-supplied `SignError` or a `CreationError`
/// may occur.
-///
-/// (C-not exported) As we don't support unbounded generics
#[derive(Eq, PartialEq, Debug, Clone)]
-pub enum SignOrCreationError<S> {
+pub enum SignOrCreationError<S = ()> {
/// An error occurred during signing
SignError(S),
assert!(new_signed.check_signature());
}
+ #[test]
+ fn test_check_feature_bits() {
+ use TaggedField::*;
+ use lightning::ln::features::InvoiceFeatures;
+ use secp256k1::Secp256k1;
+ use secp256k1::key::SecretKey;
+ use {RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp, Invoice,
+ SemanticError};
+
+ let private_key = SecretKey::from_slice(&[42; 32]).unwrap();
+ let payment_secret = lightning::ln::PaymentSecret([21; 32]);
+ let invoice_template = RawInvoice {
+ hrp: RawHrp {
+ currency: Currency::Bitcoin,
+ raw_amount: None,
+ si_prefix: None,
+ },
+ data: RawDataPart {
+ timestamp: PositiveTimestamp::from_unix_timestamp(1496314658).unwrap(),
+ tagged_fields: vec ! [
+ PaymentHash(Sha256(sha256::Hash::from_hex(
+ "0001020304050607080900010203040506070809000102030405060708090102"
+ ).unwrap())).into(),
+ Description(
+ ::Description::new(
+ "Please consider supporting this project".to_owned()
+ ).unwrap()
+ ).into(),
+ ],
+ },
+ };
+
+ // Missing features
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
+
+ // Missing feature bits
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
+ invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
+
+ // Including payment secret and feature bits
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
+ invoice.data.tagged_fields.push(Features(InvoiceFeatures::known()).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert!(Invoice::from_signed(invoice).is_ok());
+
+ // No payment secret or features
+ let invoice = {
+ let invoice = invoice_template.clone();
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert!(Invoice::from_signed(invoice).is_ok());
+
+ // No payment secret or feature bits
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(Features(InvoiceFeatures::empty()).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert!(Invoice::from_signed(invoice).is_ok());
+
+ // Missing payment secret
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(Features(InvoiceFeatures::known()).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::InvalidFeatures));
+
+ // Multiple payment secrets
+ let invoice = {
+ let mut invoice = invoice_template.clone();
+ invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
+ invoice.data.tagged_fields.push(PaymentSecret(payment_secret).into());
+ invoice.sign::<_, ()>(|hash| Ok(Secp256k1::new().sign_recoverable(hash, &private_key)))
+ }.unwrap();
+ assert_eq!(Invoice::from_signed(invoice), Err(SemanticError::MultiplePaymentSecrets));
+ }
+
#[test]
fn test_builder_amount() {
use ::*;