diff --git a/lightning/src/crypto/chacha20.rs b/lightning/src/crypto/chacha20.rs
index d1dcff1474c..cbe3e4e1062 100644
--- a/lightning/src/crypto/chacha20.rs
+++ b/lightning/src/crypto/chacha20.rs
@@ -20,20 +20,24 @@ mod real_chacha {
 		type Output = u32x4;
 		#[inline]
 		fn add(self, rhs: u32x4) -> u32x4 {
-			u32x4(self.0.wrapping_add(rhs.0),
-			      self.1.wrapping_add(rhs.1),
-			      self.2.wrapping_add(rhs.2),
-			      self.3.wrapping_add(rhs.3))
+			u32x4(
+				self.0.wrapping_add(rhs.0),
+				self.1.wrapping_add(rhs.1),
+				self.2.wrapping_add(rhs.2),
+				self.3.wrapping_add(rhs.3),
+			)
 		}
 	}
 	impl ::core::ops::Sub for u32x4 {
 		type Output = u32x4;
 		#[inline]
 		fn sub(self, rhs: u32x4) -> u32x4 {
-			u32x4(self.0.wrapping_sub(rhs.0),
-			      self.1.wrapping_sub(rhs.1),
-			      self.2.wrapping_sub(rhs.2),
-			      self.3.wrapping_sub(rhs.3))
+			u32x4(
+				self.0.wrapping_sub(rhs.0),
+				self.1.wrapping_sub(rhs.1),
+				self.2.wrapping_sub(rhs.2),
+				self.3.wrapping_sub(rhs.3),
+			)
 		}
 	}
 	impl ::core::ops::BitXor for u32x4 {
@@ -60,44 +64,48 @@ mod real_chacha {
 	impl u32x4 {
 		#[inline]
 		fn from_bytes(bytes: &[u8]) -> Self {
-			assert_eq!(bytes.len(), 4*4);
-			Self (
-				u32::from_le_bytes(bytes[0*4..1*4].try_into().expect("len is 4")),
-				u32::from_le_bytes(bytes[1*4..2*4].try_into().expect("len is 4")),
-				u32::from_le_bytes(bytes[2*4..3*4].try_into().expect("len is 4")),
-				u32::from_le_bytes(bytes[3*4..4*4].try_into().expect("len is 4")),
+			assert_eq!(bytes.len(), 4 * 4);
+			Self(
+				u32::from_le_bytes(bytes[0 * 4..1 * 4].try_into().expect("len is 4")),
+				u32::from_le_bytes(bytes[1 * 4..2 * 4].try_into().expect("len is 4")),
+				u32::from_le_bytes(bytes[2 * 4..3 * 4].try_into().expect("len is 4")),
+				u32::from_le_bytes(bytes[3 * 4..4 * 4].try_into().expect("len is 4")),
 			)
 		}
 	}
 
 	const BLOCK_SIZE: usize = 64;
 
-	#[derive(Clone,Copy)]
+	#[derive(Clone, Copy)]
 	struct ChaChaState {
 		a: u32x4,
 		b: u32x4,
 		c: u32x4,
-		d: u32x4
+		d: u32x4,
 	}
 
 	#[derive(Copy)]
 	pub struct ChaCha20 {
-		state  : ChaChaState,
-		output : [u8; BLOCK_SIZE],
-		offset : usize,
+		state: ChaChaState,
+		output: [u8; BLOCK_SIZE],
+		offset: usize,
 	}
 
-	impl Clone for ChaCha20 { fn clone(&self) -> ChaCha20 { *self } }
+	impl Clone for ChaCha20 {
+		fn clone(&self) -> ChaCha20 {
+			*self
+		}
+	}
 
 	macro_rules! swizzle {
 		($b: expr, $c: expr, $d: expr) => {{
 			let u32x4(b10, b11, b12, b13) = $b;
 			$b = u32x4(b11, b12, b13, b10);
 			let u32x4(c10, c11, c12, c13) = $c;
-			$c = u32x4(c12, c13,c10, c11);
+			$c = u32x4(c12, c13, c10, c11);
 			let u32x4(d10, d11, d12, d13) = $d;
 			$d = u32x4(d13, d10, d11, d12);
-		}}
+		}};
 	}
 
 	macro_rules! state_to_buffer {
@@ -106,19 +114,14 @@ mod real_chacha {
 			let u32x4(b1, b2, b3, b4) = $state.b;
 			let u32x4(c1, c2, c3, c4) = $state.c;
 			let u32x4(d1, d2, d3, d4) = $state.d;
-			let lens = [
-				a1,a2,a3,a4,
-				b1,b2,b3,b4,
-				c1,c2,c3,c4,
-				d1,d2,d3,d4
-			];
+			let lens = [a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4];
 			for i in 0..lens.len() {
-				$output[i*4..(i+1)*4].copy_from_slice(&lens[i].to_le_bytes());
+				$output[i * 4..(i + 1) * 4].copy_from_slice(&lens[i].to_le_bytes());
 			}
-		}}
+		}};
 	}
 
-	macro_rules! round{
+	macro_rules! round {
 		($state: expr) => {{
 			$state.a = $state.a + $state.b;
 			rotate!($state.d, $state.a, 16);
@@ -128,7 +131,7 @@ mod real_chacha {
 			rotate!($state.d, $state.a, 8);
 			$state.c = $state.c + $state.d;
 			rotate!($state.b, $state.c, 7);
-		}}
+		}};
 	}
 
 	macro_rules! rotate {
@@ -137,7 +140,7 @@ mod real_chacha {
 			let r = 32 - $rot;
 			let right = v >> r;
 			$a = (v << $rot) ^ right
-		}}
+		}};
 	}
 
 	impl ChaCha20 {
@@ -145,12 +148,16 @@ mod real_chacha {
 			assert!(key.len() == 16 || key.len() == 32);
 			assert!(nonce.len() == 8 || nonce.len() == 12);
 
-			ChaCha20{ state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 }
+			ChaCha20 { state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 }
 		}
 
 		/// Get one block from a ChaCha stream.
 		pub fn get_single_block(key: &[u8; 32], nonce: &[u8; 16]) -> [u8; 32] {
-			let mut chacha = ChaCha20 { state: ChaCha20::expand(key, nonce), output: [0u8; BLOCK_SIZE], offset: 64 };
+			let mut chacha = ChaCha20 {
+				state: ChaCha20::expand(key, nonce),
+				output: [0u8; BLOCK_SIZE],
+				offset: 64,
+			};
 			let mut chacha_bytes = [0; 32];
 			chacha.process_in_place(&mut chacha_bytes);
 			chacha_bytes
@@ -158,9 +165,7 @@ mod real_chacha {
 
 		/// Encrypts `src` into `dest` using a single block from a ChaCha stream. Passing `dest` as
 		/// `src` in a second call will decrypt it.
-		pub fn encrypt_single_block(
-			key: &[u8; 32], nonce: &[u8; 16], dest: &mut [u8], src: &[u8]
-		) {
+		pub fn encrypt_single_block(key: &[u8; 32], nonce: &[u8; 16], dest: &mut [u8], src: &[u8]) {
 			debug_assert_eq!(dest.len(), src.len());
 			debug_assert!(dest.len() <= 32);
 
@@ -172,7 +177,7 @@ mod real_chacha {
 
 		/// Same as `encrypt_single_block` only operates on a fixed-size input in-place.
 		pub fn encrypt_single_block_in_place(
-			key: &[u8; 32], nonce: &[u8; 16], bytes: &mut [u8; 32]
+			key: &[u8; 32], nonce: &[u8; 16], bytes: &mut [u8; 32],
 		) {
 			let block = ChaCha20::get_single_block(key, nonce);
 			for i in 0..bytes.len() {
@@ -184,7 +189,7 @@ mod real_chacha {
 			let constant = match key.len() {
 				16 => b"expand 16-byte k",
 				32 => b"expand 32-byte k",
-				_  => unreachable!(),
+				_ => unreachable!(),
 			};
 			ChaChaState {
 				a: u32x4::from_bytes(&constant[0..16]),
@@ -197,14 +202,14 @@ mod real_chacha {
 				d: if nonce.len() == 16 {
 					u32x4::from_bytes(&nonce[0..16])
 				} else if nonce.len() == 12 {
-					let mut nonce4 = [0; 4*4];
+					let mut nonce4 = [0; 4 * 4];
 					nonce4[4..].copy_from_slice(nonce);
 					u32x4::from_bytes(&nonce4)
 				} else {
-					let mut nonce4 = [0; 4*4];
+					let mut nonce4 = [0; 4 * 4];
 					nonce4[8..].copy_from_slice(nonce);
 					u32x4::from_bytes(&nonce4)
-				}
+				},
 			}
 		}
 
@@ -312,15 +317,16 @@ mod fuzzy_chacha {
 		}
 
 		pub fn encrypt_single_block(
-			_key: &[u8; 32], _nonce: &[u8; 16], dest: &mut [u8], src: &[u8]
+			_key: &[u8; 32], _nonce: &[u8; 16], dest: &mut [u8], src: &[u8],
 		) {
 			debug_assert_eq!(dest.len(), src.len());
 			debug_assert!(dest.len() <= 32);
 		}
 
 		pub fn encrypt_single_block_in_place(
-			_key: &[u8; 32], _nonce: &[u8; 16], _bytes: &mut [u8; 32]
-		) {}
+			_key: &[u8; 32], _nonce: &[u8; 16], _bytes: &mut [u8; 32],
+		) {
+		}
 
 		pub fn process(&mut self, input: &[u8], output: &mut [u8]) {
 			output.copy_from_slice(input);
@@ -343,128 +349,103 @@ mod test {
 	#[test]
 	fn test_chacha20_256_tls_vectors() {
 		struct TestVector {
-			key:   [u8; 32],
+			key: [u8; 32],
 			nonce: [u8; 8],
 			keystream: Vec<u8>,
 		}
 		// taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
-		let test_vectors = vec!(
-			TestVector{
+		let test_vectors = vec![
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
+					0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
+					0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
+					0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
+					0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
-					0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-					0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a,
-					0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-					0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d,
-					0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-					0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
-					0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96, 0xd7, 0x73, 0x6e, 0x7b, 0x20,
+					0x8e, 0x3c, 0x96, 0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60, 0x4f, 0x45,
+					0x09, 0x52, 0xed, 0x43, 0x2d, 0x41, 0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66,
+					0xd2, 0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c, 0x53, 0xd7, 0x92, 0xb1,
+					0xc4, 0x3f, 0xea, 0x81, 0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
-					0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
-					0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
-					0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
-					0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
-					0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
-					0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
-					0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
+				keystream: vec![
+					0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5, 0xe7, 0x86, 0xdc, 0x63, 0x97,
+					0x3f, 0x65, 0x3a, 0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13, 0x4f, 0xcb,
+					0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31, 0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08,
+					0x45, 0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b, 0x52, 0x77, 0x06, 0x2e,
+					0xb7, 0xa0, 0x43, 0x3e, 0x44, 0x5f, 0x41, 0xe3,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
-				keystream: vec!(
-					0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
-					0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
-					0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
-					0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
-					0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
-					0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
-					0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
-					0x44, 0x5f, 0x41, 0xe3,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb, 0xf5, 0xcf, 0x35, 0xbd, 0x3d,
+					0xd3, 0x3b, 0x80, 0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac, 0x33, 0x96,
+					0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32, 0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5,
+					0x3c, 0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54, 0x5d, 0xdc, 0x49, 0x7a,
+					0x0b, 0x46, 0x6e, 0x7d, 0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
 				],
-				nonce: [ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
-					0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
-					0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
-					0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
-					0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
-					0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
-					0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
-					0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-					0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-					0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-					0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+					0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
+					0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+					0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+				],
+				nonce: [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07],
+				keystream: vec![
+					0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69, 0x82, 0x10, 0x5f, 0xfb, 0x64,
+					0x0b, 0xb7, 0x75, 0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93, 0xec, 0x01,
+					0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1, 0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46,
+					0x41, 0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69, 0x05, 0xd3, 0xbe, 0x59,
+					0xea, 0x1c, 0x53, 0xf1, 0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a, 0x38,
+					0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94, 0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a,
+					0xde, 0x66, 0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58, 0x89, 0xfb, 0x60,
+					0xe8, 0x46, 0x29, 0xc9, 0xbd, 0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
+					0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e, 0x09, 0xa7, 0xe7, 0x78, 0x49,
+					0x2b, 0x56, 0x2e, 0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7, 0x9d, 0xb9,
+					0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15, 0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f,
+					0xc3, 0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a, 0x97, 0xa5, 0xf5, 0x76,
+					0xfe, 0x06, 0x40, 0x25, 0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5, 0x07,
+					0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69, 0x59, 0x66, 0x09, 0x96, 0x54, 0x6c,
+					0xc9, 0xc4, 0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7, 0x0e, 0xaf, 0x46,
+					0xf7, 0x6d, 0xad, 0x39, 0x79, 0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
+					0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a, 0x94, 0xdf, 0x76, 0x28, 0xfe,
+					0x4e, 0xaa, 0xf2, 0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a, 0xd0, 0xf9,
+					0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09, 0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40,
+					0x7a, 0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
 				],
-				nonce: [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
-				keystream: vec!(
-					0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
-					0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
-					0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
-					0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
-					0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
-					0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
-					0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
-					0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
-					0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
-					0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
-					0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
-					0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
-					0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
-					0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
-					0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
-					0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
-					0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
-					0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
-					0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
-					0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
-					0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
-					0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
-					0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
-					0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
-					0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
-					0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
-					0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
-					0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
-					0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
-					0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
-					0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
-					0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
-				),
 			},
-		);
+		];
 
 		for tv in test_vectors.iter() {
 			let mut c = ChaCha20::new(&tv.key, &tv.nonce);
@@ -478,128 +459,103 @@ mod test {
 	#[test]
 	fn test_chacha20_256_tls_vectors_96_nonce() {
 		struct TestVector {
-			key:   [u8; 32],
+			key: [u8; 32],
 			nonce: [u8; 12],
 			keystream: Vec<u8>,
 		}
 		// taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
-		let test_vectors = vec!(
-			TestVector{
+		let test_vectors = vec![
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90, 0x40, 0x5d, 0x6a, 0xe5, 0x53,
+					0x86, 0xbd, 0x28, 0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a, 0xa8, 0x36,
+					0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7, 0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48,
+					0x8d, 0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37, 0x6a, 0x43, 0xb8, 0xf4,
+					0x15, 0x18, 0xa1, 0x1c, 0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
-					0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-					0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a,
-					0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-					0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d,
-					0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-					0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
-					0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96, 0xd7, 0x73, 0x6e, 0x7b, 0x20,
+					0x8e, 0x3c, 0x96, 0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60, 0x4f, 0x45,
+					0x09, 0x52, 0xed, 0x43, 0x2d, 0x41, 0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66,
+					0xd2, 0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c, 0x53, 0xd7, 0x92, 0xb1,
+					0xc4, 0x3f, 0xea, 0x81, 0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
-					0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
-					0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
-					0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
-					0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
-					0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
-					0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
-					0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
+				keystream: vec![
+					0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5, 0xe7, 0x86, 0xdc, 0x63, 0x97,
+					0x3f, 0x65, 0x3a, 0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13, 0x4f, 0xcb,
+					0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31, 0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08,
+					0x45, 0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b, 0x52, 0x77, 0x06, 0x2e,
+					0xb7, 0xa0, 0x43, 0x3e, 0x44, 0x5f, 0x41, 0xe3,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
-				keystream: vec!(
-					0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
-					0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
-					0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
-					0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
-					0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
-					0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
-					0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
-					0x44, 0x5f, 0x41, 0xe3,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+				keystream: vec![
+					0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb, 0xf5, 0xcf, 0x35, 0xbd, 0x3d,
+					0xd3, 0x3b, 0x80, 0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac, 0x33, 0x96,
+					0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32, 0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5,
+					0x3c, 0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54, 0x5d, 0xdc, 0x49, 0x7a,
+					0x0b, 0x46, 0x6e, 0x7d, 0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
 				],
-				nonce: [ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-				keystream: vec!(
-					0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
-					0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
-					0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
-					0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
-					0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
-					0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
-					0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
-					0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
-				),
-			}, TestVector{
+			},
+			TestVector {
 				key: [
-					0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-					0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-					0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-					0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+					0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
+					0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+					0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+				],
+				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07],
+				keystream: vec![
+					0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69, 0x82, 0x10, 0x5f, 0xfb, 0x64,
+					0x0b, 0xb7, 0x75, 0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93, 0xec, 0x01,
+					0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1, 0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46,
+					0x41, 0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69, 0x05, 0xd3, 0xbe, 0x59,
+					0xea, 0x1c, 0x53, 0xf1, 0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a, 0x38,
+					0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94, 0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a,
+					0xde, 0x66, 0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58, 0x89, 0xfb, 0x60,
+					0xe8, 0x46, 0x29, 0xc9, 0xbd, 0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
+					0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e, 0x09, 0xa7, 0xe7, 0x78, 0x49,
+					0x2b, 0x56, 0x2e, 0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7, 0x9d, 0xb9,
+					0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15, 0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f,
+					0xc3, 0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a, 0x97, 0xa5, 0xf5, 0x76,
+					0xfe, 0x06, 0x40, 0x25, 0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5, 0x07,
+					0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69, 0x59, 0x66, 0x09, 0x96, 0x54, 0x6c,
+					0xc9, 0xc4, 0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7, 0x0e, 0xaf, 0x46,
+					0xf7, 0x6d, 0xad, 0x39, 0x79, 0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
+					0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a, 0x94, 0xdf, 0x76, 0x28, 0xfe,
+					0x4e, 0xaa, 0xf2, 0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a, 0xd0, 0xf9,
+					0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09, 0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40,
+					0x7a, 0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
 				],
-				nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
-				keystream: vec!(
-					0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
-					0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
-					0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
-					0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
-					0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
-					0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
-					0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
-					0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
-					0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
-					0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
-					0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
-					0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
-					0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
-					0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
-					0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
-					0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
-					0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
-					0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
-					0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
-					0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
-					0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
-					0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
-					0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
-					0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
-					0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
-					0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
-					0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
-					0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
-					0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
-					0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
-					0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
-					0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
-				),
 			},
-		);
+		];
 
 		for tv in test_vectors.iter() {
 			let mut c = ChaCha20::new(&tv.key, &tv.nonce);
@@ -616,13 +572,13 @@ mod test {
 		// using a 12-byte nonce, with the block starting at the counter offset given by the remaining 4
 		// bytes.
 		let key = [
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-			0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-			0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+			0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
+			0x1c, 0x1d, 0x1e, 0x1f,
 		];
 		let nonce_16bytes = [
-			0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
+			0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+			0x0a, 0x0b,
 		];
 		let counter_pos = &nonce_16bytes[..4];
 		let nonce_12bytes = &nonce_16bytes[4..];
@@ -640,14 +596,13 @@ mod test {
 	#[test]
 	fn encrypt_single_block() {
 		let key = [
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-			0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-			0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+			0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
+			0x1c, 0x1d, 0x1e, 0x1f,
 		];
 		let nonce = [
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-			0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+			0x0e, 0x0f,
 		];
 		let bytes = [1; 32];
 
@@ -663,14 +618,13 @@ mod test {
 	#[test]
 	fn encrypt_single_block_in_place() {
 		let key = [
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-			0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-			0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+			0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
+			0x1c, 0x1d, 0x1e, 0x1f,
 		];
 		let nonce = [
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-			0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+			0x0e, 0x0f,
 		];
 		let unencrypted_bytes = [1; 32];
 		let mut bytes = unencrypted_bytes;
diff --git a/lightning/src/crypto/chacha20poly1305rfc.rs b/lightning/src/crypto/chacha20poly1305rfc.rs
index 76d6040c224..f1c261cb1f1 100644
--- a/lightning/src/crypto/chacha20poly1305rfc.rs
+++ b/lightning/src/crypto/chacha20poly1305rfc.rs
@@ -13,8 +13,8 @@
 #[cfg(not(fuzzing))]
 mod real_chachapoly {
 	use super::super::chacha20::ChaCha20;
-	use super::super::poly1305::Poly1305;
 	use super::super::fixed_time_eq;
+	use super::super::poly1305::Poly1305;
 
 	#[derive(Clone, Copy)]
 	pub struct ChaCha20Poly1305RFC {
@@ -70,7 +70,9 @@ mod real_chachapoly {
 			self.mac.raw_result(out_tag);
 		}
 
-		pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) {
+		pub fn encrypt_full_message_in_place(
+			&mut self, input_output: &mut [u8], out_tag: &mut [u8],
+		) {
 			self.encrypt_in_place(input_output);
 			self.finish_and_get_tag(out_tag);
 		}
@@ -98,7 +100,9 @@ mod real_chachapoly {
 		/// Decrypt the `input`, checking the given `tag` prior to writing the decrypted contents
 		/// into `output`. Note that, because `output` is not touched until the `tag` is checked,
 		/// this decryption is *variable time*.
-		pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
+		pub fn variable_time_decrypt(
+			&mut self, input: &[u8], output: &mut [u8], tag: &[u8],
+		) -> Result<(), ()> {
 			assert!(input.len() == output.len());
 			assert!(!self.finished);
 
@@ -111,7 +115,7 @@ mod real_chachapoly {
 			self.mac.input(&self.aad_len.to_le_bytes());
 			self.mac.input(&(self.data_len as u64).to_le_bytes());
 
-			let mut calc_tag =  [0u8; 16];
+			let mut calc_tag = [0u8; 16];
 			self.mac.raw_result(&mut calc_tag);
 			if fixed_time_eq(&calc_tag, tag) {
 				self.cipher.process(input, output);
@@ -121,9 +125,15 @@ mod real_chachapoly {
 			}
 		}
 
-		pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
+		pub fn check_decrypt_in_place(
+			&mut self, input_output: &mut [u8], tag: &[u8],
+		) -> Result<(), ()> {
 			self.decrypt_in_place(input_output);
-			if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) }
+			if self.finish_and_check_tag(tag) {
+				Ok(())
+			} else {
+				Err(())
+			}
 		}
 
 		/// Decrypt in place, without checking the tag. Use `finish_and_check_tag` to check it
@@ -146,7 +156,7 @@ mod real_chachapoly {
 			self.mac.input(&self.aad_len.to_le_bytes());
 			self.mac.input(&(self.data_len as u64).to_le_bytes());
 
-			let mut calc_tag =  [0u8; 16];
+			let mut calc_tag = [0u8; 16];
 			self.mac.raw_result(&mut calc_tag);
 			if fixed_time_eq(&calc_tag, tag) {
 				true
@@ -177,10 +187,7 @@ mod fuzzy_chachapoly {
 			let mut tag = [0; 16];
 			tag.copy_from_slice(&key[0..16]);
 
-			ChaCha20Poly1305RFC {
-				tag,
-				finished: false,
-			}
+			ChaCha20Poly1305RFC { tag, finished: false }
 		}
 
 		pub fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) {
@@ -192,7 +199,9 @@ mod fuzzy_chachapoly {
 			self.finished = true;
 		}
 
-		pub fn encrypt_full_message_in_place(&mut self, input_output: &mut [u8], out_tag: &mut [u8]) {
+		pub fn encrypt_full_message_in_place(
+			&mut self, input_output: &mut [u8], out_tag: &mut [u8],
+		) {
 			self.encrypt_in_place(input_output);
 			self.finish_and_get_tag(out_tag);
 		}
@@ -207,19 +216,29 @@ mod fuzzy_chachapoly {
 			self.finished = true;
 		}
 
-		pub fn variable_time_decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
+		pub fn variable_time_decrypt(
+			&mut self, input: &[u8], output: &mut [u8], tag: &[u8],
+		) -> Result<(), ()> {
 			assert!(input.len() == output.len());
 			assert!(self.finished == false);
 
-			if tag[..] != self.tag[..] { return Err(()); }
+			if tag[..] != self.tag[..] {
+				return Err(());
+			}
 			output.copy_from_slice(input);
 			self.finished = true;
 			Ok(())
 		}
 
-		pub fn check_decrypt_in_place(&mut self, input_output: &mut [u8], tag: &[u8]) -> Result<(), ()> {
+		pub fn check_decrypt_in_place(
+			&mut self, input_output: &mut [u8], tag: &[u8],
+		) -> Result<(), ()> {
 			self.decrypt_in_place(input_output);
-			if self.finish_and_check_tag(tag) { Ok(()) } else { Err(()) }
+			if self.finish_and_check_tag(tag) {
+				Ok(())
+			} else {
+				Err(())
+			}
 		}
 
 		pub(in super::super) fn decrypt_in_place(&mut self, _input: &mut [u8]) {
@@ -227,7 +246,9 @@ mod fuzzy_chachapoly {
 		}
 
 		pub(in super::super) fn finish_and_check_tag(&mut self, tag: &[u8]) -> bool {
-			if tag[..] != self.tag[..] { return false; }
+			if tag[..] != self.tag[..] {
+				return false;
+			}
 			self.finished = true;
 			true
 		}
diff --git a/lightning/src/crypto/mod.rs b/lightning/src/crypto/mod.rs
index b4f5af8f119..4dc851a3683 100644
--- a/lightning/src/crypto/mod.rs
+++ b/lightning/src/crypto/mod.rs
@@ -2,8 +2,8 @@
 use bitcoin::hashes::cmp::fixed_time_eq;
 
 pub(crate) mod chacha20;
+pub(crate) mod chacha20poly1305rfc;
 #[cfg(not(fuzzing))]
 pub(crate) mod poly1305;
-pub(crate) mod chacha20poly1305rfc;
 pub(crate) mod streams;
 pub(crate) mod utils;
diff --git a/lightning/src/crypto/poly1305.rs b/lightning/src/crypto/poly1305.rs
index 7b744912561..6ac1c6c9694 100644
--- a/lightning/src/crypto/poly1305.rs
+++ b/lightning/src/crypto/poly1305.rs
@@ -13,25 +13,33 @@ use crate::prelude::*;
 
 #[derive(Clone, Copy)]
 pub struct Poly1305 {
-	r         : [u32; 5],
-	h         : [u32; 5],
-	pad       : [u32; 4],
-	leftover  : usize,
-	buffer    : [u8; 16],
-	finalized : bool,
+	r: [u32; 5],
+	h: [u32; 5],
+	pad: [u32; 4],
+	leftover: usize,
+	buffer: [u8; 16],
+	finalized: bool,
 }
 
 impl Poly1305 {
 	pub fn new(key: &[u8]) -> Poly1305 {
 		assert!(key.len() == 32);
-		let mut poly = Poly1305{ r: [0u32; 5], h: [0u32; 5], pad: [0u32; 4], leftover: 0, buffer: [0u8; 16], finalized: false };
+		let mut poly = Poly1305 {
+			r: [0u32; 5],
+			h: [0u32; 5],
+			pad: [0u32; 4],
+			leftover: 0,
+			buffer: [0u8; 16],
+			finalized: false,
+		};
 
 		// r &= 0xffffffc0ffffffc0ffffffc0fffffff
-		poly.r[0] = (u32::from_le_bytes(key[ 0.. 4].try_into().expect("len is 4"))     ) & 0x3ffffff;
-		poly.r[1] = (u32::from_le_bytes(key[ 3.. 7].try_into().expect("len is 4")) >> 2) & 0x3ffff03;
-		poly.r[2] = (u32::from_le_bytes(key[ 6..10].try_into().expect("len is 4")) >> 4) & 0x3ffc0ff;
-		poly.r[3] = (u32::from_le_bytes(key[ 9..13].try_into().expect("len is 4")) >> 6) & 0x3f03fff;
-		poly.r[4] = (u32::from_le_bytes(key[12..16].try_into().expect("len is 4")) >> 8) & 0x00fffff;
+		poly.r[0] = (u32::from_le_bytes(key[0..4].try_into().expect("len is 4"))) & 0x3ffffff;
+		poly.r[1] = (u32::from_le_bytes(key[3..7].try_into().expect("len is 4")) >> 2) & 0x3ffff03;
+		poly.r[2] = (u32::from_le_bytes(key[6..10].try_into().expect("len is 4")) >> 4) & 0x3ffc0ff;
+		poly.r[3] = (u32::from_le_bytes(key[9..13].try_into().expect("len is 4")) >> 6) & 0x3f03fff;
+		poly.r[4] =
+			(u32::from_le_bytes(key[12..16].try_into().expect("len is 4")) >> 8) & 0x00fffff;
 
 		poly.pad[0] = u32::from_le_bytes(key[16..20].try_into().expect("len is 4"));
 		poly.pad[1] = u32::from_le_bytes(key[20..24].try_into().expect("len is 4"));
@@ -42,7 +50,7 @@ impl Poly1305 {
 	}
 
 	fn block(&mut self, m: &[u8]) {
-		let hibit : u32 = if self.finalized { 0 } else { 1 << 24 };
+		let hibit: u32 = if self.finalized { 0 } else { 1 << 24 };
 
 		let r0 = self.r[0];
 		let r1 = self.r[1];
@@ -62,27 +70,58 @@ impl Poly1305 {
 		let mut h4 = self.h[4];
 
 		// h += m
-		h0 += (u32::from_le_bytes(m[ 0.. 4].try_into().expect("len is 4"))     ) & 0x3ffffff;
-		h1 += (u32::from_le_bytes(m[ 3.. 7].try_into().expect("len is 4")) >> 2) & 0x3ffffff;
-		h2 += (u32::from_le_bytes(m[ 6..10].try_into().expect("len is 4")) >> 4) & 0x3ffffff;
-		h3 += (u32::from_le_bytes(m[ 9..13].try_into().expect("len is 4")) >> 6) & 0x3ffffff;
+		h0 += (u32::from_le_bytes(m[0..4].try_into().expect("len is 4"))) & 0x3ffffff;
+		h1 += (u32::from_le_bytes(m[3..7].try_into().expect("len is 4")) >> 2) & 0x3ffffff;
+		h2 += (u32::from_le_bytes(m[6..10].try_into().expect("len is 4")) >> 4) & 0x3ffffff;
+		h3 += (u32::from_le_bytes(m[9..13].try_into().expect("len is 4")) >> 6) & 0x3ffffff;
 		h4 += (u32::from_le_bytes(m[12..16].try_into().expect("len is 4")) >> 8) | hibit;
 
 		// h *= r
-		let     d0 = (h0 as u64 * r0 as u64) + (h1 as u64 * s4 as u64) + (h2 as u64 * s3 as u64) + (h3 as u64 * s2 as u64) + (h4 as u64 * s1 as u64);
-		let mut d1 = (h0 as u64 * r1 as u64) + (h1 as u64 * r0 as u64) + (h2 as u64 * s4 as u64) + (h3 as u64 * s3 as u64) + (h4 as u64 * s2 as u64);
-		let mut d2 = (h0 as u64 * r2 as u64) + (h1 as u64 * r1 as u64) + (h2 as u64 * r0 as u64) + (h3 as u64 * s4 as u64) + (h4 as u64 * s3 as u64);
-		let mut d3 = (h0 as u64 * r3 as u64) + (h1 as u64 * r2 as u64) + (h2 as u64 * r1 as u64) + (h3 as u64 * r0 as u64) + (h4 as u64 * s4 as u64);
-		let mut d4 = (h0 as u64 * r4 as u64) + (h1 as u64 * r3 as u64) + (h2 as u64 * r2 as u64) + (h3 as u64 * r1 as u64) + (h4 as u64 * r0 as u64);
+		let d0 = (h0 as u64 * r0 as u64)
+			+ (h1 as u64 * s4 as u64)
+			+ (h2 as u64 * s3 as u64)
+			+ (h3 as u64 * s2 as u64)
+			+ (h4 as u64 * s1 as u64);
+		let mut d1 = (h0 as u64 * r1 as u64)
+			+ (h1 as u64 * r0 as u64)
+			+ (h2 as u64 * s4 as u64)
+			+ (h3 as u64 * s3 as u64)
+			+ (h4 as u64 * s2 as u64);
+		let mut d2 = (h0 as u64 * r2 as u64)
+			+ (h1 as u64 * r1 as u64)
+			+ (h2 as u64 * r0 as u64)
+			+ (h3 as u64 * s4 as u64)
+			+ (h4 as u64 * s3 as u64);
+		let mut d3 = (h0 as u64 * r3 as u64)
+			+ (h1 as u64 * r2 as u64)
+			+ (h2 as u64 * r1 as u64)
+			+ (h3 as u64 * r0 as u64)
+			+ (h4 as u64 * s4 as u64);
+		let mut d4 = (h0 as u64 * r4 as u64)
+			+ (h1 as u64 * r3 as u64)
+			+ (h2 as u64 * r2 as u64)
+			+ (h3 as u64 * r1 as u64)
+			+ (h4 as u64 * r0 as u64);
 
 		// (partial) h %= p
-		let mut c : u32;
-		                c = (d0 >> 26) as u32; h0 = d0 as u32 & 0x3ffffff;
-		d1 += c as u64; c = (d1 >> 26) as u32; h1 = d1 as u32 & 0x3ffffff;
-		d2 += c as u64; c = (d2 >> 26) as u32; h2 = d2 as u32 & 0x3ffffff;
-		d3 += c as u64; c = (d3 >> 26) as u32; h3 = d3 as u32 & 0x3ffffff;
-		d4 += c as u64; c = (d4 >> 26) as u32; h4 = d4 as u32 & 0x3ffffff;
-		h0 += c * 5;    c = h0 >> 26; h0 &= 0x3ffffff;
+		let mut c: u32;
+		c = (d0 >> 26) as u32;
+		h0 = d0 as u32 & 0x3ffffff;
+		d1 += c as u64;
+		c = (d1 >> 26) as u32;
+		h1 = d1 as u32 & 0x3ffffff;
+		d2 += c as u64;
+		c = (d2 >> 26) as u32;
+		h2 = d2 as u32 & 0x3ffffff;
+		d3 += c as u64;
+		c = (d3 >> 26) as u32;
+		h3 = d3 as u32 & 0x3ffffff;
+		d4 += c as u64;
+		c = (d4 >> 26) as u32;
+		h4 = d4 as u32 & 0x3ffffff;
+		h0 += c * 5;
+		c = h0 >> 26;
+		h0 &= 0x3ffffff;
 		h1 += c;
 
 		self.h[0] = h0;
@@ -95,7 +134,7 @@ impl Poly1305 {
 	pub fn finish(&mut self) {
 		if self.leftover > 0 {
 			self.buffer[self.leftover] = 1;
-			for i in self.leftover+1..16 {
+			for i in self.leftover + 1..16 {
 				self.buffer[i] = 0;
 			}
 			self.finalized = true;
@@ -110,19 +149,36 @@ impl Poly1305 {
 		let mut h3 = self.h[3];
 		let mut h4 = self.h[4];
 
-		let mut c : u32;
-		             c = h1 >> 26; h1 &= 0x3ffffff;
-		h2 +=     c; c = h2 >> 26; h2 &= 0x3ffffff;
-		h3 +=     c; c = h3 >> 26; h3 &= 0x3ffffff;
-		h4 +=     c; c = h4 >> 26; h4 &= 0x3ffffff;
-		h0 += c * 5; c = h0 >> 26; h0 &= 0x3ffffff;
-		h1 +=     c;
+		let mut c: u32;
+		c = h1 >> 26;
+		h1 &= 0x3ffffff;
+		h2 += c;
+		c = h2 >> 26;
+		h2 &= 0x3ffffff;
+		h3 += c;
+		c = h3 >> 26;
+		h3 &= 0x3ffffff;
+		h4 += c;
+		c = h4 >> 26;
+		h4 &= 0x3ffffff;
+		h0 += c * 5;
+		c = h0 >> 26;
+		h0 &= 0x3ffffff;
+		h1 += c;
 
 		// compute h + -p
-		let mut g0 = h0.wrapping_add(5); c = g0 >> 26; g0 &= 0x3ffffff;
-		let mut g1 = h1.wrapping_add(c); c = g1 >> 26; g1 &= 0x3ffffff;
-		let mut g2 = h2.wrapping_add(c); c = g2 >> 26; g2 &= 0x3ffffff;
-		let mut g3 = h3.wrapping_add(c); c = g3 >> 26; g3 &= 0x3ffffff;
+		let mut g0 = h0.wrapping_add(5);
+		c = g0 >> 26;
+		g0 &= 0x3ffffff;
+		let mut g1 = h1.wrapping_add(c);
+		c = g1 >> 26;
+		g1 &= 0x3ffffff;
+		let mut g2 = h2.wrapping_add(c);
+		c = g2 >> 26;
+		g2 &= 0x3ffffff;
+		let mut g3 = h3.wrapping_add(c);
+		c = g3 >> 26;
+		g3 &= 0x3ffffff;
 		let mut g4 = h4.wrapping_add(c).wrapping_sub(1 << 26);
 
 		// select h if h < p, or h + -p if h >= p
@@ -140,17 +196,21 @@ impl Poly1305 {
 		h4 = (h4 & mask) | g4;
 
 		// h = h % (2^128)
-		h0 = ((h0      ) | (h1 << 26)) & 0xffffffff;
-		h1 = ((h1 >>  6) | (h2 << 20)) & 0xffffffff;
+		h0 = ((h0) | (h1 << 26)) & 0xffffffff;
+		h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
 		h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
-		h3 = ((h3 >> 18) | (h4 <<  8)) & 0xffffffff;
+		h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
 
 		// h = mac = (h + pad) % (2^128)
-		let mut f : u64;
-		f = h0 as u64 + self.pad[0] as u64            ; h0 = f as u32;
-		f = h1 as u64 + self.pad[1] as u64 + (f >> 32); h1 = f as u32;
-		f = h2 as u64 + self.pad[2] as u64 + (f >> 32); h2 = f as u32;
-		f = h3 as u64 + self.pad[3] as u64 + (f >> 32); h3 = f as u32;
+		let mut f: u64;
+		f = h0 as u64 + self.pad[0] as u64;
+		h0 = f as u32;
+		f = h1 as u64 + self.pad[1] as u64 + (f >> 32);
+		h1 = f as u32;
+		f = h2 as u64 + self.pad[2] as u64 + (f >> 32);
+		h2 = f as u32;
+		f = h3 as u64 + self.pad[3] as u64 + (f >> 32);
+		h3 = f as u32;
 
 		self.h[0] = h0;
 		self.h[1] = h1;
@@ -165,7 +225,7 @@ impl Poly1305 {
 		if self.leftover > 0 {
 			let want = min(16 - self.leftover, m.len());
 			for i in 0..want {
-				self.buffer[self.leftover+i] = m[i];
+				self.buffer[self.leftover + i] = m[i];
 			}
 			m = &m[want..];
 			self.leftover += want;
@@ -194,7 +254,7 @@ impl Poly1305 {
 
 	pub fn raw_result(&mut self, output: &mut [u8]) {
 		assert!(output.len() >= 16);
-		if !self.finalized{
+		if !self.finalized {
 			self.finish();
 		}
 		output[0..4].copy_from_slice(&self.h[0].to_le_bytes());
@@ -219,35 +279,27 @@ mod test {
 	#[test]
 	fn test_nacl_vector() {
 		let key = [
-			0xee,0xa6,0xa7,0x25,0x1c,0x1e,0x72,0x91,
-			0x6d,0x11,0xc2,0xcb,0x21,0x4d,0x3c,0x25,
-			0x25,0x39,0x12,0x1d,0x8e,0x23,0x4e,0x65,
-			0x2d,0x65,0x1f,0xa4,0xc8,0xcf,0xf8,0x80,
+			0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2, 0xcb, 0x21, 0x4d,
+			0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23, 0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4,
+			0xc8, 0xcf, 0xf8, 0x80,
 		];
 
 		let msg = [
-			0x8e,0x99,0x3b,0x9f,0x48,0x68,0x12,0x73,
-			0xc2,0x96,0x50,0xba,0x32,0xfc,0x76,0xce,
-			0x48,0x33,0x2e,0xa7,0x16,0x4d,0x96,0xa4,
-			0x47,0x6f,0xb8,0xc5,0x31,0xa1,0x18,0x6a,
-			0xc0,0xdf,0xc1,0x7c,0x98,0xdc,0xe8,0x7b,
-			0x4d,0xa7,0xf0,0x11,0xec,0x48,0xc9,0x72,
-			0x71,0xd2,0xc2,0x0f,0x9b,0x92,0x8f,0xe2,
-			0x27,0x0d,0x6f,0xb8,0x63,0xd5,0x17,0x38,
-			0xb4,0x8e,0xee,0xe3,0x14,0xa7,0xcc,0x8a,
-			0xb9,0x32,0x16,0x45,0x48,0xe5,0x26,0xae,
-			0x90,0x22,0x43,0x68,0x51,0x7a,0xcf,0xea,
-			0xbd,0x6b,0xb3,0x73,0x2b,0xc0,0xe9,0xda,
-			0x99,0x83,0x2b,0x61,0xca,0x01,0xb6,0xde,
-			0x56,0x24,0x4a,0x9e,0x88,0xd5,0xf9,0xb3,
-			0x79,0x73,0xf6,0x22,0xa4,0x3d,0x14,0xa6,
-			0x59,0x9b,0x1f,0x65,0x4c,0xb4,0x5a,0x74,
-			0xe3,0x55,0xa5,
+			0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba, 0x32, 0xfc,
+			0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4, 0x47, 0x6f, 0xb8, 0xc5,
+			0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c, 0x98, 0xdc, 0xe8, 0x7b, 0x4d, 0xa7,
+			0xf0, 0x11, 0xec, 0x48, 0xc9, 0x72, 0x71, 0xd2, 0xc2, 0x0f, 0x9b, 0x92, 0x8f, 0xe2,
+			0x27, 0x0d, 0x6f, 0xb8, 0x63, 0xd5, 0x17, 0x38, 0xb4, 0x8e, 0xee, 0xe3, 0x14, 0xa7,
+			0xcc, 0x8a, 0xb9, 0x32, 0x16, 0x45, 0x48, 0xe5, 0x26, 0xae, 0x90, 0x22, 0x43, 0x68,
+			0x51, 0x7a, 0xcf, 0xea, 0xbd, 0x6b, 0xb3, 0x73, 0x2b, 0xc0, 0xe9, 0xda, 0x99, 0x83,
+			0x2b, 0x61, 0xca, 0x01, 0xb6, 0xde, 0x56, 0x24, 0x4a, 0x9e, 0x88, 0xd5, 0xf9, 0xb3,
+			0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6, 0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4,
+			0x5a, 0x74, 0xe3, 0x55, 0xa5,
 		];
 
 		let expected = [
-			0xf3,0xff,0xc7,0x70,0x3f,0x94,0x00,0xe5,
-			0x2a,0x7d,0xfb,0x4b,0x3d,0x33,0x05,0xd9,
+			0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5, 0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33,
+			0x05, 0xd9,
 		];
 
 		let mut mac = [0u8; 16];
@@ -273,20 +325,19 @@ mod test {
 	#[test]
 	fn donna_self_test() {
 		let wrap_key = [
-			0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00,
 		];
 
 		let wrap_msg = [
-			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff,
 		];
 
 		let wrap_mac = [
-			0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00,
 		];
 
 		let mut mac = [0u8; 16];
@@ -294,15 +345,14 @@ mod test {
 		assert_eq!(&mac[..], &wrap_mac[..]);
 
 		let total_key = [
-			0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xff,
-			0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xff, 0xff,
-			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-			0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+			0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0x00, 0x00, 0x00, 0x00,
 		];
 
 		let total_mac = [
-			0x64, 0xaf, 0xe2, 0xe8, 0xd6, 0xad, 0x7b, 0xbd,
-			0xd2, 0x87, 0xf9, 0x7c, 0x44, 0x62, 0x3d, 0x39,
+			0x64, 0xaf, 0xe2, 0xe8, 0xd6, 0xad, 0x7b, 0xbd, 0xd2, 0x87, 0xf9, 0x7c, 0x44, 0x62,
+			0x3d, 0x39,
 		];
 
 		let mut tpoly = Poly1305::new(&total_key);
@@ -323,17 +373,17 @@ mod test {
 		let key = b"this is 32-byte key for Poly1305";
 		let msg = [0u8; 32];
 		let expected = [
-			0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6,
-			0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc, 0x03, 0x07,
+			0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6, 0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc,
+			0x03, 0x07,
 		];
 		let mut mac = [0u8; 16];
 		poly1305(key, &msg, &mut mac);
 		assert_eq!(&mac[..], &expected[..]);
 
 		let msg = b"Hello world!";
-		let expected= [
-			0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16,
-			0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2, 0xb2, 0xf0,
+		let expected = [
+			0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16, 0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2,
+			0xb2, 0xf0,
 		];
 		poly1305(key, msg, &mut mac);
 		assert_eq!(&mac[..], &expected[..]);
diff --git a/lightning/src/crypto/streams.rs b/lightning/src/crypto/streams.rs
index 7287eed84dc..9c7df314685 100644
--- a/lightning/src/crypto/streams.rs
+++ b/lightning/src/crypto/streams.rs
@@ -1,9 +1,11 @@
 use crate::crypto::chacha20::ChaCha20;
 use crate::crypto::chacha20poly1305rfc::ChaCha20Poly1305RFC;
 
-use crate::ln::msgs::DecodeError;
-use crate::util::ser::{FixedLengthReader, LengthRead, LengthReadableArgs, Readable, Writeable, Writer};
 use crate::io::{self, Read, Write};
+use crate::ln::msgs::DecodeError;
+use crate::util::ser::{
+	FixedLengthReader, LengthRead, LengthReadableArgs, Readable, Writeable, Writer,
+};
 
 pub(crate) struct ChaChaReader<'a, R: io::Read> {
 	pub chacha: &'a mut ChaCha20,
@@ -58,7 +60,9 @@ impl<T: Readable> LengthReadableArgs<[u8; 32]> for ChaChaPolyReadAdapter<T> {
 	// LengthRead must be used instead of std::io::Read because we need the total length to separate
 	// out the tag at the end.
 	fn read<R: LengthRead>(r: &mut R, secret: [u8; 32]) -> Result<Self, DecodeError> {
-		if r.total_bytes() < 16 { return Err(DecodeError::InvalidValue) }
+		if r.total_bytes() < 16 {
+			return Err(DecodeError::InvalidValue);
+		}
 
 		let mut chacha = ChaCha20Poly1305RFC::new(&secret, &[0; 12], &[]);
 		let decrypted_len = r.total_bytes() - 16;
@@ -70,14 +74,13 @@ impl<T: Readable> LengthReadableArgs<[u8; 32]> for ChaChaPolyReadAdapter<T> {
 		let mut tag = [0 as u8; 16];
 		r.read_exact(&mut tag)?;
 		if !chacha.finish_and_check_tag(&tag) {
-			return Err(DecodeError::InvalidValue)
+			return Err(DecodeError::InvalidValue);
 		}
 
 		Ok(Self { readable })
 	}
 }
 
-
 /// Enables simultaneously reading and decrypting a ChaCha20Poly1305RFC stream from a std::io::Read.
 struct ChaChaPolyReader<'a, R: Read> {
 	pub chacha: &'a mut ChaCha20Poly1305RFC,
@@ -111,7 +114,9 @@ impl<'a, W: Writer> Writer for ChaChaPolyWriter<'a, W> {
 		let mut src_idx = 0;
 		while src_idx < src.len() {
 			let mut write_buffer = [0; 8192];
-			let bytes_written = (&mut write_buffer[..]).write(&src[src_idx..]).expect("In-memory writes can't fail");
+			let bytes_written = (&mut write_buffer[..])
+				.write(&src[src_idx..])
+				.expect("In-memory writes can't fail");
 			self.chacha.encrypt_in_place(&mut write_buffer[..bytes_written]);
 			self.write.write_all(&write_buffer[..bytes_written])?;
 			src_idx += bytes_written;
@@ -120,11 +125,10 @@ impl<'a, W: Writer> Writer for ChaChaPolyWriter<'a, W> {
 	}
 }
 
-
 #[cfg(test)]
 mod tests {
-	use crate::ln::msgs::DecodeError;
 	use super::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter};
+	use crate::ln::msgs::DecodeError;
 	use crate::util::ser::{self, FixedLengthReader, LengthReadableArgs, Writeable};
 
 	// Used for for testing various lengths of serialization.
@@ -155,34 +159,26 @@ mod tests {
 
 				// Now deserialize the object back and make sure it matches the original.
 				let mut rd = FixedLengthReader::new(encrypted_writeable, writeable_len);
-				let read_adapter = <ChaChaPolyReadAdapter<TestWriteable>>::read(&mut rd, rho).unwrap();
+				let read_adapter =
+					<ChaChaPolyReadAdapter<TestWriteable>>::read(&mut rd, rho).unwrap();
 				assert_eq!($obj, read_adapter.readable);
 			};
 		}
 
 		// Try a big object that will require multiple write buffers.
-		let big_writeable = TestWriteable {
-			field1: vec![43],
-			field2: vec![44; 4192],
-			field3: vec![45; 4192 + 1],
-		};
+		let big_writeable =
+			TestWriteable { field1: vec![43], field2: vec![44; 4192], field3: vec![45; 4192 + 1] };
 		check_object_read_write!(big_writeable);
 
 		// Try a small object that fits into one write buffer.
-		let small_writeable = TestWriteable {
-			field1: vec![43],
-			field2: vec![44],
-			field3: vec![45],
-		};
+		let small_writeable =
+			TestWriteable { field1: vec![43], field2: vec![44], field3: vec![45] };
 		check_object_read_write!(small_writeable);
 	}
 
 	fn do_chacha_stream_adapters_ser_macros() -> Result<(), DecodeError> {
-		let writeable = TestWriteable {
-			field1: vec![43],
-			field2: vec![44; 4192],
-			field3: vec![45; 4192 + 1],
-		};
+		let writeable =
+			TestWriteable { field1: vec![43], field2: vec![44; 4192], field3: vec![45; 4192 + 1] };
 
 		// First, serialize the object into a TLV stream, encrypted with ChaCha20Poly1305.
 		let rho = [42; 32];
diff --git a/lightning/src/crypto/utils.rs b/lightning/src/crypto/utils.rs
index aab406157f8..cd4d9bfa6d5 100644
--- a/lightning/src/crypto/utils.rs
+++ b/lightning/src/crypto/utils.rs
@@ -1,7 +1,7 @@
-use bitcoin::hashes::{Hash, HashEngine};
 use bitcoin::hashes::hmac::{Hmac, HmacEngine};
 use bitcoin::hashes::sha256::Hash as Sha256;
-use bitcoin::secp256k1::{Message, Secp256k1, SecretKey, ecdsa::Signature, Signing};
+use bitcoin::hashes::{Hash, HashEngine};
+use bitcoin::secp256k1::{ecdsa::Signature, Message, Secp256k1, SecretKey, Signing};
 
 use crate::sign::EntropySource;
 
@@ -43,14 +43,16 @@ macro_rules! hkdf_extract_expand {
 		let k5 = Hmac::from_engine(hmac).to_byte_array();
 
 		(k1, k2, k3, k4, k5)
-	}}
+	}};
 }
 
 pub fn hkdf_extract_expand_twice(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32]) {
 	hkdf_extract_expand!(salt, ikm, 2)
 }
 
-pub fn hkdf_extract_expand_5x(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32], [u8; 32], [u8; 32], [u8; 32]) {
+pub fn hkdf_extract_expand_5x(
+	salt: &[u8], ikm: &[u8],
+) -> ([u8; 32], [u8; 32], [u8; 32], [u8; 32], [u8; 32]) {
 	hkdf_extract_expand!(salt, ikm, 5)
 }
 
@@ -66,8 +68,11 @@ pub fn sign<C: Signing>(ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey) -> Si
 #[inline]
 #[allow(unused_variables)]
 pub fn sign_with_aux_rand<C: Signing, ES: Deref>(
-	ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey, entropy_source: &ES
-) -> Signature where ES::Target: EntropySource {
+	ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey, entropy_source: &ES,
+) -> Signature
+where
+	ES::Target: EntropySource,
+{
 	#[cfg(feature = "grind_signatures")]
 	let sig = loop {
 		let sig = ctx.sign_ecdsa_with_noncedata(msg, sk, &entropy_source.get_secure_random_bytes());
diff --git a/rustfmt_excluded_files b/rustfmt_excluded_files
index b19cbdd4973..d3c5f934a16 100644
--- a/rustfmt_excluded_files
+++ b/rustfmt_excluded_files
@@ -17,12 +17,6 @@
 ./lightning/src/chain/onchaintx.rs
 ./lightning/src/chain/package.rs
 ./lightning/src/chain/transaction.rs
-./lightning/src/crypto/chacha20.rs
-./lightning/src/crypto/chacha20poly1305rfc.rs
-./lightning/src/crypto/mod.rs
-./lightning/src/crypto/poly1305.rs
-./lightning/src/crypto/streams.rs
-./lightning/src/crypto/utils.rs
 ./lightning/src/events/bump_transaction.rs
 ./lightning/src/events/mod.rs
 ./lightning/src/lib.rs