cw-auths 0.2.0

Authentication library for smart accounts of CosmWasm
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

use types::{
    cosmwasm_std::{from_json, Api, Binary, Env, Storage}, 
    errors::{AuthError, ReplayError, StorageError}, 
    stores::{get_map_records, map_get, VERIFYING_ID, CREDENTIAL_INFOS as CREDS}, 
    Credential, CredentialRecord, MsgDataToSign, MsgDataToVerify, SignedDataMsg
};




pub fn get_credential_records(
    storage: &dyn Storage
) -> Result<Vec<CredentialRecord>, StorageError> {
    get_map_records(storage, &CREDS, "credentials")
}




 fn parse_cred_args(
    id: &str,
    msg: &SignedDataMsg
) -> (String, Option<String>, Option<Binary>) {
    match &msg.payload {
        Some(payload) => {
            let id = match &payload.credential_id {
                Some(id) => id.to_lowercase(),
                None => id.to_string(),
            };
            (id, payload.hrp.clone(), payload.extension.clone())
            
        }   
        None => (id.to_string(), None, None)
    }
}


pub fn cred_from_signed(
    api : &dyn Api,
    storage:  &dyn Storage,
    msg: SignedDataMsg,
) -> Result<Credential, AuthError> {
    let (id, hrp, ext) = parse_cred_args(
        VERIFYING_ID.load(storage).map_err(|_| AuthError::NoCredentials)?.as_str(),
        &msg
    );
    
    let mut info = map_get(storage, &CREDS, &id, "credential")
        .map_err(|e| AuthError::generic(e.to_string()))?;

    info.hrp = hrp.or(info.hrp);
    let cred = construct_credential((id, info), msg, ext)?;
    cred.verify_cosmwasm(api)?;
    Ok(cred)
}





#[cfg(feature = "session")]
pub fn session_cred_from_signed(
    api : &dyn Api,
    storage:  &dyn Storage,
    key: &str,
    msg: SignedDataMsg,
) -> Result<Credential, AuthError> {
    let (id, hrp, ext) = parse_cred_args( key, &msg);
    let session = map_get(storage, &super::stores::SESSIONS, &id, "session key")
        .map_err(|e| AuthError::generic(e.to_string()))?;

    let mut info = session.grantee.1.clone();
    info.hrp = hrp.or(info.hrp);
    let cred = construct_credential((id, info), msg, ext)?;
    cred.verify_cosmwasm(api)?;
    Ok(cred)
}


fn construct_credential(
    _info: (String, types::CredentialInfo), 
    _msg: SignedDataMsg, 
    _ext: Option<Binary>
) -> Result<Credential, AuthError> {
    todo!()
}





pub fn convert<M : saa_schema::serde::de::DeserializeOwned>(
    data: &[u8]
) -> Result<MsgDataToSign<M>, ReplayError> {
    from_json(data)
    .map_err(|_| ReplayError::Convertion("MsgDataToSign".to_string()))
}



pub fn convert_validate(
    data: &[u8],
    env: &Env,
    nonce: u64
) -> Result<(), ReplayError> {
    let msg : MsgDataToVerify = from_json(data)
                            .map_err(|_| ReplayError::Convertion("MsgDataToVerify".to_string()))?;
    msg.validate(env, nonce)?;
    Ok(())
}



pub fn convert_validate_return<M : saa_schema::serde::de::DeserializeOwned>(
    data: &[u8],
    env: &Env,
    nonce: u64
) -> Result<MsgDataToSign<M>, ReplayError> {
    let msg  = convert(data)?;
    msg.validate(env, nonce)?;
    Ok(msg)

}