hubert 0.5.0

Secure distributed substrate for multiparty transactions using write-once key-value storage with ARID-based addressing
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::io::Cursor;

use futures_util::TryStreamExt;
use ipfs_api_backend_hyper::{IpfsApi, IpfsClient};

use super::error::Error;

/// Add (upload) bytes to IPFS and return the CID.
pub async fn add_bytes(
    client: &IpfsClient,
    bytes: Vec<u8>,
) -> Result<String, Error> {
    let add_res = client.add(Cursor::new(bytes)).await?;
    Ok(add_res.hash)
}

/// Cat (download) bytes from IPFS by CID.
pub async fn cat_bytes(
    client: &IpfsClient,
    cid: &str,
) -> Result<Vec<u8>, Error> {
    let mut stream = client.cat(cid);
    let mut result = Vec::new();
    while let Some(chunk) = stream.try_next().await? {
        result.extend_from_slice(&chunk);
    }
    Ok(result)
}

/// Pin a CID to ensure it persists in local IPFS storage.
pub async fn pin_cid(
    client: &IpfsClient,
    cid: &str,
    recursive: bool,
) -> Result<(), Error> {
    client.pin_add(cid, recursive).await?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use bc_envelope::Envelope;
    use dcbor::CBOREncodable;

    #[test]
    fn test_envelope_roundtrip() {
        let original = Envelope::new("test data");
        let bytes = original.to_cbor_data();
        let roundtrip =
            Envelope::try_from_cbor_data(bytes).expect("deserialize failed");
        assert_eq!(original, roundtrip);
    }

    #[test]
    fn test_envelope_with_assertions() {
        let original = Envelope::new("subject")
            .add_assertion("key1", "value1")
            .add_assertion("key2", 42);
        let bytes = original.to_cbor_data();
        let roundtrip =
            Envelope::try_from_cbor_data(bytes).expect("deserialize failed");
        assert_eq!(original, roundtrip);
    }
}