blossom: cleanup examples

Signed-off-by: Yuki Kishimoto <[email protected]>

Author: yukibtc

crates/nostr-blossom/examples/delete.rs

@@ -1,11 +1,7 @@
-use std::error::Error;
-use std::str::FromStr;
-
 use clap::Parser;
-use nostr::hashes::sha256;
-use nostr::key::SecretKey;
-use nostr::Keys;
-use nostr_blossom::client::BlossomClient;
+use nostr::hashes::sha256::Hash as Sha256Hash;
+use nostr::prelude::*;
+use nostr_blossom::prelude::*;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "Delete a blob from a Blossom server", long_about = None)]
@@ -16,29 +12,27 @@ struct Args {
 
     /// The SHA256 hash of the blob to delete (in hex)
     #[arg(long)]
-    sha256: String,
+    sha256: Sha256Hash,
 
-    /// Optional private key for signing the deletion (in hex)
+    /// Optional private key for signing the deletion
     #[arg(long, value_name = "PRIVATE_KEY")]
-    private_key: String,
+    private_key: SecretKey,
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     let args = Args::parse();
 
     let client = BlossomClient::new(&args.server);
 
     // Create signer keys using the given private key
-    let keys = Keys::new(SecretKey::from_hex(&args.private_key)?);
+    let keys = Keys::new(args.private_key);
 
     println!("Attempting to delete blob with SHA256: {}", args.sha256);
 
-    let blob_hash = sha256::Hash::from_str(&args.sha256)?;
-
-    match client.delete_blob(blob_hash, None, &keys).await {
+    match client.delete_blob(args.sha256, None, &keys).await {
         Ok(()) => println!("Blob deleted successfully."),
-        Err(e) => eprintln!("Failed to delete blob: {}", e),
+        Err(e) => eprintln!("{e}"),
     }
 
     Ok(())

crates/nostr-blossom/examples/download.rs

@@ -1,10 +1,9 @@
-use std::error::Error;
 use std::fs;
-use std::str::FromStr;
 
 use clap::Parser;
-use nostr::hashes::sha256;
-use nostr_blossom::client::BlossomClient;
+use nostr::hashes::sha256::Hash as Sha256Hash;
+use nostr::prelude::*;
+use nostr_blossom::prelude::*;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "Download a blob from a Blossom server", long_about = None)]
@@ -15,36 +14,36 @@ struct Args {
 
     /// SHA256 hash of the blob to download
     #[arg(long)]
-    sha256: String,
+    sha256: Sha256Hash,
 
-    /// Private key to use for authorization (in hex)
+    /// Private key to use for authorization
     #[arg(long)]
-    private_key: String,
+    private_key: SecretKey,
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     let args = Args::parse();
 
     // Initialize the client.
     let client = BlossomClient::new(&args.server);
 
-    // Convert the provided SHA256 string into a hash.
-    let blob_sha = sha256::Hash::from_str(&args.sha256)?;
-
     // Parse the private key.
-    let keypair = nostr::Keys::parse(&args.private_key)?;
+    let keypair = Keys::new(args.private_key);
 
     // Download the blob with optional authorization.
-    match client.get_blob(blob_sha, None, None, Some(&keypair)).await {
+    match client
+        .get_blob(args.sha256, None, None, Some(&keypair))
+        .await
+    {
         Ok(blob) => {
             println!("Successfully downloaded blob with {} bytes", blob.len());
-            let file_name = format!("{}", blob_sha);
+            let file_name = format!("{}", args.sha256);
             fs::write(&file_name, &blob)?;
             println!("Blob saved as {}", file_name);
         }
-        Err(err) => {
-            eprintln!("Failed to download blob: {}", err);
+        Err(e) => {
+            eprintln!("{e}");
         }
     }
 

crates/nostr-blossom/examples/integration_test.rs

@@ -20,9 +20,9 @@ struct Args {
     #[arg(long)]
     file: Option<PathBuf>,
 
-    /// Private key to use for signing (in hex)
+    /// Private key to use for signing
     #[arg(long, value_name = "PRIVATE_KEY")]
-    private_key: String,
+    private_key: SecretKey,
 }
 
 #[tokio::main]
@@ -33,7 +33,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Create the Blossom client.
     let client = BlossomClient::new(&args.server);
     // Create signer keys from the provided private key.
-    let keys = Keys::new(SecretKey::from_hex(args.private_key.as_str())?);
+    let keys = Keys::new(args.private_key);
 
     // Read the blob data from a file if provided, otherwise use default test data.
     let data = if let Some(file_path) = args.file {

crates/nostr-blossom/examples/list.rs

@@ -1,10 +1,6 @@
-use std::error::Error;
-use std::str::FromStr;
-
 use clap::Parser;
-use nostr::key::SecretKey;
-use nostr::{Keys, PublicKey};
-use nostr_blossom::client::BlossomClient;
+use nostr::prelude::*;
+use nostr_blossom::prelude::*;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "List blob on a Blossom server", long_about = None)]
@@ -13,30 +9,27 @@ struct Args {
     #[arg(long)]
     server: String,
 
-    /// The public key to list blobs for (in hex format)
+    /// The public key to list blobs for
     #[arg(long)]
-    pubkey: String,
+    pubkey: PublicKey,
 
     /// Optional private key for authorization (in hex)
     #[arg(long)]
-    private_key: Option<String>,
+    private_key: Option<SecretKey>,
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     let args = Args::parse();
     let client = BlossomClient::new(&args.server);
 
-    let pubkey = PublicKey::from_str(&args.pubkey)?;
-
     // Check if a private key was provided and branch accordingly
-    if let Some(private_key_str) = args.private_key {
+    if let Some(private_key) = args.private_key {
         // Attempt to create the secret key, propagating error if parsing fails
-        let secret_key = SecretKey::from_hex(&private_key_str)?;
-        let keys = Keys::new(secret_key);
+        let keys = Keys::new(private_key);
 
         let descriptors = client
-            .list_blobs(&pubkey, None, None, None, Some(&keys))
+            .list_blobs(&args.pubkey, None, None, None, Some(&keys))
             .await?;
 
         println!("Successfully listed blobs (with auth):");
@@ -45,7 +38,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
     } else {
         let descriptors = client
-            .list_blobs(&pubkey, None, None, None, None::<&Keys>)
+            .list_blobs(&args.pubkey, None, None, None, None::<&Keys>)
             .await?;
 
         println!("Successfully listed blobs (without auth):");

crates/nostr-blossom/examples/upload.rs

@@ -1,10 +1,9 @@
-use std::error::Error;
 use std::fs;
+use std::path::PathBuf;
 
 use clap::Parser;
-use nostr::key::SecretKey;
-use nostr::Keys;
-use nostr_blossom::client::BlossomClient;
+use nostr::prelude::*;
+use nostr_blossom::prelude::*;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "Upload a blob to a Blossom server", long_about = None)]
@@ -15,19 +14,19 @@ struct Args {
 
     /// Path to the file to upload
     #[arg(long)]
-    file: String,
+    file: PathBuf,
 
     /// Optional content type (e.g., "application/octet-stream")
     #[arg(long)]
     content_type: Option<String>,
 
-    /// Optional private key for signing the upload (in hex)
+    /// Optional private key for signing the upload
     #[arg(long)]
-    private_key: Option<String>,
+    private_key: Option<SecretKey>,
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     let args = Args::parse();
 
     let client = BlossomClient::new(&args.server);
@@ -44,16 +43,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Create signer keys.
     // If a private key is provided, try to use it; otherwise generate a new key.
     let keys = match args.private_key {
-        Some(private_key) => match SecretKey::from_hex(private_key.as_str()) {
-            Ok(secret_key) => Keys::new(secret_key),
-            Err(e) => {
-                eprintln!(
-                    "Failed to parse private key: {}. Using generated key instead.",
-                    e
-                );
-                Keys::generate()
-            }
-        },
+        Some(private_key) => Keys::new(private_key),
         None => Keys::generate(),
     };
 
@@ -64,8 +54,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
         Ok(descriptor) => {
             println!("Successfully uploaded blob: {:?}", descriptor);
         }
-        Err(err) => {
-            eprintln!("Failed to upload blob: {}", err);
+        Err(e) => {
+            eprintln!("{e}");
         }
     }