quartz-contract-core 0.5.0

A CosmWasm framework for securely interacting with Intel SGX enclaves.
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

use std::fmt::Debug;

use cosmwasm_schema::cw_serde;
use cosmwasm_std::StdError;

use super::attested::Noop;
use crate::{error::Error, msg::HasDomainType};

pub type AnySigned<M, P, S> = Signed<M, AnyAuth<P, S>>;

#[derive(Clone, Debug, PartialEq)]
pub struct Signed<M, A> {
    msg: M,
    auth: A,
}

impl<M, A> Signed<M, A> {
    pub fn new(msg: M, auth: A) -> Self {
        Self { msg, auth }
    }

    pub fn into_tuple(self) -> (M, A) {
        let Self { msg, auth } = self;
        (msg, auth)
    }

    pub fn msg(&self) -> &M {
        &self.msg
    }

    pub fn auth(&self) -> &A {
        &self.auth
    }
}

#[cw_serde]
pub struct RawSigned<RM, RA> {
    pub msg: RM,
    pub auth: RA,
}

impl<RM, RA> RawSigned<RM, RA> {
    pub fn new(msg: RM, auth: RA) -> Self {
        Self { msg, auth }
    }
}

impl<RM, RA> HasDomainType for RawSigned<RM, RA>
where
    RM: HasDomainType,
    RA: HasDomainType,
{
    type DomainType = Signed<RM::DomainType, RA::DomainType>;
}

impl<RM, RA> TryFrom<RawSigned<RM, RA>> for Signed<RM::DomainType, RA::DomainType>
where
    RM: HasDomainType,
    RA: HasDomainType,
{
    type Error = StdError;

    fn try_from(value: RawSigned<RM, RA>) -> Result<Self, Self::Error> {
        Ok(Self {
            msg: value.msg.try_into()?,
            auth: value.auth.try_into()?,
        })
    }
}

impl<RM, RA> From<Signed<RM::DomainType, RA::DomainType>> for RawSigned<RM, RA>
where
    RM: HasDomainType,
    RA: HasDomainType,
{
    fn from(value: Signed<RM::DomainType, RA::DomainType>) -> Self {
        Self {
            msg: value.msg.into(),
            auth: value.auth.into(),
        }
    }
}

pub trait MsgVerifier {
    type PubKey;
    type Sig;

    fn verify(&self, pub_key: &Self::PubKey, sig: &Self::Sig) -> Result<(), Error>;
}

#[derive(Clone, Debug, PartialEq)]
pub struct AnyAuth<P, S> {
    pub pub_key: P,
    pub sig: S,
}

impl<P, S> AnyAuth<P, S> {
    pub fn new(pub_key: P, sig: S) -> Self {
        Self { pub_key, sig }
    }
}

pub trait Auth<P, S> {
    fn pub_key(&self) -> &P;
    fn sig(&self) -> &S;
}

impl<P, S> Auth<P, S> for AnyAuth<P, S> {
    fn pub_key(&self) -> &P {
        &self.pub_key
    }

    fn sig(&self) -> &S {
        &self.sig
    }
}

impl<M: MsgVerifier> MsgVerifier for Noop<M> {
    type PubKey = M::PubKey;
    type Sig = M::Sig;

    fn verify(&self, pub_key: &Self::PubKey, sig: &Self::Sig) -> Result<(), Error> {
        self.0.verify(pub_key, sig)
    }
}