cbat 0.0.19

The unofficial Rust crate for the Coinbase Advanced Trade API
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

use cbat::prelude::*;

#[tokio::main]
async fn main() {
    // Initialize the client with your API credentials
    let client = Client::new(
        "orders-example",
        std::env::var("CBAT_KEY_NAME").expect("CBAT_KEY_NAME must be set"),
        std::env::var("CBAT_KEY_SECRET").expect("CBAT_KEY_SECRET must be set"),
    );

    // Preview an order before creating it
    println!("=== Previewing Order ===");
    let preview_request = PreviewOrderRequest {
        product_id: "BTC-USD",
        side: "BUY",
        order_configuration: OrderConfiguration {
            limit_limit_gtc: Some(LimitLimitGtc {
                base_size: Some("0.001".to_string()),
                limit_price: Some("50000.0".to_string()),
                post_only: None,
                quote_size: None,
            }),
            market_market_ioc: None,
            sor_limit_ioc: None,
            limit_limit_gtd: None,
            limit_limit_fok: None,
            stop_limit_stop_limit_gtc: None,
            stop_limit_stop_limit_gtd: None,
            trigger_bracket_gtc: None,
            trigger_bracket_gtd: None,
        },
        leverage: None,
        margin_type: None,
        retail_portfolio_id: None,
    };

    match ApiOrders::preview_order(&client, preview_request).await {
        Ok(preview) => println!("{:#?}", preview),
        Err(e) => eprintln!("Error previewing order: {}", e),
    }

    // Create a limit order
    println!("\n=== Creating Limit Order ===");
    let create_request = CreateOrderRequest {
        client_order_id: &uuid::Uuid::new_v4().to_string(),
        product_id: "BTC-USD",
        side: "BUY",
        order_configuration: OrderConfiguration {
            limit_limit_gtc: Some(LimitLimitGtc {
                base_size: Some("0.001".to_string()),
                limit_price: Some("50000.0".to_string()),
                post_only: None,
                quote_size: None,
            }),
            market_market_ioc: None,
            sor_limit_ioc: None,
            limit_limit_gtd: None,
            limit_limit_fok: None,
            stop_limit_stop_limit_gtc: None,
            stop_limit_stop_limit_gtd: None,
            trigger_bracket_gtc: None,
            trigger_bracket_gtd: None,
        },
        leverage: None,
        margin_type: None,
        retail_portfolio_id: None,
        preview_id: None,
    };

    let order_id = match ApiOrders::create_order(&client, create_request).await {
        Ok(response) => {
            println!("Order created successfully");
            response.success_response.unwrap().order_id
        }
        Err(e) => {
            eprintln!("Error creating order: {}", e);
            return;
        }
    };

    // Get order details
    println!("\n=== Getting Order Details ===");
    match ApiOrders::get_order(&client, &order_id, None, None).await {
        Ok(order) => println!("{:#?}", order),
        Err(e) => eprintln!("Error getting order: {}", e),
    }

    // List orders
    println!("\n=== Listing Orders ===");
    match ApiOrders::list_orders(&client, None, None, None, None, None, None, None, None, None, None, None, None, None, None, Some(&"1".to_string()), None, None).await {
        Ok(orders) => println!("{:#?}", orders),
        Err(e) => eprintln!("Error listing orders: {}", e),
    }

    // List fills
    println!("\n=== Listing Fills ===");
    match ApiOrders::list_fills(&client, None, None, None, None, None, None, Some(1), None, None).await {
        Ok(fills) => println!("{:#?}", fills),
        Err(e) => eprintln!("Error listing fills: {}", e),
    }

    // Cancel the order
    println!("\n=== Canceling Order ===");
    match ApiOrders::cancel_orders(&client, vec![&order_id]).await {
        Ok(result) => println!("{:#?}", result),
        Err(e) => eprintln!("Error canceling order: {}", e),
    }
}