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

pub fn sign_id(&self, id: Id) -> Result<Signature, Error>

Sign a 32-bit hash

pub fn sign(&self, message: &[u8]) -> Result<Signature, Error>

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

Trait Implementations

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 Signer for PrivateKey

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

Decrypt NIP-44

fn nip44_conversation_key(&self, other: &PublicKey) -> Result<[u8; 32], Error>

Get NIP-44 conversation key

fn is_locked(&self) -> bool

Is the signer locked?

fn unlock(&mut self, _password: &str) -> Result<(), Error>

Try to unlock access to the private key

fn lock(&mut self)

Lock access to the private key

fn change_passphrase( &mut self, _old: &str, _new: &str, _log_n: u8, ) -> Result<(), Error>

Change the passphrase used for locking access to the private key

fn upgrade(&mut self, _pass: &str, _log_n: u8) -> Result<(), Error>

Upgrade the encrypted private key to the latest format

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 export_private_key_in_hex( &mut self, _pass: &str, _log_n: u8, ) -> Result<(String, bool), Error>

Export the private key in hex.

fn export_private_key_in_bech32( &mut self, _pass: &str, _log_n: u8, ) -> Result<(String, bool), Error>

Export the private key in bech32.

fn sign_id(&self, id: Id) -> Result<Signature, Error>

Sign a 32-bit hash

fn sign(&self, message: &[u8]) -> Result<Signature, Error>

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

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

Encrypt

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

Get the security level of the private key

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

Generate delegation signature

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

Verify delegation signature

fn sign_event(&self, input: PreEvent) -> Result<Event, Error>

Sign an event

fn sign_event2(&self, input: PreEventV2) -> Result<EventV2, Error>

Sign an event

fn sign_event_with_pow( &self, input: PreEvent, zero_bits: u8, work_sender: Option<Sender<u8>>, ) -> Result<Event, Error>

Sign an event with Proof-of-Work

fn giftwrap(&self, input: PreEvent, pubkey: PublicKey) -> Result<Event, Error>

Giftwrap an event

fn giftwrap2( &self, input: PreEventV2, pubkey: PublicKey, ) -> Result<EventV2, Error>

Giftwrap an event

fn create_metadata_event( &self, input: PreEvent, metadata: Metadata, ) -> Result<Event, Error>

Create an event that sets Metadata

fn create_zap_request_event( &self, recipient_pubkey: PublicKey, zapped_event: Option<Id>, millisatoshis: u64, relays: Vec<String>, content: String, ) -> Result<Event, Error>

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

fn decrypt_event_contents(&self, event: &Event) -> Result<String, Error>

Decrypt the contents of an event

fn unwrap_giftwrap(&self, event: &Event) -> Result<Rumor, Error>

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

fn unwrap_giftwrap2(&self, event: &EventV2) -> Result<RumorV2, Error>

If a gift wrap event, unwrap and return the inner Rumor @deprecated for migrations only

fn unwrap_giftwrap1(&self, event: &EventV1) -> Result<RumorV1, Error>

If a gift wrap event, unwrap and return the inner Rumor @deprecated for migrations only