Merge pull request #3107 from mhrheaume/mhr/closure_reason_abandoned
[rust-lightning] / lightning / src / ln / onion_route_tests.rs
index 52ae2908022c7894300b4a42824de38f3ab5e39e..02109c888f5f16dda8bd09137e0cb989c3765d57 100644 (file)
 use crate::chain::channelmonitor::{CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS};
 use crate::sign::{EntropySource, NodeSigner, Recipient};
 use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PathFailure, PaymentFailureReason};
-use crate::ln::{PaymentHash, PaymentSecret};
+use crate::ln::types::{PaymentHash, PaymentSecret};
 use crate::ln::channel::EXPIRE_PREV_CONFIG_TICKS;
 use crate::ln::channelmanager::{HTLCForwardInfo, FailureCode, CLTV_FAR_FAR_AWAY, DISABLE_GOSSIP_TICKS, MIN_CLTV_EXPIRY_DELTA, PendingAddHTLCInfo, PendingHTLCInfo, PendingHTLCRouting, PaymentId, RecipientOnionFields};
 use crate::ln::onion_utils;
 use crate::routing::gossip::{NetworkUpdate, RoutingFees};
 use crate::routing::router::{get_route, PaymentParameters, Route, RouteParameters, RouteHint, RouteHintHop};
 use crate::ln::features::{InitFeatures, Bolt11InvoiceFeatures};
+use crate::ln::functional_test_utils::test_default_channel_config;
 use crate::ln::msgs;
-use crate::ln::msgs::{ChannelMessageHandler, ChannelUpdate};
+use crate::ln::msgs::{ChannelMessageHandler, ChannelUpdate, OutboundTrampolinePayload};
 use crate::ln::wire::Encode;
 use crate::util::ser::{Writeable, Writer, BigSize};
 use crate::util::test_utils;
 use crate::util::config::{UserConfig, ChannelConfig, MaxDustHTLCExposure};
 use crate::util::errors::APIError;
 
-use bitcoin::hash_types::BlockHash;
-
+use bitcoin::blockdata::constants::ChainHash;
 use bitcoin::hashes::{Hash, HashEngine};
 use bitcoin::hashes::hmac::{Hmac, HmacEngine};
 use bitcoin::hashes::sha256::Hash as Sha256;
 
 use bitcoin::secp256k1;
-use bitcoin::secp256k1::{Secp256k1, SecretKey};
+use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 
 use crate::io;
 use crate::prelude::*;
-use core::default::Default;
+use bitcoin::hashes::hex::FromHex;
 
 use crate::ln::functional_test_utils::*;
 
@@ -180,11 +180,6 @@ fn run_onion_failure_test_with_fail_intercept<F1,F2,F3>(
                if expected_channel_update.is_some() {
                        match network_update {
                                Some(update) => match update {
-                                       &NetworkUpdate::ChannelUpdateMessage { .. } => {
-                                               if let NetworkUpdate::ChannelUpdateMessage { .. } = expected_channel_update.unwrap() {} else {
-                                                       panic!("channel_update not found!");
-                                               }
-                                       },
                                        &NetworkUpdate::ChannelFailure { ref short_channel_id, ref is_permanent } => {
                                                if let NetworkUpdate::ChannelFailure { short_channel_id: ref expected_short_channel_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
                                                        assert!(*short_channel_id == *expected_short_channel_id);
@@ -234,12 +229,13 @@ fn run_onion_failure_test_with_fail_intercept<F1,F2,F3>(
 
 impl msgs::ChannelUpdate {
        fn dummy(short_channel_id: u64) -> msgs::ChannelUpdate {
+               use bitcoin::hash_types::BlockHash;
                use bitcoin::secp256k1::ffi::Signature as FFISignature;
                use bitcoin::secp256k1::ecdsa::Signature;
                msgs::ChannelUpdate {
                        signature: Signature::from(unsafe { FFISignature::new() }),
                        contents: msgs::UnsignedChannelUpdate {
-                               chain_hash: BlockHash::hash(&vec![0u8][..]),
+                               chain_hash: ChainHash::from(BlockHash::hash(&vec![0u8][..]).as_ref()),
                                short_channel_id,
                                timestamp: 0,
                                flags: 0,
@@ -299,12 +295,13 @@ fn test_fee_failures() {
        claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_success);
 
        // If the hop gives fee_insufficient but enough fees were provided, then the previous hop
-       // malleated the payment before forwarding, taking funds when they shouldn't have.
+       // malleated the payment before forwarding, taking funds when they shouldn't have. However,
+       // because we ignore channel update contents, we will still blame the 2nd channel.
        let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[2]);
-       let short_channel_id = channels[0].0.contents.short_channel_id;
+       let short_channel_id = channels[1].0.contents.short_channel_id;
        run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, &payment_secret, |msg| {
                msg.amount_msat -= 1;
-       }, || {}, true, Some(UPDATE|12), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: true}), Some(short_channel_id));
+       }, || {}, true, Some(UPDATE|12), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false}), Some(short_channel_id));
 
        // In an earlier version, we spuriously failed to forward payments if the expected feerate
        // changed between the channel open and the payment.
@@ -328,7 +325,7 @@ fn test_onion_failure() {
        // to 2000, which is above the default value of 1000 set in create_node_chanmgrs.
        // This exposed a previous bug because we were using the wrong value all the way down in
        // Channel::get_counterparty_htlc_minimum_msat().
-       let mut node_2_cfg: UserConfig = Default::default();
+       let mut node_2_cfg: UserConfig = test_default_channel_config();
        node_2_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
        node_2_cfg.channel_handshake_config.announced_channel = true;
        node_2_cfg.channel_handshake_limits.force_announced_channel_preference = false;
@@ -356,8 +353,9 @@ fn test_onion_failure() {
                let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
                let cur_height = nodes[0].best_block_info().1 + 1;
                let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
+               let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
                let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
-                       &route.paths[0], 40000, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
+                       &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
                let mut new_payloads = Vec::new();
                for payload in onion_payloads.drain(..) {
                        new_payloads.push(BogusOnionHopData::new(payload));
@@ -374,8 +372,9 @@ fn test_onion_failure() {
                let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
                let cur_height = nodes[0].best_block_info().1 + 1;
                let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
+               let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
                let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
-                       &route.paths[0], 40000, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
+                       &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
                let mut new_payloads = Vec::new();
                for payload in onion_payloads.drain(..) {
                        new_payloads.push(BogusOnionHopData::new(payload));
@@ -475,7 +474,9 @@ fn test_onion_failure() {
                let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
                let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
                msg.reason = onion_utils::build_first_hop_failure_packet(onion_keys[0].shared_secret.as_ref(), UPDATE|7, &err_data);
-       }, ||{}, true, Some(UPDATE|7), Some(NetworkUpdate::ChannelUpdateMessage{msg: chan_update.clone()}), Some(short_channel_id));
+       }, ||{}, true, Some(UPDATE|7),
+       Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+       Some(short_channel_id));
 
        // Check we can still handle onion failures that include channel updates without a type prefix
        let err_data_without_type = chan_update.encode_with_len();
@@ -485,7 +486,9 @@ fn test_onion_failure() {
                let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
                let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
                msg.reason = onion_utils::build_first_hop_failure_packet(onion_keys[0].shared_secret.as_ref(), UPDATE|7, &err_data_without_type);
-       }, ||{}, true, Some(UPDATE|7), Some(NetworkUpdate::ChannelUpdateMessage{msg: chan_update}), Some(short_channel_id));
+       }, ||{}, true, Some(UPDATE|7),
+       Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+       Some(short_channel_id));
 
        let short_channel_id = channels[1].0.contents.short_channel_id;
        run_onion_failure_test_with_fail_intercept("permanent_channel_failure", 100, &nodes, &route, &payment_hash, &payment_secret, |msg| {
@@ -520,7 +523,9 @@ fn test_onion_failure() {
        let mut bogus_route = route.clone();
        let route_len = bogus_route.paths[0].hops.len();
        bogus_route.paths[0].hops[route_len-1].fee_msat = amt_to_forward;
-       run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, &payment_secret, |_| {}, ||{}, true, Some(UPDATE|11), Some(NetworkUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy(short_channel_id)}), Some(short_channel_id));
+       run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, &payment_secret, |_| {}, ||{}, true, Some(UPDATE|11),
+               Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+               Some(short_channel_id));
 
        // Clear pending payments so that the following positive test has the correct payment hash.
        for node in nodes.iter() {
@@ -532,16 +537,18 @@ fn test_onion_failure() {
        let preimage = send_along_route(&nodes[0], bogus_route, &[&nodes[1], &nodes[2]], amt_to_forward+1).0;
        claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], preimage);
 
-       let short_channel_id = channels[0].0.contents.short_channel_id;
+       // We ignore channel update contents in onion errors, so will blame the 2nd channel even though
+       // the first node is the one that messed up.
+       let short_channel_id = channels[1].0.contents.short_channel_id;
        run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, &payment_secret, |msg| {
                msg.amount_msat -= 1;
-       }, || {}, true, Some(UPDATE|12), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: true}), Some(short_channel_id));
+       }, || {}, true, Some(UPDATE|12), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false}), Some(short_channel_id));
 
-       let short_channel_id = channels[0].0.contents.short_channel_id;
+       let short_channel_id = channels[1].0.contents.short_channel_id;
        run_onion_failure_test("incorrect_cltv_expiry", 0, &nodes, &route, &payment_hash, &payment_secret, |msg| {
                // need to violate: cltv_expiry - cltv_expiry_delta >= outgoing_cltv_value
                msg.cltv_expiry -= 1;
-       }, || {}, true, Some(UPDATE|13), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: true}), Some(short_channel_id));
+       }, || {}, true, Some(UPDATE|13), Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false}), Some(short_channel_id));
 
        let short_channel_id = channels[1].0.contents.short_channel_id;
        run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, &payment_secret, |msg| {
@@ -549,7 +556,9 @@ fn test_onion_failure() {
                connect_blocks(&nodes[0], height - nodes[0].best_block_info().1);
                connect_blocks(&nodes[1], height - nodes[1].best_block_info().1);
                connect_blocks(&nodes[2], height - nodes[2].best_block_info().1);
-       }, ||{}, true, Some(UPDATE|14), Some(NetworkUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy(short_channel_id)}), Some(short_channel_id));
+       }, ||{}, true, Some(UPDATE|14),
+       Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+       Some(short_channel_id));
 
        run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, &payment_secret, |_| {}, || {
                nodes[2].node.fail_htlc_backwards(&payment_hash);
@@ -593,7 +602,9 @@ fn test_onion_failure() {
                // disconnect event to the channel between nodes[1] ~ nodes[2]
                nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id());
                nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id());
-       }, true, Some(UPDATE|7), Some(NetworkUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy(short_channel_id)}), Some(short_channel_id));
+       }, true, Some(UPDATE|7),
+       Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+       Some(short_channel_id));
        run_onion_failure_test("channel_disabled", 0, &nodes, &route, &payment_hash, &payment_secret, |_| {}, || {
                // disconnect event to the channel between nodes[1] ~ nodes[2]
                for _ in 0..DISABLE_GOSSIP_TICKS + 1 {
@@ -602,7 +613,9 @@ fn test_onion_failure() {
                }
                nodes[1].node.get_and_clear_pending_msg_events();
                nodes[2].node.get_and_clear_pending_msg_events();
-       }, true, Some(UPDATE|20), Some(NetworkUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy(short_channel_id)}), Some(short_channel_id));
+       }, true, Some(UPDATE|20),
+       Some(NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false }),
+       Some(short_channel_id));
        reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2]));
 
        run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, &payment_secret, |msg| {
@@ -611,8 +624,9 @@ fn test_onion_failure() {
                let height = nodes[2].best_block_info().1;
                route.paths[0].hops[1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.paths[0].hops[0].cltv_expiry_delta + 1;
                let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
+               let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
                let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(
-                       &route.paths[0], 40000, RecipientOnionFields::spontaneous_empty(), height, &None).unwrap();
+                       &route.paths[0], 40000, &recipient_onion_fields, height, &None).unwrap();
                let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
                msg.cltv_expiry = htlc_cltv;
                msg.onion_routing_packet = onion_packet;
@@ -639,14 +653,40 @@ fn test_onion_failure() {
                        let um = onion_utils::gen_um_from_shared_secret(&onion_keys[1].shared_secret.as_ref());
                        let mut hmac = HmacEngine::<Sha256>::new(&um);
                        hmac.input(&decoded_err_packet.encode()[32..]);
-                       decoded_err_packet.hmac = Hmac::from_engine(hmac).into_inner();
+                       decoded_err_packet.hmac = Hmac::from_engine(hmac).to_byte_array();
                        msg.reason = onion_utils::encrypt_failure_packet(
                                &onion_keys[1].shared_secret.as_ref(), &decoded_err_packet.encode()[..])
                }, || nodes[2].node.fail_htlc_backwards(&payment_hash), false, None,
                Some(NetworkUpdate::NodeFailure { node_id: route.paths[0].hops[1].pubkey, is_permanent: true }),
                Some(channels[1].0.contents.short_channel_id));
-       run_onion_failure_test_with_fail_intercept("0-length channel update in UPDATE onion failure", 200, &nodes,
-               &route, &payment_hash, &payment_secret, |_msg| {}, |msg| {
+       run_onion_failure_test_with_fail_intercept("0-length channel update in intermediate node UPDATE onion failure",
+               100, &nodes, &route, &payment_hash, &payment_secret, |msg| {
+                       msg.amount_msat -= 1;
+               }, |msg| {
+                       let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
+                       let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
+                       let mut decoded_err_packet = msgs::DecodedOnionErrorPacket {
+                               failuremsg: vec![
+                                       0x10, 0x7, // UPDATE|7
+                                       0x0, 0x0 // 0-len channel update
+                               ],
+                               pad: vec![0; 255 - 4 /* 4-byte error message */],
+                               hmac: [0; 32],
+                       };
+                       let um = onion_utils::gen_um_from_shared_secret(&onion_keys[0].shared_secret.as_ref());
+                       let mut hmac = HmacEngine::<Sha256>::new(&um);
+                       hmac.input(&decoded_err_packet.encode()[32..]);
+                       decoded_err_packet.hmac = Hmac::from_engine(hmac).to_byte_array();
+                       msg.reason = onion_utils::encrypt_failure_packet(
+                               &onion_keys[0].shared_secret.as_ref(), &decoded_err_packet.encode()[..])
+               }, || {}, true, Some(0x1000|7),
+               Some(NetworkUpdate::ChannelFailure {
+                       short_channel_id: channels[1].0.contents.short_channel_id,
+                       is_permanent: false,
+               }),
+               Some(channels[1].0.contents.short_channel_id));
+       run_onion_failure_test_with_fail_intercept("0-length channel update in final node UPDATE onion failure",
+               200, &nodes, &route, &payment_hash, &payment_secret, |_msg| {}, |msg| {
                        let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
                        let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
                        let mut decoded_err_packet = msgs::DecodedOnionErrorPacket {
@@ -660,7 +700,7 @@ fn test_onion_failure() {
                        let um = onion_utils::gen_um_from_shared_secret(&onion_keys[1].shared_secret.as_ref());
                        let mut hmac = HmacEngine::<Sha256>::new(&um);
                        hmac.input(&decoded_err_packet.encode()[32..]);
-                       decoded_err_packet.hmac = Hmac::from_engine(hmac).into_inner();
+                       decoded_err_packet.hmac = Hmac::from_engine(hmac).to_byte_array();
                        msg.reason = onion_utils::encrypt_failure_packet(
                                &onion_keys[1].shared_secret.as_ref(), &decoded_err_packet.encode()[..])
                }, || nodes[2].node.fail_htlc_backwards(&payment_hash), true, Some(0x1000|7),
@@ -764,7 +804,7 @@ fn do_test_onion_failure_stale_channel_update(announced_channel: bool) {
                        htlc_minimum_msat: None,
                }])];
                let payment_params = PaymentParameters::from_node_id(*channel_to_update_counterparty, TEST_FINAL_CLTV)
-                       .with_bolt11_features(nodes[2].node.invoice_features()).unwrap()
+                       .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap()
                        .with_route_hints(hop_hints).unwrap();
                get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, PAYMENT_AMT)
        };
@@ -814,9 +854,9 @@ fn do_test_onion_failure_stale_channel_update(announced_channel: bool) {
        // We'll be attempting to route payments using the default ChannelUpdate for channels. This will
        // lead to onion failures at the first hop once we update the ChannelConfig for the
        // second hop.
-       let expect_onion_failure = |name: &str, error_code: u16, channel_update: &msgs::ChannelUpdate| {
+       let expect_onion_failure = |name: &str, error_code: u16| {
                let short_channel_id = channel_to_update.1;
-               let network_update = NetworkUpdate::ChannelUpdateMessage { msg: channel_update.clone() };
+               let network_update = NetworkUpdate::ChannelFailure { short_channel_id, is_permanent: false };
                run_onion_failure_test(
                        name, 0, &nodes, &route, &payment_hash, &payment_secret, |_| {}, || {}, true,
                        Some(error_code), Some(network_update), Some(short_channel_id),
@@ -848,7 +888,7 @@ fn do_test_onion_failure_stale_channel_update(announced_channel: bool) {
        // Connect a block, which should expire the previous config, leading to a failure when
        // forwarding the HTLC.
        expire_prev_config();
-       expect_onion_failure("fee_insufficient", UPDATE|12, &msg);
+       expect_onion_failure("fee_insufficient", UPDATE|12);
 
        // Redundant updates should not trigger a new ChannelUpdate.
        assert!(update_and_get_channel_update(&config, false, None, false).is_none());
@@ -861,15 +901,15 @@ fn do_test_onion_failure_stale_channel_update(announced_channel: bool) {
        // new ChannelUpdate.
        config.forwarding_fee_base_msat = default_config.forwarding_fee_base_msat;
        config.cltv_expiry_delta = u16::max_value();
-       let msg = update_and_get_channel_update(&config, true, Some(&msg), true).unwrap();
-       expect_onion_failure("incorrect_cltv_expiry", UPDATE|13, &msg);
+       assert!(update_and_get_channel_update(&config, true, Some(&msg), true).is_some());
+       expect_onion_failure("incorrect_cltv_expiry", UPDATE|13);
 
        // Reset the proportional fee and increase the CLTV expiry delta which should trigger a new
        // ChannelUpdate.
        config.cltv_expiry_delta = default_config.cltv_expiry_delta;
        config.forwarding_fee_proportional_millionths = u32::max_value();
-       let msg = update_and_get_channel_update(&config, true, Some(&msg), true).unwrap();
-       expect_onion_failure("fee_insufficient", UPDATE|12, &msg);
+       assert!(update_and_get_channel_update(&config, true, Some(&msg), true).is_some());
+       expect_onion_failure("fee_insufficient", UPDATE|12);
 
        // To test persistence of the updated config, we'll re-initialize the ChannelManager.
        let config_after_restart = {
@@ -921,8 +961,9 @@ fn test_always_create_tlv_format_onion_payloads() {
        assert!(!hops[1].node_features.supports_variable_length_onion());
 
        let cur_height = nodes[0].best_block_info().1 + 1;
+       let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
        let (onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
-               &route.paths[0], 40000, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
+               &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
 
        match onion_payloads[0] {
                msgs::OutboundOnionPayload::Forward {..} => {},
@@ -940,6 +981,25 @@ fn test_always_create_tlv_format_onion_payloads() {
        }
 }
 
+#[test]
+fn test_trampoline_onion_payload_serialization() {
+       // As per https://github.com/lightning/bolts/blob/c01d2e6267d4a8d1095f0f1188970055a9a22d29/bolt04/trampoline-payment-onion-test.json#L3
+       let trampoline_payload = OutboundTrampolinePayload::Forward {
+               amt_to_forward: 100000000,
+               outgoing_cltv_value: 800000,
+               outgoing_node_id: PublicKey::from_slice(&<Vec<u8>>::from_hex("02edabbd16b41c8371b92ef2f04c1185b4f03b6dcd52ba9b78d9d7c89c8f221145").unwrap()).unwrap(),
+       };
+
+       let slice_to_hex = |slice: &[u8]| {
+               slice.iter()
+                       .map(|b| format!("{:02x}", b).to_string())
+                       .collect::<String>()
+       };
+
+       let carol_payload_hex = slice_to_hex(&trampoline_payload.encode());
+       assert_eq!(carol_payload_hex, "2e020405f5e10004030c35000e2102edabbd16b41c8371b92ef2f04c1185b4f03b6dcd52ba9b78d9d7c89c8f221145");
+}
+
 fn do_test_fail_htlc_backwards_with_reason(failure_code: FailureCode) {
 
        let chanmon_cfgs = create_chanmon_cfgs(2);
@@ -1021,7 +1081,7 @@ macro_rules! get_phantom_route {
                let phantom_pubkey = $nodes[1].keys_manager.get_node_id(Recipient::PhantomNode).unwrap();
                let phantom_route_hint = $nodes[1].node.get_phantom_route_hints();
                let payment_params = PaymentParameters::from_node_id(phantom_pubkey, TEST_FINAL_CLTV)
-                       .with_bolt11_features($nodes[1].node.invoice_features()).unwrap()
+                       .with_bolt11_features($nodes[1].node.bolt11_invoice_features()).unwrap()
                        .with_route_hints(vec![RouteHint(vec![
                                        RouteHintHop {
                                                src_node_id: $nodes[0].node.get_our_node_id(),
@@ -1093,7 +1153,7 @@ fn test_phantom_onion_hmac_failure() {
                                }, ..
                        }) => {
                                onion_packet.hmac[onion_packet.hmac.len() - 1] ^= 1;
-                               Sha256::hash(&onion_packet.hop_data).into_inner().to_vec()
+                               Sha256::hash(&onion_packet.hop_data).to_byte_array().to_vec()
                        },
                        _ => panic!("Unexpected forward"),
                }
@@ -1157,9 +1217,10 @@ fn test_phantom_invalid_onion_payload() {
                                        let height = nodes[0].best_block_info().1;
                                        let session_priv = SecretKey::from_slice(&session_priv).unwrap();
                                        let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
+                                       let recipient_onion_fields = RecipientOnionFields::secret_only(payment_secret);
                                        let (mut onion_payloads, _, _) = onion_utils::build_onion_payloads(
                                                &route.paths[0], msgs::MAX_VALUE_MSAT + 1,
-                                               RecipientOnionFields::secret_only(payment_secret), height + 1, &None).unwrap();
+                                               &recipient_onion_fields, height + 1, &None).unwrap();
                                        // We only want to construct the onion packet for the last hop, not the entire route, so
                                        // remove the first hop's payload and its keys.
                                        onion_keys.remove(0);
@@ -1291,7 +1352,7 @@ fn test_phantom_failure_too_low_cltv() {
        // Ensure the payment fails with the expected error.
        let mut error_data = recv_value_msat.to_be_bytes().to_vec();
        error_data.extend_from_slice(
-               &nodes[0].node.best_block.read().unwrap().height().to_be_bytes(),
+               &nodes[0].node.best_block.read().unwrap().height.to_be_bytes(),
        );
        let mut fail_conditions = PaymentFailedConditions::new()
                .blamed_scid(phantom_scid)
@@ -1421,7 +1482,7 @@ fn test_phantom_failure_too_low_recv_amt() {
 
        // Ensure the payment fails with the expected error.
        let mut error_data = bad_recv_amt_msat.to_be_bytes().to_vec();
-       error_data.extend_from_slice(&nodes[1].node.best_block.read().unwrap().height().to_be_bytes());
+       error_data.extend_from_slice(&nodes[1].node.best_block.read().unwrap().height.to_be_bytes());
        let mut fail_conditions = PaymentFailedConditions::new()
                .blamed_scid(phantom_scid)
                .expected_htlc_error_data(0x4000 | 15, &error_data);
@@ -1479,10 +1540,10 @@ fn do_test_phantom_dust_exposure_failure(multiplier_dust_limit: bool) {
        err_data.extend_from_slice(&channel.1.encode());
 
        let mut fail_conditions = PaymentFailedConditions::new()
-               .blamed_scid(channel.0.contents.short_channel_id)
+               .blamed_scid(route.paths[0].hops.last().as_ref().unwrap().short_channel_id)
                .blamed_chan_closed(false)
                .expected_htlc_error_data(0x1000 | 7, &err_data);
-               expect_payment_failed_conditions(&nodes[0], payment_hash, false, fail_conditions);
+       expect_payment_failed_conditions(&nodes[0], payment_hash, false, fail_conditions);
 }
 
 #[test]
@@ -1528,7 +1589,7 @@ fn test_phantom_failure_reject_payment() {
 
        // Ensure the payment fails with the expected error.
        let mut error_data = recv_amt_msat.to_be_bytes().to_vec();
-       error_data.extend_from_slice(&nodes[1].node.best_block.read().unwrap().height().to_be_bytes());
+       error_data.extend_from_slice(&nodes[1].node.best_block.read().unwrap().height.to_be_bytes());
        let mut fail_conditions = PaymentFailedConditions::new()
                .blamed_scid(phantom_scid)
                .expected_htlc_error_data(0x4000 | 15, &error_data);