mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-03-15 15:39:09 +01:00
Rename MppId to PaymentId
Leftover from previous PR Jeff feedback. Useful in upcoming commits as we'll expose this to users for payment retries
This commit is contained in:
parent
5811f5bcce
commit
28eea12bbe
3 changed files with 39 additions and 39 deletions
|
@ -5509,7 +5509,7 @@ mod tests {
|
|||
use bitcoin::hashes::hex::FromHex;
|
||||
use hex;
|
||||
use ln::{PaymentPreimage, PaymentHash};
|
||||
use ln::channelmanager::{HTLCSource, MppId};
|
||||
use ln::channelmanager::{HTLCSource, PaymentId};
|
||||
use ln::channel::{Channel,InboundHTLCOutput,OutboundHTLCOutput,InboundHTLCState,OutboundHTLCState,HTLCOutputInCommitment,HTLCCandidate,HTLCInitiator,TxCreationKeys};
|
||||
use ln::channel::MAX_FUNDING_SATOSHIS;
|
||||
use ln::features::InitFeatures;
|
||||
|
@ -5683,7 +5683,7 @@ mod tests {
|
|||
path: Vec::new(),
|
||||
session_priv: SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
|
||||
first_hop_htlc_msat: 548,
|
||||
mpp_id: MppId([42; 32]),
|
||||
payment_id: PaymentId([42; 32]),
|
||||
}
|
||||
});
|
||||
|
||||
|
|
|
@ -172,20 +172,20 @@ struct ClaimableHTLC {
|
|||
onion_payload: OnionPayload,
|
||||
}
|
||||
|
||||
/// A payment identifier used to correlate an MPP payment's per-path HTLC sources internally.
|
||||
/// A payment identifier used to uniquely identify a payment to LDK.
|
||||
#[derive(Hash, Copy, Clone, PartialEq, Eq, Debug)]
|
||||
pub(crate) struct MppId(pub [u8; 32]);
|
||||
pub(crate) struct PaymentId(pub [u8; 32]);
|
||||
|
||||
impl Writeable for MppId {
|
||||
impl Writeable for PaymentId {
|
||||
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
|
||||
self.0.write(w)
|
||||
}
|
||||
}
|
||||
|
||||
impl Readable for MppId {
|
||||
impl Readable for PaymentId {
|
||||
fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
|
||||
let buf: [u8; 32] = Readable::read(r)?;
|
||||
Ok(MppId(buf))
|
||||
Ok(PaymentId(buf))
|
||||
}
|
||||
}
|
||||
/// Tracks the inbound corresponding to an outbound HTLC
|
||||
|
@ -198,7 +198,7 @@ pub(crate) enum HTLCSource {
|
|||
/// Technically we can recalculate this from the route, but we cache it here to avoid
|
||||
/// doing a double-pass on route when we get a failure back
|
||||
first_hop_htlc_msat: u64,
|
||||
mpp_id: MppId,
|
||||
payment_id: PaymentId,
|
||||
},
|
||||
}
|
||||
#[cfg(test)]
|
||||
|
@ -208,7 +208,7 @@ impl HTLCSource {
|
|||
path: Vec::new(),
|
||||
session_priv: SecretKey::from_slice(&[1; 32]).unwrap(),
|
||||
first_hop_htlc_msat: 0,
|
||||
mpp_id: MppId([2; 32]),
|
||||
payment_id: PaymentId([2; 32]),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -499,7 +499,7 @@ pub struct ChannelManager<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref,
|
|||
/// payments over a single path).
|
||||
///
|
||||
/// Locked *after* channel_state.
|
||||
pending_outbound_payments: Mutex<HashMap<MppId, HashSet<[u8; 32]>>>,
|
||||
pending_outbound_payments: Mutex<HashMap<PaymentId, HashSet<[u8; 32]>>>,
|
||||
|
||||
our_network_key: SecretKey,
|
||||
our_network_pubkey: PublicKey,
|
||||
|
@ -1878,7 +1878,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
}
|
||||
|
||||
// Only public for testing, this should otherwise never be called direcly
|
||||
pub(crate) fn send_payment_along_path(&self, path: &Vec<RouteHop>, payment_hash: &PaymentHash, payment_secret: &Option<PaymentSecret>, total_value: u64, cur_height: u32, mpp_id: MppId, keysend_preimage: &Option<PaymentPreimage>) -> Result<(), APIError> {
|
||||
pub(crate) fn send_payment_along_path(&self, path: &Vec<RouteHop>, payment_hash: &PaymentHash, payment_secret: &Option<PaymentSecret>, total_value: u64, cur_height: u32, payment_id: PaymentId, keysend_preimage: &Option<PaymentPreimage>) -> Result<(), APIError> {
|
||||
log_trace!(self.logger, "Attempting to send payment for path with next hop {}", path.first().unwrap().short_channel_id);
|
||||
let prng_seed = self.keys_manager.get_secure_random_bytes();
|
||||
let session_priv_bytes = self.keys_manager.get_secure_random_bytes();
|
||||
|
@ -1894,7 +1894,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
|
||||
let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
|
||||
let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap();
|
||||
let sessions = pending_outbounds.entry(mpp_id).or_insert(HashSet::new());
|
||||
let sessions = pending_outbounds.entry(payment_id).or_insert(HashSet::new());
|
||||
assert!(sessions.insert(session_priv_bytes));
|
||||
|
||||
let err: Result<(), _> = loop {
|
||||
|
@ -1917,7 +1917,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
path: path.clone(),
|
||||
session_priv: session_priv.clone(),
|
||||
first_hop_htlc_msat: htlc_msat,
|
||||
mpp_id,
|
||||
payment_id,
|
||||
}, onion_packet, &self.logger), channel_state, chan)
|
||||
} {
|
||||
Some((update_add, commitment_signed, monitor_update)) => {
|
||||
|
@ -2017,7 +2017,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
let mut total_value = 0;
|
||||
let our_node_id = self.get_our_node_id();
|
||||
let mut path_errs = Vec::with_capacity(route.paths.len());
|
||||
let mpp_id = MppId(self.keys_manager.get_secure_random_bytes());
|
||||
let payment_id = PaymentId(self.keys_manager.get_secure_random_bytes());
|
||||
'path_check: for path in route.paths.iter() {
|
||||
if path.len() < 1 || path.len() > 20 {
|
||||
path_errs.push(Err(APIError::RouteError{err: "Path didn't go anywhere/had bogus size"}));
|
||||
|
@ -2039,7 +2039,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
let cur_height = self.best_block.read().unwrap().height() + 1;
|
||||
let mut results = Vec::new();
|
||||
for path in route.paths.iter() {
|
||||
results.push(self.send_payment_along_path(&path, &payment_hash, payment_secret, total_value, cur_height, mpp_id, &keysend_preimage));
|
||||
results.push(self.send_payment_along_path(&path, &payment_hash, payment_secret, total_value, cur_height, payment_id, &keysend_preimage));
|
||||
}
|
||||
let mut has_ok = false;
|
||||
let mut has_err = false;
|
||||
|
@ -2875,11 +2875,11 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
self.fail_htlc_backwards_internal(channel_state,
|
||||
htlc_src, &payment_hash, HTLCFailReason::Reason { failure_code, data: onion_failure_data});
|
||||
},
|
||||
HTLCSource::OutboundRoute { session_priv, mpp_id, path, .. } => {
|
||||
HTLCSource::OutboundRoute { session_priv, payment_id, path, .. } => {
|
||||
let mut session_priv_bytes = [0; 32];
|
||||
session_priv_bytes.copy_from_slice(&session_priv[..]);
|
||||
let mut outbounds = self.pending_outbound_payments.lock().unwrap();
|
||||
if let hash_map::Entry::Occupied(mut sessions) = outbounds.entry(mpp_id) {
|
||||
if let hash_map::Entry::Occupied(mut sessions) = outbounds.entry(payment_id) {
|
||||
if sessions.get_mut().remove(&session_priv_bytes) {
|
||||
self.pending_events.lock().unwrap().push(
|
||||
events::Event::PaymentPathFailed {
|
||||
|
@ -2922,12 +2922,12 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
// from block_connected which may run during initialization prior to the chain_monitor
|
||||
// being fully configured. See the docs for `ChannelManagerReadArgs` for more.
|
||||
match source {
|
||||
HTLCSource::OutboundRoute { ref path, session_priv, mpp_id, .. } => {
|
||||
HTLCSource::OutboundRoute { ref path, session_priv, payment_id, .. } => {
|
||||
let mut session_priv_bytes = [0; 32];
|
||||
session_priv_bytes.copy_from_slice(&session_priv[..]);
|
||||
let mut outbounds = self.pending_outbound_payments.lock().unwrap();
|
||||
let mut all_paths_failed = false;
|
||||
if let hash_map::Entry::Occupied(mut sessions) = outbounds.entry(mpp_id) {
|
||||
if let hash_map::Entry::Occupied(mut sessions) = outbounds.entry(payment_id) {
|
||||
if !sessions.get_mut().remove(&session_priv_bytes) {
|
||||
log_trace!(self.logger, "Received duplicative fail for HTLC with payment_hash {}", log_bytes!(payment_hash.0));
|
||||
return;
|
||||
|
@ -3181,12 +3181,12 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
|
|||
|
||||
fn claim_funds_internal(&self, mut channel_state_lock: MutexGuard<ChannelHolder<Signer>>, source: HTLCSource, payment_preimage: PaymentPreimage, forwarded_htlc_value_msat: Option<u64>, from_onchain: bool) {
|
||||
match source {
|
||||
HTLCSource::OutboundRoute { session_priv, mpp_id, .. } => {
|
||||
HTLCSource::OutboundRoute { session_priv, payment_id, .. } => {
|
||||
mem::drop(channel_state_lock);
|
||||
let mut session_priv_bytes = [0; 32];
|
||||
session_priv_bytes.copy_from_slice(&session_priv[..]);
|
||||
let mut outbounds = self.pending_outbound_payments.lock().unwrap();
|
||||
let found_payment = if let Some(mut sessions) = outbounds.remove(&mpp_id) {
|
||||
let found_payment = if let Some(mut sessions) = outbounds.remove(&payment_id) {
|
||||
sessions.remove(&session_priv_bytes)
|
||||
} else { false };
|
||||
if found_payment {
|
||||
|
@ -5079,23 +5079,23 @@ impl Readable for HTLCSource {
|
|||
let mut session_priv: ::util::ser::OptionDeserWrapper<SecretKey> = ::util::ser::OptionDeserWrapper(None);
|
||||
let mut first_hop_htlc_msat: u64 = 0;
|
||||
let mut path = Some(Vec::new());
|
||||
let mut mpp_id = None;
|
||||
let mut payment_id = None;
|
||||
read_tlv_fields!(reader, {
|
||||
(0, session_priv, required),
|
||||
(1, mpp_id, option),
|
||||
(1, payment_id, option),
|
||||
(2, first_hop_htlc_msat, required),
|
||||
(4, path, vec_type),
|
||||
});
|
||||
if mpp_id.is_none() {
|
||||
// For backwards compat, if there was no mpp_id written, use the session_priv bytes
|
||||
if payment_id.is_none() {
|
||||
// For backwards compat, if there was no payment_id written, use the session_priv bytes
|
||||
// instead.
|
||||
mpp_id = Some(MppId(*session_priv.0.unwrap().as_ref()));
|
||||
payment_id = Some(PaymentId(*session_priv.0.unwrap().as_ref()));
|
||||
}
|
||||
Ok(HTLCSource::OutboundRoute {
|
||||
session_priv: session_priv.0.unwrap(),
|
||||
first_hop_htlc_msat: first_hop_htlc_msat,
|
||||
path: path.unwrap(),
|
||||
mpp_id: mpp_id.unwrap(),
|
||||
payment_id: payment_id.unwrap(),
|
||||
})
|
||||
}
|
||||
1 => Ok(HTLCSource::PreviousHopData(Readable::read(reader)?)),
|
||||
|
@ -5107,12 +5107,12 @@ impl Readable for HTLCSource {
|
|||
impl Writeable for HTLCSource {
|
||||
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::io::Error> {
|
||||
match self {
|
||||
HTLCSource::OutboundRoute { ref session_priv, ref first_hop_htlc_msat, ref path, mpp_id } => {
|
||||
HTLCSource::OutboundRoute { ref session_priv, ref first_hop_htlc_msat, ref path, payment_id } => {
|
||||
0u8.write(writer)?;
|
||||
let mpp_id_opt = Some(mpp_id);
|
||||
let payment_id_opt = Some(payment_id);
|
||||
write_tlv_fields!(writer, {
|
||||
(0, session_priv, required),
|
||||
(1, mpp_id_opt, option),
|
||||
(1, payment_id_opt, option),
|
||||
(2, first_hop_htlc_msat, required),
|
||||
(4, path, vec_type),
|
||||
});
|
||||
|
@ -5518,11 +5518,11 @@ impl<'a, Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
|
|||
}
|
||||
|
||||
let pending_outbound_payments_count_compat: u64 = Readable::read(reader)?;
|
||||
let mut pending_outbound_payments_compat: HashMap<MppId, HashSet<[u8; 32]>> =
|
||||
let mut pending_outbound_payments_compat: HashMap<PaymentId, HashSet<[u8; 32]>> =
|
||||
HashMap::with_capacity(cmp::min(pending_outbound_payments_count_compat as usize, MAX_ALLOC_SIZE/32));
|
||||
for _ in 0..pending_outbound_payments_count_compat {
|
||||
let session_priv = Readable::read(reader)?;
|
||||
if pending_outbound_payments_compat.insert(MppId(session_priv), [session_priv].iter().cloned().collect()).is_some() {
|
||||
if pending_outbound_payments_compat.insert(PaymentId(session_priv), [session_priv].iter().cloned().collect()).is_some() {
|
||||
return Err(DecodeError::InvalidValue)
|
||||
};
|
||||
}
|
||||
|
@ -5596,7 +5596,7 @@ mod tests {
|
|||
use bitcoin::hashes::sha256::Hash as Sha256;
|
||||
use core::time::Duration;
|
||||
use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
|
||||
use ln::channelmanager::{MppId, PaymentSendFailure};
|
||||
use ln::channelmanager::{PaymentId, PaymentSendFailure};
|
||||
use ln::features::{InitFeatures, InvoiceFeatures};
|
||||
use ln::functional_test_utils::*;
|
||||
use ln::msgs;
|
||||
|
@ -5747,11 +5747,11 @@ mod tests {
|
|||
let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
|
||||
let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph, &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 100_000, TEST_FINAL_CLTV, &logger).unwrap();
|
||||
let (payment_preimage, our_payment_hash, payment_secret) = get_payment_preimage_hash!(&nodes[1]);
|
||||
let mpp_id = MppId([42; 32]);
|
||||
let payment_id = PaymentId([42; 32]);
|
||||
// Use the utility function send_payment_along_path to send the payment with MPP data which
|
||||
// indicates there are more HTLCs coming.
|
||||
let cur_height = CHAN_CONFIRM_DEPTH + 1; // route_payment calls send_payment, which adds 1 to the current height. So we do the same here to match.
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200_000, cur_height, mpp_id, &None).unwrap();
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200_000, cur_height, payment_id, &None).unwrap();
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
|
||||
assert_eq!(events.len(), 1);
|
||||
|
@ -5781,7 +5781,7 @@ mod tests {
|
|||
expect_payment_failed!(nodes[0], our_payment_hash, true);
|
||||
|
||||
// Send the second half of the original MPP payment.
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200_000, cur_height, mpp_id, &None).unwrap();
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200_000, cur_height, payment_id, &None).unwrap();
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
|
||||
assert_eq!(events.len(), 1);
|
||||
|
|
|
@ -19,7 +19,7 @@ use chain::transaction::OutPoint;
|
|||
use chain::keysinterface::BaseSign;
|
||||
use ln::{PaymentPreimage, PaymentSecret, PaymentHash};
|
||||
use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC};
|
||||
use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, MppId, RAACommitmentOrder, PaymentSendFailure, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA};
|
||||
use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, PaymentId, RAACommitmentOrder, PaymentSendFailure, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA};
|
||||
use ln::channel::{Channel, ChannelError};
|
||||
use ln::{chan_utils, onion_utils};
|
||||
use ln::chan_utils::HTLC_SUCCESS_TX_WEIGHT;
|
||||
|
@ -3957,8 +3957,8 @@ fn do_test_htlc_timeout(send_partial_mpp: bool) {
|
|||
// Use the utility function send_payment_along_path to send the payment with MPP data which
|
||||
// indicates there are more HTLCs coming.
|
||||
let cur_height = CHAN_CONFIRM_DEPTH + 1; // route_payment calls send_payment, which adds 1 to the current height. So we do the same here to match.
|
||||
let mpp_id = MppId([42; 32]);
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200000, cur_height, mpp_id, &None).unwrap();
|
||||
let payment_id = PaymentId([42; 32]);
|
||||
nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200000, cur_height, payment_id, &None).unwrap();
|
||||
check_added_monitors!(nodes[0], 1);
|
||||
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
|
||||
assert_eq!(events.len(), 1);
|
||||
|
|
Loading…
Add table
Reference in a new issue