Update to multihash 0.19

Cargo.toml

@@ -11,15 +11,16 @@ edition = "2021"
 rust-version = "1.60"
 
 [features]
-default = ["std", "multihash/default"]
-std = ["multihash/std", "unsigned-varint/std", "alloc", "multibase/std", "serde/std"]
+default = ["std", "multihash/default", "multihash-codetable/default"]
+std = ["multihash/std", "multihash-codetable/std", "unsigned-varint/std", "alloc", "multibase/std", "serde/std"]
 alloc = ["multibase", "multihash/alloc", "core2/alloc", "serde/alloc"]
-arb = ["quickcheck", "rand", "multihash/arb", "multihash/multihash-impl", "multihash/sha2", "arbitrary"]
+arb = ["quickcheck", "rand", "multihash/arb", "arbitrary"]
 scale-codec = ["parity-scale-codec", "multihash/scale-codec"]
 serde-codec = ["alloc", "serde", "multihash/serde-codec", "serde_bytes"]
 
 [dependencies]
-multihash = { version = "0.18.0", default-features = false }
+multihash = { version = "0.19.0", default-features = false }
+multihash-codetable = { version = "0.1.0", default-features = false, features = ["digest", "sha2"] }
 unsigned-varint = { version = "0.7.0", default-features = false }
 
 multibase = { version = "0.9.1", optional = true, default-features = false }
@@ -33,5 +34,5 @@ arbitrary = { version = "1.1.0", optional = true }
 core2 = { version = "0.4", default-features = false }
 
 [dev-dependencies]
+multihash-derive = { version = "0.9.0", default-features = false }
 serde_json = "1.0.59"
-

examples/readme.rs

@@ -1,4 +1,4 @@
-use cid::multihash::{Code, MultihashDigest};
+use cid::multihash_codetable::{Code, MultihashDigest};
 use cid::Cid;
 use std::convert::TryFrom;
 

src/arb.rs

@@ -2,7 +2,8 @@
 
 use std::convert::TryFrom;
 
-use multihash::{Code, MultihashDigest, MultihashGeneric};
+use multihash::Multihash;
+use multihash_codetable::{Code, MultihashDigest};
 use quickcheck::Gen;
 use rand::{
     distributions::{weighted::WeightedIndex, Distribution},
@@ -48,7 +49,7 @@ impl<const S: usize> quickcheck::Arbitrary for CidGeneric<S> {
                 _ => unreachable!(),
             };
 
-            let hash: MultihashGeneric<S> = quickcheck::Arbitrary::arbitrary(g);
+            let hash: Multihash<S> = quickcheck::Arbitrary::arbitrary(g);
             CidGeneric::new_v1(codec, hash)
         }
     }
@@ -57,7 +58,7 @@ impl<const S: usize> quickcheck::Arbitrary for CidGeneric<S> {
 impl<'a, const S: usize> arbitrary::Arbitrary<'a> for CidGeneric<S> {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         if S >= 32 && u.ratio(1, 10)? {
-            let mh = MultihashGeneric::wrap(Code::Sha2_256.into(), u.bytes(32)?).unwrap();
+            let mh = Multihash::wrap(Code::Sha2_256.into(), u.bytes(32)?).unwrap();
             return Ok(CidGeneric::new_v0(mh).expect("32 bytes is correct for v0"));
         }
 
@@ -86,7 +87,7 @@ impl<'a, const S: usize> arbitrary::Arbitrary<'a> for CidGeneric<S> {
         let v1 = size_hint::and_all(&[
             <[u8; 2]>::size_hint(depth),
             (0, Some(8)),
-            <MultihashGeneric<S> as arbitrary::Arbitrary>::size_hint(depth),
+            <Multihash<S> as arbitrary::Arbitrary>::size_hint(depth),
         ]);
         if S >= 32 {
             size_hint::and(<u8>::size_hint(depth), size_hint::or((32, Some(32)), v1))
@@ -100,7 +101,7 @@ impl<'a, const S: usize> arbitrary::Arbitrary<'a> for CidGeneric<S> {
 mod tests {
     use crate::CidGeneric;
     use arbitrary::{Arbitrary, Unstructured};
-    use multihash::MultihashGeneric;
+    use multihash::Multihash;
 
     #[test]
     fn arbitrary() {
@@ -110,7 +111,7 @@ mod tests {
         ]);
         let c = <CidGeneric<16> as Arbitrary>::arbitrary(&mut u).unwrap();
         let c2 =
-            CidGeneric::<16>::new_v1(22, MultihashGeneric::wrap(13, &[6, 7, 8, 9, 6]).unwrap());
+            CidGeneric::<16>::new_v1(22, Multihash::wrap(13, &[6, 7, 8, 9, 6]).unwrap());
         assert_eq!(c.hash(), c2.hash());
         assert_eq!(c.codec(), c2.codec());
         assert_eq!(c, c2)

src/cid.rs

@@ -10,7 +10,7 @@ use core::convert::TryFrom;
 #[cfg(feature = "alloc")]
 use multibase::{encode as base_encode, Base};
 
-use multihash::MultihashGeneric as Multihash;
+use multihash::Multihash;
 use unsigned_varint::encode as varint_encode;
 
 #[cfg(feature = "alloc")]
@@ -228,7 +228,7 @@ impl<const S: usize> Cid<S> {
     /// ```
     /// use cid::Cid;
     /// use multibase::Base;
-    /// use multihash::{Code, MultihashDigest};
+    /// use multihash_codetable::{Code, MultihashDigest};
     ///
     /// const RAW: u64 = 0x55;
     ///

src/lib.rs

@@ -21,6 +21,7 @@ pub use self::version::Version;
 #[cfg(feature = "alloc")]
 pub use multibase;
 pub use multihash;
+pub use multihash_codetable;
 
 /// A Cid that contains a multihash with an allocated size of 512 bits.
 ///

tests/lib.rs

@@ -4,7 +4,8 @@ use std::str::FromStr;
 
 use cid::{Cid, CidGeneric, Error, Version};
 use multibase::Base;
-use multihash::{derive::Multihash, Code, MultihashDigest};
+use multihash_derive::MultihashDigest;
+use multihash_codetable::{Code, MultihashDigest as MultihashDerive};
 
 const RAW: u64 = 0x55;
 const DAG_PB: u64 = 0x70;
@@ -174,10 +175,10 @@ fn a_function_that_takes_a_generic_cid<const S: usize>(cid: &CidGeneric<S>) -> S
 // is using `Cid` instead of `Cid<SomeSize>`. The code will still work with other sizes.
 #[test]
 fn method_can_take_differently_sized_cids() {
-    #[derive(Clone, Copy, Debug, Eq, PartialEq, Multihash)]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq, MultihashDerive)]
     #[mh(alloc_size = 128)]
     enum Code128 {
-        #[mh(code = 0x12, hasher = multihash::Sha2_256)]
+        #[mh(code = 0x12, hasher = multihash_codetable::Sha2_256)]
         Sha2_256,
     }