Merge pull request #104 from crisdut/fix/convert-merkle-proof

Fix merkle proof conversion

Author: dr-orlovsky

commit_verify/src/lnpbp4.rs

@@ -538,7 +538,7 @@ impl CommitConceal for MerkleBlock {
     fn commit_conceal(&self) -> Self::ConcealedCommitment {
         let mut concealed = self.clone();
         concealed
-            .conceal_except(&[])
+            .conceal_except([])
             .expect("broken internal MerkleBlock structure");
         debug_assert_eq!(concealed.cross_section.len(), 1);
         concealed.cross_section[0].merkle_node_with(0)
@@ -843,8 +843,9 @@ impl MerkleBlock {
         for node in &self.cross_section {
             match node {
                 TreeNode::ConcealedNode { depth, hash } => {
+                    let inserted = map.insert(*depth, *hash).is_none();
                     debug_assert!(
-                        map.insert(*depth, *hash).is_none(),
+                        inserted,
                         "MerkleBlock conceal procedure is broken"
                     );
                 }

strict_encoding/derive/tests/basics.rs

@@ -80,7 +80,7 @@ fn bytes() -> Result {
         &Vect {
             data: data[2..].to_vec(),
         },
-        &data,
+        data,
     )?;
 
     #[derive(Clone, PartialEq, Eq, Debug)]
@@ -102,7 +102,7 @@ fn bytes() -> Result {
     #[derive(Clone, PartialEq, Eq, Debug)]
     #[derive(StrictEncode, StrictDecode)]
     struct Heap(Box<[u8]>);
-    test_encoding_roundtrip(&Heap(Box::from(&data[2..])), &data)
+    test_encoding_roundtrip(&Heap(Box::from(&data[2..])), data)
         .map_err(Error::from)
 }
 
@@ -124,7 +124,7 @@ fn skipping() -> Result {
             data: s!("String"),
             ephemeral: false,
         },
-        &[0x06, 0x00, b'S', b't', b'r', b'i', b'n', b'g'],
+        [0x06, 0x00, b'S', b't', b'r', b'i', b'n', b'g'],
     )
     .map_err(Error::from)
 }

strict_encoding/derive/tests/tlv.rs

@@ -187,7 +187,7 @@ fn tlv_optional() -> Result {
             fixed: 0xDD,
             tlv: None,
         },
-        &[0xDD],
+        [0xDD],
     )?;
     test_encoding_roundtrip(
         &Tlv {
@@ -210,7 +210,7 @@ fn tlv_newtype() -> Result {
     #[network_encoding(use_tlv)]
     struct Tlv(#[network_encoding(tlv = 0xBEEF)] Option<u32>);
 
-    test_encoding_roundtrip(&Tlv(None), &[])?;
+    test_encoding_roundtrip(&Tlv(None), [])?;
     //    println!("{:02x?}", Tlv::strict_deserialize(tlv_u32!())?);
     test_encoding_roundtrip(&Tlv(Some(TLV_U32)), tlv_u32!())
         .map_err(Error::from)
@@ -228,7 +228,7 @@ fn tlv_default() -> Result {
         tlv: Vec<u8>,
     }
 
-    test_encoding_roundtrip(&TlvDefault::default(), &[0x00])?;
+    test_encoding_roundtrip(&TlvDefault::default(), [0x00])?;
 
     test_encoding_roundtrip(
         &TlvDefault {
@@ -271,19 +271,19 @@ fn tlv_ordering() -> Result {
         0x01, 0x00, // length
         0xA2, // value
     ];
-    let _: Tlv = strict_deserialize(&data).unwrap();
+    let _: Tlv = strict_deserialize(data).unwrap();
 
-    test_encoding_roundtrip(&Tlv::default(), &[])?;
+    test_encoding_roundtrip(&Tlv::default(), [])?;
     test_encoding_roundtrip(
         &Tlv {
             second: Some(0xA2),
             first: Some(0xA1),
         },
-        &data,
+        data,
     )?;
 
     // Now lets switch ordering
-    Tlv::strict_deserialize(&[
+    Tlv::strict_deserialize([
         // Count of TLV fields
         0x02, 0x00, //
         // Second goes first
@@ -318,16 +318,16 @@ fn pseudo_tlv() -> Result {
     ];
 
     // Checking that the data are entirely consumed
-    let _: Tlv = strict_deserialize(&data1).unwrap();
-    let _: Tlv = strict_deserialize(&data2).unwrap();
+    let _: Tlv = strict_deserialize(data1).unwrap();
+    let _: Tlv = strict_deserialize(data2).unwrap();
 
-    test_encoding_roundtrip(&Tlv::default(), &data1)?;
+    test_encoding_roundtrip(&Tlv::default(), data1)?;
     test_encoding_roundtrip(
         &Tlv {
             vec: vec![0xB1, 0xB2, 0xB3],
             unknown_tlvs: bmap! {},
         },
-        &data2,
+        data2,
     )
     .map_err(Error::from)
 }
@@ -345,13 +345,13 @@ fn tlv_collection() -> Result {
         vec: Vec<u8>,
     }
 
-    test_encoding_roundtrip(&Tlv::default(), &[])?;
+    test_encoding_roundtrip(&Tlv::default(), [])?;
     test_encoding_roundtrip(
         &Tlv {
             map: bmap! { 0xA1u8 => s!("First"), 0xA2u8 => s!("Second") },
             vec: vec![0xB1, 0xB2, 0xB3],
         },
-        &[
+        [
             // Count of TLV fields
             0x02, 0x00, //
             // First goes first
@@ -389,7 +389,7 @@ fn tlv_unknown() -> Result {
         rest_of_tlvs: tlv::Stream,
     }
 
-    test_encoding_roundtrip(&TlvStream::default(), &[0x00; 2])
+    test_encoding_roundtrip(&TlvStream::default(), [0x00; 2])
         .map_err(Error::from)
 }
 

strict_encoding/src/bitcoin.rs

@@ -923,7 +923,7 @@ pub(crate) mod test {
         test_encoding_roundtrip(&secp_pk_03, PK_BYTES_03).unwrap();
         test_encoding_roundtrip(&secp_pk_one, PK_BYTES_ONEKEY).unwrap();
         assert_eq!(
-            secp256k1::PublicKey::strict_deserialize(&PK_BYTES_04),
+            secp256k1::PublicKey::strict_deserialize(PK_BYTES_04),
             Err(Error::DataIntegrityError(s!("invalid public key data: \
                                               uncompressed Secp256k1 \
                                               public key format is not \
@@ -1026,21 +1026,21 @@ pub(crate) mod test {
         let msg = Message::from_slice(&[1u8; 32]).unwrap();
 
         let ecdsa = secp.sign_ecdsa(&msg, &sk_ecdsa);
-        test_encoding_roundtrip(&ecdsa, &ECDSA_BYTES).unwrap();
+        test_encoding_roundtrip(&ecdsa, ECDSA_BYTES).unwrap();
         assert!(secp.verify_ecdsa(&msg, &ecdsa, &pk_ecdsa).is_ok());
 
         let schnorr =
             secp.sign_schnorr_with_aux_rand(&msg, &sk_schnorr, &[0u8; 32]);
-        test_encoding_roundtrip(&schnorr, &SCHNORR_BYTES).unwrap();
+        test_encoding_roundtrip(&schnorr, SCHNORR_BYTES).unwrap();
         assert!(secp.verify_schnorr(&schnorr, &msg, &pk_schnorr).is_ok());
 
         // Schnorr signature can be deserialized as ECDSA and vice verse,
         // (since there is no encoding-level way of verifying its type)
         // but MUST be invalid upon signature validation
         let schnorr_as_ecdsa: ecdsa::Signature =
-            test_vec_decoding_roundtrip(&SCHNORR_BYTES).unwrap();
+            test_vec_decoding_roundtrip(SCHNORR_BYTES).unwrap();
         let ecdsa_as_schnorr: schnorr::Signature =
-            test_vec_decoding_roundtrip(&ECDSA_BYTES).unwrap();
+            test_vec_decoding_roundtrip(ECDSA_BYTES).unwrap();
         assert_eq!(
             secp.verify_ecdsa(&msg, &schnorr_as_ecdsa, &pk_ecdsa),
             Err(secp256k1::Error::IncorrectSignature)
@@ -1066,16 +1066,16 @@ pub(crate) mod test {
     #[test]
     fn test_encoding_network(
     ) -> Result<(), DataEncodingTestFailure<bitcoin::Network>> {
-        test_encoding_roundtrip(&bitcoin::Network::Bitcoin, &[
+        test_encoding_roundtrip(&bitcoin::Network::Bitcoin, [
             0xF9, 0xBE, 0xB4, 0xD9,
         ])?;
-        test_encoding_roundtrip(&bitcoin::Network::Testnet, &[
+        test_encoding_roundtrip(&bitcoin::Network::Testnet, [
             0x0B, 0x11, 0x09, 0x07,
         ])?;
-        test_encoding_roundtrip(&bitcoin::Network::Signet, &[
+        test_encoding_roundtrip(&bitcoin::Network::Signet, [
             0x0A, 0x03, 0xCF, 0x40,
         ])?;
-        test_encoding_roundtrip(&bitcoin::Network::Regtest, &[
+        test_encoding_roundtrip(&bitcoin::Network::Regtest, [
             0xFA, 0xBF, 0xB5, 0xDA,
         ])
     }
@@ -1224,9 +1224,9 @@ pub(crate) mod test {
 
         // test random and null outpoints
         let outpoint = OutPoint::new(txid, vout);
-        test_encoding_roundtrip(&outpoint, &OUTPOINT).unwrap();
+        test_encoding_roundtrip(&outpoint, OUTPOINT).unwrap();
         let null = OutPoint::null();
-        test_encoding_roundtrip(&null, &OUTPOINT_NULL).unwrap();
+        test_encoding_roundtrip(&null, OUTPOINT_NULL).unwrap();
     }
 
     #[test]
@@ -1342,14 +1342,14 @@ pub(crate) mod test {
             9ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
         )
         .unwrap();
-        test_encoding_roundtrip(&ext_pubkey1, &EXT_PUBKEY1).unwrap();
+        test_encoding_roundtrip(&ext_pubkey1, EXT_PUBKEY1).unwrap();
 
         let ext_pubkey2 = bip32::ExtendedPubKey::from_str(
             "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJP\
             MM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5",
         )
         .unwrap();
-        test_encoding_roundtrip(&ext_pubkey2, &EXT_PUBKEY2).unwrap();
+        test_encoding_roundtrip(&ext_pubkey2, EXT_PUBKEY2).unwrap();
     }
 
     #[test]
@@ -1390,28 +1390,27 @@ pub(crate) mod test {
         ];
 
         // OP_RETURN
-        let op_return: Script =
-            test_vec_decoding_roundtrip(&OP_RETURN).unwrap();
+        let op_return: Script = test_vec_decoding_roundtrip(OP_RETURN).unwrap();
         assert!(op_return.is_op_return());
 
         // P2PK
-        let p2pk: Script = test_vec_decoding_roundtrip(&P2PK).unwrap();
+        let p2pk: Script = test_vec_decoding_roundtrip(P2PK).unwrap();
         assert!(p2pk.is_p2pk());
 
         //P2PKH
-        let p2pkh: Script = test_vec_decoding_roundtrip(&P2PKH).unwrap();
+        let p2pkh: Script = test_vec_decoding_roundtrip(P2PKH).unwrap();
         assert!(p2pkh.is_p2pkh());
 
         //P2SH
-        let p2sh: Script = test_vec_decoding_roundtrip(&P2SH).unwrap();
+        let p2sh: Script = test_vec_decoding_roundtrip(P2SH).unwrap();
         assert!(p2sh.is_p2sh());
 
         //P2WPKH
-        let p2wpkh: Script = test_vec_decoding_roundtrip(&P2WPKH).unwrap();
+        let p2wpkh: Script = test_vec_decoding_roundtrip(P2WPKH).unwrap();
         assert!(p2wpkh.is_v0_p2wpkh());
 
         //P2WSH
-        let p2wsh: Script = test_vec_decoding_roundtrip(&P2WSH).unwrap();
+        let p2wsh: Script = test_vec_decoding_roundtrip(P2WSH).unwrap();
         assert!(p2wsh.is_v0_p2wsh());
     }
 }

strict_encoding/src/miniscript.rs

@@ -1207,15 +1207,15 @@ mod test {
 
     #[test]
     #[should_panic]
-    fn test_bare_ctx() { BareCtx::strict_deserialize(&[0u8]).unwrap(); }
+    fn test_bare_ctx() { BareCtx::strict_deserialize([0u8]).unwrap(); }
 
     #[test]
     #[should_panic]
-    fn test_legacy_ctx() { Legacy::strict_deserialize(&[0u8]).unwrap(); }
+    fn test_legacy_ctx() { Legacy::strict_deserialize([0u8]).unwrap(); }
 
     #[test]
     #[should_panic]
-    fn test_segwitv0_ctx() { Segwitv0::strict_deserialize(&[0u8]).unwrap(); }
+    fn test_segwitv0_ctx() { Segwitv0::strict_deserialize([0u8]).unwrap(); }
 
     #[test]
     fn test_policy() {

strict_encoding/src/slice32.rs

@@ -58,7 +58,7 @@ mod test {
         assert_eq!(&ser, &data);
         assert_eq!(Slice32::strict_deserialize(&ser), Ok(slice32));
 
-        assert_eq!(Slice32::from_slice(&data), Some(slice32));
+        assert_eq!(Slice32::from_slice(data), Some(slice32));
         assert_eq!(Slice32::from_slice(&data[..30]), None);
         assert_eq!(&slice32.to_vec(), &data);
         assert_eq!(&slice32.as_inner()[..], &data);