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
109
110
111
112
113
114
115
116
117
118
119
120

use crate::client::Kalshi;
use crate::error::Result;
use crate::generated::{
    AmendOrderV2Request, AmendOrderV2Response, BatchCancelOrdersV2Request,
    BatchCancelOrdersV2Response, BatchCreateOrdersV2Request, BatchCreateOrdersV2Response,
    CancelOrderV2Response, CreateOrderV2Request, CreateOrderV2Response, DecreaseOrderV2Request,
    DecreaseOrderV2Response, GetOrderQueuePositionResponse, GetOrderQueuePositionsResponse,
    GetOrderResponse, GetOrdersResponse,
};
use crate::params::{
    AmendOrderV2Params, CancelOrderV2Params, DecreaseOrderV2Params, GetOrderQueuePositionsParams,
    GetOrdersParams,
};

/// Client for order listing, creation, cancellation, amendment, and queue-position endpoints.
#[derive(Clone, Debug)]
pub struct OrdersClient {
    client: Kalshi,
}

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

    pub async fn list(&self, params: &GetOrdersParams) -> Result<GetOrdersResponse> {
        self.client.typed().get_orders(params).await
    }

    pub async fn get(&self, order_id: impl AsRef<str>) -> Result<GetOrderResponse> {
        self.client.typed().get_order(order_id).await
    }

    pub async fn queue_positions(
        &self,
        params: &GetOrderQueuePositionsParams,
    ) -> Result<GetOrderQueuePositionsResponse> {
        self.client.typed().get_order_queue_positions(params).await
    }

    pub async fn queue_position(
        &self,
        order_id: impl AsRef<str>,
    ) -> Result<GetOrderQueuePositionResponse> {
        self.client.typed().get_order_queue_position(order_id).await
    }

    pub async fn create(&self, order: &CreateOrderV2Request) -> Result<CreateOrderV2Response> {
        self.client.typed().create_order_v2(order).await
    }

    pub async fn batch_create(
        &self,
        body: &BatchCreateOrdersV2Request,
    ) -> Result<BatchCreateOrdersV2Response> {
        self.client.typed().batch_create_orders_v2(body).await
    }

    pub async fn batch_cancel(
        &self,
        body: &BatchCancelOrdersV2Request,
    ) -> Result<BatchCancelOrdersV2Response> {
        self.client.typed().batch_cancel_orders_v2(body).await
    }

    pub async fn cancel(&self, order_id: impl AsRef<str>) -> Result<CancelOrderV2Response> {
        self.cancel_with_params(order_id, &CancelOrderV2Params::new())
            .await
    }

    pub async fn cancel_with_params(
        &self,
        order_id: impl AsRef<str>,
        params: &CancelOrderV2Params,
    ) -> Result<CancelOrderV2Response> {
        self.client.typed().cancel_order_v2(order_id, params).await
    }

    pub async fn amend(
        &self,
        order_id: impl AsRef<str>,
        body: &AmendOrderV2Request,
    ) -> Result<AmendOrderV2Response> {
        self.amend_with_params(order_id, &AmendOrderV2Params::new(), body)
            .await
    }

    pub async fn amend_with_params(
        &self,
        order_id: impl AsRef<str>,
        params: &AmendOrderV2Params,
        body: &AmendOrderV2Request,
    ) -> Result<AmendOrderV2Response> {
        self.client
            .typed()
            .amend_order_v2(order_id, params, body)
            .await
    }

    pub async fn decrease(
        &self,
        order_id: impl AsRef<str>,
        body: &DecreaseOrderV2Request,
    ) -> Result<DecreaseOrderV2Response> {
        self.decrease_with_params(order_id, &DecreaseOrderV2Params::new(), body)
            .await
    }

    pub async fn decrease_with_params(
        &self,
        order_id: impl AsRef<str>,
        params: &DecreaseOrderV2Params,
        body: &DecreaseOrderV2Request,
    ) -> Result<DecreaseOrderV2Response> {
        self.client
            .typed()
            .decrease_order_v2(order_id, params, body)
            .await
    }
}