Orderbook API

import { OrderbookServiceClient } from './proto/OrderbookServiceClientPb'
import { GetMarketsInfoRequest } from './proto/orderbook_pb'

const client = new OrderbookServiceClient('http://localhost:5001')

const request = new GetMarketsInfoRequest()
const response = await client.getMarketsInfo(request, {})
const markets = response.getMarketsList()

import (
    "context"
    pb "your-package/proto"
)

client := pb.NewOrderbookServiceClient(conn)
request := &pb.GetMarketsInfoRequest{}

response, err := client.GetMarketsInfo(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
markets := response.GetMarkets()

use tonic::Request;
use your_package::orderbook_service_client::OrderbookServiceClient;
use your_package::GetMarketsInfoRequest;

let mut client = OrderbookServiceClient::connect("http://localhost:5001").await?;
let request = Request::new(GetMarketsInfoRequest {});

let response = client.get_markets_info(request).await?.into_inner();
let markets = response.markets;

const request = new GetMarketInfoRequest()
request.setFirstCurrency({
  network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
  assetId: 'BTC'
})
request.setOtherCurrency({
  network: { protocol: 1, chainId: '1', name: 'Ethereum' },
  assetId: '0x0000000000000000000000000000000000000000'
})

const response = await client.getMarketInfo(request, {})
const marketInfo = response.getMarketInfo()

request := &pb.GetMarketInfoRequest{
    FirstCurrency: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
        AssetId: "BTC",
    },
    OtherCurrency: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
        AssetId: "0x0000000000000000000000000000000000000000",
    },
}

response, err := client.GetMarketInfo(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
marketInfo := response.GetMarketInfo()

let request = Request::new(GetMarketInfoRequest {
    first_currency: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 0,
            chain_id: "0".to_string(),
            name: "Bitcoin".to_string(),
        }),
        asset_id: "BTC".to_string(),
    }),
    other_currency: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 1,
            chain_id: "1".to_string(),
            name: "Ethereum".to_string(),
        }),
        asset_id: "0x0000000000000000000000000000000000000000".to_string(),
    }),
});

let response = client.get_market_info(request).await?.into_inner();
let market_info = response.market_info;

const request = new InitMarketRequest()
request.setFirstCurrency({
  network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
  assetId: 'BTC'
})
request.setOtherCurrency({
  network: { protocol: 1, chainId: '1', name: 'Ethereum' },
  assetId: '0x0000000000000000000000000000000000000000'
})

const response = await client.initMarket(request, {})

request := &pb.InitMarketRequest{
    FirstCurrency: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
        AssetId: "BTC",
    },
    OtherCurrency: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
        AssetId: "0x0000000000000000000000000000000000000000",
    },
}

response, err := client.InitMarket(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}

let request = Request::new(InitMarketRequest {
    first_currency: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 0,
            chain_id: "0".to_string(),
            name: "Bitcoin".to_string(),
        }),
        asset_id: "BTC".to_string(),
    }),
    other_currency: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 1,
            chain_id: "1".to_string(),
            name: "Ethereum".to_string(),
        }),
        asset_id: "0x0000000000000000000000000000000000000000".to_string(),
    }),
});

let response = client.init_market(request).await?.into_inner();

const request = new GetInitializedMarketsRequest()
const response = await client.getInitializedMarkets(request, {})
const markets = response.getMarketsList()

request := &pb.GetInitializedMarketsRequest{}

response, err := client.GetInitializedMarkets(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
markets := response.GetMarkets()

let request = Request::new(GetInitializedMarketsRequest {});

let response = client.get_initialized_markets(request).await?.into_inner();
let markets = response.markets;

const request = new GetOrderbookRequest()
request.setBase({
  network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
  assetId: 'BTC'
})
request.setQuote({
  network: { protocol: 1, chainId: '1', name: 'Ethereum' },
  assetId: '0x0000000000000000000000000000000000000000'
})

const response = await client.getOrderbook(request, {})
const orderbook = response.getOrderbook()

request := &pb.GetOrderbookRequest{
    Base: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
        AssetId: "BTC",
    },
    Quote: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
        AssetId: "0x0000000000000000000000000000000000000000",
    },
}

response, err := client.GetOrderbook(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
orderbook := response.GetOrderbook()

let request = Request::new(GetOrderbookRequest {
    base: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 0,
            chain_id: "0".to_string(),
            name: "Bitcoin".to_string(),
        }),
        asset_id: "BTC".to_string(),
    }),
    quote: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 1,
            chain_id: "1".to_string(),
            name: "Ethereum".to_string(),
        }),
        asset_id: "0x0000000000000000000000000000000000000000".to_string(),
    }),
});

let response = client.get_orderbook(request).await?.into_inner();
let orderbook = response.orderbook;

const request = new GetOrderbookBalancesRequest()
const response = await client.getOrderbookBalances(request, {})
const balances = response.getBalancesList()

request := &pb.GetOrderbookBalancesRequest{}

response, err := client.GetOrderbookBalances(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
balances := response.GetBalances()

let request = Request::new(GetOrderbookBalancesRequest {});

let response = client.get_orderbook_balances(request).await?.into_inner();
let balances = response.balances;

const request = new EstimateOrderRequest()
request.setOrderVariant({
  marketOrder: {
    base: {
      network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
      assetId: 'BTC'
    },
    quote: {
      network: { protocol: 1, chainId: '1', name: 'Ethereum' },
      assetId: '0x0000000000000000000000000000000000000000'
    },
    amount: { base: { amount: '1000000' } }, // 0.01 BTC
    side: OrderSide.BUY
  }
})

const response = await client.estimateOrder(request, {})
const match = response.getOrderMatch()

request := &pb.EstimateOrderRequest{
    OrderVariant: &pb.OrderVariant{
        Variant: &pb.OrderVariant_MarketOrder{
            MarketOrder: &pb.MarketOrder{
                Base: &pb.OrderbookCurrency{
                    Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
                    AssetId: "BTC",
                },
                Quote: &pb.OrderbookCurrency{
                    Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
                    AssetId: "0x0000000000000000000000000000000000000000",
                },
                Amount: &pb.OrderAmount{
                    Amount: &pb.OrderAmount_Base{
                        Base: &pb.BaseAmount{Amount: "1000000"},
                    },
                },
                Side: pb.OrderSide_BUY,
            },
        },
    },
}

response, err := client.EstimateOrder(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
match := response.GetOrderMatch()

use your_package::order_variant::Variant;

let request = Request::new(EstimateOrderRequest {
    order_variant: Some(OrderVariant {
        variant: Some(Variant::MarketOrder(MarketOrder {
            base: Some(OrderbookCurrency {
                network: Some(Network {
                    protocol: 0,
                    chain_id: "0".to_string(),
                    name: "Bitcoin".to_string(),
                }),
                asset_id: "BTC".to_string(),
            }),
            quote: Some(OrderbookCurrency {
                network: Some(Network {
                    protocol: 1,
                    chain_id: "1".to_string(),
                    name: "Ethereum".to_string(),
                }),
                asset_id: "0x0000000000000000000000000000000000000000".to_string(),
            }),
            amount: Some(order_amount::Amount::Base(BaseAmount {
                amount: "1000000".to_string(),
            })),
            side: OrderSide::Buy as i32,
        })),
    }),
});

let response = client.estimate_order(request).await?.into_inner();
let match_result = response.order_match;

const request = new EstimateOrderRequest()
request.setOrderVariant({
  addLiquidity: {
    base: { ... },
    quote: { ... },
    minBuyPrice: '27.5',
    midPrice: '28.0',
    maxSellPrice: '28.5',
    amount: { quote: { amount: '50000000000000000000' } }, // 50 ETH
    removeOnFill: false
  }
})

const response = await client.estimateOrder(request, {})

request := &pb.EstimateOrderRequest{
    OrderVariant: &pb.OrderVariant{
        Variant: &pb.OrderVariant_AddLiquidity{
            AddLiquidity: &pb.AddLiquidity{
                Base:         &pb.OrderbookCurrency{...},
                Quote:        &pb.OrderbookCurrency{...},
                MinBuyPrice:  "27.5",
                MidPrice:     "28.0",
                MaxSellPrice: "28.5",
                Amount: &pb.OrderAmount{
                    Amount: &pb.OrderAmount_Quote{
                        Quote: &pb.QuoteAmount{Amount: "50000000000000000000"},
                    },
                },
                RemoveOnFill: false,
            },
        },
    },
}

response, err := client.EstimateOrder(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}

let request = Request::new(EstimateOrderRequest {
    order_variant: Some(OrderVariant {
        variant: Some(Variant::AddLiquidity(AddLiquidity {
            base: Some(OrderbookCurrency {...}),
            quote: Some(OrderbookCurrency {...}),
            min_buy_price: "27.5".to_string(),
            mid_price: "28.0".to_string(),
            max_sell_price: "28.5".to_string(),
            amount: Some(order_amount::Amount::Quote(QuoteAmount {
                amount: "50000000000000000000".to_string(),
            })),
            remove_on_fill: false,
        })),
    }),
});

let response = client.estimate_order(request).await?.into_inner();

const request = new CreateOrderRequest()
request.setOrderVariant({
  marketOrder: {
    base: {
      network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
      assetId: 'BTC'
    },
    quote: {
      network: { protocol: 1, chainId: '1', name: 'Ethereum' },
      assetId: '0x0000000000000000000000000000000000000000'
    },
    amount: { base: { amount: '1000000' } },
    side: OrderSide.SELL
  }
})

const response = await client.createOrder(request, {})
const orderId = response.getOrderId()
console.log('Order created:', orderId)

request := &pb.CreateOrderRequest{
    OrderVariant: &pb.OrderVariant{
        Variant: &pb.OrderVariant_MarketOrder{
            MarketOrder: &pb.MarketOrder{
                Base: &pb.OrderbookCurrency{
                    Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
                    AssetId: "BTC",
                },
                Quote: &pb.OrderbookCurrency{
                    Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
                    AssetId: "0x0000000000000000000000000000000000000000",
                },
                Amount: &pb.OrderAmount{
                    Amount: &pb.OrderAmount_Base{
                        Base: &pb.BaseAmount{Amount: "1000000"},
                    },
                },
                Side: pb.OrderSide_SELL,
            },
        },
    },
}

response, err := client.CreateOrder(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
orderId := response.GetOrderId()
fmt.Printf("Order created: %s\n", orderId)

let request = Request::new(CreateOrderRequest {
    order_variant: Some(OrderVariant {
        variant: Some(Variant::MarketOrder(MarketOrder {
            base: Some(OrderbookCurrency {
                network: Some(Network {
                    protocol: 0,
                    chain_id: "0".to_string(),
                    name: "Bitcoin".to_string(),
                }),
                asset_id: "BTC".to_string(),
            }),
            quote: Some(OrderbookCurrency {
                network: Some(Network {
                    protocol: 1,
                    chain_id: "1".to_string(),
                    name: "Ethereum".to_string(),
                }),
                asset_id: "0x0000000000000000000000000000000000000000".to_string(),
            }),
            amount: Some(order_amount::Amount::Base(BaseAmount {
                amount: "1000000".to_string(),
            })),
            side: OrderSide::Sell as i32,
        })),
    }),
});

let response = client.create_order(request).await?.into_inner();
let order_id = response.order_id;
println!("Order created: {}", order_id);

const request = new CancelOrderRequest()
request.setOrderId('order_abc123')

const response = await client.cancelOrder(request, {})
if (response.getRemoved()) {
  console.log('Order cancelled successfully')
}

request := &pb.CancelOrderRequest{
    OrderId: "order_abc123",
}

response, err := client.CancelOrder(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
if response.GetRemoved() {
    fmt.Println("Order cancelled successfully")
}

let request = Request::new(CancelOrderRequest {
    order_id: "order_abc123".to_string(),
});

let response = client.cancel_order(request).await?.into_inner();
if response.removed {
    println!("Order cancelled successfully");
}

const request = new CancelAllOrdersRequest()
await client.cancelAllOrders(request, {})
console.log('All orders cancelled')

request := &pb.CancelAllOrdersRequest{}

_, err := client.CancelAllOrders(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
fmt.Println("All orders cancelled")

let request = Request::new(CancelAllOrdersRequest {});

client.cancel_all_orders(request).await?;
println!("All orders cancelled");

const request = new GetOrderRequest()
request.setOrderId('order_abc123')

const response = await client.getOrder(request, {})
const order = response.getOrder()

request := &pb.GetOrderRequest{
    OrderId: "order_abc123",
}

response, err := client.GetOrder(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
order := response.GetOrder()

let request = Request::new(GetOrderRequest {
    order_id: "order_abc123".to_string(),
});

let response = client.get_order(request).await?.into_inner();
let order = response.order;

const request = new GetOwnOrdersRequest()
request.setBase({
  network: { protocol: 0, chainId: '0', name: 'Bitcoin' },
  assetId: 'BTC'
})
request.setQuote({
  network: { protocol: 1, chainId: '1', name: 'Ethereum' },
  assetId: '0x0000000000000000000000000000000000000000'
})

const response = await client.getOwnOrders(request, {})
const orders = response.getOrdersMap()

request := &pb.GetOwnOrdersRequest{
    Base: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 0, ChainId: "0", Name: "Bitcoin"},
        AssetId: "BTC",
    },
    Quote: &pb.OrderbookCurrency{
        Network: &pb.Network{Protocol: 1, ChainId: "1", Name: "Ethereum"},
        AssetId: "0x0000000000000000000000000000000000000000",
    },
}

response, err := client.GetOwnOrders(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
orders := response.GetOrders()

let request = Request::new(GetOwnOrdersRequest {
    base: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 0,
            chain_id: "0".to_string(),
            name: "Bitcoin".to_string(),
        }),
        asset_id: "BTC".to_string(),
    }),
    quote: Some(OrderbookCurrency {
        network: Some(Network {
            protocol: 1,
            chain_id: "1".to_string(),
            name: "Ethereum".to_string(),
        }),
        asset_id: "0x0000000000000000000000000000000000000000".to_string(),
    }),
});

let response = client.get_own_orders(request).await?.into_inner();
let orders = response.orders;

const request = new GetAllOwnOrdersRequest()
const response = await client.getAllOwnOrders(request, {})
const allOrders = response.getOrdersMap()

request := &pb.GetAllOwnOrdersRequest{}

response, err := client.GetAllOwnOrders(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
allOrders := response.GetOrders()

let request = Request::new(GetAllOwnOrdersRequest {});

let response = client.get_all_own_orders(request).await?.into_inner();
let all_orders = response.orders;

const request = new GetTradeHistoryRequest()
request.setBase({ ... })
request.setQuote({ ... })

const response = await client.getTradeHistory(request, {})
const trades = response.getTradeHistoryList()

request := &pb.GetTradeHistoryRequest{
    Base:  &pb.OrderbookCurrency{...},
    Quote: &pb.OrderbookCurrency{...},
}

response, err := client.GetTradeHistory(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
trades := response.GetTradeHistory()

let request = Request::new(GetTradeHistoryRequest {
    base: Some(OrderbookCurrency {...}),
    quote: Some(OrderbookCurrency {...}),
});

let response = client.get_trade_history(request).await?.into_inner();
let trades = response.trade_history;

const request = new GetPairMarketTradesRequest()
request.setBase({ ... })
request.setQuote({ ... })

const response = await client.getPairMarketTrades(request, {})
const trades = response.getTradesList()

request := &pb.GetPairMarketTradesRequest{
    Base:  &pb.OrderbookCurrency{...},
    Quote: &pb.OrderbookCurrency{...},
}

response, err := client.GetPairMarketTrades(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
trades := response.GetTrades()

let request = Request::new(GetPairMarketTradesRequest {
    base: Some(OrderbookCurrency {...}),
    quote: Some(OrderbookCurrency {...}),
});

let response = client.get_pair_market_trades(request).await?.into_inner();
let trades = response.trades;

const request = new GetAllMarketTradesRequest()
const response = await client.getAllMarketTrades(request, {})
const trades = response.getPairMarketTradesList()

request := &pb.GetAllMarketTradesRequest{}

response, err := client.GetAllMarketTrades(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
trades := response.GetPairMarketTrades()

let request = Request::new(GetAllMarketTradesRequest {});

let response = client.get_all_market_trades(request).await?.into_inner();
let trades = response.pair_market_trades;

const request = new GetPairSwapTradesRequest()
request.setFromCurrency({ ... })
request.setToCurrency({ ... })

const response = await client.getPairSwapTrades(request, {})
const swapTrades = response.getTradesList()

request := &pb.GetPairSwapTradesRequest{
    FromCurrency: &pb.OrderbookCurrency{...},
    ToCurrency:   &pb.OrderbookCurrency{...},
}

response, err := client.GetPairSwapTrades(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
swapTrades := response.GetTrades()

let request = Request::new(GetPairSwapTradesRequest {
    from_currency: Some(OrderbookCurrency {...}),
    to_currency: Some(OrderbookCurrency {...}),
});

let response = client.get_pair_swap_trades(request).await?.into_inner();
let swap_trades = response.trades;

const request = new GetAllSwapTradesRequest()
const response = await client.getAllSwapTrades(request, {})
const allSwaps = response.getPairSwapTradesList()

request := &pb.GetAllSwapTradesRequest{}

response, err := client.GetAllSwapTrades(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}
allSwaps := response.GetPairSwapTrades()

let request = Request::new(GetAllSwapTradesRequest {});

let response = client.get_all_swap_trades(request).await?.into_inner();
let all_swaps = response.pair_swap_trades;

const request = new SubscribeMarketEventsRequest()
request.setBase({ ... })
request.setQuote({ ... })

const stream = client.subscribeMarketEvents(request, {})

stream.on('data', (event) => {
  if (event.hasIsSynced()) {
    console.log('Market synced')
  }
  if (event.hasOrderbookUpdate()) {
    const update = event.getOrderbookUpdate()
    console.log('Orderbook updated:', update)
  }
  if (event.hasTradeUpdate()) {
    const trade = event.getTradeUpdate()
    console.log('Trade:', trade.getBaseAmount(), '@', trade.getPrice())
  }
  if (event.hasDailyStatsUpdate()) {
    const stats = event.getDailyStatsUpdate()
    console.log('24h volume:', stats.getVolatility()?.getBaseVolume())
  }
  if (event.hasCandlestickUpdate()) {
    const candle = event.getCandlestickUpdate()
    console.log('Candle:', candle.getInterval(), candle.getCandlestick())
  }
})

stream.on('error', (err) => console.error('Stream error:', err))
stream.on('end', () => console.log('Stream ended'))

request := &pb.SubscribeMarketEventsRequest{
    Base:  &pb.OrderbookCurrency{...},
    Quote: &pb.OrderbookCurrency{...},
}

stream, err := client.SubscribeMarketEvents(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}

for {
    event, err := stream.Recv()
    if err != nil {
        log.Printf("Stream error: %v", err)
        break
    }

    if event.GetIsSynced() {
        fmt.Println("Market synced")
    }
    if update := event.GetOrderbookUpdate(); update != nil {
        fmt.Printf("Orderbook updated: %v\n", update)
    }
    if trade := event.GetTradeUpdate(); trade != nil {
        fmt.Printf("Trade: %s @ %s\n", trade.GetBaseAmount(), trade.GetPrice())
    }
    if stats := event.GetDailyStatsUpdate(); stats != nil {
        fmt.Printf("24h volume: %s\n", stats.GetVolatility().GetBaseVolume())
    }
    if candle := event.GetCandlestickUpdate(); candle != nil {
        fmt.Printf("Candle: %v %v\n", candle.GetInterval(), candle.GetCandlestick())
    }
}

use tokio_stream::StreamExt;

let request = Request::new(SubscribeMarketEventsRequest {
    base: Some(OrderbookCurrency {...}),
    quote: Some(OrderbookCurrency {...}),
});

let mut stream = client.subscribe_market_events(request).await?.into_inner();

while let Some(event) = stream.next().await {
    let event = event?;

    if event.is_synced {
        println!("Market synced");
    }
    if let Some(update) = event.orderbook_update {
        println!("Orderbook updated: {:?}", update);
    }
    if let Some(trade) = event.trade_update {
        println!("Trade: {} @ {}", trade.base_amount, trade.price);
    }
    if let Some(stats) = event.daily_stats_update {
        if let Some(vol) = stats.volatility {
            println!("24h volume: {}", vol.base_volume);
        }
    }
    if let Some(candle) = event.candlestick_update {
        println!("Candle: {:?} {:?}", candle.interval, candle.candlestick);
    }
}

const request = new SubscribeDexEventsRequest()
const stream = client.subscribeDexEvents(request, {})

stream.on('data', (event) => {
  const timestamp = event.getTimestamp()

  if (event.hasBalanceUpdate()) {
    const balance = event.getBalanceUpdate()
    console.log('Balance updated:', balance.getCurrency(), balance.getBalance())
  }

  if (event.hasOrderUpdate()) {
    const update = event.getOrderUpdate()
    if (update.hasOrderCreated()) {
      console.log('Order created:', update.getOrderCreated().getOrderId())
    }
    if (update.hasOrderCompleted()) {
      console.log('Order completed:', update.getOrderCompleted().getOrderId())
    }
  }

  if (event.hasOrderMatched()) {
    const matched = event.getOrderMatched()
    console.log('Order matched:', matched.getOwnOrderId())
    console.log('Is taker:', matched.getIsTaker())
  }

  if (event.hasSwapUpdate()) {
    const swap = event.getSwapUpdate()
    const progress = swap.getProgress()
    console.log('Swap status:', progress.getStatus())
    if (progress.hasError()) {
      console.error('Swap error:', progress.getError())
    }
  }
})

request := &pb.SubscribeDexEventsRequest{}

stream, err := client.SubscribeDexEvents(context.Background(), request)
if err != nil {
    log.Fatalf("Error: %v", err)
}

for {
    event, err := stream.Recv()
    if err != nil {
        log.Printf("Stream error: %v", err)
        break
    }

    timestamp := event.GetTimestamp()

    if balance := event.GetBalanceUpdate(); balance != nil {
        fmt.Printf("Balance updated: %v %v\n",
            balance.GetCurrency(), balance.GetBalance())
    }

    if update := event.GetOrderUpdate(); update != nil {
        if created := update.GetOrderCreated(); created != nil {
            fmt.Printf("Order created: %s\n", created.GetOrderId())
        }
        if completed := update.GetOrderCompleted(); completed != nil {
            fmt.Printf("Order completed: %s\n", completed.GetOrderId())
        }
    }

    if matched := event.GetOrderMatched(); matched != nil {
        fmt.Printf("Order matched: %s\n", matched.GetOwnOrderId())
        fmt.Printf("Is taker: %v\n", matched.GetIsTaker())
    }

    if swap := event.GetSwapUpdate(); swap != nil {
        progress := swap.GetProgress()
        fmt.Printf("Swap status: %v\n", progress.GetStatus())
        if errMsg := progress.GetError(); errMsg != "" {
            fmt.Printf("Swap error: %s\n", errMsg)
        }
    }
}

use tokio_stream::StreamExt;

let request = Request::new(SubscribeDexEventsRequest {});

let mut stream = client.subscribe_dex_events(request).await?.into_inner();

while let Some(event) = stream.next().await {
    let event = event?;
    let timestamp = event.timestamp;

    if let Some(balance) = event.balance_update {
        println!("Balance updated: {:?} {:?}",
            balance.currency, balance.balance);
    }

    if let Some(update) = event.order_update {
        if let Some(created) = update.order_created {
            println!("Order created: {}", created.order_id);
        }
        if let Some(completed) = update.order_completed {
            println!("Order completed: {}", completed.order_id);
        }
    }

    if let Some(matched) = event.order_matched {
        println!("Order matched: {}", matched.own_order_id);
        println!("Is taker: {}", matched.is_taker);
    }

    if let Some(swap) = event.swap_update {
        if let Some(progress) = swap.progress {
            println!("Swap status: {:?}", progress.status);
            if let Some(error) = progress.error {
                eprintln!("Swap error: {}", error);
            }
        }
    }
}

async function placeLimitOrder(
  client: OrderbookServiceClient,
  base: OrderbookCurrency,
  quote: OrderbookCurrency,
  midPrice: string,
  spreadPercent: number,
  quoteAmount: string
) {
  const spread = parseFloat(midPrice) * (spreadPercent / 100)
  const minBuyPrice = (parseFloat(midPrice) - spread).toString()
  const maxSellPrice = (parseFloat(midPrice) + spread).toString()

  // Estimate first
  const estimateReq = new EstimateOrderRequest()
  estimateReq.setOrderVariant({
    addLiquidity: {
      base,
      quote,
      minBuyPrice,
      midPrice,
      maxSellPrice,
      amount: { quote: { amount: quoteAmount } },
      removeOnFill: false
    }
  })

  const estimate = await client.estimateOrder(estimateReq, {})
  console.log('Estimated match:', estimate.getOrderMatch())

  // Create order
  const createReq = new CreateOrderRequest()
  createReq.setOrderVariant({
    addLiquidity: {
      base,
      quote,
      minBuyPrice,
      midPrice,
      maxSellPrice,
      amount: { quote: { amount: quoteAmount } },
      removeOnFill: false
    }
  })

  const response = await client.createOrder(createReq, {})
  return response.getOrderId()
}

// Example: Provide liquidity at 28 ETH/BTC with 1% spread
const orderId = await placeLimitOrder(
  client,
  btcCurrency,
  ethCurrency,
  '28.0',      // mid price
  1.0,         // 1% spread
  '50000000000000000000' // 50 ETH
)

func placeLimitOrder(
    client pb.OrderbookServiceClient,
    base *pb.OrderbookCurrency,
    quote *pb.OrderbookCurrency,
    midPrice string,
    spreadPercent float64,
    quoteAmount string,
) (string, error) {
    midPriceFloat, _ := strconv.ParseFloat(midPrice, 64)
    spread := midPriceFloat * (spreadPercent / 100)
    minBuyPrice := fmt.Sprintf("%f", midPriceFloat-spread)
    maxSellPrice := fmt.Sprintf("%f", midPriceFloat+spread)

    // Estimate first
    estimateReq := &pb.EstimateOrderRequest{
        OrderVariant: &pb.OrderVariant{
            Variant: &pb.OrderVariant_AddLiquidity{
                AddLiquidity: &pb.AddLiquidity{
                    Base:         base,
                    Quote:        quote,
                    MinBuyPrice:  minBuyPrice,
                    MidPrice:     midPrice,
                    MaxSellPrice: maxSellPrice,
                    Amount: &pb.OrderAmount{
                        Amount: &pb.OrderAmount_Quote{
                            Quote: &pb.QuoteAmount{Amount: quoteAmount},
                        },
                    },
                    RemoveOnFill: false,
                },
            },
        },
    }

    estimate, err := client.EstimateOrder(context.Background(), estimateReq)
    if err != nil {
        return "", err
    }
    fmt.Printf("Estimated match: %v\n", estimate.GetOrderMatch())

    // Create order
    createReq := &pb.CreateOrderRequest{
        OrderVariant: estimateReq.OrderVariant,
    }

    response, err := client.CreateOrder(context.Background(), createReq)
    if err != nil {
        return "", err
    }
    return response.GetOrderId(), nil
}

// Example: Provide liquidity at 28 ETH/BTC with 1% spread
orderId, err := placeLimitOrder(
    client,
    btcCurrency,
    ethCurrency,
    "28.0",                    // mid price
    1.0,                       // 1% spread
    "50000000000000000000",    // 50 ETH
)

async fn place_limit_order(
    client: &mut OrderbookServiceClient<Channel>,
    base: OrderbookCurrency,
    quote: OrderbookCurrency,
    mid_price: &str,
    spread_percent: f64,
    quote_amount: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    let mid_price_float: f64 = mid_price.parse()?;
    let spread = mid_price_float * (spread_percent / 100.0);
    let min_buy_price = (mid_price_float - spread).to_string();
    let max_sell_price = (mid_price_float + spread).to_string();

    // Estimate first
    let estimate_req = Request::new(EstimateOrderRequest {
        order_variant: Some(OrderVariant {
            variant: Some(Variant::AddLiquidity(AddLiquidity {
                base: Some(base.clone()),
                quote: Some(quote.clone()),
                min_buy_price: min_buy_price.clone(),
                mid_price: mid_price.to_string(),
                max_sell_price: max_sell_price.clone(),
                amount: Some(order_amount::Amount::Quote(QuoteAmount {
                    amount: quote_amount.to_string(),
                })),
                remove_on_fill: false,
            })),
        }),
    });

    let estimate = client.estimate_order(estimate_req).await?.into_inner();
    println!("Estimated match: {:?}", estimate.order_match);

    // Create order
    let create_req = Request::new(CreateOrderRequest {
        order_variant: Some(OrderVariant {
            variant: Some(Variant::AddLiquidity(AddLiquidity {
                base: Some(base),
                quote: Some(quote),
                min_buy_price,
                mid_price: mid_price.to_string(),
                max_sell_price,
                amount: Some(order_amount::Amount::Quote(QuoteAmount {
                    amount: quote_amount.to_string(),
                })),
                remove_on_fill: false,
            })),
        }),
    });

    let response = client.create_order(create_req).await?.into_inner();
    Ok(response.order_id)
}

// Example: Provide liquidity at 28 ETH/BTC with 1% spread
let order_id = place_limit_order(
    &mut client,
    btc_currency,
    eth_currency,
    "28.0",                    // mid price
    1.0,                       // 1% spread
    "50000000000000000000",    // 50 ETH
).await?;

async function buyMarket(
  client: OrderbookServiceClient,
  base: OrderbookCurrency,
  quote: OrderbookCurrency,
  baseAmount: string
) {
  const request = new CreateOrderRequest()
  request.setOrderVariant({
    marketOrder: {
      base,
      quote,
      amount: { base: { amount: baseAmount } },
      side: OrderSide.BUY
    }
  })

  const response = await client.createOrder(request, {})
  return response.getOrderId()
}

func buyMarket(
    client pb.OrderbookServiceClient,
    base *pb.OrderbookCurrency,
    quote *pb.OrderbookCurrency,
    baseAmount string,
) (string, error) {
    request := &pb.CreateOrderRequest{
        OrderVariant: &pb.OrderVariant{
            Variant: &pb.OrderVariant_MarketOrder{
                MarketOrder: &pb.MarketOrder{
                    Base:  base,
                    Quote: quote,
                    Amount: &pb.OrderAmount{
                        Amount: &pb.OrderAmount_Base{
                            Base: &pb.BaseAmount{Amount: baseAmount},
                        },
                    },
                    Side: pb.OrderSide_BUY,
                },
            },
        },
    }

    response, err := client.CreateOrder(context.Background(), request)
    if err != nil {
        return "", err
    }
    return response.GetOrderId(), nil
}

async fn buy_market(
    client: &mut OrderbookServiceClient<Channel>,
    base: OrderbookCurrency,
    quote: OrderbookCurrency,
    base_amount: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    let request = Request::new(CreateOrderRequest {
        order_variant: Some(OrderVariant {
            variant: Some(Variant::MarketOrder(MarketOrder {
                base: Some(base),
                quote: Some(quote),
                amount: Some(order_amount::Amount::Base(BaseAmount {
                    amount: base_amount.to_string(),
                })),
                side: OrderSide::Buy as i32,
            })),
        }),
    });

    let response = client.create_order(request).await?.into_inner();
    Ok(response.order_id)
}

async function swapBTCtoUSDT(
  client: OrderbookServiceClient,
  amount: string
) {
  // BTC → ETH → USDT
  const request = new CreateOrderRequest()
  request.setOrderVariant({
    swapOrder: {
      fromCurrency: btcCurrency,
      currencyPath: [ethCurrency],
      toCurrency: usdtCurrency,
      amount: { sending: { value: amount } }
    }
  })

  const response = await client.createOrder(request, {})
  return response.getOrderId()
}

func swapBTCtoUSDT(
    client pb.OrderbookServiceClient,
    amount string,
) (string, error) {
    // BTC → ETH → USDT
    request := &pb.CreateOrderRequest{
        OrderVariant: &pb.OrderVariant{
            Variant: &pb.OrderVariant_SwapOrder{
                SwapOrder: &pb.SwapOrder{
                    FromCurrency: btcCurrency,
                    CurrencyPath: []*pb.OrderbookCurrency{ethCurrency},
                    ToCurrency:   usdtCurrency,
                    Amount: &pb.SwapAmount{
                        Amount: &pb.SwapAmount_Sending{
                            Sending: &pb.SendingAmount{Value: amount},
                        },
                    },
                },
            },
        },
    }

    response, err := client.CreateOrder(context.Background(), request)
    if err != nil {
        return "", err
    }
    return response.GetOrderId(), nil
}

async fn swap_btc_to_usdt(
    client: &mut OrderbookServiceClient<Channel>,
    amount: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    // BTC → ETH → USDT
    let request = Request::new(CreateOrderRequest {
        order_variant: Some(OrderVariant {
            variant: Some(Variant::SwapOrder(SwapOrder {
                from_currency: Some(btc_currency),
                currency_path: vec![eth_currency],
                to_currency: Some(usdt_currency),
                amount: Some(swap_amount::Amount::Sending(SendingAmount {
                    value: amount.to_string(),
                })),
            })),
        }),
    });

    let response = client.create_order(request).await?.into_inner();
    Ok(response.order_id)
}