indy-credx 1.1.1

Verifiable credential issuance and presentation for Hyperledger Indy (https://www.hyperledger.org/projects), which provides a distributed-ledger-based foundation for self-sovereign identity (https://sovrin.org).
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

use crate::error::{Error, ErrorKind, Result};

use std::os::raw::c_char;
use std::panic::{catch_unwind, UnwindSafe};
use std::sync::RwLock;

use ffi_support::rust_string_to_c;

use once_cell::sync::Lazy;

static LAST_ERROR: Lazy<RwLock<Option<Error>>> = Lazy::new(|| RwLock::new(None));

#[derive(Debug, PartialEq, Copy, Clone, Serialize)]
#[repr(i64)]
pub enum ErrorCode {
    Success = 0,
    Input = 1,
    IOError = 2,
    InvalidState = 3,
    Unexpected = 4,
    CredentialRevoked = 5,
    InvalidUserRevocId = 6,
    ProofRejected = 7,
    RevocationRegistryFull = 8,
}

impl From<ErrorKind> for ErrorCode {
    fn from(kind: ErrorKind) -> ErrorCode {
        match kind {
            ErrorKind::Input => ErrorCode::Input,
            ErrorKind::IOError => ErrorCode::IOError,
            ErrorKind::InvalidState => ErrorCode::InvalidState,
            ErrorKind::Unexpected => ErrorCode::Unexpected,
            ErrorKind::CredentialRevoked => ErrorCode::CredentialRevoked,
            ErrorKind::InvalidUserRevocId => ErrorCode::InvalidUserRevocId,
            ErrorKind::ProofRejected => ErrorCode::ProofRejected,
            ErrorKind::RevocationRegistryFull => ErrorCode::RevocationRegistryFull,
        }
    }
}

impl<T> From<Result<T>> for ErrorCode {
    fn from(result: Result<T>) -> ErrorCode {
        match result {
            Ok(_) => ErrorCode::Success,
            Err(err) => ErrorCode::from(err.kind()),
        }
    }
}

#[no_mangle]
pub extern "C" fn credx_get_current_error(error_json_p: *mut *const c_char) -> ErrorCode {
    trace!("credx_get_current_error");

    let error = rust_string_to_c(get_current_error_json());
    unsafe { *error_json_p = error };

    ErrorCode::Success
}

pub fn catch_error<F>(f: F) -> ErrorCode
where
    F: FnOnce() -> Result<()> + UnwindSafe,
{
    match catch_unwind(f) {
        Ok(Ok(_)) => ErrorCode::Success,
        Ok(Err(err)) => {
            // lib error
            set_last_error(Some(err))
        }
        Err(_) => {
            // panic error
            let err = err_msg!(Unexpected, "Panic during execution");
            set_last_error(Some(err))
        }
    }
}

pub fn get_current_error_json() -> String {
    if let Some(err) = Option::take(&mut *LAST_ERROR.write().unwrap()) {
        let message = err.to_string();
        let code = ErrorCode::from(err.kind()) as usize;
        serde_json::json!({"code": code, "message": message}).to_string()
    } else {
        r#"{"code":0,"message":null}"#.to_owned()
    }
}

pub fn set_last_error(error: Option<Error>) -> ErrorCode {
    trace!("credx_set_last_error");
    let code = match error.as_ref() {
        Some(err) => err.kind().into(),
        None => ErrorCode::Success,
    };
    *LAST_ERROR.write().unwrap() = error;
    code
}