tiny-cid 0.2.8

CID in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use std::convert::TryFrom;

use quickcheck::{Arbitrary, Gen};
use rand::seq::SliceRandom;
use rand::Rng;
use tiny_multihash::{Multihash, MultihashDigest, SHA2_256};

use crate::codec::*;
use crate::{Cid, Version};

const CODECS: [u64; 18] = [
    RAW,
    DAG_PROTOBUF,
    DAG_CBOR,
    DAG_JSON,
    GIT_RAW,
    ETHEREUM_BLOCK,
    ETHEREUM_BLOCK_LIST,
    ETHEREUM_TX_TRIE,
    ETHEREUM_TX,
    ETHEREUM_TX_RECEIPT_TRIE,
    ETHEREUM_RECEIPT,
    ETHEREUM_STATE_TRIE,
    ETHEREUM_ACCOUNT_SNAPSHOT,
    ETHEREUM_STORAGE_TRIE,
    BITCOIN_BLOCK,
    BITCOIN_TX,
    ZCASH_BLOCK,
    ZCASH_TX,
];

const POPULAR: [u64; 4] = [RAW, DAG_PROTOBUF, DAG_CBOR, DAG_JSON];

impl Arbitrary for Version {
    fn arbitrary<G: Gen>(g: &mut G) -> Self {
        let version = if g.gen_bool(0.7) { 1 } else { 0 };
        Version::try_from(version).unwrap()
    }
}

impl Arbitrary for Cid {
    fn arbitrary<G: Gen>(g: &mut G) -> Self {
        let version: Version = Arbitrary::arbitrary(g);
        if version == Version::V0 {
            let data: Vec<u8> = Arbitrary::arbitrary(g);
            let hash = Multihash::new(SHA2_256, &data).unwrap().to_raw().unwrap();
            Cid::new_v0(hash).expect("sha2_256 is a valid hash for cid v0")
        } else {
            loop {
                // chose the most frequently used codecs more often
                let codec = if g.gen_bool(0.7) {
                    *POPULAR.choose(g).unwrap()
                } else {
                    *CODECS.choose(g).unwrap()
                };
                let hash: Multihash = Arbitrary::arbitrary(g);
                if hash.size() > 32 {
                    continue;
                }
                return Cid::new_v1(codec, hash.to_raw().unwrap());
            }
        }
    }
}