privacy_http_sdk 1.0.9

Privacy HTTP SDK for Rust
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

//! C++ FFI bindings for DID-NOSTR functionality

use std::ffi::{CStr, CString};
use std::os::raw::c_char;
use crate::did_nostr::*;

/// Create a DID from NOSTR public key (hex)
/// # Safety
/// Caller must ensure pubkey_hex is a valid null-terminated string
#[no_mangle]
pub unsafe extern "C" fn did_nostr_create(
    pubkey_hex: *const c_char,
) -> *mut c_char {
    if pubkey_hex.is_null() {
        let err = CString::new("null pointer").unwrap();
        return err.into_raw();
    }

    let hex_cstr = match CStr::from_ptr(pubkey_hex).to_str() {
        Ok(s) => s,
        Err(_) => {
            let err = CString::new("invalid UTF-8").unwrap();
            return err.into_raw();
        }
    };

    match NostrPublicKey::from_hex(hex_cstr) {
        Ok(pubkey) => {
            let did = DidNostr::from_pubkey(pubkey);
            let result = CString::new(did.to_string()).unwrap();
            result.into_raw()
        }
        Err(e) => {
            let err = CString::new(format!("error: {}", e)).unwrap();
            err.into_raw()
        }
    }
}

/// Parse DID from string
/// # Safety
/// Caller must ensure did_str is a valid null-terminated string
#[no_mangle]
pub unsafe extern "C" fn did_nostr_parse(
    did_str: *const c_char,
) -> *mut c_char {
    if did_str.is_null() {
        let err = CString::new("null pointer").unwrap();
        return err.into_raw();
    }

    let did_cstr = match CStr::from_ptr(did_str).to_str() {
        Ok(s) => s,
        Err(_) => {
            let err = CString::new("invalid UTF-8").unwrap();
            return err.into_raw();
        }
    };

    match DidNostr::from_str(did_cstr) {
        Ok(did) => {
            let result = CString::new(did.to_string()).unwrap();
            result.into_raw()
        }
        Err(e) => {
            let err = CString::new(format!("error: {}", e)).unwrap();
            err.into_raw()
        }
    }
}

/// Extract public key from DID
/// # Safety
/// Caller must ensure did_str is a valid null-terminated string
#[no_mangle]
pub unsafe extern "C" fn did_nostr_get_pubkey(
    did_str: *const c_char,
) -> *mut c_char {
    if did_str.is_null() {
        let err = CString::new("null pointer").unwrap();
        return err.into_raw();
    }

    let did_cstr = match CStr::from_ptr(did_str).to_str() {
        Ok(s) => s,
        Err(_) => {
            let err = CString::new("invalid UTF-8").unwrap();
            return err.into_raw();
        }
    };

    match DidNostr::from_str(did_cstr) {
        Ok(did) => {
            let result = CString::new(did.pubkey().as_hex()).unwrap();
            result.into_raw()
        }
        Err(e) => {
            let err = CString::new(format!("error: {}", e)).unwrap();
            err.into_raw()
        }
    }
}

/// Free a string allocated by the Rust library
/// # Safety
/// Caller must ensure ptr is a valid pointer returned by did_nostr_* functions
#[no_mangle]
pub unsafe extern "C" fn did_nostr_free(ptr: *mut c_char) {
    if !ptr.is_null() {
        let _ = CString::from_raw(ptr);
    }
}