Skip to main content

bpx_api_client/routes/
vault.rs

1use crate::error::Result;
2
3use bpx_api_types::vault::{
4    Vault, VaultHistory, VaultHistoryParams, VaultMint, VaultMintHistoryParams, VaultMintRequest,
5    VaultRedeem, VaultRedeemCancelRequest, VaultRedeemHistoryParams, VaultRedeemRequest,
6};
7
8use crate::BpxClient;
9
10#[doc(hidden)]
11pub const API_VAULTS: &str = "/api/v1/vaults";
12#[doc(hidden)]
13pub const API_VAULT_MINT: &str = "/api/v1/vault/mint";
14#[doc(hidden)]
15pub const API_VAULT_REDEEM: &str = "/api/v1/vault/redeem";
16#[doc(hidden)]
17pub const API_VAULTS_HISTORY: &str = "/api/v1/vaults/history";
18#[doc(hidden)]
19pub const API_VAULT_MINTS_HISTORY: &str = "/wapi/v1/history/vault/mint";
20#[doc(hidden)]
21pub const API_VAULT_REDEEMS_HISTORY: &str = "/wapi/v1/history/vault/redeem";
22
23impl BpxClient {
24    /// Fetches information about all available vaults on the exchange.
25    pub async fn get_vaults(&self) -> Result<Vec<Vault>> {
26        let url = self.base_url.join(API_VAULTS)?;
27        let res = self.get(url).await?;
28        res.json().await.map_err(Into::into)
29    }
30
31    /// Mints vault tokens by depositing an asset into a vault.
32    pub async fn vault_mint(&self, request: VaultMintRequest) -> Result<()> {
33        let url = self.base_url.join(API_VAULT_MINT)?;
34        let res = self.post(url, request).await?;
35        let _ = res.bytes().await?;
36        Ok(())
37    }
38
39    /// Submits a request to redeem vault tokens for USDC.
40    pub async fn vault_redeem(&self, request: VaultRedeemRequest) -> Result<()> {
41        let url = self.base_url.join(API_VAULT_REDEEM)?;
42        let res = self.post(url, request).await?;
43        let _ = res.bytes().await?;
44        Ok(())
45    }
46
47    /// Cancels a pending redeem request for a vault.
48    pub async fn vault_redeem_cancel(&self, request: VaultRedeemCancelRequest) -> Result<()> {
49        let url = self.base_url.join(API_VAULT_REDEEM)?;
50        let res = self.delete(url, request).await?;
51        let _ = res.bytes().await?;
52        Ok(())
53    }
54
55    /// Fetches historical vault data (NAV, equity, circulating supply).
56    pub async fn get_vault_history(&self, params: VaultHistoryParams) -> Result<Vec<VaultHistory>> {
57        let query_string = serde_qs::to_string(&params)
58            .map_err(|e| crate::error::Error::UrlParseError(e.to_string().into_boxed_str()))?;
59        let mut url = self.base_url.join(API_VAULTS_HISTORY)?;
60        url.set_query(Some(&query_string));
61        let res = self.get(url).await?;
62        res.json().await.map_err(Into::into)
63    }
64
65    /// Fetches vault mint history (authenticated).
66    pub async fn get_vault_mints(&self, params: VaultMintHistoryParams) -> Result<Vec<VaultMint>> {
67        let query_string = serde_qs::to_string(&params)
68            .map_err(|e| crate::error::Error::UrlParseError(e.to_string().into_boxed_str()))?;
69        let mut url = self.base_url.join(API_VAULT_MINTS_HISTORY)?;
70        url.set_query(Some(&query_string));
71        let res = self.get(url).await?;
72        res.json().await.map_err(Into::into)
73    }
74
75    /// Fetches vault redeem history (authenticated).
76    pub async fn get_vault_redeems(
77        &self,
78        params: VaultRedeemHistoryParams,
79    ) -> Result<Vec<VaultRedeem>> {
80        let query_string = serde_qs::to_string(&params)
81            .map_err(|e| crate::error::Error::UrlParseError(e.to_string().into_boxed_str()))?;
82        let mut url = self.base_url.join(API_VAULT_REDEEMS_HISTORY)?;
83        url.set_query(Some(&query_string));
84        let res = self.get(url).await?;
85        res.json().await.map_err(Into::into)
86    }
87}