X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fchannelmanager.rs;h=31529343d56d22b646ab37c44f0f3639be7d2dec;hb=615ef7d6f88464ed8478a8c8cc0e7582ba66d773;hp=bfd41d11a8c1bc3f815d676db9336b39794e34a0;hpb=a7082901fe8302d1944cb3365f192626f4dbac22;p=rust-lightning diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index bfd41d11..31529343 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -96,7 +96,7 @@ enum PendingHTLCRouting { short_channel_id: u64, // This should be NonZero eventually when we bump MSRV }, Receive { - payment_data: Option, + payment_data: msgs::FinalOnionHopData, incoming_cltv_expiry: u32, // Used to track when we should expire pending HTLCs that go unclaimed }, } @@ -156,11 +156,10 @@ pub(crate) struct HTLCPreviousHopData { struct ClaimableHTLC { prev_hop: HTLCPreviousHopData, value: u64, - /// Filled in when the HTLC was received with a payment_secret packet, which contains a - /// total_msat (which may differ from value if this is a Multi-Path Payment) and a + /// Contains a total_msat (which may differ from value if this is a Multi-Path Payment) and a /// payment_secret which prevents path-probing attacks and can associate different HTLCs which /// are part of the same payment. - payment_data: Option, + payment_data: msgs::FinalOnionHopData, cltv_expiry: u32, } @@ -327,12 +326,11 @@ pub(super) struct ChannelHolder { /// guarantees are made about the existence of a channel with the short id here, nor the short /// ids in the PendingHTLCInfo! pub(super) forward_htlcs: HashMap>, - /// (payment_hash, payment_secret) -> Vec for tracking HTLCs that - /// were to us and can be failed/claimed by the user + /// Map from payment hash to any HTLCs which are to us and can be failed/claimed by the user. /// Note that while this is held in the same mutex as the channels themselves, no consistency /// guarantees are made about the channels given here actually existing anymore by the time you /// go to read them! - claimable_htlcs: HashMap<(PaymentHash, Option), Vec>, + claimable_htlcs: HashMap>, /// Messages to send to peers - pushed to in the same lock that they are generated in (except /// for broadcast messages, where ordering isn't as strict). pub(super) pending_msg_events: Vec, @@ -364,6 +362,8 @@ struct PendingInboundPayment { /// Time at which this HTLC expires - blocks with a header time above this value will result in /// this payment being removed. expiry_time: u64, + /// Arbitrary identifier the user specifies (or not) + user_payment_id: u64, // Other required attributes of the payment, optionally enforced: payment_preimage: Option, min_value_msat: Option, @@ -451,7 +451,7 @@ pub struct ChannelManager>, @@ -588,6 +588,11 @@ pub(crate) const MAX_LOCAL_BREAKDOWN_TIMEOUT: u16 = 2 * 6 * 24 * 7; pub const MIN_CLTV_EXPIRY_DELTA: u16 = 6 * 6; pub(super) const CLTV_FAR_FAR_AWAY: u32 = 6 * 24 * 7; //TODO? +/// Minimum CLTV difference between the current block height and received inbound payments. +/// Invoices generated for payment to us must set their `min_final_cltv_expiry` field to at least +/// this value. +pub const MIN_FINAL_CLTV_EXPIRY: u32 = HTLC_FAIL_BACK_BUFFER; + // Check that our CLTV_EXPIRY is at least CLTV_CLAIM_BUFFER + ANTI_REORG_DELAY + LATENCY_GRACE_PERIOD_BLOCKS, // ie that if the next-hop peer fails the HTLC within // LATENCY_GRACE_PERIOD_BLOCKS then we'll still have CLTV_CLAIM_BUFFER left to timeout it onchain, @@ -1247,6 +1252,10 @@ impl ChannelMana msgs::OnionHopDataFormat::FinalNode { payment_data } => payment_data, }; + if payment_data.is_none() { + return_err!("We require payment_secrets", 0x4000|0x2000|3, &[0;0]); + } + // Note that we could obviously respond immediately with an update_fulfill_htlc // message, however that would leak that we are the recipient of this payment, so // instead we stay symmetric with the forwarding case, only responding (after a @@ -1254,7 +1263,7 @@ impl ChannelMana PendingHTLCStatus::Forward(PendingHTLCInfo { routing: PendingHTLCRouting::Receive { - payment_data, + payment_data: payment_data.unwrap(), incoming_cltv_expiry: msg.cltv_expiry, }, payment_hash: msg.payment_hash.clone(), @@ -1948,61 +1957,95 @@ impl ChannelMana routing: PendingHTLCRouting::Receive { payment_data, incoming_cltv_expiry }, incoming_shared_secret, payment_hash, amt_to_forward, .. }, prev_funding_outpoint } => { - let prev_hop = HTLCPreviousHopData { - short_channel_id: prev_short_channel_id, - outpoint: prev_funding_outpoint, - htlc_id: prev_htlc_id, - incoming_packet_shared_secret: incoming_shared_secret, - }; - - let mut total_value = 0; - let payment_secret_opt = - if let &Some(ref data) = &payment_data { Some(data.payment_secret.clone()) } else { None }; - let htlcs = channel_state.claimable_htlcs.entry((payment_hash, payment_secret_opt)) - .or_insert(Vec::new()); - htlcs.push(ClaimableHTLC { - prev_hop, + let claimable_htlc = ClaimableHTLC { + prev_hop: HTLCPreviousHopData { + short_channel_id: prev_short_channel_id, + outpoint: prev_funding_outpoint, + htlc_id: prev_htlc_id, + incoming_packet_shared_secret: incoming_shared_secret, + }, value: amt_to_forward, payment_data: payment_data.clone(), cltv_expiry: incoming_cltv_expiry, - }); - if let &Some(ref data) = &payment_data { - for htlc in htlcs.iter() { - total_value += htlc.value; - if htlc.payment_data.as_ref().unwrap().total_msat != data.total_msat { - total_value = msgs::MAX_VALUE_MSAT; - } - if total_value >= msgs::MAX_VALUE_MSAT { break; } - } - if total_value >= msgs::MAX_VALUE_MSAT || total_value > data.total_msat { - for htlc in htlcs.iter() { - let mut htlc_msat_height_data = byte_utils::be64_to_array(htlc.value).to_vec(); - htlc_msat_height_data.extend_from_slice( - &byte_utils::be32_to_array(self.best_block.read().unwrap().height()), - ); - failed_forwards.push((HTLCSource::PreviousHopData(HTLCPreviousHopData { - short_channel_id: htlc.prev_hop.short_channel_id, - outpoint: prev_funding_outpoint, - htlc_id: htlc.prev_hop.htlc_id, - incoming_packet_shared_secret: htlc.prev_hop.incoming_packet_shared_secret, - }), payment_hash, - HTLCFailReason::Reason { failure_code: 0x4000 | 15, data: htlc_msat_height_data } - )); - } - } else if total_value == data.total_msat { - new_events.push(events::Event::PaymentReceived { - payment_hash, - payment_secret: Some(data.payment_secret), - amt: total_value, - }); + }; + + macro_rules! fail_htlc { + ($htlc: expr) => { + let mut htlc_msat_height_data = byte_utils::be64_to_array($htlc.value).to_vec(); + htlc_msat_height_data.extend_from_slice( + &byte_utils::be32_to_array(self.best_block.read().unwrap().height()), + ); + failed_forwards.push((HTLCSource::PreviousHopData(HTLCPreviousHopData { + short_channel_id: $htlc.prev_hop.short_channel_id, + outpoint: prev_funding_outpoint, + htlc_id: $htlc.prev_hop.htlc_id, + incoming_packet_shared_secret: $htlc.prev_hop.incoming_packet_shared_secret, + }), payment_hash, + HTLCFailReason::Reason { failure_code: 0x4000 | 15, data: htlc_msat_height_data } + )); } - } else { - new_events.push(events::Event::PaymentReceived { - payment_hash, - payment_secret: None, - amt: amt_to_forward, - }); } + + // Check that the payment hash and secret are known. Note that we + // MUST take care to handle the "unknown payment hash" and + // "incorrect payment secret" cases here identically or we'd expose + // that we are the ultimate recipient of the given payment hash. + // Further, we must not expose whether we have any other HTLCs + // associated with the same payment_hash pending or not. + let mut payment_secrets = self.pending_inbound_payments.lock().unwrap(); + match payment_secrets.entry(payment_hash) { + hash_map::Entry::Vacant(_) => { + log_trace!(self.logger, "Failing new HTLC with payment_hash {} as we didn't have a corresponding inbound payment.", log_bytes!(payment_hash.0)); + fail_htlc!(claimable_htlc); + }, + hash_map::Entry::Occupied(inbound_payment) => { + if inbound_payment.get().payment_secret != payment_data.payment_secret { + log_trace!(self.logger, "Failing new HTLC with payment_hash {} as it didn't match our expected payment secret.", log_bytes!(payment_hash.0)); + fail_htlc!(claimable_htlc); + } else if inbound_payment.get().min_value_msat.is_some() && payment_data.total_msat < inbound_payment.get().min_value_msat.unwrap() { + log_trace!(self.logger, "Failing new HTLC with payment_hash {} as it didn't match our minimum value (had {}, needed {}).", + log_bytes!(payment_hash.0), payment_data.total_msat, inbound_payment.get().min_value_msat.unwrap()); + fail_htlc!(claimable_htlc); + } else { + let mut total_value = 0; + let htlcs = channel_state.claimable_htlcs.entry(payment_hash) + .or_insert(Vec::new()); + htlcs.push(claimable_htlc); + for htlc in htlcs.iter() { + total_value += htlc.value; + if htlc.payment_data.total_msat != payment_data.total_msat { + log_trace!(self.logger, "Failing HTLCs with payment_hash {} as the HTLCs had inconsistent total values (eg {} and {})", + log_bytes!(payment_hash.0), payment_data.total_msat, htlc.payment_data.total_msat); + total_value = msgs::MAX_VALUE_MSAT; + } + if total_value >= msgs::MAX_VALUE_MSAT { break; } + } + if total_value >= msgs::MAX_VALUE_MSAT || total_value > payment_data.total_msat { + log_trace!(self.logger, "Failing HTLCs with payment_hash {} as the total value {} ran over expected value {} (or HTLCs were inconsistent)", + log_bytes!(payment_hash.0), total_value, payment_data.total_msat); + for htlc in htlcs.iter() { + fail_htlc!(htlc); + } + } else if total_value == payment_data.total_msat { + new_events.push(events::Event::PaymentReceived { + payment_hash, + payment_preimage: inbound_payment.get().payment_preimage, + payment_secret: payment_data.payment_secret, + amt: total_value, + user_payment_id: inbound_payment.get().user_payment_id, + }); + // Only ever generate at most one PaymentReceived + // per registered payment_hash, even if it isn't + // claimed. + inbound_payment.remove_entry(); + } else { + // Nothing to do - we haven't reached the total + // payment value yet, wait until we receive more + // MPP parts. + } + } + }, + }; }, HTLCForwardInfo::AddHTLC { .. } => { panic!("short_channel_id == 0 should imply any pending_forward entries are of type Receive"); @@ -2088,15 +2131,11 @@ impl ChannelMana /// along the path (including in our own channel on which we received it). /// Returns false if no payment was found to fail backwards, true if the process of failing the /// HTLC backwards has been started. - pub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash, _payment_secret: &Option) -> bool { + pub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash) -> bool { let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier); let mut channel_state = Some(self.channel_state.lock().unwrap()); - let payment_secrets = self.pending_inbound_payments.lock().unwrap(); - let payment_secret = if let Some(secret) = payment_secrets.get(&payment_hash) { - Some(secret.payment_secret) - } else { return false; }; - let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(&(*payment_hash, payment_secret)); + let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(payment_hash); if let Some(mut sources) = removed_source { for htlc in sources.drain(..) { if channel_state.is_none() { channel_state = Some(self.channel_state.lock().unwrap()); } @@ -2261,28 +2300,22 @@ impl ChannelMana /// generating message events for the net layer to claim the payment, if possible. Thus, you /// should probably kick the net layer to go send messages if this returns true! /// - /// You must specify the expected amounts for this HTLC, and we will only claim HTLCs - /// available within a few percent of the expected amount. This is critical for several - /// reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the - /// payment_preimage without having provided the full value and b) it avoids certain - /// privacy-breaking recipient-probing attacks which may reveal payment activity to - /// motivated attackers. - /// - /// Note that the privacy concerns in (b) are not relevant in payments with a payment_secret - /// set. Thus, for such payments we will claim any payments which do not under-pay. + /// Note that if you did not set an `amount_msat` when calling [`create_inbound_payment`] or + /// [`create_inbound_payment_for_hash`] you must check that the amount in the `PaymentReceived` + /// event matches your expectation. If you fail to do so and call this method, you may provide + /// the sender "proof-of-payment" when they did not fulfill the full expected payment. /// /// May panic if called except in response to a PaymentReceived event. - pub fn claim_funds(&self, payment_preimage: PaymentPreimage, _payment_secret: &Option, expected_amount: u64) -> bool { + /// + /// [`create_inbound_payment`]: Self::create_inbound_payment + /// [`create_inbound_payment_for_hash`]: Self::create_inbound_payment_for_hash + pub fn claim_funds(&self, payment_preimage: PaymentPreimage) -> bool { let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier); let mut channel_state = Some(self.channel_state.lock().unwrap()); - let payment_secrets = self.pending_inbound_payments.lock().unwrap(); - let payment_secret = if let Some(secret) = payment_secrets.get(&payment_hash) { - Some(secret.payment_secret) - } else { return false; }; - let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(&(payment_hash, payment_secret)); + let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(&payment_hash); if let Some(mut sources) = removed_source { assert!(!sources.is_empty()); @@ -2297,27 +2330,19 @@ impl ChannelMana // we got all the HTLCs and then a channel closed while we were waiting for the user to // provide the preimage, so worrying too much about the optimal handling isn't worth // it. - - let (is_mpp, mut valid_mpp) = if let &Some(ref data) = &sources[0].payment_data { - assert!(payment_secret.is_some()); - (true, data.total_msat >= expected_amount) - } else { - assert!(payment_secret.is_none()); - (false, false) - }; - + let mut valid_mpp = true; for htlc in sources.iter() { - if !is_mpp || !valid_mpp { break; } if let None = channel_state.as_ref().unwrap().short_to_id.get(&htlc.prev_hop.short_channel_id) { valid_mpp = false; + break; } } let mut errs = Vec::new(); let mut claimed_any_htlcs = false; for htlc in sources.drain(..) { - if channel_state.is_none() { channel_state = Some(self.channel_state.lock().unwrap()); } - if (is_mpp && !valid_mpp) || (!is_mpp && (htlc.value < expected_amount || htlc.value > expected_amount * 2)) { + if !valid_mpp { + if channel_state.is_none() { channel_state = Some(self.channel_state.lock().unwrap()); } let mut htlc_msat_height_data = byte_utils::be64_to_array(htlc.value).to_vec(); htlc_msat_height_data.extend_from_slice(&byte_utils::be32_to_array( self.best_block.read().unwrap().height())); @@ -2334,10 +2359,7 @@ impl ChannelMana claimed_any_htlcs = true; } else { errs.push(e); } }, - Err(None) if is_mpp => unreachable!("We already checked for channel existence, we can't fail here!"), - Err(None) => { - log_warn!(self.logger, "Channel we expected to claim an HTLC from was closed."); - }, + Err(None) => unreachable!("We already checked for channel existence, we can't fail here!"), Ok(()) => claimed_any_htlcs = true, } } @@ -3362,7 +3384,7 @@ impl ChannelMana } } - fn set_payment_hash_secret_map(&self, payment_hash: PaymentHash, payment_preimage: Option, min_value_msat: Option, invoice_expiry_delta_secs: u32) -> Result { + fn set_payment_hash_secret_map(&self, payment_hash: PaymentHash, payment_preimage: Option, min_value_msat: Option, invoice_expiry_delta_secs: u32, user_payment_id: u64) -> Result { assert!(invoice_expiry_delta_secs <= 60*60*24*365); // Sadly bitcoin timestamps are u32s, so panic before 2106 let payment_secret = PaymentSecret(self.keys_manager.get_secure_random_bytes()); @@ -3372,7 +3394,7 @@ impl ChannelMana match payment_secrets.entry(payment_hash) { hash_map::Entry::Vacant(e) => { e.insert(PendingInboundPayment { - payment_secret, min_value_msat, payment_preimage, + payment_secret, min_value_msat, user_payment_id, payment_preimage, // We assume that highest_seen_timestamp is pretty close to the current time - // its updated when we receive a new block with the maximum time we've seen in // a header. It should never be more than two hours in the future. @@ -3394,15 +3416,22 @@ impl ChannelMana /// This differs from [`create_inbound_payment_for_hash`] only in that it generates the /// [`PaymentHash`] and [`PaymentPreimage`] for you, returning the first and storing the second. /// + /// The [`PaymentPreimage`] will ultimately be returned to you in the [`PaymentReceived`], which + /// will have the [`PaymentReceived::payment_preimage`] field filled in. That should then be + /// passed directly to [`claim_funds`]. + /// /// See [`create_inbound_payment_for_hash`] for detailed documentation on behavior and requirements. /// + /// [`claim_funds`]: Self::claim_funds + /// [`PaymentReceived`]: events::Event::PaymentReceived + /// [`PaymentReceived::payment_preimage`]: events::Event::PaymentReceived::payment_preimage /// [`create_inbound_payment_for_hash`]: Self::create_inbound_payment_for_hash - pub fn create_inbound_payment(&self, min_value_msat: Option, invoice_expiry_delta_secs: u32) -> (PaymentHash, PaymentSecret) { + pub fn create_inbound_payment(&self, min_value_msat: Option, invoice_expiry_delta_secs: u32, user_payment_id: u64) -> (PaymentHash, PaymentSecret) { let payment_preimage = PaymentPreimage(self.keys_manager.get_secure_random_bytes()); let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); (payment_hash, - self.set_payment_hash_secret_map(payment_hash, Some(payment_preimage), min_value_msat, invoice_expiry_delta_secs) + self.set_payment_hash_secret_map(payment_hash, Some(payment_preimage), min_value_msat, invoice_expiry_delta_secs, user_payment_id) .expect("RNG Generated Duplicate PaymentHash")) } @@ -3416,6 +3445,12 @@ impl ChannelMana /// The [`PaymentHash`] (and corresponding [`PaymentPreimage`]) must be globally unique. This /// method may return an Err if another payment with the same payment_hash is still pending. /// + /// `user_payment_id` will be provided back in [`PaymentReceived::user_payment_id`] events to + /// allow tracking of which events correspond with which calls to this and + /// [`create_inbound_payment`]. `user_payment_id` has no meaning inside of LDK, it is simply + /// copied to events and otherwise ignored. It may be used to correlate PaymentReceived events + /// with invoice metadata stored elsewhere. + /// /// `min_value_msat` should be set if the invoice being generated contains a value. Any payment /// received for the returned [`PaymentHash`] will be required to be at least `min_value_msat` /// before a [`PaymentReceived`] event will be generated, ensuring that we do not provide the @@ -3435,10 +3470,14 @@ impl ChannelMana /// /// May panic if `invoice_expiry_delta_secs` is greater than one year. /// + /// Note that invoices generated for inbound payments should have their `min_final_cltv_expiry` + /// set to at least [`MIN_FINAL_CLTV_EXPIRY`]. + /// /// [`create_inbound_payment`]: Self::create_inbound_payment /// [`PaymentReceived`]: events::Event::PaymentReceived - pub fn create_inbound_payment_for_hash(&self, payment_hash: PaymentHash, min_value_msat: Option, invoice_expiry_delta_secs: u32) -> Result { - self.set_payment_hash_secret_map(payment_hash, None, min_value_msat, invoice_expiry_delta_secs) + /// [`PaymentReceived::user_payment_id`]: events::Event::PaymentReceived::user_payment_id + pub fn create_inbound_payment_for_hash(&self, payment_hash: PaymentHash, min_value_msat: Option, invoice_expiry_delta_secs: u32, user_payment_id: u64) -> Result { + self.set_payment_hash_secret_map(payment_hash, None, min_value_msat, invoice_expiry_delta_secs, user_payment_id) } } @@ -3570,6 +3609,10 @@ where } max_time!(self.last_node_announcement_serial); max_time!(self.highest_seen_timestamp); + let mut payment_secrets = self.pending_inbound_payments.lock().unwrap(); + payment_secrets.retain(|_, inbound_payment| { + inbound_payment.expiry_time > header.time as u64 + }); } fn get_relevant_txids(&self) -> Vec { @@ -3667,7 +3710,7 @@ where }); if let Some(height) = height_opt { - channel_state.claimable_htlcs.retain(|&(ref payment_hash, _), htlcs| { + channel_state.claimable_htlcs.retain(|payment_hash, htlcs| { htlcs.retain(|htlc| { // If height is approaching the number of blocks we think it takes us to get // our commitment transaction confirmed before the HTLC expires, plus the @@ -4041,7 +4084,8 @@ impl Writeable for PendingHTLCInfo { }, &PendingHTLCRouting::Receive { ref payment_data, ref incoming_cltv_expiry } => { 1u8.write(writer)?; - payment_data.write(writer)?; + payment_data.payment_secret.write(writer)?; + payment_data.total_msat.write(writer)?; incoming_cltv_expiry.write(writer)?; }, } @@ -4062,7 +4106,10 @@ impl Readable for PendingHTLCInfo { short_channel_id: Readable::read(reader)?, }, 1u8 => PendingHTLCRouting::Receive { - payment_data: Readable::read(reader)?, + payment_data: msgs::FinalOnionHopData { + payment_secret: Readable::read(reader)?, + total_msat: Readable::read(reader)?, + }, incoming_cltv_expiry: Readable::read(reader)?, }, _ => return Err(DecodeError::InvalidValue), @@ -4134,12 +4181,29 @@ impl_writeable!(HTLCPreviousHopData, 0, { incoming_packet_shared_secret }); -impl_writeable!(ClaimableHTLC, 0, { - prev_hop, - value, - payment_data, - cltv_expiry -}); +impl Writeable for ClaimableHTLC { + fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> { + self.prev_hop.write(writer)?; + self.value.write(writer)?; + self.payment_data.payment_secret.write(writer)?; + self.payment_data.total_msat.write(writer)?; + self.cltv_expiry.write(writer) + } +} + +impl Readable for ClaimableHTLC { + fn read(reader: &mut R) -> Result { + Ok(ClaimableHTLC { + prev_hop: Readable::read(reader)?, + value: Readable::read(reader)?, + payment_data: msgs::FinalOnionHopData { + payment_secret: Readable::read(reader)?, + total_msat: Readable::read(reader)?, + }, + cltv_expiry: Readable::read(reader)?, + }) + } +} impl Writeable for HTLCSource { fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> { @@ -4244,6 +4308,7 @@ impl Readable for HTLCForwardInfo { impl_writeable!(PendingInboundPayment, 0, { payment_secret, expiry_time, + user_payment_id, payment_preimage, min_value_msat }); @@ -4788,7 +4853,7 @@ pub mod bench { payment_preimage.0[0..8].copy_from_slice(&payment_count.to_le_bytes()); payment_count += 1; let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()); - let payment_secret = $node_b.create_inbound_payment_for_hash(payment_hash, None, 7200).unwrap(); + let payment_secret = $node_b.create_inbound_payment_for_hash(payment_hash, None, 7200, 0).unwrap(); $node_a.send_payment(&route, payment_hash, &Some(payment_secret)).unwrap(); let payment_event = SendEvent::from_event($node_a.get_and_clear_pending_msg_events().pop().unwrap()); @@ -4801,7 +4866,7 @@ pub mod bench { expect_pending_htlcs_forwardable!(NodeHolder { node: &$node_b }); expect_payment_received!(NodeHolder { node: &$node_b }, payment_hash, payment_secret, 10_000); - assert!($node_b.claim_funds(payment_preimage, &Some(payment_secret), 10_000)); + assert!($node_b.claim_funds(payment_preimage)); match $node_b.get_and_clear_pending_msg_events().pop().unwrap() { MessageSendEvent::UpdateHTLCs { node_id, updates } => {