From 21d40446c54066e10024bde38f5d2cf46caa3c71 Mon Sep 17 00:00:00 2001
From: Warm Beer <mickvd99@gmail.com>
Date: Mon, 4 Nov 2024 17:34:32 +0100
Subject: [PATCH] feat: added WASM functions for private data upload to vault
 using receipts & added metamask test

---
 autonomi/examples/metamask/index.html  |   4 +-
 autonomi/examples/metamask/index.js    | 188 ++++++++++++++++++-------
 autonomi/src/client/external_signer.rs |  13 +-
 autonomi/src/client/wasm.rs            | 183 +++++++++++++++++++++++-
 autonomi/tests/external_signer.rs      |  12 +-
 5 files changed, 332 insertions(+), 68 deletions(-)
diff --git a/autonomi/examples/metamask/index.html b/autonomi/examples/metamask/index.html
index 50844bd7f9..128273acbc 100644
--- a/autonomi/examples/metamask/index.html
+++ b/autonomi/examples/metamask/index.html
@@ -7,12 +7,12 @@
 <body>
 <!-- credits: https://rustwasm.github.io/docs/wasm-bindgen/examples/without-a-bundler.html -->
 <script type="module">
-    import {externalSignerPut} from "./index.js";
+    import {externalSignerPrivateDataPutToVault} from "./index.js";
 
     async function run() {
         document.getElementById("btn-run").disabled = true;
         const peerAddr = document.getElementById('peer_id').value;
-        await externalSignerPut(peerAddr);
+        await externalSignerPrivateDataPutToVault(peerAddr);
     }
 
     document.getElementById("btn-run").addEventListener("click", run, false);
diff --git a/autonomi/examples/metamask/index.js b/autonomi/examples/metamask/index.js
index 633eb36317..25b8b2fcad 100644
--- a/autonomi/examples/metamask/index.js
+++ b/autonomi/examples/metamask/index.js
@@ -1,6 +1,6 @@
 import init, * as autonomi from '../../pkg/autonomi.js';
 
-export async function externalSignerPut(peerAddr) {
+export async function externalSignerPrivateDataPutToVault(peerAddr) {
     try {
         // Check if MetaMask (window.ethereum) is available
         if (typeof window.ethereum === 'undefined') {
@@ -21,76 +21,107 @@ export async function externalSignerPut(peerAddr) {
         // Generate 1MB of random bytes in a Uint8Array
         const data = new Uint8Array(1024 * 1024).map(() => Math.floor(Math.random() * 256));
 
-        // Get quotes and payment information (this would need actual implementation)
-        const [quotes, quotePayments, free_chunks] = await client.getQuotes(data);
+        // Encrypt the data to chunks
+        const [dataMapChunk, dataChunks, dataMapChunkAddress, dataChunkAddresses] = autonomi.encryptData(data);
 
-        // Get the EVM network
-        let evmNetwork = autonomi.getEvmNetwork();
+        // Fetch quotes for the chunks
+        const [quotes, quotePayments, _freeChunks] = await client.getQuotes(dataChunkAddresses);
 
-        // Form quotes payment calldata
-        const payForQuotesCalldata = autonomi.getPayForQuotesCalldata(
-            evmNetwork,
-            quotePayments
-        );
+        // Pay for data chunks (not the data map)
+        const receipt = await executeQuotePayments(sender, quotes, quotePayments);
 
-        // Form approve to spend tokens calldata
-        const approveCalldata = autonomi.getApproveToSpendTokensCalldata(
-            evmNetwork,
-            payForQuotesCalldata.approve_spender,
-            payForQuotesCalldata.approve_amount
-        );
+        // Wait for a few seconds to allow tx to confirm
+        await new Promise(resolve => setTimeout(resolve, 5000));
 
-        console.log("Sending approve transaction..");
+        // Upload the data
+        const privateDataAccess = await client.privateDataPutWithReceipt(data, receipt);
 
-        // Approve to spend tokens
-        let txHash = await sendTransaction({
-            from: sender,
-            to: approveCalldata[1],
-            data: approveCalldata[0]
-        });
+        // Create a private archive
+        const privateArchive = new autonomi.PrivateArchive();
+
+        // Add our data's data map chunk to the private archive
+        privateArchive.addNewFile("test", privateDataAccess);
+
+        // Get the private archive's bytes
+        const privateArchiveBytes = privateArchive.bytes();
+
+        // Encrypt the private archive to chunks
+        const [paDataMapChunk, paDataChunks, paDataMapChunkAddress, paDataChunkAddresses] = autonomi.encryptData(privateArchiveBytes);
 
-        await waitForTransactionConfirmation(txHash);
+        // Fetch quotes for the private archive chunks
+        const [paQuotes, paQuotePayments, _paFreeChunks] = await client.getQuotes(paDataChunkAddresses);
 
-        let payments = {};
+        // Pay for the private archive chunks (not the data map)
+        const paReceipt = await executeQuotePayments(sender, paQuotes, paQuotePayments);
 
-        // Execute batched quote payment transactions
-        for (const [calldata, quoteHashes] of payForQuotesCalldata.batched_calldata_map) {
-            console.log("Sending batched data payment transaction..");
+        // Wait for a few seconds to allow tx to confirm
+        await new Promise(resolve => setTimeout(resolve, 5000));
 
-            let txHash = await sendTransaction({
-                from: sender,
-                to: payForQuotesCalldata.to,
-                data: calldata
-            });
+        // Upload the private archive
+        const privateArchiveAccess = await client.privateArchivePutWithReceipt(privateArchive, paReceipt);
 
-            await waitForTransactionConfirmation(txHash);
+        // Generate a random vault key (should normally be derived from a constant signature)
+        const vaultKey = autonomi.genSecretKey();
 
-            // Record the transaction hashes for each quote
-            quoteHashes.forEach(quoteHash => {
-                payments[quoteHash] = txHash;
-            });
+        // Fetch user data from vault (won't exist, so will be empty)
+        let userData;
+
+        try {
+            userData = await client.getUserDataFromVault(vaultKey);
+        } catch (err) {
+            userData = new autonomi.UserData();
         }
 
-        // Generate payment proof
-        const proof = autonomi.getPaymentProofFromQuotesAndPayments(quotes, payments);
+        // Add archive to user data
+        userData.addPrivateFileArchive(privateArchiveAccess, "test-archive");
 
-        // Submit the data with proof of payment
-        const addr = await client.dataPutWithProof(data, proof);
+        // Get or create a scratchpad for the user data
+        let scratchpad = await client.getOrCreateUserDataScratchpad(vaultKey);
 
-        // Wait for a few seconds to allow data to propagate
-        await new Promise(resolve => setTimeout(resolve, 10000));
+        // Content address of the scratchpad
+        let scratchPadAddress = scratchpad.xorName();
 
-        // Fetch the data back
-        const fetchedData = await client.dataGet(addr);
+        // Fetch quotes for the scratchpad
+        const [spQuotes, spQuotePayments, _spFreeChunks] = await client.getQuotes(scratchPadAddress ? [scratchPadAddress] : []);
 
-        if (fetchedData.toString() === data.toString()) {
-            console.log("Fetched data matches the original data!");
-        } else {
-            throw new Error("Fetched data does not match original data!")
-        }
+        // Pay for the private archive chunks (not the data map)
+        const spReceipt = await executeQuotePayments(sender, spQuotes, spQuotePayments);
+
+        // Wait for a few seconds to allow tx to confirm
+        await new Promise(resolve => setTimeout(resolve, 5000));
 
-        console.log("Data successfully put and verified!");
+        // Update vault
+        await client.putUserDataToVaultWithReceipt(userData, spReceipt, vaultKey);
 
+        // VERIFY UPLOADED DATA
+
+        // Fetch user data
+        let fetchedUserData = await client.getUserDataFromVault(vaultKey);
+
+        // Get the first key
+        let fetchedPrivateArchiveAccess = fetchedUserData.privateFileArchives().keys().next().value;
+
+        // Get private archive
+        let fetchedPrivateArchive = await client.privateArchiveGet(fetchedPrivateArchiveAccess);
+
+        // Select first file in private archive
+        let [fetchedFilePath, [fetchedPrivateFileAccess, fetchedFileMetadata]] = fetchedPrivateArchive.map().entries().next().value;
+
+        console.log(fetchedFilePath);
+        console.log(fetchedPrivateFileAccess);
+        console.log(fetchedFileMetadata);
+
+        // Fetch private file/data
+        let fetchedPrivateFile = await client.privateDataGet(fetchedPrivateFileAccess);
+
+        // Compare to original data
+        console.log("Comparing fetched data to original data..");
+
+        if (fetchedPrivateFile.toString() === data.toString()) {
+            console.log("Data matches! Private file upload to vault was successful!");
+        } else {
+            console.log("Data does not match!! Something went wrong..")
+        }
     } catch (error) {
         console.error("An error occurred:", error);
     }
@@ -146,4 +177,57 @@ async function waitForTransactionConfirmation(txHash) {
         // Wait for 1 second before checking again
         await delay(1000);
     }
+}
+
+const executeQuotePayments = async (sender, quotes, quotePayments) => {
+    // Get the EVM network
+    let evmNetwork = autonomi.getEvmNetwork();
+
+    // Form quotes payment calldata
+    const payForQuotesCalldata = autonomi.getPayForQuotesCalldata(
+        evmNetwork,
+        quotePayments
+    );
+
+    // Form approve to spend tokens calldata
+    const approveCalldata = autonomi.getApproveToSpendTokensCalldata(
+        evmNetwork,
+        payForQuotesCalldata.approve_spender,
+        payForQuotesCalldata.approve_amount
+    );
+
+    console.log("Sending approve transaction..");
+
+    // Approve to spend tokens
+    let hash = await sendTransaction({
+        from: sender,
+        to: approveCalldata[1],
+        data: approveCalldata[0]
+    });
+
+    // Wait for approve tx to confirm
+    await waitForTransactionConfirmation(hash);
+
+    let payments = {};
+
+    // Execute batched quote payment transactions
+    for (const [calldata, quoteHashes] of payForQuotesCalldata.batched_calldata_map) {
+        console.log("Sending batched data payment transaction..");
+
+        let hash = await sendTransaction({
+            from: sender,
+            to: payForQuotesCalldata.to,
+            data: calldata
+        });
+
+        await waitForTransactionConfirmation(hash);
+
+        // Record the transaction hashes for each quote
+        quoteHashes.forEach(quoteHash => {
+            payments[quoteHash] = hash;
+        });
+    }
+
+    // Generate receipt
+    return autonomi.getReceiptFromQuotesAndPayments(quotes, payments);
 }
\ No newline at end of file
diff --git a/autonomi/src/client/external_signer.rs b/autonomi/src/client/external_signer.rs
index c4f473d378..401b6d3151 100644
--- a/autonomi/src/client/external_signer.rs
+++ b/autonomi/src/client/external_signer.rs
@@ -36,19 +36,12 @@ impl Client {
 
 /// Encrypts data as chunks.
 ///
-/// Returns the data map chunk, file chunks and a list of all content addresses including the data map.
-pub fn encrypt_data(data: Bytes) -> Result<(Chunk, Vec<Chunk>, Vec<XorName>), PutError> {
+/// Returns the data map chunk and file chunks.
+pub fn encrypt_data(data: Bytes) -> Result<(Chunk, Vec<Chunk>), PutError> {
     let now = sn_networking::target_arch::Instant::now();
     let result = encrypt(data)?;
 
     debug!("Encryption took: {:.2?}", now.elapsed());
 
-    let map_xor_name = *result.0.address().xorname();
-    let mut xor_names = vec![map_xor_name];
-
-    for chunk in &result.1 {
-        xor_names.push(*chunk.name());
-    }
-
-    Ok((result.0, result.1, xor_names))
+    Ok((result.0, result.1))
 }
diff --git a/autonomi/src/client/wasm.rs b/autonomi/src/client/wasm.rs
index 4400252f33..03b16ee13f 100644
--- a/autonomi/src/client/wasm.rs
+++ b/autonomi/src/client/wasm.rs
@@ -4,6 +4,8 @@ use super::vault::UserData;
 use crate::client::data_private::PrivateDataAccess;
 use crate::client::payment::Receipt;
 use libp2p::Multiaddr;
+use serde_wasm_bindgen::Serializer;
+use sn_protocol::storage::Chunk;
 use wasm_bindgen::prelude::*;
 
 /// The `Client` object allows interaction with the network to store and retrieve data.
@@ -35,6 +37,24 @@ impl AttoTokens {
     }
 }
 
+#[wasm_bindgen(js_name = Chunk)]
+pub struct JsChunk(Chunk);
+
+#[wasm_bindgen(js_class = Chunk)]
+impl JsChunk {
+    /// Returns the bytes.
+    #[wasm_bindgen]
+    pub fn bytes(&self) -> Vec<u8> {
+        self.0.value.to_vec()
+    }
+
+    /// Returns the XOR name.
+    #[wasm_bindgen]
+    pub fn xor_name(&self) -> String {
+        self.0.address.xorname().to_string()
+    }
+}
+
 #[wasm_bindgen(js_class = Client)]
 impl JsClient {
     /// Connect to the network via the given peers.
@@ -153,6 +173,7 @@ mod archive {
     use super::*;
     use crate::client::{address::str_to_addr, archive::Archive};
     use std::path::PathBuf;
+    use wasm_bindgen::JsError;
 
     /// Structure mapping paths to data addresses.
     #[wasm_bindgen(js_name = Archive)]
@@ -190,6 +211,13 @@ mod archive {
             let files = serde_wasm_bindgen::to_value(self.0.map())?;
             Ok(files)
         }
+
+        /// Serialize to bytes.
+        #[wasm_bindgen(js_name = bytes)]
+        pub fn into_bytes(&self) -> Result<Vec<u8>, JsError> {
+            let root_serialized = rmp_serde::to_vec(&self.0)?;
+            Ok(root_serialized)
+        }
     }
 
     #[wasm_bindgen(js_class = Client)]
@@ -226,7 +254,7 @@ mod archive_private {
     use crate::client::data_private::PrivateDataAccess;
     use crate::client::payment::Receipt;
     use std::path::PathBuf;
-    use wasm_bindgen::JsValue;
+    use wasm_bindgen::{JsError, JsValue};
 
     /// Structure mapping paths to data addresses.
     #[wasm_bindgen(js_name = PrivateArchive)]
@@ -255,6 +283,13 @@ mod archive_private {
             let files = serde_wasm_bindgen::to_value(self.0.map())?;
             Ok(files)
         }
+
+        /// Serialize to bytes.
+        #[wasm_bindgen(js_name = bytes)]
+        pub fn into_bytes(&self) -> Result<Vec<u8>, JsError> {
+            let root_serialized = rmp_serde::to_vec(&self.0)?;
+            Ok(root_serialized)
+        }
     }
 
     #[wasm_bindgen(js_class = Client)]
@@ -319,6 +354,13 @@ mod archive_private {
 #[cfg(feature = "vault")]
 mod vault {
     use super::*;
+    use crate::client::address::addr_to_str;
+    use crate::client::archive_private::PrivateArchiveAccess;
+    use crate::client::payment::Receipt;
+    use crate::client::vault::user_data::USER_DATA_VAULT_CONTENT_IDENTIFIER;
+    use crate::client::vault::VaultContentType;
+    use sn_protocol::storage::Scratchpad;
+    use wasm_bindgen::{JsError, JsValue};
 
     /// Structure to keep track of uploaded archives, registers and other data.
     #[wasm_bindgen(js_name = UserData)]
@@ -362,6 +404,38 @@ mod vault {
             Ok(())
         }
 
+        /// Store a private archive data map in the user data with an optional name.
+        ///
+        /// # Example
+        ///
+        /// ```js
+        /// userData.addPrivateFileArchive(privateArchiveAccess, "foo");
+        /// ```
+        #[wasm_bindgen(js_name = addPrivateFileArchive)]
+        pub fn add_private_file_archive(
+            &mut self,
+            private_archive_access: JsValue,
+            name: Option<String>,
+        ) -> Result<(), JsError> {
+            let private_archive_access: PrivateArchiveAccess =
+                serde_wasm_bindgen::from_value(private_archive_access)?;
+
+            let old_name = if let Some(ref name) = name {
+                self.0
+                    .add_private_file_archive_with_name(private_archive_access, name.clone())
+            } else {
+                self.0.add_private_file_archive(private_archive_access)
+            };
+
+            if let Some(old_name) = old_name {
+                tracing::warn!(
+                    "Changing name of private archive from `{old_name:?}` to `{name:?}`"
+                );
+            }
+
+            Ok(())
+        }
+
         #[wasm_bindgen(js_name = removeFileArchive)]
         pub fn remove_file_archive(&mut self, archive: String) -> Result<(), JsError> {
             let archive = str_to_addr(&archive)?;
@@ -370,11 +444,45 @@ mod vault {
             Ok(())
         }
 
+        #[wasm_bindgen(js_name = removePrivateFileArchive)]
+        pub fn remove_private_file_archive(
+            &mut self,
+            private_archive_access: JsValue,
+        ) -> Result<(), JsError> {
+            let private_archive_access: PrivateArchiveAccess =
+                serde_wasm_bindgen::from_value(private_archive_access)?;
+
+            self.0.remove_private_file_archive(private_archive_access);
+
+            Ok(())
+        }
+
         #[wasm_bindgen(js_name = fileArchives)]
         pub fn file_archives(&self) -> Result<JsValue, JsError> {
             let archives = serde_wasm_bindgen::to_value(&self.0.file_archives)?;
             Ok(archives)
         }
+
+        #[wasm_bindgen(js_name = privateFileArchives)]
+        pub fn private_file_archives(&self) -> Result<JsValue, JsError> {
+            let archives = serde_wasm_bindgen::to_value(&self.0.private_file_archives)?;
+            Ok(archives)
+        }
+    }
+
+    #[wasm_bindgen(js_name = Scratchpad)]
+    pub struct JsScratchpad(Scratchpad);
+
+    #[wasm_bindgen(js_class = Scratchpad)]
+    impl JsScratchpad {
+        /// Returns a VEC with the XOR name.
+        #[wasm_bindgen(js_name = xorName)]
+        pub fn xor_name(&self) -> Option<String> {
+            self.0
+                .network_address()
+                .as_xorname()
+                .map(|xor_name| addr_to_str(xor_name))
+        }
     }
 
     #[wasm_bindgen(js_class = Client)]
@@ -418,6 +526,68 @@ mod vault {
 
             Ok(())
         }
+
+        /// Put the user data to the vault.
+        ///
+        /// # Example
+        ///
+        /// ```js
+        /// const secretKey = genSecretKey();
+        /// await client.putUserDataToVaultWithReceipt(userData, receipt, secretKey);
+        /// ```
+        #[wasm_bindgen(js_name = putUserDataToVaultWithReceipt)]
+        pub async fn put_user_data_to_vault_with_receipt(
+            &self,
+            user_data: &JsUserData,
+            receipt: JsValue,
+            secret_key: &SecretKeyJs,
+        ) -> Result<(), JsError> {
+            let receipt: Receipt = serde_wasm_bindgen::from_value(receipt)?;
+
+            self.0
+                .put_user_data_to_vault(&secret_key.0, receipt.into(), user_data.0.clone())
+                .await?;
+
+            Ok(())
+        }
+
+        /// Returns an existing scratchpad or creates a new one if it does not exist.
+        #[wasm_bindgen(js_name = getOrCreateScratchpad)]
+        pub async fn get_or_create_scratchpad(
+            &self,
+            secret_key: &SecretKeyJs,
+            vault_content_type: JsValue,
+        ) -> Result<JsValue, JsError> {
+            let vault_content_type: VaultContentType =
+                serde_wasm_bindgen::from_value(vault_content_type)?;
+
+            let result = self
+                .0
+                .get_or_create_scratchpad(&secret_key.0, vault_content_type)
+                .await?;
+
+            let js_value = serde_wasm_bindgen::to_value(&result)?;
+
+            Ok(js_value)
+        }
+
+        /// Returns an existing user data scratchpad or creates a new one if it does not exist.
+        #[wasm_bindgen(js_name = getOrCreateUserDataScratchpad)]
+        pub async fn get_or_create_user_data_scratchpad(
+            &self,
+            secret_key: &SecretKeyJs,
+        ) -> Result<JsScratchpad, JsError> {
+            let vault_content_type = *USER_DATA_VAULT_CONTENT_IDENTIFIER;
+
+            let (scratchpad, _is_new) = self
+                .0
+                .get_or_create_scratchpad(&secret_key.0, vault_content_type)
+                .await?;
+
+            let js_scratchpad = JsScratchpad(scratchpad);
+
+            Ok(js_scratchpad)
+        }
     }
 }
 
@@ -492,13 +662,22 @@ mod external_signer {
     /// # Example
     ///
     /// ```js
-    /// const [dataMapChunk, dataChunks, [chunkAddresses]] = client.encryptData(data);
+    /// const [dataMapChunk, dataChunks, dataMapChunkAddress, dataChunkAddresses] = client.encryptData(data);
     /// ``
     #[wasm_bindgen(js_name = encryptData)]
     pub fn encrypt(data: Vec<u8>) -> Result<JsValue, JsError> {
         let data = crate::Bytes::from(data);
         let result = encrypt_data(data)?;
+        let map_xor_name = *result.0.address().xorname();
+        let mut xor_names = vec![];
+
+        for chunk in &result.1 {
+            xor_names.push(*chunk.name());
+        }
+
+        let result = (result.0, result.1, map_xor_name, xor_names);
         let js_value = serde_wasm_bindgen::to_value(&result)?;
+
         Ok(js_value)
     }
 
diff --git a/autonomi/tests/external_signer.rs b/autonomi/tests/external_signer.rs
index 53dce804db..161e881cad 100644
--- a/autonomi/tests/external_signer.rs
+++ b/autonomi/tests/external_signer.rs
@@ -20,7 +20,15 @@ use tokio::time::sleep;
 use xor_name::XorName;
 
 async fn pay_for_data(client: &Client, wallet: &Wallet, data: Bytes) -> eyre::Result<Receipt> {
-    let (_data_map_chunk, _chunks, xor_names) = encrypt_data(data)?;
+    let (data_map_chunk, chunks) = encrypt_data(data)?;
+
+    let map_xor_name = *data_map_chunk.address().xorname();
+    let mut xor_names = vec![map_xor_name];
+
+    for chunk in chunks {
+        xor_names.push(*chunk.name());
+    }
+
     pay_for_content_addresses(client, wallet, xor_names.into_iter()).await
 }
 
@@ -117,7 +125,7 @@ async fn external_signer_put() -> eyre::Result<()> {
     sleep(Duration::from_secs(5)).await;
 
     let private_archive_access = client
-        .private_data_put(archive_serialized, receipt.into())
+        .private_archive_put(private_archive, receipt.into())
         .await?;
 
     let vault_key = VaultSecretKey::random();
