🦀 derive-rs

**High-performance, type-safe Rust client for interacting with Derive Protocol's perpetual futures and options platform**

## Examples

[Getting Started](#-getting-started) •

[Documentation](https://docs.rs/derive-rs) •

[Examples](#-examples) •

[Features](#-features) •

[Contributing](#-contributing)

## Features & Roadmap

</div>



---- [x] Support rfq

- [x] Support position movements

## ✨ Overview- [] Test reconnection flow


`derive-rs` is a comprehensive Rust SDK for [Derive Protocol](https://derive.xyz), providing seamless access to decentralized derivatives trading. Built with modern async Rust, it offers a robust, production-ready solution for algorithmic trading, market making, and DeFi integrations.

### Why derive-rs?

- 🚀 **Blazingly Fast** - Built on Tokio with async/await for maximum concurrency
- 🔒 **Type-Safe** - Compile-time guarantees with comprehensive type definitions
- 🔌 **WebSocket & REST** - Real-time market data and reliable REST endpoints
- 📦 **Zero Config** - Works out of the box with sensible defaults
- 🧪 **Battle-Tested** - Extensive test coverage and production-ready
- 🛠️ **Developer Friendly** - Intuitive API design with builder patterns

---

## 🚀 Getting Started

### Installation

Add `derive-rs` to your `Cargo.toml`:

```toml
[dependencies]
derive-rs = "0.1.5"
tokio = { version = "1.53", features = ["full"] }

use derive_rs::{WsClient, Environment};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client with credentials
    let client = WsClient::new(
        Environment::Testnet,
        Some("YOUR_PRIVATE_KEY".to_string()),
        Some("YOUR_WALLET_ADDRESS".to_string()),
        Some(1234), // subaccount_id
    ).await?;
    
    // Login to the WebSocket
    client.login().await?;
    
    // Place your first order
    use derive_rs::actions::OrderArgs;
    use derive_rs::models::{Direction, OrderType, TimeInForce};
    use bigdecimal::BigDecimal;
    
    let order = OrderArgs::builder()
        .instrument_name("ETH-PERP")
        .amount(BigDecimal::from(1))
        .limit_price(BigDecimal::from(3000))
        .direction(Direction::Buy)
        .order_type(OrderType::Limit)
        .time_in_force(TimeInForce::GTC)
        .build();
    
    let result = client.orders().place(order).await?;
    println!("Order placed: {:#?}", result);
    
    Ok(())
}

use derive_rs::{WsClient, Environment, types::ExternalEvent};
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = WsClient::new_public(Environment::Testnet).await?;
    
    // Subscribe to ticker updates
    let mut ticker_stream = client.subscriptions()
        .market_data()
        .ticker_slim("ETH-USDC", "100")
        .await?;
    
    // Process tickers in real-time
    loop {
        tokio::select! {
            Some(ticker) = ticker_stream.next() => {
                match ticker {
                    Ok(data) => println!("ETH Price: {:?}", data),
                    Err(e) => eprintln!("Error: {:?}", e),
                }
            }
            event = client.run_till_event() => {
                match event {
                    ExternalEvent::Connected => {
                        println!("WebSocket connected");
                        client.resubscribe_all().await?;
                    }
                    ExternalEvent::Disconnected => println!("Disconnected"),
                    ExternalEvent::Exited => break,
                }
            }
        }
    }
    
    Ok(())
}

use derive_rs::actions::{OrderArgs, ReplaceArgs, ExecuteQuoteArgs};

// Orders
client.orders().place(order_args).await?;
client.orders().replace(replace_args).await?;

// RFQs
client.rfqs().send_rfq(rfq_request).await?;
client.rfqs().execute_best_quote(quote_args).await?;

// Fund Movements
client.fund_movements().deposit(deposit_args).await?;
client.fund_movements().withdraw(withdraw_args).await?;

// Session Keys
client.session_keys().add(session_key_args).await?;

┌─────────────────────────────────────────────────────────────┐
│                         Your Application                     │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┴──────────────────────────────────┐
│                        derive-rs SDK                         │
├──────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Actions   │  │     RPC     │  │   Subscriptions     │ │
│  │  (Signing)  │  │  (Request)  │  │   (Streaming)       │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
│  ┌──────────────────────────────────────────────────────────┤
│  │              WebSocket Client (yawc)                     │
│  └──────────────────────────────────────────────────────────┤
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────┴──────────────────────────────────┐
│                    Derive Protocol API                       │
│           wss://testnet.api.derive.xyz/v3/ws                │
└──────────────────────────────────────────────────────────────┘