Struct PrivateKey

pub struct PrivateKey(/* private fields */);

This is a private key which is to be kept secret and is used to prove identity

Implementations

impl PrivateKey

pub fn export_encrypted( &self, password: &str, log2_rounds: u8, ) -> Result<EncryptedPrivateKey, Error>

Export in a (non-portable) encrypted form. This does not downgrade the security of the key, but you are responsible to keep it encrypted. You should not attempt to decrypt it, only use import_encrypted() on it, or something similar in another library/client which also respects key security.

This currently exports into EncryptedPrivateKey version 2.

We recommend you zeroize() the password you pass in after you are done with it.

pub fn import_encrypted( encrypted: &EncryptedPrivateKey, password: &str, ) -> Result<PrivateKey, Error>

Import an encrypted private key which was exported with export_encrypted().

We recommend you zeroize() the password you pass in after you are done with it.

This is backwards-compatible with keys that were exported with older code.

impl PrivateKey

pub fn shared_secret( &self, other: &PublicKey, algo: ContentEncryptionAlgorithm, ) -> [u8; 32]

Get the shared secret

pub fn encrypt( &self, other: &PublicKey, plaintext: &str, algo: ContentEncryptionAlgorithm, ) -> Result<String, Error>

Encrypt

pub fn detect_encryption_algorithm( ciphertext: &str, ) -> ContentEncryptionAlgorithm

Detect encryption algorithm of ciphertext

pub fn decrypt( &self, other: &PublicKey, ciphertext: &str, ) -> Result<String, Error>

Decrypt (detects encryption version)

pub fn decrypt_nip04( &self, other: &PublicKey, ciphertext: &str, ) -> Result<Vec<u8>, Error>

Decrypt NIP-04 only

pub fn decrypt_nip44( &self, other: &PublicKey, ciphertext: &str, ) -> Result<String, Error>

Decrypt NIP-44 only, version is detected

impl PrivateKey

pub fn new() -> PrivateKey

Generate a new PrivateKey (which can be used to get the PublicKey)

pub fn generate() -> PrivateKey

Generate a new PrivateKey (which can be used to get the PublicKey)

pub fn public_key(&self) -> PublicKey

Get the PublicKey matching this PrivateKey

pub fn key_security(&self) -> KeySecurity

Get the security level of the private key

pub fn as_hex_string(&mut self) -> String

Render into a hexadecimal string

WARNING: This weakens the security of your key. Your key will be marked with KeySecurity::Weak if you execute this.

pub fn try_from_hex_string(v: &str) -> Result<PrivateKey, Error>

Create from a hexadecimal string

This creates a key with KeySecurity::Weak. Use generate() or import_encrypted() for KeySecurity::Medium

pub fn as_bech32_string(&mut self) -> String

Export as a bech32 encoded string

WARNING: This weakens the security of your key. Your key will be marked with KeySecurity::Weak if you execute this.

pub fn try_from_bech32_string(s: &str) -> Result<PrivateKey, Error>

Import from a bech32 encoded string

This creates a key with KeySecurity::Weak. Use generate() or import_encrypted() for KeySecurity::Medium

pub fn as_secret_key(&self) -> SecretKey

As a secp256k1::SecretKey

Trait Implementations

impl Clone for PrivateKey

fn clone(&self) -> PrivateKey

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrivateKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PrivateKey

fn default() -> Self

Returns the “default value” for a type.

impl Drop for PrivateKey

fn drop(&mut self)

Executes the destructor for this type.

impl MutExportableSigner for PrivateKey

fn export_private_key_in_hex<'life0, 'life1, 'async_trait>( &'life0 mut self, _pass: &'life1 str, _log_n: u8, ) -> Pin<Box<dyn Future<Output = Result<(String, bool), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Export the private key in hex.

fn export_private_key_in_bech32<'life0, 'life1, 'async_trait>( &'life0 mut self, _pass: &'life1 str, _log_n: u8, ) -> Pin<Box<dyn Future<Output = Result<(String, bool), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Export the private key in bech32.

impl Signer for PrivateKey

fn decrypt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, other: &'life1 PublicKey, ciphertext: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Decrypt NIP-44

fn public_key(&self) -> PublicKey

What is the signer’s public key?

fn encrypted_private_key(&self) -> Option<EncryptedPrivateKey>

What is the signer’s encrypted private key?

fn sign_event<'life0, 'async_trait>( &'life0 self, input: PreEvent, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sign an event

fn encrypt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, other: &'life1 PublicKey, plaintext: &'life2 str, algo: ContentEncryptionAlgorithm, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Encrypt

fn key_security(&self) -> Result<KeySecurity, Error>

Get the security level of the private key

fn giftwrap<'life0, 'async_trait>( &'life0 self, input: PreEvent, pubkey: PublicKey, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Giftwrap an event

fn create_metadata_event<'life0, 'async_trait>( &'life0 self, input: PreEvent, metadata: Metadata, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create an event that sets Metadata

fn create_zap_request_event<'life0, 'async_trait>( &'life0 self, recipient_pubkey: PublicKey, zapped_event: Option<Id>, millisatoshis: u64, relays: Vec<String>, content: String, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a ZapRequest event These events are not published to nostr, they are sent to a lnurl.

fn decrypt_event_contents<'life0, 'life1, 'async_trait>( &'life0 self, event: &'life1 Event, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Decrypt the contents of an event

fn unwrap_giftwrap<'life0, 'life1, 'async_trait>( &'life0 self, event: &'life1 Event, ) -> Pin<Box<dyn Future<Output = Result<Rumor, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

If a gift wrap event, unwrap and return the inner Rumor

impl SignerExt for PrivateKey

fn sign_id<'life0, 'async_trait>( &'life0 self, id: Id, ) -> Pin<Box<dyn Future<Output = Result<Signature, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sign a 32-bit hash asynchronously

fn sign<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Signature, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sign a message asynchronously (this hashes with SHA-256 first internally)

fn nip44_conversation_key<'life0, 'life1, 'async_trait>( &'life0 self, other: &'life1 PublicKey, ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get NIP-44 conversation key

fn generate_delegation_signature<'life0, 'life1, 'async_trait>( &'life0 self, delegated_pubkey: PublicKey, delegation_conditions: &'life1 DelegationConditions, ) -> Pin<Box<dyn Future<Output = Result<Signature, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Generate delegation signature

fn verify_delegation_signature( &self, delegated_pubkey: PublicKey, delegation_conditions: &DelegationConditions, signature: &Signature, ) -> Result<(), Error>

Verify delegation signature

fn sign_event_with_pow<'life0, 'async_trait>( &'life0 self, input: PreEvent, zero_bits: u8, work_sender: Option<Sender<u8>>, ) -> Pin<Box<dyn Future<Output = Result<Event, Error>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Sign an event with Proof-of-Work