varsig 0.1.0

Varsig signature metadata
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
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
139
140
141
142
143
144
145
146
147
148
149

//! IPLD Codec trait.

use std::{
    error::Error,
    io::{BufRead, Write},
};

use ipld_core::codec::Codec as IpldCodec;
use serde::{Deserialize, Serialize};
use serde_ipld_dagcbor::{codec::DagCborCodec, error::CodecError};

#[cfg(feature = "dag_json")]
use serde_ipld_dagjson::{codec::DagJsonCodec, error::CodecError as JsonError};

/// IPLD Codec trait.
///
/// This trait is a generalization of the `libipld_core::codec::Codec` trait.
/// Specifically this allows an application to accept multiple codecs
/// and distinguish with a runtime enum. This is important for Varsig,
/// since it may need to encode to the configured codec for signature verification.
///
/// An implementation is provided for types that have `ipld_core::codec::Codec`.
pub trait Codec<T>: Sized {
    /// Encoding error type.
    type EncodingError: Error;

    /// Decoding error type.
    type DecodingError: Error;

    /// Multicodec code.
    ///
    /// This is not a `const` because an implementation may
    /// support more than one IPLD codec, so it is runtime dependent.
    fn multicodec_code(&self) -> u64;

    /// Try to create a codec from a series of tags.
    fn try_from_tags(code: &[u64]) -> Option<Self>;

    /// Encode the payload to the given buffer.
    ///
    /// ## Parameters
    ///
    /// - `payload`: The payload to encode.
    /// - `buffer`: The buffer to write the encoded payload to.
    ///
    /// ## Returns
    ///
    /// Returns `Ok(())` on success, or an error of type `Self::EncodingError` on failure.
    ///
    /// ## Errors
    ///
    /// If the encoding fails, it returns an error of type `Self::EncodingError`.
    fn encode_payload<W: Write>(
        &self,
        payload: &T,
        buffer: &mut W,
    ) -> Result<(), Self::EncodingError>;

    /// Decode the payload from the given reader.
    ///
    /// ## Parameters
    ///
    /// - `reader`: The reader to read the encoded payload from.
    ///
    /// ## Returns
    ///
    /// Returns the decoded payload of type `T` on success,
    /// or an error of type `Self::DecodingError` on failure.
    ///
    /// ## Errors
    ///
    /// If the decoding fails, it returns an error of type `Self::DecodingError`.
    fn decode_payload<R: BufRead>(&self, reader: &mut R) -> Result<T, Self::DecodingError>;
}

impl<T: Serialize + for<'de> Deserialize<'de>> Codec<T> for DagCborCodec {
    type EncodingError = CodecError;
    type DecodingError = CodecError;

    fn multicodec_code(&self) -> u64 {
        <DagCborCodec as IpldCodec<T>>::CODE
    }

    fn try_from_tags(code: &[u64]) -> Option<Self> {
        if code.is_empty() {
            return None;
        }

        if code.len() > 1 {
            return None;
        }

        if *code.first()? == <DagCborCodec as IpldCodec<T>>::CODE {
            Some(DagCborCodec)
        } else {
            None
        }
    }

    fn encode_payload<W: Write>(
        &self,
        payload: &T,
        buffer: &mut W,
    ) -> Result<(), Self::EncodingError> {
        DagCborCodec::encode(buffer, payload)
    }

    fn decode_payload<R: BufRead>(&self, reader: &mut R) -> Result<T, Self::DecodingError> {
        DagCborCodec::decode(reader)
    }
}

#[cfg(feature = "dag_json")]
impl<T: Serialize + for<'de> Deserialize<'de>> Codec<T> for DagJsonCodec {
    type EncodingError = JsonError;
    type DecodingError = JsonError;

    fn multicodec_code(&self) -> u64 {
        <DagJsonCodec as IpldCodec<T>>::CODE
    }

    fn try_from_tags(code: &[u64]) -> Option<Self> {
        if code.is_empty() {
            return None;
        }

        if code.len() > 1 {
            return None;
        }

        if code[0] == <DagJsonCodec as IpldCodec<T>>::CODE {
            Some(DagJsonCodec)
        } else {
            None
        }
    }

    fn encode_payload<W: Write>(
        &self,
        payload: &T,
        buffer: &mut W,
    ) -> Result<(), Self::EncodingError> {
        DagJsonCodec::encode(buffer, payload)
    }

    fn decode_payload<R: BufRead>(&self, reader: &mut R) -> Result<T, Self::DecodingError> {
        DagJsonCodec::decode(reader)
    }
}