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

//! Preset IPLD encoding types.

use crate::codec::Codec;
use serde::{Deserialize, Serialize};
use std::io::{BufRead, Write};
use thiserror::Error;

/// IPLD encoding types.
#[repr(u64)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Encoding {
    /// `DAG-CBOR` encoding.
    #[cfg(feature = "dag_cbor")]
    DagCbor = 0x71,

    /// `DAG-JSON` encoding.
    #[cfg(feature = "dag_json")]
    DagJson = 0x0129,

    /// Canonicalized JWT encoding.
    #[cfg(feature = "jwt")]
    Jwt = 0x6a77,

    /// EIP-191 encoding.
    #[cfg(feature = "eip191")]
    Eip191 = 0xe191,
}

impl<T: Serialize + for<'a> Deserialize<'a>> Codec<T> for Encoding {
    type EncodingError = EncodingError;
    type DecodingError = DecodingError;

    fn multicodec_code(&self) -> u64 {
        *self as u64
    }

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

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

        match code.first()? {
            #[cfg(feature = "dag_cbor")]
            0x71 => Some(Encoding::DagCbor),

            #[cfg(feature = "dag_json")]
            0x0129 => Some(Encoding::DagJson),

            #[cfg(feature = "jwt")]
            0x6a77 => Some(Encoding::Jwt),

            #[cfg(feature = "eip191")]
            0xe191 => Some(Encoding::Eip191),

            _ => None,
        }
    }

    /// Encode the payload to the given buffer.
    fn encode_payload<W: Write>(
        &self,
        payload: &T,
        buffer: &mut W,
    ) -> Result<(), Self::EncodingError> {
        match self {
            #[cfg(feature = "dag_cbor")]
            Encoding::DagCbor => Ok(serde_ipld_dagcbor::to_writer(buffer, payload)?),

            #[cfg(feature = "dag_json")]
            Encoding::DagJson => Ok(serde_ipld_dagjson::to_writer(buffer, payload)?),

            #[cfg(feature = "jwt")]
            Encoding::Jwt => todo!(),

            #[cfg(feature = "eip191")]
            Encoding::Eip191 => todo!(),
        }
    }

    /// Decode the payload from the given reader buffer.
    fn decode_payload<R: BufRead>(&self, reader: &mut R) -> Result<T, Self::DecodingError> {
        match self {
            #[cfg(feature = "dag_cbor")]
            Encoding::DagCbor => Ok(serde_ipld_dagcbor::from_reader(reader)?),

            #[cfg(feature = "dag_json")]
            Encoding::DagJson => Ok(serde_ipld_dagjson::from_reader(reader)?),

            #[cfg(feature = "jwt")]
            Encoding::Jwt => todo!(),

            #[cfg(feature = "eip191")]
            Encoding::Eip191 => todo!(),
        }
    }
}

/// Encoding errors for the enabled encoding types.
#[derive(Debug, Error)]
pub enum EncodingError {
    /// Encoding error from `DAG-CBOR`.
    #[cfg(feature = "dag_cbor")]
    #[error(transparent)]
    CborError(#[from] serde_ipld_dagcbor::EncodeError<std::io::Error>),

    /// Encoding error from `DAG-JSON`.
    #[cfg(feature = "dag_json")]
    #[error(transparent)]
    JsonError(#[from] serde_ipld_dagjson::error::EncodeError),
}

/// Decoding errors for the enabled encoding types.
#[derive(Debug, Error)]
pub enum DecodingError {
    /// Decoding error from `DAG-CBOR`.
    #[cfg(feature = "dag_cbor")]
    #[error(transparent)]
    CborError(#[from] serde_ipld_dagcbor::DecodeError<std::io::Error>),

    /// Decoding error from `DAG-JSON`.
    #[cfg(feature = "dag_json")]
    #[error(transparent)]
    JsonError(#[from] serde_ipld_dagjson::error::DecodeError),
}