nostr/gossip
1
0
Fork 0
mirror of https://github.com/mikedilger/gossip.git synced 2024-09-29 00:11:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change gossip_identity to use Arc<parking_lot::RwLock<T>>

Browse Source
This commit is contained in:
Mike Dilger 2024-08-30 10:33:21 +12:00
parent fb3a200ca0
commit 4e2f97d012
1 changed files with 44 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
gossip-lib/src/gossip_identity.rs
View File

@ -8,16 +8,17 @@ use nostr_types::{
};
use parking_lot::RwLock;
use std::sync::mpsc::Sender;
use std::sync::Arc;
use tokio::task;
pub struct GossipIdentity {
pub inner: RwLock<Identity>,
pub inner: Arc<RwLock<Identity>>,
}
impl Default for GossipIdentity {
fn default() -> GossipIdentity {
GossipIdentity {
inner: RwLock::new(Identity::default()),
inner: Arc::new(RwLock::new(Identity::default())),
}
}
}
@ -27,16 +28,16 @@ impl GossipIdentity {
let pk = GLOBALS.db().read_setting_public_key();
let epk = GLOBALS.db().read_encrypted_private_key()?;
match (pk, epk) {
(Some(pk), Some(epk)) => *self.inner.write() = Identity::from_locked_parts(pk, epk),
(Some(pk), None) => *self.inner.write() = Identity::Public(pk),
(None, _) => *self.inner.write() = Identity::None,
(Some(pk), Some(epk)) => *self.inner.write_arc() = Identity::from_locked_parts(pk, epk),
(Some(pk), None) => *self.inner.write_arc() = Identity::Public(pk),
(None, _) => *self.inner.write_arc() = Identity::None,
}
Ok(())
}
// Any function that changes GossipIdentity should run this to save back changes
fn on_change(&self) -> Result<(), Error> {
let binding = self.inner.read();
let binding = self.inner.read_arc();
let (pk, epk) = match *binding {
Identity::None => (None, None),
Identity::Public(pk) => (Some(pk), None),
@ -50,7 +51,7 @@ impl GossipIdentity {
// Any function that changes GossipIdentity and changes the key should run this instead
fn on_keychange(&self) -> Result<(), Error> {
self.on_change()?;
if !matches!(*self.inner.read(), Identity::None) {
if !matches!(*self.inner.read_arc(), Identity::None) {
// Rebuild the event tag index if the identity changes
// since the 'p' tags it needs to index just changed.
task::spawn(async move {
@ -103,13 +104,13 @@ impl GossipIdentity {
}
pub(crate) fn set_public_key(&self, public_key: PublicKey) -> Result<(), Error> {
*self.inner.write() = Identity::Public(public_key);
*self.inner.write_arc() = Identity::Public(public_key);
self.on_keychange()?;
Ok(())
}
pub(crate) fn clear_public_key(&self) -> Result<(), Error> {
*self.inner.write() = Identity::None;
*self.inner.write_arc() = Identity::None;
self.on_keychange()?;
Ok(())
}
@ -119,14 +120,14 @@ impl GossipIdentity {
epk: EncryptedPrivateKey,
pass: &str,
) -> Result<(), Error> {
*self.inner.write() = Identity::from_encrypted_private_key(epk, pass)?;
*self.inner.write_arc() = Identity::from_encrypted_private_key(epk, pass)?;
self.on_keychange()?;
Ok(())
}
pub(crate) async fn change_passphrase(&self, old: &str, new: &str) -> Result<(), Error> {
let log_n = GLOBALS.db().read_setting_log_n();
self.inner.write().change_passphrase(old, new, log_n)?;
self.inner.write_arc().change_passphrase(old, new, log_n)?;
self.on_keychange()?;
Ok(())
}
@ -134,19 +135,19 @@ impl GossipIdentity {
pub(crate) fn set_private_key(&self, pk: PrivateKey, pass: &str) -> Result<(), Error> {
let log_n = GLOBALS.db().read_setting_log_n();
let identity = Identity::from_private_key(pk, pass, log_n)?;
*self.inner.write() = identity;
*self.inner.write_arc() = identity;
self.on_keychange()?;
Ok(())
}
pub fn unlock(&self, pass: &str) -> Result<(), Error> {
self.inner.write().unlock(pass)?;
self.inner.write_arc().unlock(pass)?;
// If older version, re-encrypt with new version at default 2^18 rounds
if let Some(epk) = self.encrypted_private_key() {
if epk.version()? < 2 {
let log_n = GLOBALS.db().read_setting_log_n();
self.inner.write().upgrade(pass, log_n)?;
self.inner.write_arc().upgrade(pass, log_n)?;
self.on_change()?;
}
}
@ -158,39 +159,39 @@ impl GossipIdentity {
pub(crate) fn generate_private_key(&self, pass: &str) -> Result<(), Error> {
let log_n = GLOBALS.db().read_setting_log_n();
*self.inner.write() = Identity::generate(pass, log_n)?;
*self.inner.write_arc() = Identity::generate(pass, log_n)?;
self.on_keychange()?;
Ok(())
}
pub(crate) fn delete_identity(&self) -> Result<(), Error> {
*self.inner.write() = Identity::None;
*self.inner.write_arc() = Identity::None;
self.on_keychange()?;
Ok(())
}
pub fn has_private_key(&self) -> bool {
self.inner.read().has_private_key()
self.inner.read_arc().has_private_key()
}
pub fn is_unlocked(&self) -> bool {
self.inner.read().is_unlocked()
self.inner.read_arc().is_unlocked()
}
pub fn public_key(&self) -> Option<PublicKey> {
self.inner.read().public_key()
self.inner.read_arc().public_key()
}
pub fn encrypted_private_key(&self) -> Option<EncryptedPrivateKey> {
self.inner.read().encrypted_private_key().cloned()
self.inner.read_arc().encrypted_private_key().cloned()
}
pub fn key_security(&self) -> Result<KeySecurity, Error> {
Ok(self.inner.read().key_security()?)
Ok(self.inner.read_arc().key_security()?)
}
pub fn sign_event(&self, input: PreEvent) -> Result<Event, Error> {
Ok(self.inner.read().sign_event(input)?)
Ok(self.inner.read_arc().sign_event(input)?)
}
pub fn sign_event_with_pow(
@ -201,7 +202,7 @@ impl GossipIdentity {
) -> Result<Event, Error> {
Ok(self
.inner
.read()
.read_arc()
.sign_event_with_pow(input, zero_bits, work_sender)?)
}
@ -209,39 +210,42 @@ impl GossipIdentity {
let log_n = GLOBALS.db().read_setting_log_n();
Ok(self
.inner
.write()
.write_arc()
.export_private_key_in_bech32(pass, log_n)?)
}
pub fn export_private_key_hex(&self, pass: &str) -> Result<(String, bool), Error> {
let log_n = GLOBALS.db().read_setting_log_n();
Ok(self.inner.write().export_private_key_in_hex(pass, log_n)?)
Ok(self
.inner
.write_arc()
.export_private_key_in_hex(pass, log_n)?)
}
pub fn unwrap_giftwrap(&self, event: &Event) -> Result<Rumor, Error> {
Ok(self.inner.read().unwrap_giftwrap(event)?)
Ok(self.inner.read_arc().unwrap_giftwrap(event)?)
}
/// @deprecated for migrations only
pub fn unwrap_giftwrap1(&self, event: &EventV1) -> Result<RumorV1, Error> {
Ok(self.inner.read().unwrap_giftwrap1(event)?)
Ok(self.inner.read_arc().unwrap_giftwrap1(event)?)
}
/// @deprecated for migrations only
pub fn unwrap_giftwrap2(&self, event: &EventV2) -> Result<RumorV2, Error> {
Ok(self.inner.read().unwrap_giftwrap2(event)?)
Ok(self.inner.read_arc().unwrap_giftwrap2(event)?)
}
pub fn decrypt_event_contents(&self, event: &Event) -> Result<String, Error> {
Ok(self.inner.read().decrypt_event_contents(event)?)
Ok(self.inner.read_arc().decrypt_event_contents(event)?)
}
pub fn decrypt(&self, other: &PublicKey, ciphertext: &str) -> Result<String, Error> {
Ok(self.inner.read().decrypt(other, ciphertext)?)
Ok(self.inner.read_arc().decrypt(other, ciphertext)?)
}
pub fn nip44_conversation_key(&self, other: &PublicKey) -> Result<[u8; 32], Error> {
Ok(self.inner.read().nip44_conversation_key(other)?)
Ok(self.inner.read_arc().nip44_conversation_key(other)?)
}
pub fn encrypt(
@ -250,7 +254,7 @@ impl GossipIdentity {
plaintext: &str,
algo: ContentEncryptionAlgorithm,
) -> Result<String, Error> {
Ok(self.inner.read().encrypt(other, plaintext, algo)?)
Ok(self.inner.read_arc().encrypt(other, plaintext, algo)?)
}
pub fn create_metadata_event(
@ -258,7 +262,10 @@ impl GossipIdentity {
input: PreEvent,
metadata: Metadata,
) -> Result<Event, Error> {
Ok(self.inner.read().create_metadata_event(input, metadata)?)
Ok(self
.inner
.read_arc()
.create_metadata_event(input, metadata)?)
}
pub fn create_zap_request_event(
@ -269,7 +276,7 @@ impl GossipIdentity {
relays: Vec<String>,
content: String,
) -> Result<Event, Error> {
Ok(self.inner.read().create_zap_request_event(
Ok(self.inner.read_arc().create_zap_request_event(
recipient_pubkey,
zapped_event,
millisatoshis,
@ -285,12 +292,12 @@ impl GossipIdentity {
) -> Result<Signature, Error> {
Ok(self
.inner
.read()
.read_arc()
.generate_delegation_signature(delegated_pubkey, delegation_conditions)?)
}
pub fn giftwrap(&self, input: PreEvent, pubkey: PublicKey) -> Result<Event, Error> {
Ok(self.inner.read().giftwrap(input, pubkey)?)
Ok(self.inner.read_arc().giftwrap(input, pubkey)?)
}
pub fn verify_delegation_signature(
@ -299,7 +306,7 @@ impl GossipIdentity {
delegation_conditions: &DelegationConditions,
signature: &Signature,
) -> Result<(), Error> {
Ok(self.inner.read().verify_delegation_signature(
Ok(self.inner.read_arc().verify_delegation_signature(
delegated_pubkey,
delegation_conditions,
signature,