saa_common/
lib.rs

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
#![cfg_attr(not(feature = "std"), no_std)]


mod identity;
mod binary;
mod errors;
pub mod hashes;
pub use errors::*;

pub use binary::{Binary, to_json_binary, from_json};


#[cfg(any(feature = "std", not(feature = "substrate")))]
pub use std::{
    string::{ToString, String},
    vec, vec::Vec, 
    format
};

#[cfg(all(not(feature = "std"), feature = "substrate"))]
pub use ink::prelude::{
    string::{ToString, String},
    vec, vec::Vec, 
    format, 
};



#[cfg(feature = "native")]
pub mod crypto {
    pub use cosmwasm_crypto::*;    
} 



#[cfg(feature = "cosmwasm")]
pub mod cosmwasm {
    pub use cosmwasm_std::{
        Api, Env, Addr, CanonicalAddr, MessageInfo, Binary,
        from_json, to_json_binary, ensure, ensure_eq, ensure_ne
    };
}


#[cfg(feature = "substrate")]
pub mod substrate {
    pub use ink::env as ink_env;
    pub use {
        ink_env::Environment as InkEnvironment,
        ink::EnvAccess as InkApi,
    };

    pub mod default {
        use ink::env as ink_env;
        pub use ink_env::DefaultEnvironment;
        pub type AccountId = <DefaultEnvironment as ink_env::Environment>::AccountId;
        pub type EnvAccess<'a> = ink::EnvAccess<'a, DefaultEnvironment>;
    }
}

/* #[cfg(feature = "cosmwasm")]
use cosmwasm::*;
#[cfg(feature = "substrate")]
use substrate::*;
 */


#[macro_export]
macro_rules! ensure {
    ($cond:expr, $e:expr) => {
        if !($cond) {
            return Err(core::convert::From::from($e));
        }
    };
}




pub trait Verifiable   {

    fn id(&self) -> CredentialId;

    fn human_id(&self) -> String {
        Binary(self.id()).to_base64()
    }

    fn validate(&self) -> Result<(), AuthError>;

    #[cfg(feature = "native")]
    fn verify(&self) -> Result<(), AuthError>;


    #[cfg(feature = "substrate")]
    fn verified_ink<'a>(
        &self,  
        _ : substrate::InkApi<'a, 
        impl substrate::InkEnvironment + Clone>
    ) -> Result<Self, AuthError> 
        where Self: Clone
    {
        #[cfg(feature = "native")]
        self.verify()?;
        #[cfg(feature = "native")]
        return Ok(self.clone());

        #[cfg(not(feature = "native"))]
        return Err(AuthError::generic("Not implemented"));
    }

    
    #[cfg(feature = "cosmwasm")]
    fn verified_cosmwasm(
        &self, 
        _:  &dyn cosmwasm::Api, 
        _:  &cosmwasm::Env, 
        _:  &Option<cosmwasm::MessageInfo>
    ) -> Result<Self, AuthError> 
        where Self: Clone
    {
        #[cfg(feature = "native")]
        self.verify()?;
        #[cfg(feature = "native")]
        return Ok(self.clone());

        #[cfg(not(feature = "native"))]
        return Err(AuthError::generic("Not implemented"));
    }
}


pub type CredentialId = Vec<u8>;