Struct KeySigner

pub struct KeySigner { /* private fields */ }

Signer with a local private key (and public key)

Implementations

impl KeySigner

pub fn from_locked_parts(epk: EncryptedPrivateKey, pk: PublicKey) -> Self

Create a Signer from an EncryptedPrivateKey

pub fn from_private_key( privk: PrivateKey, password: &str, log_n: u8, ) -> Result<Self, Error>

Create a Signer from a PrivateKey

pub fn from_encrypted_private_key( epk: EncryptedPrivateKey, pass: &str, ) -> Result<Self, Error>

Create a Signer from an EncryptedPrivateKey and a password to unlock it

pub fn generate(password: &str, log_n: u8) -> Result<Self, Error>

Create a Signer by generating a new PrivateKey

Trait Implementations

impl Debug for KeySigner

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeySigner

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExportableSigner for KeySigner

fn export_private_key_in_hex<'life0, 'life1, 'async_trait>( &'life0 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 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 LockableSigner for KeySigner

fn is_locked(&self) -> bool

Is the signer locked?

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

Try to unlock access to the private key

fn lock(&self)

Lock access to the private key

fn change_passphrase( &self, old: &str, new: &str, log_n: u8, ) -> Result<(), Error>

Change the passphrase used for locking access to the private key

fn upgrade(&self, pass: &str, log_n: u8) -> Result<(), Error>

Upgrade the encrypted private key to the latest format

impl Serialize for KeySigner

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Signer for KeySigner

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 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-04 or NIP-44

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 KeySigner

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