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

use crate::types::{
  Account, Address, AddressContainer, CreateAccount, CreateAddressResponse, PaginatedAssetWallet, VaultAccounts,
  VaultRenameResponse,
};
use crate::Client;
use crate::Result;
use serde_derive::Serialize;
use std::borrow::Borrow;
use std::fmt::{Debug, Display};

impl Client {
  /// Create an asset (address) for a vault account
  ///
  /// * [`crate::Asset`]
  /// * [createVaultAccountAsset](https://docs.fireblocks.com/api/swagger-ui/#/Vaults/createVaultAccountAsset)
  #[tracing::instrument(level = "debug", skip(self))]
  pub async fn create_address<T>(&self, vault_id: i32, asset_id: T) -> Result<CreateAddressResponse>
  where
    T: AsRef<str> + Display + Debug,
  {
    let p = format!("vault/accounts/{vault_id}/{asset_id}");
    let (u, _) = self.build_url(&p)?;
    self.post(u, None as Option<&()>).await
  }

  #[tracing::instrument(level = "debug", skip(self))]
  pub async fn addresses<T>(&self, vault_id: i32, asset_id: T) -> Result<Vec<Address>>
  where
    T: AsRef<str> + Display + Debug,
  {
    let p = format!("vault/accounts/{vault_id}/{asset_id}/addresses");
    let u = self.build_url(&p)?.0;
    self.get(u).await
  }

  #[tracing::instrument(level = "debug", skip(self, paging))]
  pub async fn addresses_paginated<T, I, K, V>(&self, vault_id: i32, asset_id: T, paging: I) -> Result<AddressContainer>
  where
    T: AsRef<str> + Display + Debug,
    I: IntoIterator,
    I::Item: Borrow<(K, V)>,
    K: AsRef<str>,
    V: AsRef<str>,
  {
    let p = format!("vault/accounts/{vault_id}/{asset_id}/addresses_paginated");
    let u = self.build_url_params(&p, Some(paging))?.0;
    self.get(u).await
  }

  #[tracing::instrument(level = "debug", skip(self))]
  pub async fn vault(&self, vault_id: i32) -> Result<Account> {
    let p = format!("vault/accounts/{vault_id}");
    let u = self.build_url(&p)?.0;
    self.get(u).await
  }

  #[tracing::instrument(level = "debug", skip(self, page))]
  pub async fn vaults<I, K, V>(&self, page: I) -> Result<VaultAccounts>
  where
    I: IntoIterator,
    I::Item: Borrow<(K, V)>,
    K: AsRef<str>,
    V: AsRef<str>,
  {
    let u = self.build_url_params("vault/accounts_paged", Some(page))?.0;
    self.get(u).await
  }

  #[tracing::instrument(level = "debug", skip(self))]
  pub async fn create_vault(&self, account: &CreateAccount) -> Result<Account> {
    let u = self.build_url("vault/accounts")?.0;
    self.post(u, Some(account)).await
  }

  #[tracing::instrument(level = "debug", skip(self))]
  pub async fn rename_vault(&self, vault_id: i32, name: &str) -> Result<VaultRenameResponse> {
    #[derive(Debug, Serialize)]
    struct Rename {
      name: String,
    }
    let u = self.build_url(&format!("vault/accounts/{vault_id}"))?.0;
    let name_req = &Rename { name: String::from(name) };
    self.put(u, Some(name_req)).await
  }

  #[tracing::instrument(level = "debug", skip(self, page))]
  pub async fn assets<I, K, V>(&self, page: I) -> Result<PaginatedAssetWallet>
  where
    I: IntoIterator,
    I::Item: Borrow<(K, V)>,
    K: AsRef<str>,
    V: AsRef<str>,
  {
    let u = self.build_url_params("vault/asset_wallets", Some(page))?.0;
    self.get(u).await
  }
}