Use blossom for file uploads (#537)

Author: zupzup

CHANGELOG.md

@@ -1,6 +1,7 @@
 # 0.3.15
 
 * Upload and download files to and from Nostr using Blossom
+    * Add `nostr_hash` to `File` (breaking DB change)
 
 # 0.3.14
 

clippy.toml

@@ -1 +1 @@
-too-many-arguments-threshold=12
+too-many-arguments-threshold=13

crates/bcr-ebill-api/src/external/file_storage.rs

@@ -6,6 +6,7 @@ use nostr::hashes::{
     Hash,
     sha256::{self, Hash as Sha256Hash},
 };
+use reqwest::Url;
 use serde::Deserialize;
 use thiserror::Error;
 
@@ -60,6 +61,23 @@ impl FileStorageClient {
     }
 }
 
+fn to_url(relay_url: &str, to_join: &str) -> Result<Url> {
+    let mut url = reqwest::Url::parse(relay_url)
+        .and_then(|url| url.join(to_join))
+        .map_err(|_| Error::InvalidRelayUrl)?;
+    match url.scheme() {
+        "ws" => {
+            url.set_scheme("http").map_err(|_| Error::InvalidRelayUrl)?;
+        }
+        "wss" => {
+            url.set_scheme("https")
+                .map_err(|_| Error::InvalidRelayUrl)?;
+        }
+        _ => (),
+    };
+    Ok(url)
+}
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl FileStorageClientApi for FileStorageClient {
@@ -71,12 +89,15 @@ impl FileStorageClientApi for FileStorageClient {
         }
         let hash = sha256::Hash::from_engine(hash_engine);
 
-        // PUT {relay_url}/upload
-        let url = reqwest::Url::parse(relay_url)
-            .and_then(|url| url.join("upload"))
-            .map_err(|_| Error::InvalidRelayUrl)?;
         // Make upload request
-        let resp: BlobDescriptorReply = self.cl.put(url).body(bytes).send().await?.json().await?;
+        let resp: BlobDescriptorReply = self
+            .cl
+            .put(to_url(relay_url, "upload")?)
+            .body(bytes)
+            .send()
+            .await?
+            .json()
+            .await?;
         let nostr_hash = resp.sha256;
 
         // Check hash
@@ -88,12 +109,15 @@ impl FileStorageClientApi for FileStorageClient {
     }
 
     async fn download(&self, relay_url: &str, nostr_hash: &str) -> Result<Vec<u8>> {
-        // GET {relay_url}/{hash}
-        let url = reqwest::Url::parse(relay_url)
-            .and_then(|url| url.join(nostr_hash))
-            .map_err(|_| Error::InvalidRelayUrl)?;
         // Make download request
-        let resp: Vec<u8> = self.cl.get(url).send().await?.bytes().await?.into();
+        let resp: Vec<u8> = self
+            .cl
+            .get(to_url(relay_url, nostr_hash)?)
+            .send()
+            .await?
+            .bytes()
+            .await?
+            .into();
 
         // Calculate hash to compare with the hash we sent
         let mut hash_engine = sha256::HashEngine::default();

crates/bcr-ebill-api/src/service/bill_service/issue.rs

@@ -14,9 +14,28 @@ use bcr_ebill_core::{
     util::BcrKeys,
 };
 use bcr_ebill_transport::BillChainEvent;
-use log::{debug, error};
+use log::{debug, error, info};
 
 impl BillService {
+    async fn encrypt_and_save_uploaded_file(
+        &self,
+        file_name: &str,
+        file_bytes: &[u8],
+        bill_id: &str,
+        bill_public_key: &str,
+        relay_url: &str,
+    ) -> Result<File> {
+        let file_hash = util::sha256_hash(file_bytes);
+        let encrypted = util::crypto::encrypt_ecies(file_bytes, bill_public_key)?;
+        let nostr_hash = self.file_upload_client.upload(relay_url, encrypted).await?;
+        info!("Saved file {file_name} with hash {file_hash} for bill {bill_id}");
+        Ok(File {
+            name: file_name.to_owned(),
+            hash: file_hash,
+            nostr_hash: nostr_hash.to_string(),
+        })
+    }
+
     pub(super) async fn issue_bill(&self, data: BillIssueData) -> Result<BitcreditBill> {
         debug!(
             "issuing bill with type {}, blank: {}",
@@ -108,6 +127,7 @@ impl BillService {
         debug!("issuing bill with drawee {public_data_drawee:?} and payee {public_data_payee:?}");
 
         let identity = self.identity_store.get_full().await?;
+        let nostr_relays = identity.identity.nostr_relays.clone();
         let keys = BcrKeys::new();
         let public_key = keys.get_public_key();
 
@@ -118,16 +138,24 @@ impl BillService {
         };
 
         let mut bill_files: Vec<File> = vec![];
-        for file_upload_id in data.file_upload_ids.iter() {
-            let (file_name, file_bytes) = &self
-                .file_upload_store
-                .read_temp_upload_file(file_upload_id)
-                .await
-                .map_err(|_| Error::NoFileForFileUploadId)?;
-            bill_files.push(
-                self.encrypt_and_save_uploaded_file(file_name, file_bytes, &bill_id, &public_key)
+        if let Some(nostr_relay) = nostr_relays.first() {
+            for file_upload_id in data.file_upload_ids.iter() {
+                let (file_name, file_bytes) = &self
+                    .file_upload_store
+                    .read_temp_upload_file(file_upload_id)
+                    .await
+                    .map_err(|_| Error::NoFileForFileUploadId)?;
+                bill_files.push(
+                    self.encrypt_and_save_uploaded_file(
+                        file_name,
+                        file_bytes,
+                        &bill_id,
+                        &public_key,
+                        nostr_relay,
+                    )
                     .await?,
-            );
+                );
+            }
         }
 
         let bill = BitcreditBill {

crates/bcr-ebill-api/src/service/bill_service/mod.rs

@@ -1,6 +1,5 @@
 use crate::blockchain::bill::BillBlockchain;
 use crate::data::{
-    File,
     bill::{
         BillCombinedBitcoinKey, BillKeys, BillsBalanceOverview, BillsFilterRole, BitcreditBill,
         BitcreditBillResult, Endorsement, LightBitcreditBillResult, PastEndorsee,
@@ -83,20 +82,10 @@ pub trait BillServiceApi: ServiceTraitBounds {
     async fn open_and_decrypt_attached_file(
         &self,
         bill_id: &str,
-        file_name: &str,
+        file: &bcr_ebill_core::File,
         bill_private_key: &str,
     ) -> Result<Vec<u8>>;
 
-    /// encrypts and saves the given uploaded file, returning the file name, as well as the hash of
-    /// the unencrypted file
-    async fn encrypt_and_save_uploaded_file(
-        &self,
-        file_name: &str,
-        file_bytes: &[u8],
-        bill_id: &str,
-        bill_public_key: &str,
-    ) -> Result<File>;
-
     /// issues a new bill
     async fn issue_new_bill(&self, data: BillIssueData) -> Result<BitcreditBill>;
 
@@ -235,7 +224,7 @@ pub mod tests {
         util,
     };
     use bcr_ebill_core::{
-        ValidationError,
+        File, ValidationError,
         bill::{
             BillAcceptanceStatus, BillCurrentWaitingState, BillPaymentStatus, BillRecourseStatus,
             BillSellStatus, BillWaitingForPaymentState, PastPaymentStatus, RecourseReason,
@@ -259,9 +248,11 @@ pub mod tests {
         util::date::DateTimeUtc,
     };
     use cashu::nut02 as cdk02;
-    use core::str;
     use mockall::predicate::{always, eq, function};
-    use std::collections::{HashMap, HashSet};
+    use std::{
+        collections::{HashMap, HashSet},
+        str::FromStr,
+    };
     use test_utils::{
         accept_block, get_baseline_bill, get_baseline_cached_bill, get_baseline_identity, get_ctx,
         get_genesis_chain, get_service, offer_to_sell_block, recourse_block, reject_accept_block,
@@ -480,9 +471,12 @@ pub mod tests {
         ctx.file_upload_store
             .expect_remove_temp_upload_folder()
             .returning(|_| Ok(()));
-        ctx.file_upload_store
-            .expect_save_attached_file()
-            .returning(move |_, _, _| Ok(()));
+        ctx.file_upload_client.expect_upload().returning(|_, _| {
+            Ok(nostr::hashes::sha256::Hash::from_str(
+                "d277fe40da2609ca08215cdfbeac44835d4371a72f1416a63c87efd67ee24bfa",
+            )
+            .unwrap())
+        });
         ctx.bill_store.expect_save_keys().returning(|_, _| Ok(()));
         ctx.bill_store
             .expect_save_bill_to_cache()
@@ -543,9 +537,12 @@ pub mod tests {
         ctx.file_upload_store
             .expect_remove_temp_upload_folder()
             .returning(|_| Ok(()));
-        ctx.file_upload_store
-            .expect_save_attached_file()
-            .returning(move |_, _, _| Ok(()));
+        ctx.file_upload_client.expect_upload().returning(|_, _| {
+            Ok(nostr::hashes::sha256::Hash::from_str(
+                "d277fe40da2609ca08215cdfbeac44835d4371a72f1416a63c87efd67ee24bfa",
+            )
+            .unwrap())
+        });
         ctx.bill_store.expect_save_keys().returning(|_, _| Ok(()));
         ctx.bill_store
             .expect_save_bill_to_cache()
@@ -686,9 +683,12 @@ pub mod tests {
         ctx.file_upload_store
             .expect_remove_temp_upload_folder()
             .returning(|_| Ok(()));
-        ctx.file_upload_store
-            .expect_save_attached_file()
-            .returning(move |_, _, _| Ok(()));
+        ctx.file_upload_client.expect_upload().returning(|_, _| {
+            Ok(nostr::hashes::sha256::Hash::from_str(
+                "d277fe40da2609ca08215cdfbeac44835d4371a72f1416a63c87efd67ee24bfa",
+            )
+            .unwrap())
+        });
         ctx.bill_store.expect_save_keys().returning(|_, _| Ok(()));
         ctx.bill_store
             .expect_save_bill_to_cache()
@@ -734,71 +734,26 @@ pub mod tests {
     }
 
     #[tokio::test]
-    async fn save_encrypt_open_decrypt_compare_hashes() {
-        let mut ctx = get_ctx();
-        let bill_id = "test_bill_id";
-        let file_name = "invoice_00000000-0000-0000-0000-000000000000.pdf";
-        let file_bytes = String::from("hello world").as_bytes().to_vec();
-        let expected_encrypted =
-            util::crypto::encrypt_ecies(&file_bytes, TEST_PUB_KEY_SECP).unwrap();
-
-        ctx.file_upload_store
-            .expect_save_attached_file()
-            .with(always(), eq(bill_id), eq(file_name))
-            .times(1)
-            .returning(|_, _, _| Ok(()));
-
-        ctx.file_upload_store
-            .expect_open_attached_file()
-            .with(eq(bill_id), eq(file_name))
-            .times(1)
-            .returning(move |_, _| Ok(expected_encrypted.clone()));
-        let service = get_service(ctx);
-
-        let bill_file = service
-            .encrypt_and_save_uploaded_file(file_name, &file_bytes, bill_id, TEST_PUB_KEY_SECP)
-            .await
-            .unwrap();
-        assert_eq!(
-            bill_file.hash,
-            String::from("DULfJyE3WQqNxy3ymuhAChyNR3yufT88pmqvAazKFMG4")
-        );
-        assert_eq!(bill_file.name, String::from(file_name));
-
-        let decrypted = service
-            .open_and_decrypt_attached_file(bill_id, file_name, TEST_PRIVATE_KEY_SECP)
-            .await
-            .unwrap();
-        assert_eq!(str::from_utf8(&decrypted).unwrap(), "hello world");
-    }
-
-    #[tokio::test]
-    async fn save_encrypt_propagates_write_file_error() {
-        let mut ctx = get_ctx();
-        ctx.file_upload_store
-            .expect_save_attached_file()
-            .returning(|_, _, _| Err(persistence::Error::Io(std::io::Error::other("test error"))));
-        let service = get_service(ctx);
-
-        assert!(
-            service
-                .encrypt_and_save_uploaded_file("file_name", &[], "test", TEST_PUB_KEY_SECP)
-                .await
-                .is_err()
-        );
-    }
-
-    #[tokio::test]
-    async fn open_decrypt_propagates_read_file_error() {
+    async fn open_decrypt_propagates_download_error() {
         let mut ctx = get_ctx();
-        ctx.file_upload_store
-            .expect_open_attached_file()
-            .returning(|_, _| Err(persistence::Error::Io(std::io::Error::other("test error"))));
+        ctx.file_upload_client.expect_download().returning(|_, _| {
+            Err(crate::external::Error::ExternalFileStorageApi(
+                crate::external::file_storage::Error::InvalidRelayUrl,
+            ))
+        });
         let service = get_service(ctx);
 
         assert!(
             service
-                .open_and_decrypt_attached_file("test", "test", TEST_PRIVATE_KEY_SECP)
+                .open_and_decrypt_attached_file(
+                    "test",
+                    &File {
+                        name: "some_file".into(),
+                        hash: "".into(),
+                        nostr_hash: "".into()
+                    },
+                    TEST_PRIVATE_KEY_SECP
+                )
                 .await
                 .is_err()
         );
@@ -6033,7 +5988,6 @@ pub mod tests {
                 1731593930,
             )
             .await;
-        println!("{res:?}");
         assert!(res.is_ok());
     }