caracal 0.2.0

Nostr client for Gemini
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

use crate::keyutil;
use crate::storage::Storage;
use bip39::Mnemonic;
use chrono::{DateTime, Utc};
use heed::types::{SerdeRmp, Str};
use heed::{Database, RoTxn};
use nostr_sdk::prelude::*;
use serde::{Deserialize, Serialize};
use std::error::Error;

#[derive(Debug, Serialize, Deserialize)]
pub struct NostrKeys<'a> {
    #[serde(borrow)]
    pub sec_key_hex: &'a str,
    pub datetime_created: DateTime<Utc>,
    pub active: bool,
    pub flags: u32,
}

type KeysDatabase<'a> = Database<Str, SerdeRmp<NostrKeys<'a>>>;

const DB_NAME: &str = "nostr_keys";
const KEYS_DEFAULT: &str = "default";

impl Storage {
    fn keys_db(
        &self,
    ) -> Result<KeysDatabase<'_>, Box<dyn Error + Send + Sync>> {
        let mut rtxn = self.get_read_txn()?;
        let dbo: Option<KeysDatabase> =
            self.env.open_database(&mut rtxn, Some(DB_NAME))?;

        if dbo.is_some() {
            Ok(dbo.unwrap())
        } else {
            Err(Box::from("Error opening nostr keys db"))
        }
    }

    pub fn create_keys_db(
        &self,
    ) -> Result<KeysDatabase<'_>, Box<dyn Error + Send + Sync>> {
        let mut wtxn = self.env.write_txn()?;
        let db: KeysDatabase =
            self.env.create_database(&mut wtxn, Some(DB_NAME))?;
        wtxn.commit()?;
        Ok(db)
    }

    pub fn get_keys(
        &self,
        rtxn: &mut RoTxn,
        idx: &str,
    ) -> Result<Keys, Box<dyn Error + Send + Sync>> {
        return match self.keys_db()?.get(rtxn, idx)? {
            Some(k) => {
                if let Ok(keys) = Keys::parse(k.sec_key_hex) {
                    return Ok(keys);
                }
                Err(Box::from("Cannot parse key!"))
            }
            None => Err(Box::from("No key")),
        };
    }

    pub fn get_default_keys(
        &self,
        rtxn: &mut RoTxn,
    ) -> Result<Keys, Box<dyn Error + Send + Sync>> {
        self.get_keys(rtxn, KEYS_DEFAULT)
    }

    pub fn create_default_keys(
        &self,
    ) -> Result<Keys, Box<dyn Error + Send + Sync>> {
        self.create_keys(KEYS_DEFAULT)
    }

    pub fn create_keys<'c>(
        &self,
        name: &str,
    ) -> Result<Keys, Box<dyn Error + Send + Sync>> {
        if let Ok(db) = self.keys_db() {
            let mut wtxn = self.env.write_txn()?;

            let keys = Keys::generate();
            let ks = keys.secret_key().to_secret_hex().clone();

            let k = NostrKeys {
                sec_key_hex: ks.as_str(),
                datetime_created: Utc::now(),
                active: true,
                flags: 0,
            };

            db.put(&mut wtxn, name, &k)?;
            wtxn.commit()?;

            Ok(keys)
        } else {
            Err(Box::from("No keys database"))
        }
    }

    pub fn create_keys_with_mnemonic<'c>(
        &self,
        name: &str,
    ) -> Result<(Keys, Mnemonic), Box<dyn Error + Send + Sync>> {
        if let Ok(db) = self.keys_db() {
            let mut wtxn = self.env.write_txn()?;
            let (keys, mnemo) = keyutil::genkeys_with_mnemonic().unwrap();

            let ks = keys.secret_key().to_secret_hex().clone();

            let k = NostrKeys {
                sec_key_hex: ks.as_str(),
                datetime_created: Utc::now(),
                active: true,
                flags: 0,
            };

            db.put(&mut wtxn, name, &k)?;
            wtxn.commit()?;

            Ok((keys, mnemo))
        } else {
            Err(Box::from("No keys db"))
        }
    }
}