use bitcoin::secp256k1::{self, PublicKey, Secp256k1, SecretKey};
use crate::blinded_path::BlindedHop;
use crate::blinded_path::utils;
use crate::io;
use crate::ln::types::PaymentSecret;
use crate::ln::channelmanager::CounterpartyForwardingInfo;
use crate::ln::features::BlindedHopFeatures;
use crate::ln::msgs::DecodeError;
use crate::offers::invoice::BlindedPayInfo;
use crate::offers::invoice_request::InvoiceRequestFields;
use crate::offers::offer::OfferId;
use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
#[allow(unused_imports)]
use crate::prelude::*;
#[derive(Clone, Debug)]
pub struct ForwardNode {
pub tlvs: ForwardTlvs,
pub node_id: PublicKey,
pub htlc_maximum_msat: u64,
}
#[derive(Clone, Debug)]
pub struct ForwardTlvs {
pub short_channel_id: u64,
pub payment_relay: PaymentRelay,
pub payment_constraints: PaymentConstraints,
pub features: BlindedHopFeatures,
}
#[derive(Clone, Debug)]
pub struct ReceiveTlvs {
pub payment_secret: PaymentSecret,
pub payment_constraints: PaymentConstraints,
pub payment_context: PaymentContext,
}
pub(crate) enum BlindedPaymentTlvs {
Forward(ForwardTlvs),
Receive(ReceiveTlvs),
}
enum BlindedPaymentTlvsRef<'a> {
Forward(&'a ForwardTlvs),
Receive(&'a ReceiveTlvs),
}
#[derive(Clone, Debug)]
pub struct PaymentRelay {
pub cltv_expiry_delta: u16,
pub fee_proportional_millionths: u32,
pub fee_base_msat: u32,
}
#[derive(Clone, Debug)]
pub struct PaymentConstraints {
pub max_cltv_expiry: u32,
pub htlc_minimum_msat: u64,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum PaymentContext {
Unknown(UnknownPaymentContext),
Bolt12Offer(Bolt12OfferContext),
Bolt12Refund(Bolt12RefundContext),
}
pub(crate) enum PaymentContextRef<'a> {
Bolt12Offer(&'a Bolt12OfferContext),
Bolt12Refund(&'a Bolt12RefundContext),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct UnknownPaymentContext(());
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Bolt12OfferContext {
pub offer_id: OfferId,
pub invoice_request: InvoiceRequestFields,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Bolt12RefundContext {}
impl PaymentContext {
pub(crate) fn unknown() -> Self {
PaymentContext::Unknown(UnknownPaymentContext(()))
}
}
impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
type Error = ();
fn try_from(info: CounterpartyForwardingInfo) -> Result<Self, ()> {
let CounterpartyForwardingInfo {
fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
} = info;
let cltv_expiry_delta = match cltv_expiry_delta {
0..=40 => 40,
41..=80 => 80,
81..=144 => 144,
145..=216 => 216,
_ => return Err(()),
};
Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
}
}
impl Writeable for ForwardTlvs {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
let features_opt =
if self.features == BlindedHopFeatures::empty() { None }
else { Some(&self.features) };
encode_tlv_stream!(w, {
(2, self.short_channel_id, required),
(10, self.payment_relay, required),
(12, self.payment_constraints, required),
(14, features_opt, option)
});
Ok(())
}
}
impl Writeable for ReceiveTlvs {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
encode_tlv_stream!(w, {
(12, self.payment_constraints, required),
(65536, self.payment_secret, required),
(65537, self.payment_context, required)
});
Ok(())
}
}
impl<'a> Writeable for BlindedPaymentTlvsRef<'a> {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
match self {
Self::Forward(tlvs) => tlvs.write(w)?,
Self::Receive(tlvs) => tlvs.write(w)?,
}
Ok(())
}
}
impl Readable for BlindedPaymentTlvs {
fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
_init_and_read_tlv_stream!(r, {
(1, _padding, option),
(2, scid, option),
(10, payment_relay, option),
(12, payment_constraints, required),
(14, features, option),
(65536, payment_secret, option),
(65537, payment_context, (default_value, PaymentContext::unknown())),
});
let _padding: Option<utils::Padding> = _padding;
if let Some(short_channel_id) = scid {
if payment_secret.is_some() {
return Err(DecodeError::InvalidValue)
}
Ok(BlindedPaymentTlvs::Forward(ForwardTlvs {
short_channel_id,
payment_relay: payment_relay.ok_or(DecodeError::InvalidValue)?,
payment_constraints: payment_constraints.0.unwrap(),
features: features.unwrap_or_else(BlindedHopFeatures::empty),
}))
} else {
if payment_relay.is_some() || features.is_some() { return Err(DecodeError::InvalidValue) }
Ok(BlindedPaymentTlvs::Receive(ReceiveTlvs {
payment_secret: payment_secret.ok_or(DecodeError::InvalidValue)?,
payment_constraints: payment_constraints.0.unwrap(),
payment_context: payment_context.0.unwrap(),
}))
}
}
}
pub(super) fn blinded_hops<T: secp256k1::Signing + secp256k1::Verification>(
secp_ctx: &Secp256k1<T>, intermediate_nodes: &[ForwardNode],
payee_node_id: PublicKey, payee_tlvs: ReceiveTlvs, session_priv: &SecretKey
) -> Result<Vec<BlindedHop>, secp256k1::Error> {
let pks = intermediate_nodes.iter().map(|node| &node.node_id)
.chain(core::iter::once(&payee_node_id));
let tlvs = intermediate_nodes.iter().map(|node| BlindedPaymentTlvsRef::Forward(&node.tlvs))
.chain(core::iter::once(BlindedPaymentTlvsRef::Receive(&payee_tlvs)));
utils::construct_blinded_hops(secp_ctx, pks, tlvs, session_priv)
}
pub(crate) fn amt_to_forward_msat(inbound_amt_msat: u64, payment_relay: &PaymentRelay) -> Option<u64> {
let inbound_amt = inbound_amt_msat as u128;
let base = payment_relay.fee_base_msat as u128;
let prop = payment_relay.fee_proportional_millionths as u128;
let post_base_fee_inbound_amt =
if let Some(amt) = inbound_amt.checked_sub(base) { amt } else { return None };
let mut amt_to_forward =
(post_base_fee_inbound_amt * 1_000_000 + 1_000_000 + prop - 1) / (prop + 1_000_000);
let fee = ((amt_to_forward * prop) / 1_000_000) + base;
if inbound_amt - fee < amt_to_forward {
amt_to_forward -= 1;
}
debug_assert_eq!(amt_to_forward + fee, inbound_amt);
u64::try_from(amt_to_forward).ok()
}
pub(super) fn compute_payinfo(
intermediate_nodes: &[ForwardNode], payee_tlvs: &ReceiveTlvs, payee_htlc_maximum_msat: u64,
min_final_cltv_expiry_delta: u16
) -> Result<BlindedPayInfo, ()> {
let mut curr_base_fee: u64 = 0;
let mut curr_prop_mil: u64 = 0;
let mut cltv_expiry_delta: u16 = min_final_cltv_expiry_delta;
for tlvs in intermediate_nodes.iter().rev().map(|n| &n.tlvs) {
if tlvs.features.requires_unknown_bits_from(&BlindedHopFeatures::empty()) { return Err(()) }
let next_base_fee = tlvs.payment_relay.fee_base_msat as u64;
let next_prop_mil = tlvs.payment_relay.fee_proportional_millionths as u64;
curr_base_fee = curr_base_fee.checked_mul(1_000_000 + next_prop_mil)
.and_then(|f| f.checked_add(1_000_000 - 1))
.map(|f| f / 1_000_000)
.and_then(|f| f.checked_add(next_base_fee))
.ok_or(())?;
curr_prop_mil = curr_prop_mil.checked_add(1_000_000)
.and_then(|f1| next_prop_mil.checked_add(1_000_000).and_then(|f2| f2.checked_mul(f1)))
.and_then(|f| f.checked_add(1_000_000 - 1))
.map(|f| f / 1_000_000)
.and_then(|f| f.checked_sub(1_000_000))
.ok_or(())?;
cltv_expiry_delta = cltv_expiry_delta.checked_add(tlvs.payment_relay.cltv_expiry_delta).ok_or(())?;
}
let mut htlc_minimum_msat: u64 = 1;
let mut htlc_maximum_msat: u64 = 21_000_000 * 100_000_000 * 1_000; for node in intermediate_nodes.iter() {
htlc_minimum_msat = amt_to_forward_msat(
core::cmp::max(node.tlvs.payment_constraints.htlc_minimum_msat, htlc_minimum_msat),
&node.tlvs.payment_relay
).unwrap_or(1); htlc_maximum_msat = amt_to_forward_msat(
core::cmp::min(node.htlc_maximum_msat, htlc_maximum_msat), &node.tlvs.payment_relay
).ok_or(())?; }
htlc_minimum_msat = core::cmp::max(
payee_tlvs.payment_constraints.htlc_minimum_msat, htlc_minimum_msat
);
htlc_maximum_msat = core::cmp::min(payee_htlc_maximum_msat, htlc_maximum_msat);
if htlc_maximum_msat < htlc_minimum_msat { return Err(()) }
Ok(BlindedPayInfo {
fee_base_msat: u32::try_from(curr_base_fee).map_err(|_| ())?,
fee_proportional_millionths: u32::try_from(curr_prop_mil).map_err(|_| ())?,
cltv_expiry_delta,
htlc_minimum_msat,
htlc_maximum_msat,
features: BlindedHopFeatures::empty(),
})
}
impl Writeable for PaymentRelay {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
self.cltv_expiry_delta.write(w)?;
self.fee_proportional_millionths.write(w)?;
HighZeroBytesDroppedBigSize(self.fee_base_msat).write(w)
}
}
impl Readable for PaymentRelay {
fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
let cltv_expiry_delta: u16 = Readable::read(r)?;
let fee_proportional_millionths: u32 = Readable::read(r)?;
let fee_base_msat: HighZeroBytesDroppedBigSize<u32> = Readable::read(r)?;
Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat: fee_base_msat.0 })
}
}
impl Writeable for PaymentConstraints {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
self.max_cltv_expiry.write(w)?;
HighZeroBytesDroppedBigSize(self.htlc_minimum_msat).write(w)
}
}
impl Readable for PaymentConstraints {
fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
let max_cltv_expiry: u32 = Readable::read(r)?;
let htlc_minimum_msat: HighZeroBytesDroppedBigSize<u64> = Readable::read(r)?;
Ok(Self { max_cltv_expiry, htlc_minimum_msat: htlc_minimum_msat.0 })
}
}
impl_writeable_tlv_based_enum!(PaymentContext,
;
(0, Unknown),
(1, Bolt12Offer),
(2, Bolt12Refund),
);
impl<'a> Writeable for PaymentContextRef<'a> {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
match self {
PaymentContextRef::Bolt12Offer(context) => {
1u8.write(w)?;
context.write(w)?;
},
PaymentContextRef::Bolt12Refund(context) => {
2u8.write(w)?;
context.write(w)?;
},
}
Ok(())
}
}
impl Writeable for UnknownPaymentContext {
fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> {
Ok(())
}
}
impl Readable for UnknownPaymentContext {
fn read<R: io::Read>(_r: &mut R) -> Result<Self, DecodeError> {
Ok(UnknownPaymentContext(()))
}
}
impl_writeable_tlv_based!(Bolt12OfferContext, {
(0, offer_id, required),
(2, invoice_request, required),
});
impl_writeable_tlv_based!(Bolt12RefundContext, {});
#[cfg(test)]
mod tests {
use bitcoin::secp256k1::PublicKey;
use crate::blinded_path::payment::{ForwardNode, ForwardTlvs, ReceiveTlvs, PaymentConstraints, PaymentContext, PaymentRelay};
use crate::ln::types::PaymentSecret;
use crate::ln::features::BlindedHopFeatures;
use crate::ln::functional_test_utils::TEST_FINAL_CLTV;
#[test]
fn compute_payinfo() {
let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
let intermediate_nodes = vec![ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 144,
fee_proportional_millionths: 500,
fee_base_msat: 100,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 100,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value(),
}, ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 144,
fee_proportional_millionths: 500,
fee_base_msat: 100,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1_000,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value(),
}];
let recv_tlvs = ReceiveTlvs {
payment_secret: PaymentSecret([0; 32]),
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
payment_context: PaymentContext::unknown(),
};
let htlc_maximum_msat = 100_000;
let blinded_payinfo = super::compute_payinfo(&intermediate_nodes[..], &recv_tlvs, htlc_maximum_msat, 12).unwrap();
assert_eq!(blinded_payinfo.fee_base_msat, 201);
assert_eq!(blinded_payinfo.fee_proportional_millionths, 1001);
assert_eq!(blinded_payinfo.cltv_expiry_delta, 300);
assert_eq!(blinded_payinfo.htlc_minimum_msat, 900);
assert_eq!(blinded_payinfo.htlc_maximum_msat, htlc_maximum_msat);
}
#[test]
fn compute_payinfo_1_hop() {
let recv_tlvs = ReceiveTlvs {
payment_secret: PaymentSecret([0; 32]),
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
payment_context: PaymentContext::unknown(),
};
let blinded_payinfo = super::compute_payinfo(&[], &recv_tlvs, 4242, TEST_FINAL_CLTV as u16).unwrap();
assert_eq!(blinded_payinfo.fee_base_msat, 0);
assert_eq!(blinded_payinfo.fee_proportional_millionths, 0);
assert_eq!(blinded_payinfo.cltv_expiry_delta, TEST_FINAL_CLTV as u16);
assert_eq!(blinded_payinfo.htlc_minimum_msat, 1);
assert_eq!(blinded_payinfo.htlc_maximum_msat, 4242);
}
#[test]
fn simple_aggregated_htlc_min() {
let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
let intermediate_nodes = vec![ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 0,
fee_base_msat: 0,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value()
}, ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 0,
fee_base_msat: 0,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 2_000,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value()
}];
let recv_tlvs = ReceiveTlvs {
payment_secret: PaymentSecret([0; 32]),
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 3,
},
payment_context: PaymentContext::unknown(),
};
let htlc_maximum_msat = 100_000;
let blinded_payinfo = super::compute_payinfo(&intermediate_nodes[..], &recv_tlvs, htlc_maximum_msat, TEST_FINAL_CLTV as u16).unwrap();
assert_eq!(blinded_payinfo.htlc_minimum_msat, 2_000);
}
#[test]
fn aggregated_htlc_min() {
let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
let intermediate_nodes = vec![ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 500,
fee_base_msat: 1_000,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 5_000,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value()
}, ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 500,
fee_base_msat: 200,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 2_000,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: u64::max_value()
}];
let recv_tlvs = ReceiveTlvs {
payment_secret: PaymentSecret([0; 32]),
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
payment_context: PaymentContext::unknown(),
};
let htlc_minimum_msat = 3798;
assert!(super::compute_payinfo(&intermediate_nodes[..], &recv_tlvs, htlc_minimum_msat - 1, TEST_FINAL_CLTV as u16).is_err());
let htlc_maximum_msat = htlc_minimum_msat + 1;
let blinded_payinfo = super::compute_payinfo(&intermediate_nodes[..], &recv_tlvs, htlc_maximum_msat, TEST_FINAL_CLTV as u16).unwrap();
assert_eq!(blinded_payinfo.htlc_minimum_msat, htlc_minimum_msat);
assert_eq!(blinded_payinfo.htlc_maximum_msat, htlc_maximum_msat);
}
#[test]
fn aggregated_htlc_max() {
let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
let intermediate_nodes = vec![ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 500,
fee_base_msat: 1_000,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: 5_000,
}, ForwardNode {
node_id: dummy_pk,
tlvs: ForwardTlvs {
short_channel_id: 0,
payment_relay: PaymentRelay {
cltv_expiry_delta: 0,
fee_proportional_millionths: 500,
fee_base_msat: 1,
},
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
features: BlindedHopFeatures::empty(),
},
htlc_maximum_msat: 10_000
}];
let recv_tlvs = ReceiveTlvs {
payment_secret: PaymentSecret([0; 32]),
payment_constraints: PaymentConstraints {
max_cltv_expiry: 0,
htlc_minimum_msat: 1,
},
payment_context: PaymentContext::unknown(),
};
let blinded_payinfo = super::compute_payinfo(&intermediate_nodes[..], &recv_tlvs, 10_000, TEST_FINAL_CLTV as u16).unwrap();
assert_eq!(blinded_payinfo.htlc_maximum_msat, 3997);
}
}