Update weight units to be u64

Author: wpaulino

lightning/src/chain/channelmonitor.rs

@@ -4781,7 +4781,7 @@ mod tests {
 				let sig = secp_ctx.sign_ecdsa(&sighash, &privkey);
 				let mut ser_sig = sig.serialize_der().to_vec();
 				ser_sig.push(EcdsaSighashType::All as u8);
-				$sum_actual_sigs += ser_sig.len();
+				$sum_actual_sigs += ser_sig.len() as u64;
 				let witness = $sighash_parts.witness_mut($idx).unwrap();
 				witness.push(ser_sig);
 				if *$weight == WEIGHT_REVOKED_OUTPUT {
@@ -4823,7 +4823,7 @@ mod tests {
 				script_pubkey: script_pubkey.clone(),
 				value: 0,
 			});
-			let base_weight = claim_tx.weight();
+			let base_weight = claim_tx.weight().to_wu();
 			let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT, weight_revoked_offered_htlc(channel_type_features), weight_revoked_offered_htlc(channel_type_features), weight_revoked_received_htlc(channel_type_features)];
 			let mut inputs_total_weight = 2; // count segwit flags
 			{
@@ -4833,7 +4833,7 @@ mod tests {
 					inputs_total_weight += inp;
 				}
 			}
-			assert_eq!(base_weight + inputs_total_weight as usize,  claim_tx.weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs));
+			assert_eq!(base_weight + inputs_total_weight, claim_tx.weight().to_wu() + /* max_length_sig */ (73 * inputs_weight.len() as u64 - sum_actual_sigs));
 		}
 
 		// Claim tx with 1 offered HTLCs, 3 received HTLCs
@@ -4855,7 +4855,7 @@ mod tests {
 				script_pubkey: script_pubkey.clone(),
 				value: 0,
 			});
-			let base_weight = claim_tx.weight();
+			let base_weight = claim_tx.weight().to_wu();
 			let inputs_weight = vec![weight_offered_htlc(channel_type_features), weight_received_htlc(channel_type_features), weight_received_htlc(channel_type_features), weight_received_htlc(channel_type_features)];
 			let mut inputs_total_weight = 2; // count segwit flags
 			{
@@ -4865,7 +4865,7 @@ mod tests {
 					inputs_total_weight += inp;
 				}
 			}
-			assert_eq!(base_weight + inputs_total_weight as usize,  claim_tx.weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs));
+			assert_eq!(base_weight + inputs_total_weight, claim_tx.weight().to_wu() + /* max_length_sig */ (73 * inputs_weight.len() as u64 - sum_actual_sigs));
 		}
 
 		// Justice tx with 1 revoked HTLC-Success tx output
@@ -4885,7 +4885,7 @@ mod tests {
 				script_pubkey: script_pubkey.clone(),
 				value: 0,
 			});
-			let base_weight = claim_tx.weight();
+			let base_weight = claim_tx.weight().to_wu();
 			let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT];
 			let mut inputs_total_weight = 2; // count segwit flags
 			{
@@ -4895,7 +4895,7 @@ mod tests {
 					inputs_total_weight += inp;
 				}
 			}
-			assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.weight() + /* max_length_isg */ (73 * inputs_weight.len() - sum_actual_sigs));
+			assert_eq!(base_weight + inputs_total_weight, claim_tx.weight().to_wu() + /* max_length_isg */ (73 * inputs_weight.len() as u64 - sum_actual_sigs));
 		}
 	}
 

lightning/src/chain/onchaintx.rs

@@ -608,7 +608,7 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
 					cur_height, self, output_value, self.destination_script.clone(), logger
 				).unwrap();
 				log_trace!(logger, "...with timer {} and feerate {}", new_timer, new_feerate);
-				assert!(predicted_weight >= transaction.weight());
+				assert!(predicted_weight >= transaction.weight().to_wu());
 				return Some((new_timer, new_feerate, OnchainClaim::Tx(transaction)));
 			}
 		} else {
@@ -637,7 +637,7 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
 					if let Some(input_amount_sat) = output.funding_amount {
 						let fee_sat = input_amount_sat - tx.output.iter().map(|output| output.value).sum::<u64>();
 						let commitment_tx_feerate_sat_per_1000_weight =
-							compute_feerate_sat_per_1000_weight(fee_sat, tx.weight() as u64);
+							compute_feerate_sat_per_1000_weight(fee_sat, tx.weight().to_wu());
 						if commitment_tx_feerate_sat_per_1000_weight >= package_target_feerate_sat_per_1000_weight {
 							log_debug!(logger, "Pre-signed {} already has feerate {} sat/kW above required {} sat/kW",
 								log_tx!(tx), commitment_tx_feerate_sat_per_1000_weight,

lightning/src/chain/package.rs

@@ -876,7 +876,7 @@ impl PackageTemplate {
 
 		locktime
 	}
-	pub(crate) fn package_weight(&self, destination_script: &Script) -> usize {
+	pub(crate) fn package_weight(&self, destination_script: &Script) -> u64 {
 		let mut inputs_weight = 0;
 		let mut witnesses_weight = 2; // count segwit flags
 		for (_, outp) in self.inputs.iter() {
@@ -888,7 +888,7 @@ impl PackageTemplate {
 		let transaction_weight = 10 * WITNESS_SCALE_FACTOR;
 		// value: 8 bytes ; var_int: 1 byte ; pk_script: `destination_script.len()`
 		let output_weight = (8 + 1 + destination_script.len()) * WITNESS_SCALE_FACTOR;
-		inputs_weight + witnesses_weight + transaction_weight + output_weight
+		(inputs_weight + witnesses_weight + transaction_weight + output_weight) as u64
 	}
 	pub(crate) fn construct_malleable_package_with_external_funding<Signer: WriteableEcdsaChannelSigner>(
 		&self, onchain_handler: &mut OnchainTxHandler<Signer>,
@@ -963,7 +963,7 @@ impl PackageTemplate {
 	/// which was used to generate the value. Will not return less than `dust_limit_sats` for the
 	/// value.
 	pub(crate) fn compute_package_output<F: Deref, L: Deref>(
-		&self, predicted_weight: usize, dust_limit_sats: u64, force_feerate_bump: bool,
+		&self, predicted_weight: u64, dust_limit_sats: u64, force_feerate_bump: bool,
 		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
 	) -> Option<(u64, u64)>
 	where
@@ -1111,21 +1111,21 @@ impl Readable for PackageTemplate {
 ///
 /// [`OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep
 /// [`FEERATE_FLOOR_SATS_PER_KW`]: crate::chain::chaininterface::MIN_RELAY_FEE_SAT_PER_1000_WEIGHT
-fn compute_fee_from_spent_amounts<F: Deref, L: Deref>(input_amounts: u64, predicted_weight: usize, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L) -> Option<(u64, u64)>
+fn compute_fee_from_spent_amounts<F: Deref, L: Deref>(input_amounts: u64, predicted_weight: u64, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L) -> Option<(u64, u64)>
 	where F::Target: FeeEstimator,
 	      L::Target: Logger,
 {
 	let sweep_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::OnChainSweep);
-	let fee_rate = cmp::min(sweep_feerate, compute_feerate_sat_per_1000_weight(input_amounts / 2, predicted_weight as u64)) as u64;
-	let fee = fee_rate * (predicted_weight as u64) / 1000;
+	let fee_rate = cmp::min(sweep_feerate, compute_feerate_sat_per_1000_weight(input_amounts / 2, predicted_weight));
+	let fee = fee_rate as u64 * (predicted_weight) / 1000;
 
 	// if the fee rate is below the floor, we don't sweep
-	if fee_rate < FEERATE_FLOOR_SATS_PER_KW as u64 {
+	if fee_rate < FEERATE_FLOOR_SATS_PER_KW {
 		log_error!(logger, "Failed to generate an on-chain tx with fee ({} sat/kw) was less than the floor ({} sat/kw)",
 					fee_rate, FEERATE_FLOOR_SATS_PER_KW);
 		None
 	} else {
-		Some((fee, fee_rate))
+		Some((fee, fee_rate as u64))
 	}
 }
 
@@ -1136,7 +1136,7 @@ fn compute_fee_from_spent_amounts<F: Deref, L: Deref>(input_amounts: u64, predic
 /// verify that those bumping heuristics respect BIP125 rules 3) and 4) and if required adjust the
 /// new fee to meet the RBF policy requirement.
 fn feerate_bump<F: Deref, L: Deref>(
-	predicted_weight: usize, input_amounts: u64, previous_feerate: u64, force_feerate_bump: bool,
+	predicted_weight: u64, input_amounts: u64, previous_feerate: u64, force_feerate_bump: bool,
 	fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
 ) -> Option<(u64, u64)>
 where
@@ -1148,12 +1148,12 @@ where
 		if new_feerate > previous_feerate {
 			(new_fee, new_feerate)
 		} else if !force_feerate_bump {
-			let previous_fee = previous_feerate * (predicted_weight as u64) / 1000;
+			let previous_fee = previous_feerate * predicted_weight / 1000;
 			(previous_fee, previous_feerate)
 		} else {
 			// ...else just increase the previous feerate by 25% (because that's a nice number)
 			let bumped_feerate = previous_feerate + (previous_feerate / 4);
-			let bumped_fee = bumped_feerate * (predicted_weight as u64) / 1000;
+			let bumped_fee = bumped_feerate * predicted_weight / 1000;
 			if input_amounts <= bumped_fee {
 				log_warn!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts);
 				return None;
@@ -1172,8 +1172,8 @@ where
 		return Some((new_fee, new_feerate));
 	}
 
-	let previous_fee = previous_feerate * (predicted_weight as u64) / 1000;
-	let min_relay_fee = MIN_RELAY_FEE_SAT_PER_1000_WEIGHT * (predicted_weight as u64) / 1000;
+	let previous_fee = previous_feerate * predicted_weight / 1000;
+	let min_relay_fee = MIN_RELAY_FEE_SAT_PER_1000_WEIGHT * predicted_weight / 1000;
 	// BIP 125 Opt-in Full Replace-by-Fee Signaling
 	// 	* 3. The replacement transaction pays an absolute fee of at least the sum paid by the original transactions.
 	//	* 4. The replacement transaction must also pay for its own bandwidth at or above the rate set by the node's minimum relay fee setting.
@@ -1182,7 +1182,7 @@ where
 	} else {
 		new_fee
 	};
-	Some((new_fee, new_fee * 1000 / (predicted_weight as u64)))
+	Some((new_fee, new_fee * 1000 / predicted_weight))
 }
 
 #[cfg(test)]
@@ -1402,27 +1402,27 @@ mod tests {
 		let secp_ctx = Secp256k1::new();
 
 		// (nVersion (4) + nLocktime (4) + count_tx_in (1) + prevout (36) + sequence (4) + script_length (1) + count_tx_out (1) + value (8) + var_int (1)) * WITNESS_SCALE_FACTOR + witness marker (2)
-		let weight_sans_output = (4 + 4 + 1 + 36 + 4 + 1 + 1 + 8 + 1) * WITNESS_SCALE_FACTOR + 2;
+		let weight_sans_output = (4 + 4 + 1 + 36 + 4 + 1 + 1 + 8 + 1) * WITNESS_SCALE_FACTOR as u64 + 2;
 
 		{
 			let revk_outp = dumb_revk_output!(secp_ctx, false);
 			let package = PackageTemplate::build_package(txid, 0, revk_outp, 0, 100);
-			assert_eq!(package.package_weight(&Script::new()),  weight_sans_output + WEIGHT_REVOKED_OUTPUT as usize);
+			assert_eq!(package.package_weight(&Script::new()),  weight_sans_output + WEIGHT_REVOKED_OUTPUT);
 		}
 
 		{
 			for channel_type_features in [ChannelTypeFeatures::only_static_remote_key(), ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies()].iter() {
 				let counterparty_outp = dumb_counterparty_output!(secp_ctx, 1_000_000, channel_type_features.clone());
 				let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, 100);
-				assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_received_htlc(channel_type_features) as usize);
+				assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_received_htlc(channel_type_features));
 			}
 		}
 
 		{
 			for channel_type_features in [ChannelTypeFeatures::only_static_remote_key(), ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies()].iter() {
 				let counterparty_outp = dumb_counterparty_offered_output!(secp_ctx, 1_000_000, channel_type_features.clone());
 				let package = PackageTemplate::build_package(txid, 0, counterparty_outp, 1000, 100);
-				assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_offered_htlc(channel_type_features) as usize);
+				assert_eq!(package.package_weight(&Script::new()), weight_sans_output + weight_offered_htlc(channel_type_features));
 			}
 		}
 	}

lightning/src/events/bump_transaction.rs

@@ -409,7 +409,7 @@ where
 				}
 			}
 			let fee_to_spend_utxo = fee_for_weight(
-				target_feerate_sat_per_1000_weight, BASE_INPUT_WEIGHT as u64 + utxo.satisfaction_weight,
+				target_feerate_sat_per_1000_weight, BASE_INPUT_WEIGHT + utxo.satisfaction_weight,
 			);
 			let should_spend = if tolerate_high_network_feerates {
 				utxo.output.value > fee_to_spend_utxo
@@ -588,7 +588,7 @@ where
 		let must_spend = vec![Input {
 			outpoint: anchor_descriptor.outpoint,
 			previous_utxo: anchor_utxo,
-			satisfaction_weight: commitment_tx.weight() as u64 + ANCHOR_INPUT_WITNESS_WEIGHT + EMPTY_SCRIPT_SIG_WEIGHT,
+			satisfaction_weight: commitment_tx.weight().to_wu() + ANCHOR_INPUT_WITNESS_WEIGHT + EMPTY_SCRIPT_SIG_WEIGHT,
 		}];
 		#[cfg(debug_assertions)]
 		let must_spend_amount =	must_spend.iter().map(|input| input.previous_utxo.value).sum::<u64>();
@@ -618,7 +618,7 @@ where
 
 		debug_assert_eq!(anchor_tx.output.len(), 1);
 		#[cfg(debug_assertions)]
-		let unsigned_tx_weight = anchor_tx.weight() as u64 - (anchor_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT);
+		let unsigned_tx_weight = anchor_tx.weight().to_wu() - (anchor_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT);
 
 		log_debug!(self.logger, "Signing anchor transaction {}", anchor_txid);
 		anchor_tx = self.utxo_source.sign_tx(anchor_tx)?;
@@ -628,15 +628,15 @@ where
 		anchor_tx.input[0].witness = anchor_descriptor.tx_input_witness(&anchor_sig);
 
 		#[cfg(debug_assertions)] {
-			let signed_tx_weight = anchor_tx.weight() as u64;
+			let signed_tx_weight = anchor_tx.weight().to_wu();
 			let expected_signed_tx_weight = unsigned_tx_weight + total_satisfaction_weight;
 			// Our estimate should be within a 1% error margin of the actual weight and we should
 			// never underestimate.
 			assert!(expected_signed_tx_weight >= signed_tx_weight &&
 				expected_signed_tx_weight - (expected_signed_tx_weight / 100) <= signed_tx_weight);
 
 			let expected_package_fee = fee_for_weight(package_target_feerate_sat_per_1000_weight,
-				signed_tx_weight + commitment_tx.weight() as u64);
+				signed_tx_weight + commitment_tx.weight().to_wu());
 			let package_fee = total_input_amount -
 				anchor_tx.output.iter().map(|output| output.value).sum::<u64>();
 			// Our fee should be within a 5% error margin of the expected fee based on the
@@ -704,7 +704,7 @@ where
 		self.process_coin_selection(&mut htlc_tx, coin_selection);
 
 		#[cfg(debug_assertions)]
-		let unsigned_tx_weight = htlc_tx.weight() as u64 - (htlc_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT);
+		let unsigned_tx_weight = htlc_tx.weight().to_wu() - (htlc_tx.input.len() as u64 * EMPTY_SCRIPT_SIG_WEIGHT);
 
 		log_debug!(self.logger, "Signing HTLC transaction {}", htlc_tx.txid());
 		htlc_tx = self.utxo_source.sign_tx(htlc_tx)?;
@@ -719,7 +719,7 @@ where
 		}
 
 		#[cfg(debug_assertions)] {
-			let signed_tx_weight = htlc_tx.weight() as u64;
+			let signed_tx_weight = htlc_tx.weight().to_wu();
 			let expected_signed_tx_weight = unsigned_tx_weight + total_satisfaction_weight;
 			// Our estimate should be within a 1% error margin of the actual weight and we should
 			// never underestimate.

lightning/src/ln/chan_utils.rs

@@ -1819,7 +1819,7 @@ impl<'a> TrustedCommitmentTransaction<'a> {
 			input,
 			output,
 		};
-		let weight = justice_tx.weight() as u64 + WEIGHT_REVOKED_OUTPUT;
+		let weight = justice_tx.weight().to_wu() + WEIGHT_REVOKED_OUTPUT;
 		let fee = fee_for_weight(feerate_per_kw as u32, weight);
 		justice_tx.output[0].value = value.checked_sub(fee).ok_or(())?;
 		Ok(justice_tx)

lightning/src/ln/functional_test_utils.rs

@@ -1415,7 +1415,7 @@ pub fn do_check_spends<F: Fn(&bitcoin::blockdata::transaction::OutPoint) -> Opti
 	for output in tx.output.iter() {
 		total_value_out += output.value;
 	}
-	let min_fee = (tx.weight() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up)
+	let min_fee = (tx.weight().to_wu() as u64 + 3) / 4; // One sat per vbyte (ie per weight/4, rounded up)
 	// Input amount - output amount = fee, so check that out + min_fee is smaller than input
 	assert!(total_value_out + min_fee <= total_value_in);
 	tx.verify(get_output).unwrap();

lightning/src/ln/functional_tests.rs

@@ -7417,7 +7417,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
 		assert_eq!(node_txn[0].output.len(), 1);
 		check_spends!(node_txn[0], revoked_txn[0]);
 		let fee_1 = penalty_sum - node_txn[0].output[0].value;
-		feerate_1 = fee_1 * 1000 / node_txn[0].weight() as u64;
+		feerate_1 = fee_1 * 1000 / node_txn[0].weight().to_wu();
 		penalty_1 = node_txn[0].txid();
 		node_txn.clear();
 	};
@@ -7437,7 +7437,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
 			// Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
 			assert_ne!(penalty_2, penalty_1);
 			let fee_2 = penalty_sum - node_txn[0].output[0].value;
-			feerate_2 = fee_2 * 1000 / node_txn[0].weight() as u64;
+			feerate_2 = fee_2 * 1000 / node_txn[0].weight().to_wu();
 			// Verify 25% bump heuristic
 			assert!(feerate_2 * 100 >= feerate_1 * 125);
 			node_txn.clear();
@@ -7460,7 +7460,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
 			// Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
 			assert_ne!(penalty_3, penalty_2);
 			let fee_3 = penalty_sum - node_txn[0].output[0].value;
-			feerate_3 = fee_3 * 1000 / node_txn[0].weight() as u64;
+			feerate_3 = fee_3 * 1000 / node_txn[0].weight().to_wu();
 			// Verify 25% bump heuristic
 			assert!(feerate_3 * 100 >= feerate_2 * 125);
 			node_txn.clear();
@@ -7579,7 +7579,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
 		first = node_txn[3].txid();
 		// Store both feerates for later comparison
 		let fee_1 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[3].output[0].value;
-		feerate_1 = fee_1 * 1000 / node_txn[3].weight() as u64;
+		feerate_1 = fee_1 * 1000 / node_txn[3].weight().to_wu();
 		penalty_txn = vec![node_txn[2].clone()];
 		node_txn.clear();
 	}
@@ -7603,7 +7603,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
 		// Verify bumped tx is different and 25% bump heuristic
 		assert_ne!(first, node_txn[0].txid());
 		let fee_2 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[0].output[0].value;
-		let feerate_2 = fee_2 * 1000 / node_txn[0].weight() as u64;
+		let feerate_2 = fee_2 * 1000 / node_txn[0].weight().to_wu();
 		assert!(feerate_2 * 100 > feerate_1 * 125);
 		let txn = vec![node_txn[0].clone()];
 		node_txn.clear();
@@ -7679,7 +7679,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
 		preimage = node_txn[0].txid();
 		let index = node_txn[0].input[0].previous_output.vout;
 		let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
-		feerate_preimage = fee * 1000 / node_txn[0].weight() as u64;
+		feerate_preimage = fee * 1000 / node_txn[0].weight().to_wu();
 
 		let (preimage_bump_tx, timeout_tx) = if node_txn[2].input[0].previous_output == node_txn[0].input[0].previous_output {
 			(node_txn[2].clone(), node_txn[1].clone())
@@ -7694,7 +7694,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
 		timeout = timeout_tx.txid();
 		let index = timeout_tx.input[0].previous_output.vout;
 		let fee = remote_txn[0].output[index as usize].value - timeout_tx.output[0].value;
-		feerate_timeout = fee * 1000 / timeout_tx.weight() as u64;
+		feerate_timeout = fee * 1000 / timeout_tx.weight().to_wu();
 
 		node_txn.clear();
 	};
@@ -7713,13 +7713,13 @@ fn test_bump_penalty_txn_on_remote_commitment() {
 
 		let index = preimage_bump.input[0].previous_output.vout;
 		let fee = remote_txn[0].output[index as usize].value - preimage_bump.output[0].value;
-		let new_feerate = fee * 1000 / preimage_bump.weight() as u64;
+		let new_feerate = fee * 1000 / preimage_bump.weight().to_wu();
 		assert!(new_feerate * 100 > feerate_timeout * 125);
 		assert_ne!(timeout, preimage_bump.txid());
 
 		let index = node_txn[0].input[0].previous_output.vout;
 		let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
-		let new_feerate = fee * 1000 / node_txn[0].weight() as u64;
+		let new_feerate = fee * 1000 / node_txn[0].weight().to_wu();
 		assert!(new_feerate * 100 > feerate_preimage * 125);
 		assert_ne!(preimage, node_txn[0].txid());