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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use anchor_lang::{system_program, AccountDeserialize, InstructionData, ToAccountMetas};
use byte_unit::Byte;
use serde_json::{json, Value};
use shadow_drive_user_staking::accounts as shdw_drive_accounts;
use shadow_drive_user_staking::instruction::InitializeAccount;
use shadow_drive_user_staking::instructions::initialize_account::UserInfo;
use solana_client::{
    client_error::{ClientError, ClientErrorKind},
    rpc_client::serialize_and_encode,
    rpc_request::RpcError,
};
use solana_sdk::{
    instruction::Instruction, signer::Signer, sysvar::rent, transaction::Transaction,
};
use solana_transaction_status::UiTransactionEncoding;
use spl_associated_token_account::get_associated_token_address;
use spl_token::ID as TokenProgram;

use super::ShadowDriveClient;
use crate::{
    constants::{PROGRAM_ADDRESS, SHDW_DRIVE_ENDPOINT, STORAGE_CONFIG_PDA, TOKEN_MINT, UPLOADER},
    derived_addresses,
    error::Error,
    models::*,
};

impl<T> ShadowDriveClient<T>
where
    T: Signer + Send + Sync,
{
    /// Creates a [`StorageAccount`](crate::models::StorageAccount) on the Shadow Drive. 
    /// [`StorageAccount`]'s can hold multiple files, and are paid for using the SHDW token.
    /// * `name` - The name of the [`StorageAccount`](crate::models::StorageAccount). Does not need to be unique.
    /// * `size` - The amount of storage the [`StorageAccount`](crate::models::StorageAccount) should be initialized with.
    /// When specifying size, only KB, MB, and GB storage units are currently supported.
    pub async fn create_storage_account(
        &self,
        name: &str,
        size: Byte,
    ) -> ShadowDriveResult<CreateStorageAccountResponse> {
        let wallet = &self.wallet;
        let wallet_pubkey = wallet.pubkey();

        let rpc_client = &self.rpc_client;

        let (user_info, _) = derived_addresses::user_info(&wallet_pubkey);

        // If userInfo hasn't been initialized, default to 0 for account seed
        let user_info_acct = rpc_client.get_account(&user_info);

        let mut account_seed: u32 = 0;
        match user_info_acct {
            Ok(user_info_acct) => {
                let user_info = UserInfo::try_deserialize(&mut user_info_acct.data.as_slice())
                    .map_err(Error::AnchorError)?;
                account_seed = user_info.account_counter;
            }
            Err(ClientError {
                kind: ClientErrorKind::RpcError(RpcError::ForUser(_)),
                ..
            }) => {
                // this is what rpc_client.get_account() returns if the account doesn't exist
                // assume 0 seed
            }
            Err(err) => {
                //a different rpc error occurred
                return Err(Error::from(err));
            }
        }

        let storage_requested: u64 = size
            .get_bytes()
            .try_into()
            .map_err(|_| Error::InvalidStorage)?;

        let (storage_account, _) = derived_addresses::storage_account(&wallet_pubkey, account_seed);

        let (stake_account, _) = derived_addresses::stake_account(&storage_account);

        let owner_ata = get_associated_token_address(&wallet_pubkey, &TOKEN_MINT);

        let accounts = shdw_drive_accounts::InitializeStorageAccount {
            storage_config: *STORAGE_CONFIG_PDA,
            user_info,
            storage_account,
            stake_account,
            token_mint: TOKEN_MINT,
            owner_1: wallet_pubkey,
            uploader: UPLOADER,
            owner_1_token_account: owner_ata,
            system_program: system_program::ID,
            token_program: TokenProgram,
            rent: rent::ID,
        };

        let args = InitializeAccount {
            identifier: name.to_string(),
            storage: storage_requested,
            owner_2: None,
        };

        let instruction = Instruction {
            program_id: PROGRAM_ADDRESS,
            accounts: accounts.to_account_metas(None),
            data: args.data(),
        };

        let mut txn = Transaction::new_with_payer(&[instruction], Some(&wallet_pubkey));

        txn.try_partial_sign(&[wallet], rpc_client.get_latest_blockhash()?)?;

        let txn_encoded = serialize_and_encode(&txn, UiTransactionEncoding::Base64)?;

        let body = serde_json::to_string(&json!({ "transaction": txn_encoded })).unwrap();

        let response = self
            .http_client
            .post(format!("{}/storage-account", SHDW_DRIVE_ENDPOINT))
            .header("Content-Type", "application/json")
            .body(body)
            .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::<CreateStorageAccountResponse>().await?;

        Ok(response)
    }
}