Replace Hash's inner conversions with explicit byte array conversions

Author: wpaulino

fuzz/src/chanmon_consistency.rs

@@ -343,7 +343,7 @@ type ChanMan<'a> = ChannelManager<Arc<TestChainMonitor>, Arc<TestBroadcaster>, A
 fn get_payment_secret_hash(dest: &ChanMan, payment_id: &mut u8) -> Option<(PaymentSecret, PaymentHash)> {
 	let mut payment_hash;
 	for _ in 0..256 {
-		payment_hash = PaymentHash(Sha256::hash(&[*payment_id; 1]).into_inner());
+		payment_hash = PaymentHash(Sha256::hash(&[*payment_id; 1]).to_byte_array());
 		if let Ok(payment_secret) = dest.create_inbound_payment_for_hash(payment_hash, None, 3600, None) {
 			return Some((payment_secret, payment_hash));
 		}

fuzz/src/full_stack.rs

@@ -531,9 +531,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					payment_params, final_value_msat);
 				let mut payment_hash = PaymentHash([0; 32]);
 				payment_hash.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
-				let mut sha = Sha256::engine();
-				sha.input(&payment_hash.0[..]);
-				payment_hash.0 = Sha256::from_engine(sha).into_inner();
+				payment_hash.0 = Sha256::hash(&payment_hash.0[..]).to_byte_array();
 				payments_sent += 1;
 				match channelmanager.send_payment(payment_hash,
 					RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), params,
@@ -550,9 +548,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 					payment_params, final_value_msat);
 				let mut payment_hash = PaymentHash([0; 32]);
 				payment_hash.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
-				let mut sha = Sha256::engine();
-				sha.input(&payment_hash.0[..]);
-				payment_hash.0 = Sha256::from_engine(sha).into_inner();
+				payment_hash.0 = Sha256::hash(&payment_hash.0[..]).to_byte_array();
 				payments_sent += 1;
 				let mut payment_secret = PaymentSecret([0; 32]);
 				payment_secret.0[0..8].copy_from_slice(&be64_to_array(payments_sent));
@@ -603,9 +599,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
 			},
 			16 => {
 				let payment_preimage = PaymentPreimage(keys_manager.get_secure_random_bytes());
-				let mut sha = Sha256::engine();
-				sha.input(&payment_preimage.0[..]);
-				let payment_hash = PaymentHash(Sha256::from_engine(sha).into_inner());
+				let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).to_byte_array());
 				// Note that this may fail - our hashes may collide and we'll end up trying to
 				// double-register the same payment_hash.
 				let _ = channelmanager.create_inbound_payment_for_hash(payment_hash, None, 1, None);

lightning-block-sync/src/rest.rs

@@ -145,7 +145,7 @@ mod tests {
 		));
 		let client = RestClient::new(server.endpoint()).unwrap();
 
-		let outpoint = OutPoint::new(bitcoin::Txid::from_inner([0; 32]), 0);
+		let outpoint = OutPoint::new(bitcoin::Txid::from_byte_array([0; 32]), 0);
 		let unspent_output = client.is_output_unspent(outpoint).await.unwrap();
 		assert_eq!(unspent_output, false);
 	}
@@ -159,7 +159,7 @@ mod tests {
 		));
 		let client = RestClient::new(server.endpoint()).unwrap();
 
-		let outpoint = OutPoint::new(bitcoin::Txid::from_inner([0; 32]), 0);
+		let outpoint = OutPoint::new(bitcoin::Txid::from_byte_array([0; 32]), 0);
 		let unspent_output = client.is_output_unspent(outpoint).await.unwrap();
 		assert_eq!(unspent_output, true);
 	}

lightning-block-sync/src/rpc.rs

@@ -275,7 +275,7 @@ mod tests {
 		let response = serde_json::json!({ "result": null });
 		let server = HttpServer::responding_with_ok(MessageBody::Content(response));
 		let client = RpcClient::new(CREDENTIALS, server.endpoint()).unwrap();
-		let outpoint = OutPoint::new(bitcoin::Txid::from_inner([0; 32]), 0);
+		let outpoint = OutPoint::new(bitcoin::Txid::from_byte_array([0; 32]), 0);
 		let unspent_output = client.is_output_unspent(outpoint).await.unwrap();
 		assert_eq!(unspent_output, false);
 	}
@@ -285,7 +285,7 @@ mod tests {
 		let response = serde_json::json!({ "result": {"bestblock": 1, "confirmations": 42}});
 		let server = HttpServer::responding_with_ok(MessageBody::Content(response));
 		let client = RpcClient::new(CREDENTIALS, server.endpoint()).unwrap();
-		let outpoint = OutPoint::new(bitcoin::Txid::from_inner([0; 32]), 0);
+		let outpoint = OutPoint::new(bitcoin::Txid::from_byte_array([0; 32]), 0);
 		let unspent_output = client.is_output_unspent(outpoint).await.unwrap();
 		assert_eq!(unspent_output, true);
 	}

lightning-invoice/src/payment.rs

@@ -10,8 +10,7 @@
 //! Convenient utilities for paying Lightning invoices.
 
 use crate::Bolt11Invoice;
-
-use bitcoin_hashes::Hash;
+use crate::bitcoin_hashes::Hash;
 
 use lightning::ln::PaymentHash;
 use lightning::ln::channelmanager::RecipientOnionFields;
@@ -60,7 +59,7 @@ pub fn payment_parameters_from_invoice(invoice: &Bolt11Invoice)
 
 fn params_from_invoice(invoice: &Bolt11Invoice, amount_msat: u64)
 -> (PaymentHash, RecipientOnionFields, RouteParameters) {
-	let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
+	let payment_hash = PaymentHash((*invoice.payment_hash()).to_byte_array());
 
 	let mut recipient_onion = RecipientOnionFields::secret_only(*invoice.payment_secret());
 	recipient_onion.payment_metadata = invoice.payment_metadata().map(|v| v.clone());

lightning-invoice/src/utils.rs

@@ -873,8 +873,7 @@ mod test {
 		let route_params = RouteParameters::from_payment_params_and_value(
 			payment_params, invoice.amount_milli_satoshis().unwrap());
 		let payment_event = {
-			let mut payment_hash = PaymentHash([0; 32]);
-			payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
+			let payment_hash = PaymentHash(invoice.payment_hash().to_byte_array());
 			nodes[0].node.send_payment(payment_hash,
 				RecipientOnionFields::secret_only(*invoice.payment_secret()),
 				PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
@@ -1295,7 +1294,7 @@ mod test {
 
 		let user_payment_preimage = PaymentPreimage([1; 32]);
 		let payment_hash = if user_generated_pmt_hash {
-			Some(PaymentHash(Sha256::hash(&user_payment_preimage.0[..]).into_inner()))
+			Some(PaymentHash(Sha256::hash(&user_payment_preimage.0[..]).to_byte_array()))
 		} else {
 			None
 		};
@@ -1308,7 +1307,7 @@ mod test {
 				route_hints, nodes[1].keys_manager, nodes[1].keys_manager, nodes[1].logger,
 				Currency::BitcoinTestnet, None, Duration::from_secs(genesis_timestamp)
 			).unwrap();
-		let (payment_hash, payment_secret) = (PaymentHash(invoice.payment_hash().into_inner()), *invoice.payment_secret());
+		let (payment_hash, payment_secret) = (PaymentHash(invoice.payment_hash().to_byte_array()), *invoice.payment_secret());
 		let payment_preimage = if user_generated_pmt_hash {
 			user_payment_preimage
 		} else {
@@ -1328,8 +1327,7 @@ mod test {
 		let params = RouteParameters::from_payment_params_and_value(
 			payment_params, invoice.amount_milli_satoshis().unwrap());
 		let (payment_event, fwd_idx) = {
-			let mut payment_hash = PaymentHash([0; 32]);
-			payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
+			let payment_hash = PaymentHash(invoice.payment_hash().to_byte_array());
 			nodes[0].node.send_payment(payment_hash,
 				RecipientOnionFields::secret_only(*invoice.payment_secret()),
 				PaymentId(payment_hash.0), params, Retry::Attempts(0)).unwrap();
@@ -1454,7 +1452,7 @@ mod test {
 			nodes[2].node.get_phantom_route_hints(),
 		];
 		let user_payment_preimage = PaymentPreimage([1; 32]);
-		let payment_hash = Some(PaymentHash(Sha256::hash(&user_payment_preimage.0[..]).into_inner()));
+		let payment_hash = Some(PaymentHash(Sha256::hash(&user_payment_preimage.0[..]).to_byte_array()));
 		let non_default_invoice_expiry_secs = 4200;
 		let min_final_cltv_expiry_delta = Some(100);
 		let duration_since_epoch = Duration::from_secs(1234567);

lightning/src/blinded_path/utils.rs

@@ -49,7 +49,7 @@ where
 				let hop_pk_blinding_factor = {
 					let mut hmac = HmacEngine::<Sha256>::new(b"blinded_node_id");
 					hmac.input(encrypted_data_ss.as_ref());
-					Hmac::from_engine(hmac).into_inner()
+					Hmac::from_engine(hmac).to_byte_array()
 				};
 				$pk.mul_tweak(secp_ctx, &Scalar::from_be_bytes(hop_pk_blinding_factor).unwrap())?
 			};
@@ -70,7 +70,7 @@ where
 				let mut sha = Sha256::engine();
 				sha.input(&msg_blinding_point.serialize()[..]);
 				sha.input(encrypted_data_ss.as_ref());
-				Sha256::from_engine(sha).into_inner()
+				Sha256::from_engine(sha).to_byte_array()
 			};
 
 			msg_blinding_point_priv = msg_blinding_point_priv.mul_tweak(&Scalar::from_be_bytes(msg_blinding_point_blinding_factor).unwrap())?;
@@ -80,7 +80,7 @@ where
 				let mut sha = Sha256::engine();
 				sha.input(&onion_packet_pubkey.serialize()[..]);
 				sha.input(onion_packet_ss.as_ref());
-				Sha256::from_engine(sha).into_inner()
+				Sha256::from_engine(sha).to_byte_array()
 			};
 			onion_packet_pubkey_priv = onion_packet_pubkey_priv.mul_tweak(&Scalar::from_be_bytes(onion_packet_pubkey_blinding_factor).unwrap())?;
 			onion_packet_pubkey = PublicKey::from_secret_key(secp_ctx, &onion_packet_pubkey_priv);

lightning/src/chain/channelmonitor.rs

@@ -2676,7 +2676,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 				},
 				ChannelMonitorUpdateStep::PaymentPreimage { payment_preimage } => {
 					log_trace!(logger, "Updating ChannelMonitor with payment preimage");
-					self.provide_payment_preimage(&PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()), &payment_preimage, broadcaster, &bounded_fee_estimator, logger)
+					self.provide_payment_preimage(&PaymentHash(Sha256::hash(&payment_preimage.0[..]).to_byte_array()), &payment_preimage, broadcaster, &bounded_fee_estimator, logger)
 				},
 				ChannelMonitorUpdateStep::CommitmentSecret { idx, secret } => {
 					log_trace!(logger, "Updating ChannelMonitor with commitment secret");
@@ -4316,7 +4316,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		let mut payment_preimages = HashMap::with_capacity(cmp::min(payment_preimages_len as usize, MAX_ALLOC_SIZE / 32));
 		for _ in 0..payment_preimages_len {
 			let preimage: PaymentPreimage = Readable::read(reader)?;
-			let hash = PaymentHash(Sha256::hash(&preimage.0[..]).into_inner());
+			let hash = PaymentHash(Sha256::hash(&preimage.0[..]).to_byte_array());
 			if let Some(_) = payment_preimages.insert(hash, preimage) {
 				return Err(DecodeError::InvalidValue);
 			}
@@ -4620,7 +4620,7 @@ mod tests {
 		{
 			for i in 0..20 {
 				let preimage = PaymentPreimage([i; 32]);
-				let hash = PaymentHash(Sha256::hash(&preimage.0[..]).into_inner());
+				let hash = PaymentHash(Sha256::hash(&preimage.0[..]).to_byte_array());
 				preimages.push((preimage, hash));
 			}
 		}
@@ -4705,9 +4705,9 @@ mod tests {
 		let dummy_commitment_tx = HolderCommitmentTransaction::dummy(&mut htlcs);
 		monitor.provide_latest_holder_commitment_tx(dummy_commitment_tx.clone(),
 			htlcs.into_iter().map(|(htlc, _)| (htlc, Some(dummy_sig), None)).collect()).unwrap();
-		monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"1").into_inner()),
+		monitor.provide_latest_counterparty_commitment_tx(Txid::from_byte_array(Sha256::hash(b"1").to_byte_array()),
 			preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
-		monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"2").into_inner()),
+		monitor.provide_latest_counterparty_commitment_tx(Txid::from_byte_array(Sha256::hash(b"2").to_byte_array()),
 			preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 		for &(ref preimage, ref hash) in preimages.iter() {
 			let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
@@ -4722,7 +4722,7 @@ mod tests {
 		test_preimages_exist!(&preimages[0..10], monitor);
 		test_preimages_exist!(&preimages[15..20], monitor);
 
-		monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"3").into_inner()),
+		monitor.provide_latest_counterparty_commitment_tx(Txid::from_byte_array(Sha256::hash(b"3").to_byte_array()),
 			preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
 
 		// Now provide a further secret, pruning preimages 15-17
@@ -4732,7 +4732,7 @@ mod tests {
 		test_preimages_exist!(&preimages[0..10], monitor);
 		test_preimages_exist!(&preimages[17..20], monitor);
 
-		monitor.provide_latest_counterparty_commitment_tx(Txid::from_inner(Sha256::hash(b"4").into_inner()),
+		monitor.provide_latest_counterparty_commitment_tx(Txid::from_byte_array(Sha256::hash(b"4").to_byte_array()),
 			preimages_slice_to_htlc_outputs!(preimages[18..20]), 281474976710652, dummy_key, &logger);
 
 		// Now update holder commitment tx info, pruning only element 18 as we still care about the

lightning/src/chain/onchaintx.rs

@@ -763,26 +763,26 @@ impl<ChannelSigner: WriteableEcdsaChannelSigner> OnchainTxHandler<ChannelSigner>
 					OnchainClaim::Tx(tx) => {
 						log_info!(logger, "Broadcasting onchain {}", log_tx!(tx));
 						broadcaster.broadcast_transactions(&[&tx]);
-						ClaimId(tx.txid().into_inner())
+						ClaimId(tx.txid().to_byte_array())
 					},
 					OnchainClaim::Event(claim_event) => {
 						log_info!(logger, "Yielding onchain event to spend inputs {:?}", req.outpoints());
 						let claim_id = match claim_event {
 							ClaimEvent::BumpCommitment { ref commitment_tx, .. } =>
 								// For commitment claims, we can just use their txid as it should
 								// already be unique.
-								ClaimId(commitment_tx.txid().into_inner()),
+								ClaimId(commitment_tx.txid().to_byte_array()),
 							ClaimEvent::BumpHTLC { ref htlcs, .. } => {
 								// For HTLC claims, commit to the entire set of HTLC outputs to
 								// claim, which will always be unique per request. Once a claim ID
 								// is generated, it is assigned and remains unchanged, even if the
 								// underlying set of HTLCs changes.
 								let mut engine = Sha256::engine();
 								for htlc in htlcs {
-									engine.input(&htlc.commitment_txid.into_inner());
+									engine.input(&htlc.commitment_txid.to_byte_array());
 									engine.input(&htlc.htlc.transaction_output_index.unwrap().to_be_bytes());
 								}
-								ClaimId(Sha256::from_engine(engine).into_inner())
+								ClaimId(Sha256::from_engine(engine).to_byte_array())
 							},
 						};
 						debug_assert!(self.pending_claim_requests.get(&claim_id).is_none());

lightning/src/chain/transaction.rs

@@ -60,7 +60,7 @@ pub struct OutPoint {
 impl OutPoint {
 	/// Convert an `OutPoint` to a lightning channel id.
 	pub fn to_channel_id(&self) -> ChannelId {
-		ChannelId::v1_from_funding_txid(&self.txid.as_inner(), self.index)
+		ChannelId::v1_from_funding_txid(self.txid.as_byte_array(), self.index)
 	}
 
 	/// Converts this OutPoint into the OutPoint field as used by rust-bitcoin