bullet-rust-sdk 0.0.4

Rust SDK for the Bullet trading platform
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
121
122
123
124
125
126
127
128
129
130
131

# Bullet Rust SDK

[![Crates.io](https://img.shields.io/crates/v/bullet-rust-sdk.svg)](https://crates.io/crates/bullet-rust-sdk)
[![Documentation](https://docs.rs/bullet-rust-sdk/badge.svg)](https://docs.rs/bullet-rust-sdk)
[![License: MIT](https://img.shields.io/crates/l/bullet-rust-sdk.svg)](LICENSE)

A Rust SDK for interacting with the Bullet trading API, with WASM bindings for JavaScript/TypeScript.

## Project Structure

```
bullet-rust-sdk/
├── rust/       # Core Rust SDK (bullet-rust-sdk)
├── wasm/       # WASM bindings for JS/TS (bullet-rust-sdk-wasm)
└── justfile    # Development commands
```

## Features

- **REST API Client**: Type-safe client generated from OpenAPI spec using Progenitor
- **WebSocket Support**: Real-time market data and order submission — including a portable `ManagedWebsocket` (auto-reconnect, exponential backoff, subscription replay, idle-stream detection, backoff reset on stable uptime, subscribe dedup) that works on both native and WASM
- **Transaction Building**: Fluent builder pattern for constructing and signing transactions
- **Cross-platform**: Works on native Rust and WASM (browser/Node.js)
- **Client Defaults**: Configure keypair, max fee, etc. once on the client

## Quick Start (Rust)

```sh
cargo add bullet-rust-sdk
cargo add tokio --features full
```

### Basic Usage

```rust
use bullet_rust_sdk::{Client, Keypair, Transaction};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to mainnet with default keypair
    let keypair = Keypair::from_hex("your-private-key")?;
    let client = Client::builder()
        .url("https://tradingapi.bullet.xyz")
        .keypair(keypair)
        .max_fee(10_000_000.into())
        .build()
        .await?;

    // Query market data
    let info = client.exchange_info().await?.into_inner();
    println!("Symbols: {}", info.symbols.len());

    // Build and send a transaction (uses client defaults)
    let response = Transaction::builder()
        .call_message(call_msg)
        .send(&client)
        .await?;

    Ok(())
}
```

## Quick Start (JavaScript/TypeScript)

```bash
npm install bullet-rust-sdk-wasm
```

```typescript
import { Client, Keypair, Transaction, User } from 'bullet-rust-sdk-wasm';

// Connect with defaults
const keypair = Keypair.fromHex('your-private-key');
const client = await Client.builder()
    .url('https://tradingapi.bullet.xyz')
    .keypair(keypair)
    .maxFee(10_000_000n)
    .build();

// Build a transaction using generated factory methods
const callMsg = User.deposit({ asset_id: 0, amount: 1000000n });

// Send transaction (uses client defaults for signing)
const response = await Transaction.builder()
    .callMessage(callMsg)
    .send(client);
```

## Development

Use `just` for all common tasks:

```bash
just              # List available recipes
just check        # Check compilation
just test         # Run Rust unit tests
just test-wasm    # Run WASM Jest tests
just build-wasm   # Build WASM for web and Node.js
just lint         # Run clippy
just fmt          # Format code
```

### Integration Tests

```bash
# Against mainnet
just test-integration

# Against custom endpoint
just test-integration http://localhost:3000
```

## Architecture

### REST Client Generation

The REST client is generated at build time from the OpenAPI spec using [Progenitor](https://github.com/oxidecomputer/progenitor). The spec is fetched from mainnet during build, with a cached fallback in `rust/openapi.json`.

### WASM CallMessage Codegen

The WASM crate uses build-time codegen to generate `wasm_bindgen` factory methods for `CallMessage` variants. This walks the `bullet-exchange-interface` schema and generates:

- **Namespace structs** (`User`, `Public`, `Keeper`, `Vault`, `Admin`) with factory methods
- **Wrapper structs** for complex types (e.g., `WasmNewOrderArgs`)
- **Enum wrappers** for schema enums

See `wasm/codegen/` for the implementation.

## Contributing

See [AGENTS.md](./AGENTS.md) for development guidelines, including the critical requirement that **WASM bindings must mirror the Rust SDK** when adding or modifying public APIs.