Drop `claimable` from `Balance::claimable_amount_satoshis` fields

In Java/TypeScript, we map enums as a base class and each variant
as a class which extends the base. In Java/TypeScript, functions
and fields share the same namespace, which means we cannot have
functions on an enum which have the same name as any fields in any
enum variants.

`Balance`'s `claimable_amount_satoshis` method aliases with fields
in each variant, and thus ultimately doesn't compile in TypeScript.

Because `Balance::claimable_amount_satoshis` has the same name as
the fields, it's also a bit confusing, as it doesn't return the
field for each variant, but sometimes returns zero if we're not
sure we can claim the balance.

Instead, we rename the fields in each enum variant to simply
`amount_satoshis`, to avoid implying that we can definitely claim
the balance.

diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
index 3f95c95fdf89c7e036d4c00f3f0375492330b35e..0ad55b1c94a3b86fd3b702fe526ebd077f1dd48f 100644 (file)
--- a/lightning/src/chain/channelmonitor.rs
+++ b/lightning/src/chain/channelmonitor.rs
@@ -576,14 +576,14 @@ pub enum Balance {
        ClaimableOnChannelClose {
                /// The amount available to claim, in satoshis, excluding the on-chain fees which will be
                /// required to do so.
        ClaimableOnChannelClose {
                /// The amount available to claim, in satoshis, excluding the on-chain fees which will be
                /// required to do so.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

        },
        /// The channel has been closed, and the given balance is ours but awaiting confirmations until
        /// we consider it spendable.
        ClaimableAwaitingConfirmations {
                /// The amount available to claim, in satoshis, possibly excluding the on-chain fees which
                /// were spent in broadcasting the transaction.
        },
        /// The channel has been closed, and the given balance is ours but awaiting confirmations until
        /// we consider it spendable.
        ClaimableAwaitingConfirmations {
                /// The amount available to claim, in satoshis, possibly excluding the on-chain fees which
                /// were spent in broadcasting the transaction.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

                /// The height at which an [`Event::SpendableOutputs`] event will be generated for this
                /// amount.
                confirmation_height: u32,
                /// The height at which an [`Event::SpendableOutputs`] event will be generated for this
                /// amount.
                confirmation_height: u32,


@@ -598,7 +598,7 @@ pub enum Balance {
        ContentiousClaimable {
                /// The amount available to claim, in satoshis, excluding the on-chain fees which will be
                /// required to do so.
        ContentiousClaimable {
                /// The amount available to claim, in satoshis, excluding the on-chain fees which will be
                /// required to do so.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

                /// The height at which the counterparty may be able to claim the balance if we have not
                /// done so.
                timeout_height: u32,
                /// The height at which the counterparty may be able to claim the balance if we have not
                /// done so.
                timeout_height: u32,


@@ -613,7 +613,7 @@ pub enum Balance {
        MaybeTimeoutClaimableHTLC {
                /// The amount potentially available to claim, in satoshis, excluding the on-chain fees
                /// which will be required to do so.
        MaybeTimeoutClaimableHTLC {
                /// The amount potentially available to claim, in satoshis, excluding the on-chain fees
                /// which will be required to do so.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

                /// The height at which we will be able to claim the balance if our counterparty has not
                /// done so.
                claimable_height: u32,
                /// The height at which we will be able to claim the balance if our counterparty has not
                /// done so.
                claimable_height: u32,


@@ -626,7 +626,7 @@ pub enum Balance {
        MaybePreimageClaimableHTLC {
                /// The amount potentially available to claim, in satoshis, excluding the on-chain fees
                /// which will be required to do so.
        MaybePreimageClaimableHTLC {
                /// The amount potentially available to claim, in satoshis, excluding the on-chain fees
                /// which will be required to do so.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

                /// The height at which our counterparty will be able to claim the balance if we have not
                /// yet received the preimage and claimed it ourselves.
                expiry_height: u32,
                /// The height at which our counterparty will be able to claim the balance if we have not
                /// yet received the preimage and claimed it ourselves.
                expiry_height: u32,


@@ -643,7 +643,7 @@ pub enum Balance {
                ///
                /// Note that for outputs from HTLC balances this may be excluding some on-chain fees that
                /// were already spent.
                ///
                /// Note that for outputs from HTLC balances this may be excluding some on-chain fees that
                /// were already spent.

-               claimable_amount_satoshis: u64,
+               amount_satoshis: u64,

        },
 }
 
        },
 }
 


@@ -656,27 +656,14 @@ impl Balance {
        /// On-chain fees required to claim the balance are not included in this amount.
        pub fn claimable_amount_satoshis(&self) -> u64 {
                match self {
        /// On-chain fees required to claim the balance are not included in this amount.
        pub fn claimable_amount_satoshis(&self) -> u64 {
                match self {

-                       Balance::ClaimableOnChannelClose {
-                               claimable_amount_satoshis,
-                       } => *claimable_amount_satoshis,
-                       Balance::ClaimableAwaitingConfirmations {
-                               claimable_amount_satoshis,
-                               ..
-                       } => *claimable_amount_satoshis,
-                       Balance::ContentiousClaimable {
-                               claimable_amount_satoshis,
-                               ..
-                       } => *claimable_amount_satoshis,
-                       Balance::MaybeTimeoutClaimableHTLC {
-                               ..
-                       } => 0,
-                       Balance::MaybePreimageClaimableHTLC {
-                               ..
-                       } => 0,
-                       Balance::CounterpartyRevokedOutputClaimable {
-                               claimable_amount_satoshis,
-                               ..
-                       } => *claimable_amount_satoshis,
+                       Balance::ClaimableOnChannelClose { amount_satoshis, .. }|
+                       Balance::ClaimableAwaitingConfirmations { amount_satoshis, .. }|
+                       Balance::ContentiousClaimable { amount_satoshis, .. }|
+                       Balance::CounterpartyRevokedOutputClaimable { amount_satoshis, .. }
+                               => *amount_satoshis,
+                       Balance::MaybeTimeoutClaimableHTLC { .. }|
+                       Balance::MaybePreimageClaimableHTLC { .. }
+                               => 0,

                }
        }
 }
                }
        }
 }


@@ -1671,7 +1658,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
                if let Some(conf_thresh) = holder_delayed_output_pending {
                        debug_assert!(holder_commitment);
                        return Some(Balance::ClaimableAwaitingConfirmations {
                if let Some(conf_thresh) = holder_delayed_output_pending {
                        debug_assert!(holder_commitment);
                        return Some(Balance::ClaimableAwaitingConfirmations {

-                               claimable_amount_satoshis: htlc.amount_msat / 1000,
+                               amount_satoshis: htlc.amount_msat / 1000,

                                confirmation_height: conf_thresh,
                        });
                } else if htlc_resolved.is_some() && !htlc_output_spend_pending {
                                confirmation_height: conf_thresh,
                        });
                } else if htlc_resolved.is_some() && !htlc_output_spend_pending {


@@ -1709,7 +1696,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
                                debug_assert!(!htlc.offered || htlc_spend_pending.is_none() || !htlc_spend_pending.unwrap().1,
                                        "We don't (currently) generate preimage claims against revoked outputs, where did you get one?!");
                                return Some(Balance::CounterpartyRevokedOutputClaimable {
                                debug_assert!(!htlc.offered || htlc_spend_pending.is_none() || !htlc_spend_pending.unwrap().1,
                                        "We don't (currently) generate preimage claims against revoked outputs, where did you get one?!");
                                return Some(Balance::CounterpartyRevokedOutputClaimable {

-                                       claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                       amount_satoshis: htlc.amount_msat / 1000,

                                });
                        }
                } else if htlc.offered == holder_commitment {
                                });
                        }
                } else if htlc.offered == holder_commitment {


@@ -1718,12 +1705,12 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
                        // and awaiting confirmations on it.
                        if let Some(conf_thresh) = holder_timeout_spend_pending {
                                return Some(Balance::ClaimableAwaitingConfirmations {
                        // and awaiting confirmations on it.
                        if let Some(conf_thresh) = holder_timeout_spend_pending {
                                return Some(Balance::ClaimableAwaitingConfirmations {

-                                       claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                       amount_satoshis: htlc.amount_msat / 1000,

                                        confirmation_height: conf_thresh,
                                });
                        } else {
                                return Some(Balance::MaybeTimeoutClaimableHTLC {
                                        confirmation_height: conf_thresh,
                                });
                        } else {
                                return Some(Balance::MaybeTimeoutClaimableHTLC {

-                                       claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                       amount_satoshis: htlc.amount_msat / 1000,

                                        claimable_height: htlc.cltv_expiry,
                                        payment_hash: htlc.payment_hash,
                                });
                                        claimable_height: htlc.cltv_expiry,
                                        payment_hash: htlc.payment_hash,
                                });


@@ -1737,12 +1724,12 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
                        debug_assert!(holder_timeout_spend_pending.is_none());
                        if let Some((conf_thresh, true)) = htlc_spend_pending {
                                return Some(Balance::ClaimableAwaitingConfirmations {
                        debug_assert!(holder_timeout_spend_pending.is_none());
                        if let Some((conf_thresh, true)) = htlc_spend_pending {
                                return Some(Balance::ClaimableAwaitingConfirmations {

-                                       claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                       amount_satoshis: htlc.amount_msat / 1000,

                                        confirmation_height: conf_thresh,
                                });
                        } else {
                                return Some(Balance::ContentiousClaimable {
                                        confirmation_height: conf_thresh,
                                });
                        } else {
                                return Some(Balance::ContentiousClaimable {

-                                       claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                       amount_satoshis: htlc.amount_msat / 1000,

                                        timeout_height: htlc.cltv_expiry,
                                        payment_hash: htlc.payment_hash,
                                        payment_preimage: *payment_preimage,
                                        timeout_height: htlc.cltv_expiry,
                                        payment_hash: htlc.payment_hash,
                                        payment_preimage: *payment_preimage,


@@ -1750,7 +1737,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
                        }
                } else if htlc_resolved.is_none() {
                        return Some(Balance::MaybePreimageClaimableHTLC {
                        }
                } else if htlc_resolved.is_none() {
                        return Some(Balance::MaybePreimageClaimableHTLC {

-                               claimable_amount_satoshis: htlc.amount_msat / 1000,
+                               amount_satoshis: htlc.amount_msat / 1000,

                                expiry_height: htlc.cltv_expiry,
                                payment_hash: htlc.payment_hash,
                        });
                                expiry_height: htlc.cltv_expiry,
                                payment_hash: htlc.payment_hash,
                        });


@@ -1823,7 +1810,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                                } else { None }
                                        }) {
                                                res.push(Balance::ClaimableAwaitingConfirmations {
                                                } else { None }
                                        }) {
                                                res.push(Balance::ClaimableAwaitingConfirmations {

-                                                       claimable_amount_satoshis: value,
+                                                       amount_satoshis: value,

                                                        confirmation_height: conf_thresh,
                                                });
                                        } else {
                                                        confirmation_height: conf_thresh,
                                                });
                                        } else {


@@ -1846,7 +1833,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                                        descriptor: SpendableOutputDescriptor::StaticOutput { output, .. }
                                                } = &event.event {
                                                        res.push(Balance::ClaimableAwaitingConfirmations {
                                                        descriptor: SpendableOutputDescriptor::StaticOutput { output, .. }
                                                } = &event.event {
                                                        res.push(Balance::ClaimableAwaitingConfirmations {

-                                                               claimable_amount_satoshis: output.value,
+                                                               amount_satoshis: output.value,

                                                                confirmation_height: event.confirmation_threshold(),
                                                        });
                                                        if let Some(confirmed_to_self_idx) = confirmed_counterparty_output.map(|(idx, _)| idx) {
                                                                confirmation_height: event.confirmation_threshold(),
                                                        });
                                                        if let Some(confirmed_to_self_idx) = confirmed_counterparty_output.map(|(idx, _)| idx) {


@@ -1865,7 +1852,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                                        .is_output_spend_pending(&BitcoinOutPoint::new(txid, confirmed_to_self_idx));
                                                if output_spendable {
                                                        res.push(Balance::CounterpartyRevokedOutputClaimable {
                                                        .is_output_spend_pending(&BitcoinOutPoint::new(txid, confirmed_to_self_idx));
                                                if output_spendable {
                                                        res.push(Balance::CounterpartyRevokedOutputClaimable {

-                                                               claimable_amount_satoshis: amt,
+                                                               amount_satoshis: amt,

                                                        });
                                                }
                                        } else {
                                                        });
                                                }
                                        } else {


@@ -1878,7 +1865,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                walk_htlcs!(true, false, us.current_holder_commitment_tx.htlc_outputs.iter().map(|(a, _, _)| a));
                                if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
                                        res.push(Balance::ClaimableAwaitingConfirmations {
                                walk_htlcs!(true, false, us.current_holder_commitment_tx.htlc_outputs.iter().map(|(a, _, _)| a));
                                if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
                                        res.push(Balance::ClaimableAwaitingConfirmations {

-                                               claimable_amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat,
+                                               amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat,

                                                confirmation_height: conf_thresh,
                                        });
                                }
                                                confirmation_height: conf_thresh,
                                        });
                                }


@@ -1888,7 +1875,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                        walk_htlcs!(true, false, prev_commitment.htlc_outputs.iter().map(|(a, _, _)| a));
                                        if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
                                                res.push(Balance::ClaimableAwaitingConfirmations {
                                        walk_htlcs!(true, false, prev_commitment.htlc_outputs.iter().map(|(a, _, _)| a));
                                        if let Some(conf_thresh) = pending_commitment_tx_conf_thresh {
                                                res.push(Balance::ClaimableAwaitingConfirmations {

-                                                       claimable_amount_satoshis: prev_commitment.to_self_value_sat,
+                                                       amount_satoshis: prev_commitment.to_self_value_sat,

                                                        confirmation_height: conf_thresh,
                                                });
                                        }
                                                        confirmation_height: conf_thresh,
                                                });
                                        }


@@ -1901,7 +1888,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                        // neither us nor our counterparty misbehaved. At worst we've under-estimated
                                        // the amount we can claim as we'll punish a misbehaving counterparty.
                                        res.push(Balance::ClaimableAwaitingConfirmations {
                                        // neither us nor our counterparty misbehaved. At worst we've under-estimated
                                        // the amount we can claim as we'll punish a misbehaving counterparty.
                                        res.push(Balance::ClaimableAwaitingConfirmations {

-                                               claimable_amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat,
+                                               amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat,

                                                confirmation_height: conf_thresh,
                                        });
                                }
                                                confirmation_height: conf_thresh,
                                        });
                                }


@@ -1912,7 +1899,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                if htlc.transaction_output_index.is_none() { continue; }
                                if htlc.offered {
                                        res.push(Balance::MaybeTimeoutClaimableHTLC {
                                if htlc.transaction_output_index.is_none() { continue; }
                                if htlc.offered {
                                        res.push(Balance::MaybeTimeoutClaimableHTLC {

-                                               claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                               amount_satoshis: htlc.amount_msat / 1000,

                                                claimable_height: htlc.cltv_expiry,
                                                payment_hash: htlc.payment_hash,
                                        });
                                                claimable_height: htlc.cltv_expiry,
                                                payment_hash: htlc.payment_hash,
                                        });


@@ -1922,14 +1909,14 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                                        // As long as the HTLC is still in our latest commitment state, treat
                                        // it as potentially claimable, even if it has long-since expired.
                                        res.push(Balance::MaybePreimageClaimableHTLC {
                                        // As long as the HTLC is still in our latest commitment state, treat
                                        // it as potentially claimable, even if it has long-since expired.
                                        res.push(Balance::MaybePreimageClaimableHTLC {

-                                               claimable_amount_satoshis: htlc.amount_msat / 1000,
+                                               amount_satoshis: htlc.amount_msat / 1000,

                                                expiry_height: htlc.cltv_expiry,
                                                payment_hash: htlc.payment_hash,
                                        });
                                }
                        }
                        res.push(Balance::ClaimableOnChannelClose {
                                                expiry_height: htlc.cltv_expiry,
                                                payment_hash: htlc.payment_hash,
                                        });
                                }
                        }
                        res.push(Balance::ClaimableOnChannelClose {

-                               claimable_amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat + claimable_inbound_htlc_value_sat,
+                               amount_satoshis: us.current_holder_commitment_tx.to_self_value_sat + claimable_inbound_htlc_value_sat,

                        });
                }
 
                        });
                }
 

diff --git a/lightning/src/ln/monitor_tests.rs b/lightning/src/ln/monitor_tests.rs
index a916dbfc9e26d13cdd12e7d29ec667772d8e7dd7..47ee09396368eea64ec1d2b7f51ad95eb5ebe39c 100644 (file)
--- a/lightning/src/ln/monitor_tests.rs
+++ b/lightning/src/ln/monitor_tests.rs
@@ -171,10 +171,10 @@ fn chanmon_claim_value_coop_close() {
        let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 
        assert_eq!(vec![Balance::ClaimableOnChannelClose {
        let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 
        assert_eq!(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(&channel_type_features) / 1000
+                       amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(&channel_type_features) / 1000

                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());

-       assert_eq!(vec![Balance::ClaimableOnChannelClose { claimable_amount_satoshis: 1_000, }],
+       assert_eq!(vec![Balance::ClaimableOnChannelClose { amount_satoshis: 1_000, }],

                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 
        nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 
        nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();


@@ -206,12 +206,12 @@ fn chanmon_claim_value_coop_close() {
        assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
        assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(&channel_type_features) / 1000,
+                       amount_satoshis: 1_000_000 - 1_000 - chan_feerate * channel::commitment_tx_base_weight(&channel_type_features) / 1000,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1000,
+                       amount_satoshis: 1000,

                        confirmation_height: nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                        confirmation_height: nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());


@@ -283,33 +283,33 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
 
        let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
        let sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
 
        let remote_txn = get_local_commitment_txn!(nodes[1], chan_id);
        let sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 3_000,
+               amount_satoshis: 3_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash,
        };
        let sent_htlc_timeout_balance = Balance::MaybeTimeoutClaimableHTLC {
                claimable_height: htlc_cltv_timeout,
                payment_hash,
        };
        let sent_htlc_timeout_balance = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 4_000,
+               amount_satoshis: 4_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
        };
        let received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
                claimable_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
        };
        let received_htlc_balance = Balance::MaybePreimageClaimableHTLC {

-               claimable_amount_satoshis: 3_000,
+               amount_satoshis: 3_000,

                expiry_height: htlc_cltv_timeout,
                payment_hash,
        };
        let received_htlc_timeout_balance = Balance::MaybePreimageClaimableHTLC {
                expiry_height: htlc_cltv_timeout,
                payment_hash,
        };
        let received_htlc_timeout_balance = Balance::MaybePreimageClaimableHTLC {

-               claimable_amount_satoshis: 4_000,
+               amount_satoshis: 4_000,

                expiry_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
        };
        let received_htlc_claiming_balance = Balance::ContentiousClaimable {
                expiry_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
        };
        let received_htlc_claiming_balance = Balance::ContentiousClaimable {

-               claimable_amount_satoshis: 3_000,
+               amount_satoshis: 3_000,

                timeout_height: htlc_cltv_timeout,
                payment_hash,
                payment_preimage,
        };
        let received_htlc_timeout_claiming_balance = Balance::ContentiousClaimable {
                timeout_height: htlc_cltv_timeout,
                payment_hash,
                payment_preimage,
        };
        let received_htlc_timeout_claiming_balance = Balance::ContentiousClaimable {

-               claimable_amount_satoshis: 4_000,
+               amount_satoshis: 4_000,

                timeout_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
                payment_preimage: timeout_payment_preimage,
                timeout_height: htlc_cltv_timeout,
                payment_hash: timeout_payment_hash,
                payment_preimage: timeout_payment_preimage,


@@ -318,12 +318,12 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        // Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
        // as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
        // Before B receives the payment preimage, it only suggests the push_msat value of 1_000 sats
        // as claimable. A lists both its to-self balance and the (possibly-claimable) HTLCs.
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }, received_htlc_balance.clone(), received_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }, received_htlc_balance.clone(), received_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -360,7 +360,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        // Once B has received the payment preimage, it includes the value of the HTLC in its
        // "claimable if you were to close the channel" balance.
        let mut a_expected_balances = vec![Balance::ClaimableOnChannelClose {
        // Once B has received the payment preimage, it includes the value of the HTLC in its
        // "claimable if you were to close the channel" balance.
        let mut a_expected_balances = vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000_000 - // Channel funding value in satoshis
+                       amount_satoshis: 1_000_000 - // Channel funding value in satoshis

                                4_000 - // The to-be-failed HTLC value in satoshis
                                3_000 - // The claimed HTLC value in satoshis
                                1_000 - // The push_msat value in satoshis
                                4_000 - // The to-be-failed HTLC value in satoshis
                                3_000 - // The claimed HTLC value in satoshis
                                1_000 - // The push_msat value in satoshis


@@ -376,7 +376,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        assert_eq!(sorted_vec(a_expected_balances),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(vec![Balance::ClaimableOnChannelClose {
        assert_eq!(sorted_vec(a_expected_balances),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000 + 3_000 + 4_000,
+                       amount_satoshis: 1_000 + 3_000 + 4_000,

                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 
                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
 


@@ -415,7 +415,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 3_000 - 4_000 - 1_000 - 3 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }, sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),


@@ -423,7 +423,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        // The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
        // CSV delay, not ANTI_REORG_DELAY.
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        // The main non-HTLC balance is just awaiting confirmations, but the claimable height is the
        // CSV delay, not ANTI_REORG_DELAY.
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                        confirmation_height: node_b_commitment_claimable,
                },
                // Both HTLC balances are "contentious" as our counterparty could claim them if we wait too
                        confirmation_height: node_b_commitment_claimable,
                },
                // Both HTLC balances are "contentious" as our counterparty could claim them if we wait too


@@ -440,7 +440,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        assert_eq!(sorted_vec(vec![sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        assert_eq!(sorted_vec(vec![sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                        confirmation_height: node_b_commitment_claimable,
                }, received_htlc_claiming_balance.clone(), received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_b_commitment_claimable,
                }, received_htlc_claiming_balance.clone(), received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -481,7 +481,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        mine_transaction(&nodes[0], &a_broadcast_txn[1]);
        assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
        mine_transaction(&nodes[0], &a_broadcast_txn[1]);
        assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());


@@ -501,10 +501,10 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        mine_transaction(&nodes[1], &b_broadcast_txn[0]);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        mine_transaction(&nodes[1], &b_broadcast_txn[0]);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                        confirmation_height: node_b_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: node_b_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                        confirmation_height: node_b_htlc_claimable,
                }, received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_b_htlc_claimable,
                }, received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -515,7 +515,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        test_spendable_output(&nodes[1], &remote_txn[0]);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        test_spendable_output(&nodes[1], &remote_txn[0]);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                        confirmation_height: node_b_htlc_claimable,
                }, received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_b_htlc_claimable,
                }, received_htlc_timeout_claiming_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -624,18 +624,18 @@ fn test_balances_on_local_commitment_htlcs() {
        check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
 
        let htlc_balance_known_preimage = Balance::MaybeTimeoutClaimableHTLC {
        check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed);
 
        let htlc_balance_known_preimage = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 10_000,
+               amount_satoshis: 10_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash,
        };
        let htlc_balance_unknown_preimage = Balance::MaybeTimeoutClaimableHTLC {
                claimable_height: htlc_cltv_timeout,
                payment_hash,
        };
        let htlc_balance_unknown_preimage = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 20_000,
+               amount_satoshis: 20_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash: payment_hash_2,
        };
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                claimable_height: htlc_cltv_timeout,
                payment_hash: payment_hash_2,
        };
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),


@@ -654,7 +654,7 @@ fn test_balances_on_local_commitment_htlcs() {
        // transaction.
        connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        // transaction.
        connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, htlc_balance_known_preimage.clone(), htlc_balance_unknown_preimage.clone()]),


@@ -669,11 +669,11 @@ fn test_balances_on_local_commitment_htlcs() {
        // balance) check failed. With this check removed, the code panicked in the `connect_blocks`
        // call, as described, two hunks down.
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        // balance) check failed. With this check removed, the code panicked in the `connect_blocks`
        // call, as described, two hunks down.
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: node_a_htlc_claimable,
                }, htlc_balance_unknown_preimage.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_a_htlc_claimable,
                }, htlc_balance_unknown_preimage.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -683,11 +683,11 @@ fn test_balances_on_local_commitment_htlcs() {
        mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
        expect_payment_sent!(nodes[0], payment_preimage_2);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
        expect_payment_sent!(nodes[0], payment_preimage_2);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: node_a_htlc_claimable,
                }, htlc_balance_unknown_preimage.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_a_htlc_claimable,
                }, htlc_balance_unknown_preimage.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -699,11 +699,11 @@ fn test_balances_on_local_commitment_htlcs() {
        expect_payment_failed!(nodes[0], payment_hash, false);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        expect_payment_failed!(nodes[0], payment_hash, false);
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: node_a_htlc_claimable,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: node_a_htlc_claimable,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -712,7 +712,7 @@ fn test_balances_on_local_commitment_htlcs() {
        // `SpendableOutputs` event and removing the claimable balance entry.
        connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
        // `SpendableOutputs` event and removing the claimable balance entry.
        connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: node_a_htlc_claimable,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                        confirmation_height: node_a_htlc_claimable,
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());


@@ -754,22 +754,22 @@ fn test_no_preimage_inbound_htlc_balances() {
        let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 
        let a_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
        let channel_type_features = get_channel_type_features!(nodes[0], nodes[1], chan_id);
 
        let a_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 10_000,
+               amount_satoshis: 10_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash: to_b_failed_payment_hash,
        };
        let a_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
                claimable_height: htlc_cltv_timeout,
                payment_hash: to_b_failed_payment_hash,
        };
        let a_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {

-               claimable_amount_satoshis: 20_000,
+               amount_satoshis: 20_000,

                expiry_height: htlc_cltv_timeout,
                payment_hash: to_a_failed_payment_hash,
        };
        let b_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {
                expiry_height: htlc_cltv_timeout,
                payment_hash: to_a_failed_payment_hash,
        };
        let b_received_htlc_balance = Balance::MaybePreimageClaimableHTLC {

-               claimable_amount_satoshis: 10_000,
+               amount_satoshis: 10_000,

                expiry_height: htlc_cltv_timeout,
                payment_hash: to_b_failed_payment_hash,
        };
        let b_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {
                expiry_height: htlc_cltv_timeout,
                payment_hash: to_b_failed_payment_hash,
        };
        let b_sent_htlc_balance = Balance::MaybeTimeoutClaimableHTLC {

-               claimable_amount_satoshis: 20_000,
+               amount_satoshis: 20_000,

                claimable_height: htlc_cltv_timeout,
                payment_hash: to_a_failed_payment_hash,
        };
                claimable_height: htlc_cltv_timeout,
                payment_hash: to_a_failed_payment_hash,
        };


@@ -779,13 +779,13 @@ fn test_no_preimage_inbound_htlc_balances() {
        // HTLC output is spent.
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
        // HTLC output is spent.
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 500_000 - 20_000,
+                       amount_satoshis: 500_000 - 20_000,

                }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -799,7 +799,7 @@ fn test_no_preimage_inbound_htlc_balances() {
        // claimable balances remain the same except for the non-HTLC balance changing variant.
        let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
        let as_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        // claimable balances remain the same except for the non-HTLC balance changing variant.
        let node_a_commitment_claimable = nodes[0].best_block_info().1 + BREAKDOWN_TIMEOUT as u32;
        let as_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]);
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), a_sent_htlc_balance.clone()]);


@@ -820,7 +820,7 @@ fn test_no_preimage_inbound_htlc_balances() {
 
        let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
        let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 
        let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
        let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 500_000 - 20_000,
+                       amount_satoshis: 500_000 - 20_000,

                        confirmation_height: node_b_commitment_claimable,
                }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]);
        assert_eq!(bs_pre_spend_claims,
                        confirmation_height: node_b_commitment_claimable,
                }, b_received_htlc_balance.clone(), b_sent_htlc_balance.clone()]);
        assert_eq!(bs_pre_spend_claims,


@@ -871,22 +871,22 @@ fn test_no_preimage_inbound_htlc_balances() {
        mine_transaction(&nodes[0], &as_htlc_timeout_claim[0]);
        let as_timeout_claimable_height = nodes[0].best_block_info().1 + (BREAKDOWN_TIMEOUT as u32) - 1;
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
        mine_transaction(&nodes[0], &as_htlc_timeout_claim[0]);
        let as_timeout_claimable_height = nodes[0].best_block_info().1 + (BREAKDOWN_TIMEOUT as u32) - 1;
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: as_timeout_claimable_height,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[0], &bs_htlc_timeout_claim[0]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: as_timeout_claimable_height,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[0], &bs_htlc_timeout_claim[0]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, a_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: as_timeout_claimable_height,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: as_timeout_claimable_height,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -898,18 +898,18 @@ fn test_no_preimage_inbound_htlc_balances() {
 
        connect_blocks(&nodes[0], 1);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
 
        connect_blocks(&nodes[0], 1);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 500_000 - 10_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: node_a_commitment_claimable,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        connect_blocks(&nodes[0], node_a_commitment_claimable - nodes[0].best_block_info().1);
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                        confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                        confirmation_height: core::cmp::max(as_timeout_claimable_height, htlc_cltv_timeout),
                }],
                nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());


@@ -924,14 +924,14 @@ fn test_no_preimage_inbound_htlc_balances() {
        mine_transaction(&nodes[1], &bs_htlc_timeout_claim[0]);
        let bs_timeout_claimable_height = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
        assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
        mine_transaction(&nodes[1], &bs_htlc_timeout_claim[0]);
        let bs_timeout_claimable_height = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
        assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 20_000,
+                       amount_satoshis: 20_000,

                        confirmation_height: bs_timeout_claimable_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[1], &as_htlc_timeout_claim[0]);
        assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: bs_timeout_claimable_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[1], &as_htlc_timeout_claim[0]);
        assert_eq!(sorted_vec(vec![b_received_htlc_balance.clone(), Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 20_000,
+                       amount_satoshis: 20_000,

                        confirmation_height: bs_timeout_claimable_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: bs_timeout_claimable_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1058,17 +1058,17 @@ fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bo
        // Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
        // lists the two on-chain timeout-able HTLCs as claimable balances.
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
        // Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
        // lists the two on-chain timeout-able HTLCs as claimable balances.
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3 - 2_000 + 3_000,
+                       amount_satoshis: 100_000 - 5_000 - 4_000 - 3 - 2_000 + 3_000,

                }, Balance::MaybeTimeoutClaimableHTLC {
                }, Balance::MaybeTimeoutClaimableHTLC {

-                       claimable_amount_satoshis: 2_000,
+                       amount_satoshis: 2_000,

                        claimable_height: missing_htlc_cltv_timeout,
                        payment_hash: missing_htlc_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {
                        claimable_height: missing_htlc_cltv_timeout,
                        payment_hash: missing_htlc_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                        claimable_height: htlc_cltv_timeout,
                        payment_hash: timeout_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {
                        claimable_height: htlc_cltv_timeout,
                        payment_hash: timeout_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {

-                       claimable_amount_satoshis: 5_000,
+                       amount_satoshis: 5_000,

                        claimable_height: live_htlc_cltv_timeout,
                        payment_hash: live_payment_hash,
                }]),
                        claimable_height: live_htlc_cltv_timeout,
                        payment_hash: live_payment_hash,
                }]),


@@ -1097,21 +1097,21 @@ fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bo
        // claim balances separated out.
        let expected_balance = vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment
        // claim balances separated out.
        let expected_balance = vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment

-                       claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
+                       amount_satoshis: 100_000 - 5_000 - 4_000 - 3,

                        confirmation_height: nodes[1].best_block_info().1 + 5,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        confirmation_height: nodes[1].best_block_info().1 + 5,
                }, Balance::CounterpartyRevokedOutputClaimable {

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                }, Balance::CounterpartyRevokedOutputClaimable {
                }, Balance::CounterpartyRevokedOutputClaimable {

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }];
 
        let to_self_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
                }];
 
        let to_self_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {

-               claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
+               amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *

                        (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
        };
        let to_self_claimed_avail_height;
        let largest_htlc_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {
                        (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
        };
        let to_self_claimed_avail_height;
        let largest_htlc_unclaimed_balance = Balance::CounterpartyRevokedOutputClaimable {

-               claimable_amount_satoshis: 5_000,
+               amount_satoshis: 5_000,

        };
        let largest_htlc_claimed_avail_height;
 
        };
        let largest_htlc_claimed_avail_height;
 


@@ -1132,11 +1132,11 @@ fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bo
        }
 
        let largest_htlc_claimed_balance = Balance::ClaimableAwaitingConfirmations {
        }
 
        let largest_htlc_claimed_balance = Balance::ClaimableAwaitingConfirmations {

-               claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
+               amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,

                confirmation_height: largest_htlc_claimed_avail_height,
        };
        let to_self_claimed_balance = Balance::ClaimableAwaitingConfirmations {
                confirmation_height: largest_htlc_claimed_avail_height,
        };
        let to_self_claimed_balance = Balance::ClaimableAwaitingConfirmations {

-               claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
+               amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *

                        (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
                        - chan_feerate * claim_txn[3].weight() as u64 / 1000,
                confirmation_height: to_self_claimed_avail_height,
                        (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
                        - chan_feerate * claim_txn[3].weight() as u64 / 1000,
                confirmation_height: to_self_claimed_avail_height,


@@ -1165,21 +1165,21 @@ fn do_test_revoked_counterparty_commitment_balances(confirm_htlc_spend_first: bo
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment

-                       claimable_amount_satoshis: 100_000 - 5_000 - 4_000 - 3,
+                       amount_satoshis: 100_000 - 5_000 - 4_000 - 3,

                        confirmation_height: nodes[1].best_block_info().1 + 1,
                }, Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: nodes[1].best_block_info().1 + 1,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - 3_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
                                - chan_feerate * claim_txn[3].weight() as u64 / 1000,
                        confirmation_height: to_self_claimed_avail_height,
                }, Balance::ClaimableAwaitingConfirmations {
                                (channel::commitment_tx_base_weight(&channel_type_features) + 3 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
                                - chan_feerate * claim_txn[3].weight() as u64 / 1000,
                        confirmation_height: to_self_claimed_avail_height,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 3_000 - chan_feerate * OUTBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
+                       amount_satoshis: 3_000 - chan_feerate * OUTBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,

                        confirmation_height: nodes[1].best_block_info().1 + 4,
                }, Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: nodes[1].best_block_info().1 + 4,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 4_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
+                       amount_satoshis: 4_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,

                        confirmation_height: nodes[1].best_block_info().1 + 5,
                }, Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: nodes[1].best_block_info().1 + 5,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,
+                       amount_satoshis: 5_000 - chan_feerate * INBOUND_HTLC_CLAIM_EXP_WEIGHT as u64 / 1000,

                        confirmation_height: largest_htlc_claimed_avail_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: largest_htlc_claimed_avail_height,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1294,16 +1294,16 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        // `CounterpartyRevokedOutputClaimable` entry doesn't change.
        let as_balances = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in B's revoked commitment
        // `CounterpartyRevokedOutputClaimable` entry doesn't change.
        let as_balances = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in B's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: to_remote_conf_height,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: to_remote_conf_height,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }]);
        assert_eq!(as_balances,
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                }]);
        assert_eq!(as_balances,
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1325,16 +1325,16 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        mine_transaction(&nodes[0], &as_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in B's revoked commitment
        mine_transaction(&nodes[0], &as_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in B's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 11_000 - 3_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: to_remote_conf_height,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                        confirmation_height: to_remote_conf_height,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }, Balance::ClaimableAwaitingConfirmations {
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
+                       amount_satoshis: as_htlc_claim_tx[0].output[0].value,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1343,11 +1343,11 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        test_spendable_output(&nodes[0], &revoked_local_txn[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output to B
        test_spendable_output(&nodes[0], &revoked_local_txn[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output to B

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }, Balance::ClaimableAwaitingConfirmations {
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: as_htlc_claim_tx[0].output[0].value,
+                       amount_satoshis: as_htlc_claim_tx[0].output[0].value,

                        confirmation_height: nodes[0].best_block_info().1 + 2,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: nodes[0].best_block_info().1 + 2,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1356,9 +1356,9 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        test_spendable_output(&nodes[0], &as_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment
        test_spendable_output(&nodes[0], &as_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -1392,18 +1392,18 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment
        connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 1_000,
+                       amount_satoshis: 1_000,

                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[0], &as_second_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
        mine_transaction(&nodes[0], &as_second_htlc_claim_tx[0]);
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: 10_000,
+                       amount_satoshis: 10_000,

                }, Balance::ClaimableAwaitingConfirmations {
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
+                       amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1411,10 +1411,10 @@ fn test_revoked_counterparty_htlc_tx_balances() {
        mine_transaction(&nodes[0], &as_second_htlc_claim_tx[1]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_self output in B's revoked commitment
        mine_transaction(&nodes[0], &as_second_htlc_claim_tx[1]);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_self output in B's revoked commitment

-                       claimable_amount_satoshis: as_second_htlc_claim_tx[1].output[0].value,
+                       amount_satoshis: as_second_htlc_claim_tx[1].output[0].value,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }, Balance::ClaimableAwaitingConfirmations {
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1,
                }, Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,
+                       amount_satoshis: as_second_htlc_claim_tx[0].output[0].value,

                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 2,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 2,
                }]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1495,13 +1495,13 @@ fn test_revoked_counterparty_aggregated_claims() {
        let _a_htlc_msgs = get_htlc_update_msgs!(&nodes[0], nodes[1].node.get_our_node_id());
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {
        let _a_htlc_msgs = get_htlc_update_msgs!(&nodes[0], nodes[1].node.get_our_node_id());
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableOnChannelClose {

-                       claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
+                       amount_satoshis: 100_000 - 4_000 - 3_000,

                }, Balance::MaybeTimeoutClaimableHTLC {
                }, Balance::MaybeTimeoutClaimableHTLC {

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                        claimable_height: htlc_cltv_timeout,
                        payment_hash: revoked_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {
                        claimable_height: htlc_cltv_timeout,
                        payment_hash: revoked_payment_hash,
                }, Balance::MaybeTimeoutClaimableHTLC {

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                        claimable_height: htlc_cltv_timeout,
                        payment_hash: claimed_payment_hash,
                }]),
                        claimable_height: htlc_cltv_timeout,
                        payment_hash: claimed_payment_hash,
                }]),


@@ -1522,16 +1522,16 @@ fn test_revoked_counterparty_aggregated_claims() {
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment

-                       claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
+                       amount_satoshis: 100_000 - 4_000 - 3_000,

                        confirmation_height: to_remote_maturity,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment
                        confirmation_height: to_remote_maturity,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -1551,19 +1551,19 @@ fn test_revoked_counterparty_aggregated_claims() {
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        // to_remote output in A's revoked commitment

-                       claimable_amount_satoshis: 100_000 - 4_000 - 3_000,
+                       amount_satoshis: 100_000 - 4_000 - 3_000,

                        confirmation_height: to_remote_maturity,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment
                        confirmation_height: to_remote_maturity,
                }, Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                        // The amount here is a bit of a misnomer, really its been reduced by the HTLC
                        // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
                        // anyway, so its not a big change.
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                        // The amount here is a bit of a misnomer, really its been reduced by the HTLC
                        // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
                        // anyway, so its not a big change.

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -1572,15 +1572,15 @@ fn test_revoked_counterparty_aggregated_claims() {
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                        // The amount here is a bit of a misnomer, really its been reduced by the HTLC
                        // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
                        // anyway, so its not a big change.
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 2
                        // The amount here is a bit of a misnomer, really its been reduced by the HTLC
                        // transaction fee, but the claimable amount is always a bit of an overshoot for HTLCs
                        // anyway, so its not a big change.

-                       claimable_amount_satoshis: 3_000,
+                       amount_satoshis: 3_000,

                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -1589,12 +1589,12 @@ fn test_revoked_counterparty_aggregated_claims() {
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }, Balance::ClaimableAwaitingConfirmations { // HTLC 2
                }, Balance::ClaimableAwaitingConfirmations { // HTLC 2

-                       claimable_amount_satoshis: claim_txn_2[1].output[0].value,
+                       amount_satoshis: claim_txn_2[1].output[0].value,

                        confirmation_height: htlc_2_claim_maturity,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
                        confirmation_height: htlc_2_claim_maturity,
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));


@@ -1604,10 +1604,10 @@ fn test_revoked_counterparty_aggregated_claims() {
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment
 
        assert_eq!(sorted_vec(vec![Balance::CounterpartyRevokedOutputClaimable {
                        // to_self output in A's revoked commitment

-                       claimable_amount_satoshis: 1_000_000 - 100_000 - chan_feerate *
+                       amount_satoshis: 1_000_000 - 100_000 - chan_feerate *

                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
                }, Balance::CounterpartyRevokedOutputClaimable { // HTLC 1

-                       claimable_amount_satoshis: 4_000,
+                       amount_satoshis: 4_000,

                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 
                }]),
                sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
 


@@ -1615,7 +1615,7 @@ fn test_revoked_counterparty_aggregated_claims() {
        let rest_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
 
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {
        let rest_claim_maturity = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
 
        assert_eq!(vec![Balance::ClaimableAwaitingConfirmations {

-                       claimable_amount_satoshis: claim_txn_2[0].output[0].value,
+                       amount_satoshis: claim_txn_2[0].output[0].value,

                        confirmation_height: rest_claim_maturity,
                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());
                        confirmation_height: rest_claim_maturity,
                }],
                nodes[1].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances());