multiformats 0.1.0

Multiformat specifications in rust-lang
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::{
    multibase::Multibase,
    multicodec::{self, Multicodec},
    multihash::Multihash,
    Error, Result,
};

#[derive(Clone, Eq, PartialEq, Debug)]
pub struct P2p {
    peer_id: PeerId,
}

#[derive(Clone, Eq, PartialEq, Debug)]
enum PeerId {
    Text(String),
    Binr(Vec<u8>),
}

impl PeerId {
    fn to_text(&self) -> Result<Self> {
        let val = match self {
            val @ PeerId::Text(_) => val.clone(),
            PeerId::Binr(buf) => {
                let (mh, _) = Multihash::decode(buf)?;
                PeerId::Text(bs58::encode(mh.encode()?).into_string())
            }
        };

        Ok(val)
    }

    fn to_bytes(&self) -> Result<Self> {
        let val = match self {
            val @ PeerId::Binr(_) => val.clone(),
            PeerId::Text(txt) => PeerId::Binr(text_to_bytes(txt)?),
        };

        Ok(val)
    }
}

impl P2p {
    pub(crate) fn from_text<'a, 'b>(parts: &'a [&'b str]) -> Result<(Self, &'a [&'b str])> {
        let val = match parts {
            [peer_id, tail @ ..] => {
                let peer_id = PeerId::Text(peer_id.to_string());
                (P2p { peer_id }, tail)
            }
            _ => err_at!(BadAddr, msg: "p2p {:?}", parts)?,
        };

        Ok(val)
    }

    pub(crate) fn to_text(&self) -> Result<String> {
        match self.peer_id.to_text()? {
            PeerId::Text(txt) => Ok("/p2p".to_string() + &txt),
            _ => unreachable!(),
        }
    }

    pub(crate) fn decode(data: &[u8]) -> Result<(Self, &[u8])> {
        use unsigned_varint::decode::u128 as uv_decode;

        let val = {
            let (addr, data) = {
                let (n, data) = err_at!(DecodeError, uv_decode(data))?;
                read_slice!(data, (n as usize), "p2p")?
            };
            let val = P2p {
                peer_id: PeerId::Binr(addr.to_vec()),
            };
            (val, data)
        };

        Ok(val)
    }

    pub(crate) fn encode(&self) -> Result<Vec<u8>> {
        use unsigned_varint::encode::u128 as uv_encode;

        let mut buf = [0_u8; 19];

        let addr = match self.peer_id.to_bytes()? {
            PeerId::Binr(buf) => buf,
            _ => unreachable!(),
        };

        let mut data = Multicodec::from_code(multicodec::P2P)?.encode()?;
        data.extend_from_slice(uv_encode(addr.len() as u128, &mut buf));
        data.extend_from_slice(&addr);
        Ok(data)
    }

    pub fn to_peer_id(&self) -> Result<String> {
        match self.peer_id.to_text()? {
            PeerId::Text(txt) => Ok(txt),
            _ => unreachable!(),
        }
    }
}

fn text_to_bytes(text: &str) -> Result<Vec<u8>> {
    let mut chars = text.chars();
    let mh = match (chars.next(), chars.next()) {
        (Some('Q'), Some('m')) | (Some('1'), Some(_)) => {
            // legacy format base58btc.
            let bytes = err_at!(BadInput, bs58::decode(text.as_bytes()).into_vec())?;
            let (mh, _) = Multihash::decode(&bytes)?;
            mh
        }
        _ => {
            let bytes = {
                let mb = Multibase::from_text(text)?;
                match mb.to_bytes() {
                    Some(bytes) => bytes,
                    None => err_at!(BadInput, msg: "{}", text)?,
                }
            };
            // <multicodec-cidv1><libp2p-key-codec><multihash>
            let (codec, bytes) = Multicodec::decode(&bytes)?;
            match codec.to_code() {
                multicodec::CID_V1 => (),
                _ => err_at!(BadInput, msg: "CID {}", codec)?,
            }

            let (codec, bytes) = Multicodec::decode(bytes)?;
            match codec.to_code() {
                multicodec::LIBP2P_KEY => (),
                _ => err_at!(BadInput, msg: "codec {}", codec)?,
            }
            let (mh, _) = Multihash::decode(bytes)?;
            mh
        }
    };

    mh.encode()
}