agglayer-primitives 0.18.0

agglayer-primitives contains various structs and traits that are the ground of agglayer protocol.
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

use alloy_primitives::Signature as AlloySignature;
use k256::ecdsa;

use super::{Address, SignatureError, B256, U256};

/// A wrapper over [AlloySignature] with custom serialization.
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "testutils", derive(arbitrary::Arbitrary))]
#[serde(from = "compat::Signature", into = "compat::Signature")]
pub struct Signature(AlloySignature);

impl Signature {
    #[inline]
    pub fn from_signature_and_parity(sig: ecdsa::Signature, v: bool) -> Self {
        AlloySignature::from_signature_and_parity(sig, v).into()
    }

    #[inline]
    pub fn new(r: U256, s: U256, v: bool) -> Self {
        AlloySignature::new(r, s, v).into()
    }

    #[inline]
    pub fn recover_address_from_prehash(&self, prehash: &B256) -> Result<Address, SignatureError> {
        self.0
            .recover_address_from_prehash(prehash)
            .map(Address::from)
    }

    #[inline]
    pub fn as_primitive_signature(&self) -> &AlloySignature {
        &self.0
    }

    #[inline]
    pub fn as_bytes(&self) -> [u8; 65] {
        self.0.as_bytes()
    }

    #[inline]
    pub fn r(&self) -> U256 {
        self.0.r()
    }

    #[inline]
    pub fn s(&self) -> U256 {
        self.0.s()
    }

    #[inline]
    pub fn v(&self) -> bool {
        self.0.v()
    }
}

impl From<AlloySignature> for Signature {
    #[inline]
    fn from(ps: AlloySignature) -> Self {
        Self(ps)
    }
}

impl From<Signature> for AlloySignature {
    #[inline]
    fn from(value: Signature) -> Self {
        value.0
    }
}

impl TryFrom<&[u8]> for Signature {
    type Error = SignatureError;

    #[inline]
    fn try_from(sig: &[u8]) -> Result<Self, Self::Error> {
        sig.try_into().map(Self)
    }
}

impl std::str::FromStr for Signature {
    type Err = <AlloySignature as std::str::FromStr>::Err;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse().map(Self)
    }
}

/// Helpers for serialization / deserialization format compatibility.
mod compat {
    use super::U256;

    #[derive(serde::Serialize, serde::Deserialize)]
    pub struct Signature {
        r: U256,
        s: U256,
        odd_y_parity: bool,
    }

    impl Signature {
        #[inline]
        fn new(r: U256, s: U256, odd_y_parity: bool) -> Self {
            Self { r, s, odd_y_parity }
        }
    }

    impl From<super::Signature> for Signature {
        #[inline]
        fn from(sig: super::Signature) -> Self {
            Self::new(sig.0.r(), sig.0.s(), sig.0.v())
        }
    }

    impl From<Signature> for super::Signature {
        #[inline]
        fn from(sig: Signature) -> Self {
            let Signature { r, s, odd_y_parity } = sig;
            Self::new(r, s, odd_y_parity)
        }
    }
}