# Build the node
make build

# Run the node
./bin/luxd

# Core SDK (for building applications)
npm install @luxfi/dex

# Trading SDK (for bots and trading strategies)
npm install @luxfi/trading

# Or install both
npm install @luxfi/dex @luxfi/trading

import { DEX } from '@luxfi/trading'

// Simple initialization with factory function
const dex = await DEX({ rpcUrl: 'http://localhost:8080/rpc' })

// Place an order
const order = await dex.limitBuy('BTC-USD', '1.0', '50000')

console.log('Order placed:', order.orderId)

import { Client, ClientConfig, OrderType, OrderSide } from '@luxfi/dex'

// Full control with the base Client
const config: ClientConfig = {
    rpcUrl: 'http://localhost:8080/rpc',
    wsUrl: 'ws://localhost:8081',
    apiKey: 'your-api-key'
}

const client = new Client(config)
await client.connect()

// Place order with full type safety
const order = await client.placeOrder({
    symbol: 'BTC-USD',
    type: OrderType.LIMIT,
    side: OrderSide.BUY,
    price: 50000,
    size: 1.0
})

// Works with either package
dex.subscribeOrderBook('BTC-USD', (book) => {
    console.log('Best bid:', book.bids[0])
    console.log('Best ask:', book.asks[0])
})

// Subscribe to trades
dex.subscribeTrades('BTC-USD', (trade) => {
    console.log('New trade:', trade)
})

// Subscribe to your orders
dex.subscribeUserOrders((order) => {
    console.log('Order update:', order)
})

import { Client, Config, NativeVenueConfig } from '@luxfi/trading'

// Aggregate liquidity across venues
const config = new Config()
    .withNative('lx-dex', NativeVenueConfig.lxDex('https://api.lux.network/rpc'))
    .withCCXT('binance', { apiKey: '...', secret: '...' })
    .withApiKey('your-api-key')
    .withTimeout(30000)

const client = new Client(config)
await client.connect()

pip install lux-dex

from lux_dex import Client

client = Client(
    json_rpc_url='http://localhost:8080/rpc',
    ws_url='ws://localhost:8081'
)

# Place an order
order = client.place_order(
    symbol='BTC-USD',
    order_type='limit',
    side='buy',
    price=50000,
    size=1.0
)

print(f'Order placed: {order.order_id}')

# Get order book
book = client.get_order_book('BTC-USD', depth=10)
print(f"Best bid: {book['bids'][0]}")
print(f"Best ask: {book['asks'][0]}")

# Get recent trades
trades = client.get_trades('BTC-USD', limit=100)
for trade in trades:
    print(f"{trade['side']} {trade['size']} @ {trade['price']}")

import asyncio
from lux_dex import AsyncClient

async def main():
    client = AsyncClient(
        json_rpc_url='http://localhost:8080/rpc',
        ws_url='ws://localhost:8081'
    )
    
    # Place order asynchronously
    order = await client.place_order(
        symbol='BTC-USD',
        order_type='limit',
        side='buy',
        price=50000,
        size=1.0
    )
    
    # Stream market data
    async for book in client.stream_order_book('BTC-USD'):
        print(f"Bid: {book.best_bid}, Ask: {book.best_ask}")

asyncio.run(main())

go get github.com/luxfi/dex/sdk/go

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/luxfi/dex/sdk/go/lxdex"
)

func main() {
    client := lxdex.NewClient(
        lxdex.WithJSONRPC("http://localhost:8080/rpc"),
        lxdex.WithGRPC("localhost:50051"),
    )

    ctx := context.Background()
    
    // Place an order
    order, err := client.PlaceOrder(ctx, &lxdex.Order{
        Symbol: "BTC-USD",
        Type:   lxdex.OrderTypeLimit,
        Side:   lxdex.Buy,
        Price:  50000,
        Size:   1.0,
    })
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Order placed: %s\n", order.OrderID)
}

// Stream order book
stream, err := client.StreamOrderBook(ctx, "BTC-USD")
if err != nil {
    log.Fatal(err)
}

for {
    update, err := stream.Recv()
    if err != nil {
        break
    }
    fmt.Printf("Order book update: %+v\n", update)
}

import (
    "context"
    "google.golang.org/grpc"
    pb "github.com/luxfi/dex/pkg/grpc/pb"
)

// Connect to gRPC server
conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
defer conn.Close()

client := pb.NewLXDEXServiceClient(conn)

// Place an order via gRPC
resp, err := client.PlaceOrder(context.Background(), &pb.PlaceOrderRequest{
    Symbol: "BTC-USD",
    Type:   pb.OrderType_LIMIT,
    Side:   pb.OrderSide_BUY,
    Price:  50000,
    Size:   1.0,
    UserId: "trader1",
})

cargo add lux-dex

[dependencies]
lux-dex = "1.2"

use lux_dex::{Client, ClientConfig, Order, OrderType, OrderSide};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig {
        rpc_url: "http://localhost:8080/rpc".to_string(),
        ws_url: Some("ws://localhost:8081".to_string()),
        ..Default::default()
    };

    let client = Client::new(config).await?;

    // Place an order
    let order = client.place_order(Order {
        symbol: "BTC-USD".to_string(),
        order_type: OrderType::Limit,
        side: OrderSide::Buy,
        price: Some(50000.0),
        size: 1.0,
        ..Default::default()
    }).await?;

    println!("Order placed: {}", order.order_id);
    Ok(())
}

git clone https://github.com/luxfi/dex
cd dex/sdk/cpp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install

#include <lxdex/client.hpp>
#include <iostream>

int main() {
    using namespace lxdex;

    ClientConfig config;
    config.ws_url = "ws://localhost:8081";
    config.api_key = "your-api-key";

    auto client = make_client(config);

    if (auto err = client->connect()) {
        std::cerr << "Failed to connect: " << err.message << std::endl;
        return 1;
    }

    // Place an order
    Order order;
    order.symbol = "BTC-USD";
    order.type = OrderType::Limit;
    order.side = OrderSide::Buy;
    order.price = 50000.0;
    order.size = 1.0;

    auto result = client->place_order(order);
    if (result.ok()) {
        std::cout << "Order placed: " << result.value.order_id << std::endl;
    }

    return 0;
}

git clone https://github.com/luxfi/dex
cd dex/sdk/c
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install

#include <lxdex.h>
#include <stdio.h>

int main() {
    lxdex_config_t config = {
        .ws_url = "ws://localhost:8081",
        .api_key = "your-api-key"
    };

    lxdex_client_t* client = lxdex_client_new(&config);

    if (lxdex_client_connect(client) != 0) {
        fprintf(stderr, "Failed to connect\n");
        return 1;
    }

    // Place an order
    lxdex_order_t order = {
        .symbol = "BTC-USD",
        .type = LXDEX_ORDER_LIMIT,
        .side = LXDEX_SIDE_BUY,
        .price = 50000.0,
        .size = 1.0
    };

    lxdex_order_response_t response;
    if (lxdex_place_order(client, &order, &response) == 0) {
        printf("Order placed: %s\n", response.order_id);
    }

    lxdex_client_free(client);
    return 0;
}

# CMakeLists.txt
find_package(lxdex REQUIRED)
target_link_libraries(your_app PRIVATE lxdex::lxdex)

gcc -o myapp myapp.c $(pkg-config --cflags --libs lxdex)

try {
    const order = await dex.limitBuy('BTC-USD', '1.0', '50000')
} catch (error) {
    if (error.code === 'INSUFFICIENT_BALANCE') {
        console.error('Not enough funds')
    } else if (error.code === 'RATE_LIMIT_EXCEEDED') {
        console.error('Too many requests')
    }
}

from lux_dex.exceptions import InsufficientBalanceError, RateLimitError

try:
    order = client.place_order(...)
except InsufficientBalanceError:
    print('Not enough funds')
except RateLimitError:
    print('Too many requests')
except Exception as e:
    print(f'Error: {e}')

order, err := client.PlaceOrder(ctx, &lxdex.Order{...})
if err != nil {
    switch e := err.(type) {
    case *lxdex.InsufficientBalanceError:
        log.Printf("Not enough funds: need %f, have %f", e.Required, e.Available)
    case *lxdex.RateLimitError:
        log.Printf("Rate limited, retry after %v", e.RetryAfter)
    default:
        log.Printf("Error: %v", err)
    }
}

const dex = await DEX({
    rpcUrl: 'https://api.lux.network/rpc',
    apiKey: 'your-api-key'
})

client = Client(
    jwt_token='eyJhbGciOiJIUzI1NiIs...'
)

# Start test node
./bin/luxd --testnet

# Use test endpoints
JSON-RPC: http://localhost:18080/rpc
gRPC: localhost:15051
WebSocket: ws://localhost:18081

# Run SDK tests
npm test           # TypeScript
python -m pytest   # Python
go test ./...      # Go