kalshi-pmx 0.1.1

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
105
106
107
108

use crate::client::Kalshi;
use crate::error::Result;
use crate::generated::{
    AcceptBlockTradeProposalRequest, AcceptQuoteRequest, CreateQuoteRequest, CreateQuoteResponse,
    CreateRFQRequest, CreateRFQResponse, EmptyResponse, GetBlockTradeProposalsResponse,
    GetCommunicationsIDResponse, GetQuoteResponse, GetQuotesResponse, GetRFQResponse,
    GetRFQsResponse, ProposeBlockTradeRequest, ProposeBlockTradeResponse,
};
use crate::params::{GetBlockTradeProposalsParams, GetQuotesParams, GetRFQsParams};

/// Client for RFQs, quotes, block trades, and communications endpoints.
#[derive(Clone, Debug)]
pub struct CommunicationsClient {
    client: Kalshi,
}

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

    pub async fn id(&self) -> Result<GetCommunicationsIDResponse> {
        self.client.typed().get_communications_id().await
    }

    pub async fn block_trade_proposals(
        &self,
        params: &GetBlockTradeProposalsParams,
    ) -> Result<GetBlockTradeProposalsResponse> {
        self.client.typed().get_block_trade_proposals(params).await
    }

    pub async fn propose_block_trade(
        &self,
        body: &ProposeBlockTradeRequest,
    ) -> Result<ProposeBlockTradeResponse> {
        self.client.typed().propose_block_trade(body).await
    }

    pub async fn accept_block_trade_proposal(
        &self,
        block_trade_proposal_id: impl AsRef<str>,
    ) -> Result<EmptyResponse> {
        let body = AcceptBlockTradeProposalRequest {
            subtrader_id: None,
            subaccount: None,
            extra: Default::default(),
        };
        self.accept_block_trade_proposal_with_options(block_trade_proposal_id, &body)
            .await
    }

    pub async fn accept_block_trade_proposal_with_options(
        &self,
        block_trade_proposal_id: impl AsRef<str>,
        body: &AcceptBlockTradeProposalRequest,
    ) -> Result<EmptyResponse> {
        self.client
            .typed()
            .accept_block_trade_proposal(block_trade_proposal_id, body)
            .await
    }

    pub async fn rfqs(&self, params: &GetRFQsParams) -> Result<GetRFQsResponse> {
        self.client.typed().get_rf_qs(params).await
    }

    pub async fn create_rfq(&self, body: &CreateRFQRequest) -> Result<CreateRFQResponse> {
        self.client.typed().create_rfq(body).await
    }

    pub async fn rfq(&self, rfq_id: impl AsRef<str>) -> Result<GetRFQResponse> {
        self.client.typed().get_rfq(rfq_id).await
    }

    pub async fn delete_rfq(&self, rfq_id: impl AsRef<str>) -> Result<EmptyResponse> {
        self.client.typed().delete_rfq(rfq_id).await
    }

    pub async fn quotes(&self, params: &GetQuotesParams) -> Result<GetQuotesResponse> {
        self.client.typed().get_quotes(params).await
    }

    pub async fn create_quote(&self, body: &CreateQuoteRequest) -> Result<CreateQuoteResponse> {
        self.client.typed().create_quote(body).await
    }

    pub async fn quote(&self, quote_id: impl AsRef<str>) -> Result<GetQuoteResponse> {
        self.client.typed().get_quote(quote_id).await
    }

    pub async fn delete_quote(&self, quote_id: impl AsRef<str>) -> Result<EmptyResponse> {
        self.client.typed().delete_quote(quote_id).await
    }

    pub async fn accept_quote(
        &self,
        quote_id: impl AsRef<str>,
        body: &AcceptQuoteRequest,
    ) -> Result<EmptyResponse> {
        self.client.typed().accept_quote(quote_id, body).await
    }

    pub async fn confirm_quote(&self, quote_id: impl AsRef<str>) -> Result<EmptyResponse> {
        let body = EmptyResponse::new();
        self.client.typed().confirm_quote(quote_id, &body).await
    }
}