refactor: don't depend on multihash features

core/Cargo.toml

@@ -19,7 +19,7 @@ instant = "0.1.11"
 libp2p-identity = { version = "0.1", path = "../identity", features = ["peerid", "ed25519"] }
 log = "0.4"
 multiaddr = { version = "0.17.0" }
-multihash = { version = "0.17.0", default-features = false, features = ["std", "multihash-impl", "identity", "sha2"] }
+multihash = { version = "0.17.0", default-features = false, features = ["std"] }
 multistream-select = { version = "0.12.1", path = "../misc/multistream-select" }
 once_cell = "1.17.1"
 parking_lot = "0.12.0"

identity/src/peer_id.rs

@@ -19,18 +19,24 @@
 // DEALINGS IN THE SOFTWARE.
 
 use multiaddr::{Multiaddr, Protocol};
-use multihash::{Code, Error, Multihash};
+use multihash::{Code, Error, MultihashGeneric};
 use rand::Rng;
+use sha2::Digest as _;
 use std::{convert::TryFrom, fmt, str::FromStr};
 use thiserror::Error;
 
+type Multihash = MultihashGeneric<64>;
+
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 /// Public keys with byte-lengths smaller than `MAX_INLINE_KEY_LENGTH` will be
 /// automatically used as the peer id using an identity multihash.
 const MAX_INLINE_KEY_LENGTH: usize = 42;
 
+const MULTIHASH_IDENTITY_CODE: u64 = 0;
+const MULTIHASH_SHA256_CODE: u64 = 0x12;
+
 /// Identifier of a peer of the network.
 ///
 /// The data is a CIDv0 compatible multihash of the protobuf encoded public key of the peer
@@ -55,18 +61,16 @@ impl fmt::Display for PeerId {
 impl PeerId {
     /// Builds a `PeerId` from a public key.
     pub fn from_public_key(key: &crate::keypair::PublicKey) -> PeerId {
-        use multihash::MultihashDigest as _;
-
         let key_enc = key.to_protobuf_encoding();
 
-        let hash_algorithm = if key_enc.len() <= MAX_INLINE_KEY_LENGTH {
-            Code::Identity
+        let multihash = if key_enc.len() <= MAX_INLINE_KEY_LENGTH {
+            Multihash::wrap(MULTIHASH_IDENTITY_CODE, &key_enc)
+                .expect("64 byte multihash provides sufficient space")
         } else {
-            Code::Sha2_256
+            Multihash::wrap(MULTIHASH_SHA256_CODE, &sha2::Sha256::digest(key_enc))
+                .expect("64 byte multihash provides sufficient space")
         };
 
-        let multihash = hash_algorithm.digest(&key_enc);
-
         PeerId { multihash }
     }
 
@@ -82,9 +86,9 @@ impl PeerId {
     /// or the hash value does not satisfy the constraints for a hashed
     /// peer ID, it is returned as an `Err`.
     pub fn from_multihash(multihash: Multihash) -> Result<PeerId, Multihash> {
-        match Code::try_from(multihash.code()) {
-            Ok(Code::Sha2_256) => Ok(PeerId { multihash }),
-            Ok(Code::Identity) if multihash.digest().len() <= MAX_INLINE_KEY_LENGTH => {
+        match multihash.code() {
+            MULTIHASH_SHA256_CODE => Ok(PeerId { multihash }),
+            MULTIHASH_IDENTITY_CODE if multihash.digest().len() <= MAX_INLINE_KEY_LENGTH => {
                 Ok(PeerId { multihash })
             }
             _ => Err(multihash),

protocols/kad/src/behaviour/test.rs

@@ -30,7 +30,7 @@ use futures_timer::Delay;
 use libp2p_core::{
     connection::ConnectedPoint,
     multiaddr::{multiaddr, Multiaddr, Protocol},
-    multihash::{Code, Multihash, MultihashDigest},
+    multihash::Multihash,
     transport::MemoryTransport,
     upgrade, Endpoint, Transport,
 };
@@ -138,7 +138,7 @@ fn build_fully_connected_nodes_with_config(
 }
 
 fn random_multihash() -> Multihash {
-    Multihash::wrap(Code::Sha2_256.into(), &thread_rng().gen::<[u8; 32]>()).unwrap()
+    Multihash::wrap(0x12, &thread_rng().gen::<[u8; 32]>()).unwrap()
 }
 
 #[derive(Clone, Debug)]
@@ -1100,7 +1100,10 @@ fn disjoint_query_does_not_finish_before_all_paths_did() {
     let mut trudy = build_node(); // Trudy the intrudor, an adversary.
     let mut bob = build_node();
 
-    let key = Key::from(Code::Sha2_256.digest(&thread_rng().gen::<[u8; 32]>()));
+    let key = Key::from(
+        Multihash::wrap(0x12, &thread_rng().gen::<[u8; 32]>())
+            .expect("32 array to fit into 64 byte multihash"),
+    );
     let record_bob = Record::new(key.clone(), b"bob".to_vec());
     let record_trudy = Record::new(key.clone(), b"trudy".to_vec());
 

protocols/kad/src/kbucket/key.rs

@@ -196,7 +196,6 @@ impl Distance {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use libp2p_core::multihash::Code;
     use quickcheck::*;
 
     impl Arbitrary for Key<PeerId> {
@@ -208,7 +207,7 @@ mod tests {
     impl Arbitrary for Key<Multihash> {
         fn arbitrary(g: &mut Gen) -> Key<Multihash> {
             let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
-            Key::from(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
+            Key::from(Multihash::wrap(0x12, &hash).unwrap())
         }
     }
 

protocols/kad/src/query/peers/closest.rs

@@ -475,7 +475,7 @@ enum PeerState {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use libp2p_core::multihash::{Code, Multihash};
+    use libp2p_core::multihash::{Multihash};
     use libp2p_identity::PeerId;
     use quickcheck::*;
     use rand::{rngs::StdRng, Rng, SeedableRng};
@@ -484,10 +484,8 @@ mod tests {
     fn random_peers<R: Rng>(n: usize, g: &mut R) -> Vec<PeerId> {
         (0..n)
             .map(|_| {
-                PeerId::from_multihash(
-                    Multihash::wrap(Code::Sha2_256.into(), &g.gen::<[u8; 32]>()).unwrap(),
-                )
-                .unwrap()
+                PeerId::from_multihash(Multihash::wrap(0x12, &g.gen::<[u8; 32]>()).unwrap())
+                    .unwrap()
             })
             .collect()
     }
@@ -504,9 +502,7 @@ mod tests {
     impl Arbitrary for ArbitraryPeerId {
         fn arbitrary(g: &mut Gen) -> ArbitraryPeerId {
             let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
-            let peer_id =
-                PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
-                    .unwrap();
+            let peer_id = PeerId::from_multihash(Multihash::wrap(0x12, &hash).unwrap()).unwrap();
             ArbitraryPeerId(peer_id)
         }
     }

protocols/kad/src/query/peers/closest/disjoint.rs

@@ -445,7 +445,7 @@ mod tests {
     use super::*;
 
     use crate::K_VALUE;
-    use libp2p_core::multihash::{Code, Multihash};
+    use libp2p_core::multihash::Multihash;
     use quickcheck::*;
     use std::collections::HashSet;
     use std::iter;
@@ -530,9 +530,7 @@ mod tests {
     impl Arbitrary for ArbitraryPeerId {
         fn arbitrary(g: &mut Gen) -> ArbitraryPeerId {
             let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
-            let peer_id =
-                PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
-                    .unwrap();
+            let peer_id = PeerId::from_multihash(Multihash::wrap(0x12, &hash).unwrap()).unwrap();
             ArbitraryPeerId(peer_id)
         }
     }

protocols/kad/src/record.rs

@@ -161,14 +161,13 @@ impl ProviderRecord {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use libp2p_core::multihash::Code;
     use quickcheck::*;
     use std::time::Duration;
 
     impl Arbitrary for Key {
         fn arbitrary(g: &mut Gen) -> Key {
             let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
-            Key::from(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
+            Key::from(Multihash::wrap(0x12, &hash).unwrap())
         }
     }
 

protocols/kad/src/record/store/memory.rs

@@ -216,12 +216,12 @@ impl RecordStore for MemoryStore {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use libp2p_core::multihash::{Code, Multihash};
+    use libp2p_core::multihash::Multihash;
     use quickcheck::*;
     use rand::Rng;
 
     fn random_multihash() -> Multihash {
-        Multihash::wrap(Code::Sha2_256.into(), &rand::thread_rng().gen::<[u8; 32]>()).unwrap()
+        Multihash::wrap(0x12, &rand::thread_rng().gen::<[u8; 32]>()).unwrap()
     }
 
     fn distance(r: &ProviderRecord) -> kbucket::Distance {

transports/webrtc/Cargo.toml

@@ -22,7 +22,8 @@ libp2p-core = { version = "0.39.0", path = "../../core"  }
 libp2p-noise = { version = "0.42.0", path = "../../transports/noise" }
 libp2p-identity = { version = "0.1.0", path = "../../identity" }
 log = "0.4"
-multihash = { version = "0.17.0", default-features = false, features = ["sha2"] }
+sha2 = "0.10.6"
+multihash = { version = "0.17.0", default-features = false }
 quick-protobuf = "0.8"
 quick-protobuf-codec = { version = "0.1", path = "../../misc/quick-protobuf-codec" }
 rand = "0.8"

transports/webrtc/src/tokio/fingerprint.rs

@@ -18,12 +18,15 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use multihash::{Code, Hasher, Multihash, MultihashDigest};
-use webrtc::dtls_transport::dtls_fingerprint::RTCDtlsFingerprint;
-
+use multihash::MultihashGeneric;
+use sha2::Digest as _;
 use std::fmt;
+use webrtc::dtls_transport::dtls_fingerprint::RTCDtlsFingerprint;
 
 const SHA256: &str = "sha-256";
+const MULTIHASH_SHA256_CODE: u64 = 0x12;
+
+type Multihash = MultihashGeneric<64>;
 
 /// A certificate fingerprint that is assumed to be created using the SHA256 hash algorithm.
 #[derive(Eq, PartialEq, Copy, Clone)]
@@ -39,13 +42,7 @@ impl Fingerprint {
 
     /// Creates a fingerprint from a raw certificate.
     pub fn from_certificate(bytes: &[u8]) -> Self {
-        let mut h = multihash::Sha2_256::default();
-        h.update(bytes);
-
-        let mut bytes: [u8; 32] = [0; 32];
-        bytes.copy_from_slice(h.finalize());
-
-        Fingerprint(bytes)
+        Fingerprint(sha2::Sha256::digest(bytes).into())
     }
 
     /// Converts [`RTCDtlsFingerprint`] to [`Fingerprint`].
@@ -62,7 +59,7 @@ impl Fingerprint {
 
     /// Converts [`type@Multihash`] to [`Fingerprint`].
     pub fn try_from_multihash(hash: Multihash) -> Option<Self> {
-        if hash.code() != u64::from(Code::Sha2_256) {
+        if hash.code() != MULTIHASH_SHA256_CODE {
             // Only support SHA256 for now.
             return None;
         }
@@ -74,9 +71,7 @@ impl Fingerprint {
 
     /// Converts this fingerprint to [`type@Multihash`].
     pub fn to_multihash(self) -> Multihash {
-        Code::Sha2_256
-            .wrap(&self.0)
-            .expect("fingerprint's len to be 32 bytes")
+        Multihash::wrap(MULTIHASH_SHA256_CODE, &self.0).expect("fingerprint's len to be 32 bytes")
     }
 
     /// Formats this fingerprint as uppercase hex, separated by colons (`:`).