kalshi-pmx 0.1.0

Async Rust client for Kalshi's Trade API and WebSocket streams.
Documentation 
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

use crate::client::Kalshi;
use crate::error::Result;
use crate::generated::{
    ApplySubaccountTransferRequest, ApplySubaccountTransferResponse, CreateSubaccountResponse,
    EmptyResponse, GetBalanceResponse, GetDepositsResponse, GetFillsResponse,
    GetPortfolioRestingOrderTotalValueResponse, GetPositionsResponse, GetSettlementsResponse,
    GetSubaccountBalancesResponse, GetSubaccountNettingResponse, GetSubaccountTransfersResponse,
    GetWithdrawalsResponse, UpdateSubaccountNettingRequest,
};
use crate::params::{
    GetBalanceParams, GetDepositsParams, GetFillsParams, GetPositionsParams, GetSettlementsParams,
    GetSubaccountTransfersParams, GetWithdrawalsParams,
};

/// Client for balances, positions, fills, settlements, transfers, deposits, and withdrawals.
#[derive(Clone, Debug)]
pub struct PortfolioClient {
    client: Kalshi,
}

impl PortfolioClient {
    pub(crate) fn new(client: Kalshi) -> Self {
        Self { client }
    }

    pub async fn balance(&self) -> Result<GetBalanceResponse> {
        self.balance_with_params(&GetBalanceParams::new()).await
    }

    pub async fn balance_with_params(
        &self,
        params: &GetBalanceParams,
    ) -> Result<GetBalanceResponse> {
        self.client.typed().get_balance(params).await
    }

    pub async fn create_subaccount(&self) -> Result<CreateSubaccountResponse> {
        self.client.typed().create_subaccount().await
    }

    pub async fn transfer_subaccount(
        &self,
        body: &ApplySubaccountTransferRequest,
    ) -> Result<ApplySubaccountTransferResponse> {
        self.client.typed().apply_subaccount_transfer(body).await
    }

    pub async fn subaccount_balances(&self) -> Result<GetSubaccountBalancesResponse> {
        self.client.typed().get_subaccount_balances().await
    }

    pub async fn subaccount_transfers(
        &self,
        params: &GetSubaccountTransfersParams,
    ) -> Result<GetSubaccountTransfersResponse> {
        self.client.typed().get_subaccount_transfers(params).await
    }

    pub async fn update_subaccount_netting(
        &self,
        body: &UpdateSubaccountNettingRequest,
    ) -> Result<EmptyResponse> {
        self.client.typed().update_subaccount_netting(body).await
    }

    pub async fn subaccount_netting(&self) -> Result<GetSubaccountNettingResponse> {
        self.client.typed().get_subaccount_netting().await
    }

    pub async fn positions(&self, params: &GetPositionsParams) -> Result<GetPositionsResponse> {
        self.client.typed().get_positions(params).await
    }

    pub async fn settlements(
        &self,
        params: &GetSettlementsParams,
    ) -> Result<GetSettlementsResponse> {
        self.client.typed().get_settlements(params).await
    }

    pub async fn deposits(&self, params: &GetDepositsParams) -> Result<GetDepositsResponse> {
        self.client.typed().get_deposits(params).await
    }

    pub async fn withdrawals(
        &self,
        params: &GetWithdrawalsParams,
    ) -> Result<GetWithdrawalsResponse> {
        self.client.typed().get_withdrawals(params).await
    }

    pub async fn total_resting_order_value(
        &self,
    ) -> Result<GetPortfolioRestingOrderTotalValueResponse> {
        self.client
            .typed()
            .get_portfolio_resting_order_total_value()
            .await
    }

    pub async fn fills(&self, params: &GetFillsParams) -> Result<GetFillsResponse> {
        self.client.typed().get_fills(params).await
    }
}