1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use reqwest::multipart::{Form, Part};
use serde_json::Value;
use solana_sdk::{pubkey::Pubkey, signer::Signer};

use super::ShadowDriveClient;
use crate::{
    constants::{SHDW_DRIVE_ENDPOINT, SHDW_DRIVE_OBJECT_PREFIX},
    error::Error,
    models::*,
};

impl<T> ShadowDriveClient<T>
where
    T: Signer,
{
    /// Replace an existing file on the Shadow Drive with the given updated file.
    /// * `storage_account_key` - The public key of the [`StorageAccount`](crate::models::StorageAccount) that contains the file.
    /// * `url` - The Shadow Drive url of the file you want to replace.
    /// * `data` - The updated [`ShadowFile`](crate::models::ShadowFile).
    /// # Example
    ///
    /// ```
    /// # use shadow_drive_rust::{ShadowDriveClient, derived_addresses::storage_account};
    /// # use solana_client::rpc_client::RpcClient;
    /// # use solana_sdk::{
    /// # pubkey::Pubkey,
    /// # signature::Keypair,
    /// # signer::{keypair::read_keypair_file, Signer},
    /// # };
    /// #
    /// # let keypair = read_keypair_file(KEYPAIR_PATH).expect("failed to load keypair at path");
    /// # let user_pubkey = keypair.pubkey();
    /// # let rpc_client = RpcClient::new("https://ssc-dao.genesysgo.net");
    /// # let shdw_drive_client = ShadowDriveClient::new(keypair, rpc_client);
    /// # let (storage_account_key, _) = storage_account(&user_pubkey, 0);
    /// # let url = String::from("https://shdw-drive.genesysgo.net/B7Qk2omAvchkePhdGovCVQuVpZHcieqPQCwFxeeBZGuT/file.txt");
    /// # let file = tokio::fs::File::open("example.png")
    /// #   .await
    /// #   .expect("failed to open file");
    /// #
    /// let edit_file_response = shdw_drive_client
    ///     .edit_file(&storage_account_key, url, file)
    ///     .await?;
    /// ```
    pub async fn edit_file(
        &self,
        storage_account_key: &Pubkey,
        data: ShadowFile,
    ) -> ShadowDriveResult<ShadowEditResponse> {
        let message_to_sign = edit_message(storage_account_key, data.name(), &data.sha256().await?);

        let signature = self
            .wallet
            .sign_message(message_to_sign.as_bytes())
            .to_string();

        let url = format!(
            "{}/{}/{}",
            SHDW_DRIVE_OBJECT_PREFIX,
            storage_account_key,
            data.name()
        );

        let form = Form::new()
            .part("file", data.into_form_part().await?)
            .part("message", Part::text(signature))
            .part("signer", Part::text(self.wallet.pubkey().to_string()))
            .part(
                "storage_account",
                Part::text(storage_account_key.to_string()),
            )
            .part("url", Part::text(url));

        let response = self
            .http_client
            .post(format!("{}/edit", SHDW_DRIVE_ENDPOINT))
            .multipart(form)
            .send()
            .await?;

        if !response.status().is_success() {
            return Err(Error::ShadowDriveServerError {
                status: response.status().as_u16(),
                message: response.json::<Value>().await?,
            });
        }

        let response = response.json::<ShadowEditResponse>().await?;

        Ok(response)
    }
}

fn edit_message(storage_account_key: &Pubkey, filename: &str, new_hash: &str) -> String {
    format!(
        "Shadow Drive Signed Message:\n StorageAccount: {}\nFile to edit: {}\nNew file hash: {}",
        storage_account_key, filename, new_hash
    )
}