Struct BunkerClient

pub struct BunkerClient {
    pub remote_signer_pubkey: PublicKey,
    pub relay_url: RelayUrl,
    pub local_signer: Arc<KeySigner>,
    pub public_key: PublicKey,
    pub timeout: Duration,
    pub client: Client,
}

This is a NIP-46 Bunker client

Fields

remote_signer_pubkey: PublicKey

The pubkey of the bunker

relay_url: RelayUrl

The relay the bunker is listening at

local_signer: Arc<KeySigner>

Our local identity

public_key: PublicKey

User Public Key

timeout: Duration

Timeout

client: Client

Client

Implementations

impl BunkerClient

pub async fn from_stored_data( remote_signer_pubkey: PublicKey, relay_url: RelayUrl, keysigner: KeySigner, public_key: PublicKey, timeout: Duration, ) -> BunkerClient

Create a new BunkerClient from stored data. This will be in the locked state.

pub fn is_locked(&self) -> bool

Is the signer locked?

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

Unlock (if locked)

pub fn lock(&self)

Lock

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

Change passphrase

pub async fn call(&self, request: Nip46Request) -> Result<Nip46Response, Error>

Send a Nip46Request and wait for a Nip46Response (up to our timeout)

pub async fn disconnect(&self) -> Result<(), Error>

Disconnect from the relay

pub async fn disconnect_and_lock(&self) -> Result<(), Error>

Disconnect from the relay and lock

Trait Implementations

impl Debug for BunkerClient

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BunkerClient

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BunkerClient

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 BunkerClient

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, pre_event: 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