nautilus_binance/spot/http/

parse.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! SBE decode functions for Binance Spot HTTP responses.
//!
//! Each function decodes raw SBE bytes into domain types, validating the
//! message header (schema ID and template ID) before extracting fields.

use rust_decimal::Decimal;

use super::{
    error::SbeDecodeError,
    models::{
        BinanceAccountInfo, BinanceAccountTrade, BinanceAggTrade, BinanceAggTrades, BinanceBalance,
        BinanceCancelOpenOrdersResponse, BinanceCancelOrderListOrder,
        BinanceCancelOrderListResponse, BinanceCancelOrderResponse, BinanceDepth,
        BinanceExchangeInfoSbe, BinanceKline, BinanceKlines, BinanceLotSizeFilterSbe,
        BinanceNewOrderResponse, BinanceNotionalFilter, BinanceOrderFill, BinanceOrderResponse,
        BinancePriceFilterSbe, BinancePriceLevel, BinanceSymbolFiltersSbe, BinanceSymbolSbe,
        BinanceTrade, BinanceTrades,
    },
};
use crate::spot::sbe::{
    cursor::SbeCursor,
    spot::{
        SBE_SCHEMA_ID, account_response_codec::SBE_TEMPLATE_ID as ACCOUNT_TEMPLATE_ID,
        account_trades_response_codec::SBE_TEMPLATE_ID as ACCOUNT_TRADES_TEMPLATE_ID,
        account_type::AccountType,
        agg_trades_response_codec::SBE_TEMPLATE_ID as AGG_TRADES_TEMPLATE_ID, bool_enum::BoolEnum,
        cancel_open_orders_response_codec::SBE_TEMPLATE_ID as CANCEL_OPEN_ORDERS_TEMPLATE_ID,
        cancel_order_list_response_codec::SBE_TEMPLATE_ID as CANCEL_ORDER_LIST_TEMPLATE_ID,
        cancel_order_response_codec::SBE_TEMPLATE_ID as CANCEL_ORDER_TEMPLATE_ID,
        cancel_replace_order_response_codec::SBE_TEMPLATE_ID as CANCEL_REPLACE_TEMPLATE_ID,
        cancel_replace_status::CancelReplaceStatus,
        depth_response_codec::SBE_TEMPLATE_ID as DEPTH_TEMPLATE_ID,
        exchange_info_response_codec::SBE_TEMPLATE_ID as EXCHANGE_INFO_TEMPLATE_ID,
        klines_response_codec::SBE_TEMPLATE_ID as KLINES_TEMPLATE_ID,
        lot_size_filter_codec::SBE_TEMPLATE_ID as LOT_SIZE_FILTER_TEMPLATE_ID,
        message_header_codec::ENCODED_LENGTH as HEADER_LENGTH,
        min_notional_filter_codec::SBE_TEMPLATE_ID as MIN_NOTIONAL_FILTER_TEMPLATE_ID,
        new_order_full_response_codec::SBE_TEMPLATE_ID as NEW_ORDER_FULL_TEMPLATE_ID,
        notional_filter_codec::SBE_TEMPLATE_ID as NOTIONAL_FILTER_TEMPLATE_ID,
        order_response_codec::SBE_TEMPLATE_ID as ORDER_TEMPLATE_ID,
        orders_response_codec::SBE_TEMPLATE_ID as ORDERS_TEMPLATE_ID,
        ping_response_codec::SBE_TEMPLATE_ID as PING_TEMPLATE_ID,
        price_filter_codec::SBE_TEMPLATE_ID as PRICE_FILTER_TEMPLATE_ID,
        server_time_response_codec::SBE_TEMPLATE_ID as SERVER_TIME_TEMPLATE_ID,
        trades_response_codec::SBE_TEMPLATE_ID as TRADES_TEMPLATE_ID,
    },
};

/// SBE message header.
#[derive(Debug, Clone, Copy)]
struct MessageHeader {
    block_length: u16,
    template_id: u16,
    schema_id: u16,
    version: u16,
}

impl MessageHeader {
    /// Decode message header using cursor.
    fn decode_cursor(cursor: &mut SbeCursor<'_>) -> Result<Self, SbeDecodeError> {
        cursor.require(HEADER_LENGTH)?;
        let block_length = cursor.read_u16_le()?;
        let template_id = cursor.read_u16_le()?;
        let schema_id = cursor.read_u16_le()?;
        let version = cursor.read_u16_le()?;
        Ok(Self {
            block_length,
            template_id,
            schema_id,
            version,
        })
    }

    /// Validate the message schema ID.
    ///
    /// The exact schema version is intentionally not enforced, matching the
    /// WebSocket SBE path. Binance evolves the schema additively within a schema ID
    /// and rolls new versions out gradually, so a single client sees both the current
    /// and next version during a rollout: 3:4 and 3:5 share identical block layouts,
    /// differing only by an added `symbolStatus` enum value, and unknown enum values
    /// decode to their null variant. Enforcing an exact version would hard-fail
    /// instrument loading on a server-side bump. A different schema ID is a breaking
    /// change and is still rejected.
    ///
    /// The decoders assume block layouts are stable within a schema ID.
    /// `decode_exchange_info` verifies the symbol block length and fails loudly on a
    /// mismatch; the market-data decoders read groups at a fixed offset, so a future
    /// version that adds fixed-block fields to those messages would need them updated
    /// to advance past the added bytes via `block_length`.
    fn validate(&self) -> Result<(), SbeDecodeError> {
        if self.schema_id != SBE_SCHEMA_ID {
            return Err(SbeDecodeError::SchemaMismatch {
                expected: SBE_SCHEMA_ID,
                actual: self.schema_id,
            });
        }
        Ok(())
    }
}

/// Decode a ping response.
///
/// Ping response has no body (block_length = 0), just validates the header.
///
/// # Errors
///
/// Returns error if buffer is too short or schema mismatch.
pub fn decode_ping(buf: &[u8]) -> Result<(), SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != PING_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    Ok(())
}

/// Decode a server time response.
///
/// Returns the server time as **microseconds** since epoch (SBE provides
/// microsecond precision vs JSON's milliseconds).
///
/// # Errors
///
/// Returns error if buffer is too short or schema mismatch.
pub fn decode_server_time(buf: &[u8]) -> Result<i64, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != SERVER_TIME_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    cursor.read_i64_le()
}

/// Decode a depth response.
///
/// Returns the order book depth with bids and asks.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or group size exceeded.
pub fn decode_depth(buf: &[u8]) -> Result<BinanceDepth, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != DEPTH_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let last_update_id = cursor.read_i64_le()?;
    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;

    let (block_len, count) = cursor.read_group_header()?;
    let bids = cursor.read_group(block_len, count, |c| {
        Ok(BinancePriceLevel {
            price_mantissa: c.read_i64_le()?,
            qty_mantissa: c.read_i64_le()?,
        })
    })?;

    let (block_len, count) = cursor.read_group_header()?;
    let asks = cursor.read_group(block_len, count, |c| {
        Ok(BinancePriceLevel {
            price_mantissa: c.read_i64_le()?,
            qty_mantissa: c.read_i64_le()?,
        })
    })?;

    Ok(BinanceDepth {
        last_update_id,
        price_exponent,
        qty_exponent,
        bids,
        asks,
    })
}

/// Decode a trades response.
///
/// Returns the list of trades.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or group size exceeded.
pub fn decode_trades(buf: &[u8]) -> Result<BinanceTrades, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != TRADES_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;

    let (block_len, count) = cursor.read_group_header()?;
    let trades = cursor.read_group(block_len, count, |c| {
        Ok(BinanceTrade {
            id: c.read_i64_le()?,
            price_mantissa: c.read_i64_le()?,
            qty_mantissa: c.read_i64_le()?,
            quote_qty_mantissa: c.read_i64_le()?,
            time: c.read_i64_le()?,
            is_buyer_maker: BoolEnum::from(c.read_u8()?) == BoolEnum::True,
            is_best_match: BoolEnum::from(c.read_u8()?) == BoolEnum::True,
        })
    })?;

    Ok(BinanceTrades {
        price_exponent,
        qty_exponent,
        trades,
    })
}

/// Decodes an aggregate trades response.
///
/// # Errors
///
/// Returns an error for an invalid header, template, or group payload.
pub fn decode_agg_trades(buf: &[u8]) -> Result<BinanceAggTrades, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != AGG_TRADES_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;
    let (block_len, count) = cursor.read_group_header()?;
    let trades = cursor.read_group(block_len, count, |c| {
        Ok(BinanceAggTrade {
            id: c.read_i64_le()?,
            price_mantissa: c.read_i64_le()?,
            qty_mantissa: c.read_i64_le()?,
            first_trade_id: c.read_i64_le()?,
            last_trade_id: c.read_i64_le()?,
            time: c.read_i64_le()?,
            is_buyer_maker: BoolEnum::from(c.read_u8()?) == BoolEnum::True,
            is_best_match: BoolEnum::from(c.read_u8()?) == BoolEnum::True,
        })
    })?;

    Ok(BinanceAggTrades {
        price_exponent,
        qty_exponent,
        trades,
    })
}

/// Klines group item block length (from SBE codec).
const KLINES_BLOCK_LENGTH: u16 = 120;

/// Decode a klines (candlestick) response.
///
/// Returns the list of klines with their price and quantity exponents.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or group size exceeded.
pub fn decode_klines(buf: &[u8]) -> Result<BinanceKlines, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != KLINES_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;

    let (block_len, count) = cursor.read_group_header()?;

    if block_len != KLINES_BLOCK_LENGTH {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: KLINES_BLOCK_LENGTH,
            actual: block_len,
        });
    }

    let mut klines = Vec::with_capacity(count as usize);

    for _ in 0..count {
        cursor.require(KLINES_BLOCK_LENGTH as usize)?;

        let open_time = cursor.read_i64_le()?;
        let open_price = cursor.read_i64_le()?;
        let high_price = cursor.read_i64_le()?;
        let low_price = cursor.read_i64_le()?;
        let close_price = cursor.read_i64_le()?;

        let volume_slice = cursor.read_bytes(16)?;
        let mut volume = [0u8; 16];
        volume.copy_from_slice(volume_slice);

        let close_time = cursor.read_i64_le()?;

        let quote_volume_slice = cursor.read_bytes(16)?;
        let mut quote_volume = [0u8; 16];
        quote_volume.copy_from_slice(quote_volume_slice);

        let num_trades = cursor.read_i64_le()?;

        let taker_buy_base_volume_slice = cursor.read_bytes(16)?;
        let mut taker_buy_base_volume = [0u8; 16];
        taker_buy_base_volume.copy_from_slice(taker_buy_base_volume_slice);

        let taker_buy_quote_volume_slice = cursor.read_bytes(16)?;
        let mut taker_buy_quote_volume = [0u8; 16];
        taker_buy_quote_volume.copy_from_slice(taker_buy_quote_volume_slice);

        klines.push(BinanceKline {
            open_time,
            open_price,
            high_price,
            low_price,
            close_price,
            volume,
            close_time,
            quote_volume,
            num_trades,
            taker_buy_base_volume,
            taker_buy_quote_volume,
        });
    }

    Ok(BinanceKlines {
        price_exponent,
        qty_exponent,
        klines,
    })
}

/// Bytes consumed from the fixed block before the end-of-block skip in each decoder.
/// These represent explicit reads and advances up to the last field we extract.
const NEW_ORDER_FULL_FIELDS_END: usize = 117;
const CANCEL_ORDER_FIELDS_END: usize = 109;
const CANCEL_ORDER_LIST_FIELDS_END: usize = 21;
const CANCEL_ORDER_LIST_ORDER_FIELDS_END: usize = 8;
const CANCEL_ORDER_LIST_REPORT_FIELDS_END: usize = 107;
const CANCEL_ORDER_LIST_REPORT_V0_BLOCK_LENGTH: u16 = 124;
const CANCEL_ORDER_LIST_REPORT_V1_BLOCK_LENGTH: u16 = 135;
const ORDER_FIELDS_END: usize = 134;

/// Minimum fixed-block length of an order in `orderResponse` and the
/// `ordersResponse` group (schema 3:3 baseline).
const ORDER_MIN_BLOCK_LENGTH: u16 = 162;

/// Sentinel value for a null `expiryReason` in schema 3:4.
const EXPIRY_REASON_NULL: u8 = 0xff;

/// Schema-3:4 byte offsets of the `expiryReason` field within each fixed block.
/// Sourced from the SBE codecs: `newOrderFullResponse` puts it at 153,
/// `orderResponse` / `ordersResponse` at 162.
const NEW_ORDER_FULL_EXPIRY_REASON_OFFSET: usize = 153;
const ORDER_EXPIRY_REASON_OFFSET: usize = 162;

/// Reads the schema-3:4 `expiryReason` byte from the fixed block when present.
///
/// `fields_end` is the cursor position (in bytes from the start of the block)
/// after the last field the caller has explicitly parsed. `expiry_reason_offset`
/// is the field's encoded offset within the block per the SBE schema.
/// Returns `Ok(None)` when the runtime `block_length` does not span the
/// `expiryReason` byte (schema 3:3 layouts) or when the byte holds the SBE
/// null sentinel. In every case the cursor is advanced to the end of the
/// fixed block.
fn read_trailing_expiry_reason(
    cursor: &mut SbeCursor<'_>,
    block_length: usize,
    fields_end: usize,
    expiry_reason_offset: usize,
) -> Result<Option<u8>, SbeDecodeError> {
    debug_assert!(fields_end <= expiry_reason_offset);
    if block_length < fields_end {
        return Ok(None);
    }
    let trailer = block_length - fields_end;
    if trailer == 0 {
        return Ok(None);
    }
    // Pre-3:4 block: no expiryReason byte at this offset, skip remaining bytes.
    if block_length <= expiry_reason_offset {
        cursor.advance(trailer)?;
        return Ok(None);
    }
    let pre = expiry_reason_offset - fields_end;
    cursor.advance(pre)?;
    let byte = cursor.read_u8()?;
    let post = trailer - pre - 1;
    if post > 0 {
        cursor.advance(post)?;
    }
    Ok((byte != EXPIRY_REASON_NULL).then_some(byte))
}

/// Decode a new order full response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_new_order_full(buf: &[u8]) -> Result<BinanceNewOrderResponse, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != NEW_ORDER_FULL_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    if usize::from(header.block_length) < NEW_ORDER_FULL_FIELDS_END {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: NEW_ORDER_FULL_FIELDS_END as u16,
            actual: header.block_length,
        });
    }

    cursor.require(header.block_length as usize)?;

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;
    let order_id = cursor.read_i64_le()?;
    let order_list_id = cursor.read_optional_i64_le()?;
    let transact_time = cursor.read_i64_le()?;
    let price_mantissa = cursor.read_i64_le()?;
    let orig_qty_mantissa = cursor.read_i64_le()?;
    let executed_qty_mantissa = cursor.read_i64_le()?;
    let cummulative_quote_qty_mantissa = cursor.read_i64_le()?;
    let status = cursor.read_u8()?.into();
    let time_in_force = cursor.read_u8()?.into();
    let order_type = cursor.read_u8()?.into();
    let side = cursor.read_u8()?.into();
    let stop_price_mantissa = cursor.read_optional_i64_le()?;

    cursor.advance(16)?; // Skip trailing_delta (8) + trailing_time (8)
    let working_time = cursor.read_optional_i64_le()?;

    cursor.advance(22)?; // Skip iceberg_qty to working_floor
    let self_trade_prevention_mode = cursor.read_u8()?.into();

    let expiry_reason = read_trailing_expiry_reason(
        &mut cursor,
        header.block_length as usize,
        NEW_ORDER_FULL_FIELDS_END,
        NEW_ORDER_FULL_EXPIRY_REASON_OFFSET,
    )?;

    let fills = decode_fills_cursor(&mut cursor)?;

    // Skip prevented matches group
    let (block_len, count) = cursor.read_group_header()?;
    cursor.advance(block_len as usize * count as usize)?;

    let symbol = cursor.read_var_string8()?;
    let client_order_id = cursor.read_var_string8()?;

    Ok(BinanceNewOrderResponse {
        price_exponent,
        qty_exponent,
        order_id,
        order_list_id,
        transact_time,
        price_mantissa,
        orig_qty_mantissa,
        executed_qty_mantissa,
        cummulative_quote_qty_mantissa,
        status,
        time_in_force,
        order_type,
        side,
        stop_price_mantissa,
        working_time,
        self_trade_prevention_mode,
        client_order_id,
        symbol,
        fills,
        expiry_reason,
    })
}

/// Decodes the replacement order from a successful cancel-replace response.
///
/// # Errors
///
/// Returns an error for a malformed wrapper or an unsuccessful replacement.
pub fn decode_cancel_replace(buf: &[u8]) -> Result<BinanceNewOrderResponse, SbeDecodeError> {
    let (_, replacement) = decode_cancel_replace_payloads(buf)?;
    decode_new_order_full(replacement)
}

pub(crate) fn decode_cancel_replace_orders(
    buf: &[u8],
) -> Result<(BinanceCancelOrderResponse, BinanceNewOrderResponse), SbeDecodeError> {
    let (cancellation, replacement) = decode_cancel_replace_payloads(buf)?;
    Ok((
        decode_cancel_order(cancellation)?,
        decode_new_order_full(replacement)?,
    ))
}

fn decode_cancel_replace_payloads(buf: &[u8]) -> Result<(&[u8], &[u8]), SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;
    if header.template_id != CANCEL_REPLACE_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    if header.block_length < 2 {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: 2,
            actual: header.block_length,
        });
    }
    let cancel_result = cursor.read_u8()?;
    let new_order_result = cursor.read_u8()?;
    cursor.advance(usize::from(header.block_length) - 2)?;

    if cancel_result != CancelReplaceStatus::Success as u8
        || new_order_result != CancelReplaceStatus::Success as u8
    {
        return Err(SbeDecodeError::InvalidValue {
            field: "cancel-replace result",
        });
    }
    let cancel_len = usize::from(cursor.read_u16_le()?);
    let cancellation = cursor.read_bytes(cancel_len)?;
    let new_order_len = cursor.read_u32_le()? as usize;
    let replacement = cursor.read_bytes(new_order_len)?;
    Ok((cancellation, replacement))
}

/// Decode a cancel order response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_cancel_order(buf: &[u8]) -> Result<BinanceCancelOrderResponse, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != CANCEL_ORDER_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    if usize::from(header.block_length) < CANCEL_ORDER_FIELDS_END {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: CANCEL_ORDER_FIELDS_END as u16,
            actual: header.block_length,
        });
    }

    cursor.require(header.block_length as usize)?;

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;
    let order_id = cursor.read_i64_le()?;
    let order_list_id = cursor.read_optional_i64_le()?;
    let transact_time = cursor.read_i64_le()?;
    let price_mantissa = cursor.read_i64_le()?;
    let orig_qty_mantissa = cursor.read_i64_le()?;
    let executed_qty_mantissa = cursor.read_i64_le()?;
    let cummulative_quote_qty_mantissa = cursor.read_i64_le()?;
    let status = cursor.read_u8()?.into();
    let time_in_force = cursor.read_u8()?.into();
    let order_type = cursor.read_u8()?.into();
    let side = cursor.read_u8()?.into();

    cursor.advance(46)?; // Skip stop_price to working_floor
    let self_trade_prevention_mode = cursor.read_u8()?.into();

    cursor.advance(header.block_length as usize - CANCEL_ORDER_FIELDS_END)?;

    let symbol = cursor.read_var_string8()?;
    let orig_client_order_id = cursor.read_var_string8()?;
    let client_order_id = cursor.read_var_string8()?;

    Ok(BinanceCancelOrderResponse {
        price_exponent,
        qty_exponent,
        order_id,
        order_list_id,
        transact_time,
        price_mantissa,
        orig_qty_mantissa,
        executed_qty_mantissa,
        cummulative_quote_qty_mantissa,
        status,
        time_in_force,
        order_type,
        side,
        self_trade_prevention_mode,
        client_order_id,
        orig_client_order_id,
        symbol,
    })
}

fn decode_cancel_order_list(buf: &[u8]) -> Result<BinanceCancelOrderListResponse, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != CANCEL_ORDER_LIST_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    if usize::from(header.block_length) < CANCEL_ORDER_LIST_FIELDS_END {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: CANCEL_ORDER_LIST_FIELDS_END as u16,
            actual: header.block_length,
        });
    }

    cursor.require(header.block_length as usize)?;
    let order_list_id = cursor.read_i64_le()?;
    let contingency_type = cursor.read_u8()?.into();
    let list_status_type = cursor.read_u8()?.into();
    let list_order_status = cursor.read_u8()?.into();
    let transaction_time = cursor.read_i64_le()?;
    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;
    cursor.advance(usize::from(header.block_length) - CANCEL_ORDER_LIST_FIELDS_END)?;

    let (order_block_length, order_count) = cursor.read_group_header_16()?;
    if usize::from(order_block_length) < CANCEL_ORDER_LIST_ORDER_FIELDS_END {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: CANCEL_ORDER_LIST_ORDER_FIELDS_END as u16,
            actual: order_block_length,
        });
    }

    let mut orders = Vec::with_capacity(order_count as usize);
    for _ in 0..order_count {
        cursor.require(order_block_length as usize)?;
        let order_id = cursor.read_i64_le()?;
        cursor.advance(usize::from(order_block_length) - CANCEL_ORDER_LIST_ORDER_FIELDS_END)?;
        let symbol = cursor.read_var_string8()?;
        let client_order_id = cursor.read_var_string8()?;
        orders.push(BinanceCancelOrderListOrder {
            symbol,
            order_id,
            client_order_id,
        });
    }

    let (report_block_length, report_count) = cursor.read_group_header_16()?;
    let report_min_block_length = if header.version == 0 {
        CANCEL_ORDER_LIST_REPORT_V0_BLOCK_LENGTH
    } else {
        CANCEL_ORDER_LIST_REPORT_V1_BLOCK_LENGTH
    };

    if report_block_length < report_min_block_length {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: report_min_block_length,
            actual: report_block_length,
        });
    }

    let mut order_reports = Vec::with_capacity(report_count as usize);

    for _ in 0..report_count {
        cursor.require(report_block_length as usize)?;
        let order_id = cursor.read_i64_le()?;
        let order_list_id = cursor.read_optional_i64_le()?;
        let transact_time = cursor.read_i64_le()?;
        let price_mantissa = cursor.read_i64_le()?;
        let orig_qty_mantissa = cursor.read_i64_le()?;
        let executed_qty_mantissa = cursor.read_i64_le()?;
        let cummulative_quote_qty_mantissa = cursor.read_i64_le()?;
        let status = cursor.read_u8()?.into();
        let time_in_force = cursor.read_u8()?.into();
        let order_type = cursor.read_u8()?.into();
        let side = cursor.read_u8()?.into();
        cursor.advance(46)?;
        let self_trade_prevention_mode = cursor.read_u8()?.into();
        cursor.advance(usize::from(report_block_length) - CANCEL_ORDER_LIST_REPORT_FIELDS_END)?;
        let symbol = cursor.read_var_string8()?;
        let orig_client_order_id = cursor.read_var_string8()?;
        let client_order_id = cursor.read_var_string8()?;
        order_reports.push(BinanceCancelOrderResponse {
            price_exponent,
            qty_exponent,
            order_id,
            order_list_id,
            transact_time,
            price_mantissa,
            orig_qty_mantissa,
            executed_qty_mantissa,
            cummulative_quote_qty_mantissa,
            status,
            time_in_force,
            order_type,
            side,
            self_trade_prevention_mode,
            client_order_id,
            orig_client_order_id,
            symbol,
        });
    }

    let list_client_order_id = cursor.read_var_string8()?;
    let symbol = cursor.read_var_string8()?;

    Ok(BinanceCancelOrderListResponse {
        order_list_id,
        contingency_type,
        list_status_type,
        list_order_status,
        transaction_time,
        list_client_order_id,
        symbol,
        orders,
        order_reports,
    })
}

/// Decode an order query response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_order(buf: &[u8]) -> Result<BinanceOrderResponse, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != ORDER_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    decode_order_block(&mut cursor, header.block_length)
}

/// Decode multiple orders response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_orders(buf: &[u8]) -> Result<Vec<BinanceOrderResponse>, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != ORDERS_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let (block_length, count) = cursor.read_group_header()?;
    let mut orders = Vec::with_capacity(count as usize);

    for _ in 0..count {
        orders.push(decode_order_block(&mut cursor, block_length)?);
    }

    Ok(orders)
}

/// Decodes one order fixed block plus its trailing var-strings, shared by the
/// `orderResponse` message and each `ordersResponse` group item.
fn decode_order_block(
    cursor: &mut SbeCursor<'_>,
    block_length: u16,
) -> Result<BinanceOrderResponse, SbeDecodeError> {
    if block_length < ORDER_MIN_BLOCK_LENGTH {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: ORDER_MIN_BLOCK_LENGTH,
            actual: block_length,
        });
    }

    cursor.require(block_length as usize)?;

    let price_exponent = cursor.read_i8()?;
    let qty_exponent = cursor.read_i8()?;
    let order_id = cursor.read_i64_le()?;
    let order_list_id = cursor.read_optional_i64_le()?;
    let price_mantissa = cursor.read_i64_le()?;
    let orig_qty_mantissa = cursor.read_i64_le()?;
    let executed_qty_mantissa = cursor.read_i64_le()?;
    let cummulative_quote_qty_mantissa = cursor.read_i64_le()?;
    let status = cursor.read_u8()?.into();
    let time_in_force = cursor.read_u8()?.into();
    let order_type = cursor.read_u8()?.into();
    let side = cursor.read_u8()?.into();
    let stop_price_mantissa = cursor.read_optional_i64_le()?;

    cursor.advance(16)?; // Skip trailing_delta + trailing_time
    let iceberg_qty_mantissa = cursor.read_optional_i64_le()?;
    let time = cursor.read_i64_le()?;
    let update_time = cursor.read_i64_le()?;
    let is_working = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    let working_time = cursor.read_optional_i64_le()?;
    let orig_quote_order_qty_mantissa = cursor.read_i64_le()?;

    cursor.advance(14)?; // Skip strategy_id to working_floor
    let self_trade_prevention_mode = cursor.read_u8()?.into();

    let expiry_reason = read_trailing_expiry_reason(
        cursor,
        block_length as usize,
        ORDER_FIELDS_END,
        ORDER_EXPIRY_REASON_OFFSET,
    )?;

    let symbol = cursor.read_var_string8()?;
    let client_order_id = cursor.read_var_string8()?;

    Ok(BinanceOrderResponse {
        price_exponent,
        qty_exponent,
        order_id,
        order_list_id,
        price_mantissa,
        orig_qty_mantissa,
        executed_qty_mantissa,
        cummulative_quote_qty_mantissa,
        status,
        time_in_force,
        order_type,
        side,
        stop_price_mantissa,
        iceberg_qty_mantissa,
        time,
        update_time,
        is_working,
        working_time,
        orig_quote_order_qty_mantissa,
        self_trade_prevention_mode,
        client_order_id,
        symbol,
        expiry_reason,
    })
}

/// Decode cancel open orders response.
///
/// Each item contains an embedded cancel-order or cancel-order-list SBE message.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_cancel_open_orders(
    buf: &[u8],
) -> Result<Vec<BinanceCancelOpenOrdersResponse>, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != CANCEL_OPEN_ORDERS_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    if header.block_length != 0 {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: 0,
            actual: header.block_length,
        });
    }

    let (block_length, count) = cursor.read_group_header()?;
    if block_length != 0 {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: 0,
            actual: block_length,
        });
    }

    if count == 0 {
        return Ok(Vec::new());
    }

    let mut responses = Vec::with_capacity(count as usize);

    // Each group item has block_length=0, followed by u16 length + embedded SBE message
    for _ in 0..count {
        let response_len = cursor.read_u16_le()? as usize;
        let embedded_bytes = cursor.read_bytes(response_len)?;
        let mut embedded_cursor = SbeCursor::new(embedded_bytes);
        let embedded_header = MessageHeader::decode_cursor(&mut embedded_cursor)?;
        embedded_header.validate()?;
        let response = match embedded_header.template_id {
            CANCEL_ORDER_TEMPLATE_ID => {
                BinanceCancelOpenOrdersResponse::Order(decode_cancel_order(embedded_bytes)?)
            }
            CANCEL_ORDER_LIST_TEMPLATE_ID => BinanceCancelOpenOrdersResponse::OrderList(
                decode_cancel_order_list(embedded_bytes)?,
            ),
            template_id => return Err(SbeDecodeError::UnknownTemplateId(template_id)),
        };
        responses.push(response);
    }

    Ok(responses)
}

/// Account response block length (from SBE codec).
const ACCOUNT_BLOCK_LENGTH: usize = 64;

/// Balance group item block length (from SBE codec).
const BALANCE_BLOCK_LENGTH: u16 = 17;

/// Decode account information response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_account(buf: &[u8]) -> Result<BinanceAccountInfo, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != ACCOUNT_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    cursor.require(ACCOUNT_BLOCK_LENGTH)?;

    let commission_exponent = cursor.read_i8()?;
    let maker_commission_mantissa = cursor.read_i64_le()?;
    let taker_commission_mantissa = cursor.read_i64_le()?;
    let buyer_commission_mantissa = cursor.read_i64_le()?;
    let seller_commission_mantissa = cursor.read_i64_le()?;
    let can_trade = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    let can_withdraw = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    let can_deposit = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    cursor.advance(1)?; // Skip brokered
    let require_self_trade_prevention = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    let prevent_sor = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
    let update_time = cursor.read_i64_le()?;
    let account_type_enum = AccountType::from(cursor.read_u8()?);
    cursor.advance(16)?; // Skip tradeGroupId + uid

    let account_type = account_type_enum.to_string();

    let (block_length, balance_count) = cursor.read_group_header()?;

    if block_length != BALANCE_BLOCK_LENGTH {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: BALANCE_BLOCK_LENGTH,
            actual: block_length,
        });
    }

    let mut balances = Vec::with_capacity(balance_count as usize);

    for _ in 0..balance_count {
        cursor.require(block_length as usize)?;

        let exponent = cursor.read_i8()?;
        let free_mantissa = cursor.read_i64_le()?;
        let locked_mantissa = cursor.read_i64_le()?;

        let asset = cursor.read_var_string8()?;

        balances.push(BinanceBalance {
            asset,
            free_mantissa,
            locked_mantissa,
            exponent,
        });
    }

    Ok(BinanceAccountInfo {
        commission_exponent,
        maker_commission_mantissa,
        taker_commission_mantissa,
        buyer_commission_mantissa,
        seller_commission_mantissa,
        can_trade,
        can_withdraw,
        can_deposit,
        require_self_trade_prevention,
        prevent_sor,
        update_time,
        account_type,
        balances,
    })
}

/// Account trade group item block length (from SBE codec).
const ACCOUNT_TRADE_BLOCK_LENGTH: u16 = 70;

/// Decode account trades response.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or decode error.
#[allow(dead_code)]
pub fn decode_account_trades(buf: &[u8]) -> Result<Vec<BinanceAccountTrade>, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != ACCOUNT_TRADES_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    let (block_length, trade_count) = cursor.read_group_header()?;

    if block_length != ACCOUNT_TRADE_BLOCK_LENGTH {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: ACCOUNT_TRADE_BLOCK_LENGTH,
            actual: block_length,
        });
    }

    let mut trades = Vec::with_capacity(trade_count as usize);

    for _ in 0..trade_count {
        cursor.require(block_length as usize)?;

        let price_exponent = cursor.read_i8()?;
        let qty_exponent = cursor.read_i8()?;
        let commission_exponent = cursor.read_i8()?;
        let id = cursor.read_i64_le()?;
        let order_id = cursor.read_i64_le()?;
        let order_list_id = cursor.read_optional_i64_le()?;
        let price_mantissa = cursor.read_i64_le()?;
        let qty_mantissa = cursor.read_i64_le()?;
        let quote_qty_mantissa = cursor.read_i64_le()?;
        let commission_mantissa = cursor.read_i64_le()?;
        let time = cursor.read_i64_le()?;
        let is_buyer = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
        let is_maker = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;
        let is_best_match = BoolEnum::from(cursor.read_u8()?) == BoolEnum::True;

        let symbol = cursor.read_var_string8()?;
        let commission_asset = cursor.read_var_string8()?;

        trades.push(BinanceAccountTrade {
            price_exponent,
            qty_exponent,
            commission_exponent,
            id,
            order_id,
            order_list_id,
            price_mantissa,
            qty_mantissa,
            quote_qty_mantissa,
            commission_mantissa,
            time,
            is_buyer,
            is_maker,
            is_best_match,
            symbol,
            commission_asset,
        });
    }

    Ok(trades)
}

/// Fills group item block length (from SBE codec).
const FILLS_BLOCK_LENGTH: u16 = 42;

/// Decode order fills using cursor.
fn decode_fills_cursor(
    cursor: &mut SbeCursor<'_>,
) -> Result<Vec<BinanceOrderFill>, SbeDecodeError> {
    let (block_length, count) = cursor.read_group_header()?;

    if block_length != FILLS_BLOCK_LENGTH {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: FILLS_BLOCK_LENGTH,
            actual: block_length,
        });
    }

    let mut fills = Vec::with_capacity(count as usize);

    for _ in 0..count {
        cursor.require(block_length as usize)?;

        let commission_exponent = cursor.read_i8()?;
        cursor.advance(1)?; // Skip matchType
        let price_mantissa = cursor.read_i64_le()?;
        let qty_mantissa = cursor.read_i64_le()?;
        let commission_mantissa = cursor.read_i64_le()?;
        let trade_id = cursor.read_optional_i64_le()?;
        cursor.advance(8)?; // Skip allocId

        let commission_asset = cursor.read_var_string8()?;

        fills.push(BinanceOrderFill {
            price_mantissa,
            qty_mantissa,
            commission_mantissa,
            commission_exponent,
            commission_asset,
            trade_id,
        });
    }

    Ok(fills)
}

/// Symbols group block length (from SBE codec).
const SYMBOL_BLOCK_LENGTH: usize = 19;

/// Decode exchange info response.
///
/// ExchangeInfo response contains rate limits, exchange filters, symbols, and SOR info.
/// We only decode the symbols array which contains instrument definitions.
///
/// # Errors
///
/// Returns error if buffer is too short, schema mismatch, or template ID mismatch.
///
/// # Panics
///
/// This function will panic if filter byte slices cannot be converted to fixed-size arrays,
/// which should not occur if the SBE data is well-formed.
pub fn decode_exchange_info(buf: &[u8]) -> Result<BinanceExchangeInfoSbe, SbeDecodeError> {
    let mut cursor = SbeCursor::new(buf);
    let header = MessageHeader::decode_cursor(&mut cursor)?;
    header.validate()?;

    if header.template_id != EXCHANGE_INFO_TEMPLATE_ID {
        return Err(SbeDecodeError::UnknownTemplateId(header.template_id));
    }

    // Skip rate_limits group
    let (rate_limits_block_len, rate_limits_count) = cursor.read_group_header()?;
    cursor.advance(rate_limits_block_len as usize * rate_limits_count as usize)?;

    // Skip exchange_filters group
    let (_exchange_filters_block_len, exchange_filters_count) = cursor.read_group_header()?;
    for _ in 0..exchange_filters_count {
        // Each filter is a varString8
        cursor.read_var_string8()?;
    }

    // Decode symbols group
    let (symbols_block_len, symbols_count) = cursor.read_group_header()?;

    if symbols_block_len != SYMBOL_BLOCK_LENGTH as u16 {
        return Err(SbeDecodeError::InvalidBlockLength {
            expected: SYMBOL_BLOCK_LENGTH as u16,
            actual: symbols_block_len,
        });
    }

    let mut symbols = Vec::with_capacity(symbols_count as usize);

    for _ in 0..symbols_count {
        cursor.require(SYMBOL_BLOCK_LENGTH)?;

        // Fixed fields (19 bytes)
        let status = cursor.read_u8()?;
        let base_asset_precision = cursor.read_u8()?;
        let quote_asset_precision = cursor.read_u8()?;
        let _base_commission_precision = cursor.read_u8()?;
        let _quote_commission_precision = cursor.read_u8()?;
        let order_types = cursor.read_u16_le()?;
        let iceberg_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let oco_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let oto_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let quote_order_qty_market_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let allow_trailing_stop = cursor.read_u8()? == BoolEnum::True as u8;
        let cancel_replace_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let amend_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let is_spot_trading_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let is_margin_trading_allowed = cursor.read_u8()? == BoolEnum::True as u8;
        let _default_self_trade_prevention_mode = cursor.read_u8()?;
        let _allowed_self_trade_prevention_modes = cursor.read_u8()?;
        let _peg_instructions_allowed = cursor.read_u8()?;

        let (_filters_block_len, filters_count) = cursor.read_group_header()?;
        let mut filters = BinanceSymbolFiltersSbe::default();

        for _ in 0..filters_count {
            let filter_bytes = cursor.read_var_bytes8()?;

            // Filters can have header (8 bytes) or be raw body only,
            // detect format by checking if bytes [2..4] contain a valid template_id
            let (template_id, offset) = if filter_bytes.len() >= HEADER_LENGTH + 2 {
                let potential_template = u16::from_le_bytes([filter_bytes[2], filter_bytes[3]]);
                if potential_template == PRICE_FILTER_TEMPLATE_ID
                    || potential_template == LOT_SIZE_FILTER_TEMPLATE_ID
                    || potential_template == MIN_NOTIONAL_FILTER_TEMPLATE_ID
                    || potential_template == NOTIONAL_FILTER_TEMPLATE_ID
                {
                    (potential_template, HEADER_LENGTH)
                } else {
                    let raw_template = u16::from_le_bytes([filter_bytes[0], filter_bytes[1]]);
                    (raw_template, 2)
                }
            } else if filter_bytes.len() >= 2 {
                let raw_template = u16::from_le_bytes([filter_bytes[0], filter_bytes[1]]);
                (raw_template, 2)
            } else {
                continue;
            };

            // Filter body layout: exponent(1) + min(8) + max(8) + size(8) = 25 bytes
            match template_id {
                MIN_NOTIONAL_FILTER_TEMPLATE_ID | NOTIONAL_FILTER_TEMPLATE_ID => {
                    let mut filter = SbeCursor::new(&filter_bytes[offset..]);
                    let exponent = filter.read_i8()?;
                    let min = decode_notional_amount(&mut filter, exponent)?;
                    let apply_min_to_market = decode_notional_market_flag(&mut filter)?;
                    let (max, apply_max_to_market) = if template_id == NOTIONAL_FILTER_TEMPLATE_ID {
                        (
                            Some(decode_notional_amount(&mut filter, exponent)?),
                            decode_notional_market_flag(&mut filter)?,
                        )
                    } else {
                        (None, false)
                    };

                    let avg_price_mins = u32::try_from(filter.read_i32_le()?).map_err(|_| {
                        SbeDecodeError::InvalidValue {
                            field: "avgPriceMins",
                        }
                    })?;

                    filters.notional_filters.push(BinanceNotionalFilter {
                        min,
                        max,
                        apply_min_to_market,
                        apply_max_to_market,
                        avg_price_mins,
                    });
                }
                PRICE_FILTER_TEMPLATE_ID if filter_bytes.len() >= offset + 25 => {
                    let price_exp = filter_bytes[offset] as i8;
                    let min_price = i64::from_le_bytes(
                        filter_bytes[offset + 1..offset + 9].try_into().unwrap(),
                    );
                    let max_price = i64::from_le_bytes(
                        filter_bytes[offset + 9..offset + 17].try_into().unwrap(),
                    );
                    let tick_size = i64::from_le_bytes(
                        filter_bytes[offset + 17..offset + 25].try_into().unwrap(),
                    );
                    filters.price_filter = Some(BinancePriceFilterSbe {
                        price_exponent: price_exp,
                        min_price,
                        max_price,
                        tick_size,
                    });
                }
                LOT_SIZE_FILTER_TEMPLATE_ID if filter_bytes.len() >= offset + 25 => {
                    let qty_exp = filter_bytes[offset] as i8;
                    let min_qty = i64::from_le_bytes(
                        filter_bytes[offset + 1..offset + 9].try_into().unwrap(),
                    );
                    let max_qty = i64::from_le_bytes(
                        filter_bytes[offset + 9..offset + 17].try_into().unwrap(),
                    );
                    let step_size = i64::from_le_bytes(
                        filter_bytes[offset + 17..offset + 25].try_into().unwrap(),
                    );
                    filters.lot_size_filter = Some(BinanceLotSizeFilterSbe {
                        qty_exponent: qty_exp,
                        min_qty,
                        max_qty,
                        step_size,
                    });
                }
                _ => {}
            }
        }

        // Permission sets nested group
        let (_perm_sets_block_len, perm_sets_count) = cursor.read_group_header()?;
        let mut permissions = Vec::with_capacity(perm_sets_count as usize);
        for _ in 0..perm_sets_count {
            // Permissions nested group
            let (_perms_block_len, perms_count) = cursor.read_group_header()?;
            let mut perm_set = Vec::with_capacity(perms_count as usize);
            for _ in 0..perms_count {
                let perm = cursor.read_var_string8()?;
                perm_set.push(perm);
            }
            permissions.push(perm_set);
        }

        // Variable-length strings
        let symbol = cursor.read_var_string8()?;
        let base_asset = cursor.read_var_string8()?;
        let quote_asset = cursor.read_var_string8()?;

        symbols.push(BinanceSymbolSbe {
            symbol,
            base_asset,
            quote_asset,
            base_asset_precision,
            quote_asset_precision,
            status,
            order_types,
            iceberg_allowed,
            oco_allowed,
            oto_allowed,
            quote_order_qty_market_allowed,
            allow_trailing_stop,
            cancel_replace_allowed,
            amend_allowed,
            is_spot_trading_allowed,
            is_margin_trading_allowed,
            filters,
            permissions,
        });
    }

    // Skip SOR group (we don't need it)

    Ok(BinanceExchangeInfoSbe { symbols })
}

fn decode_notional_amount(
    cursor: &mut SbeCursor<'_>,
    exponent: i8,
) -> Result<Decimal, SbeDecodeError> {
    let mantissa = cursor.read_i64_le()?;
    if exponent == i8::MIN || mantissa < 0 {
        return Err(SbeDecodeError::InvalidValue { field: "notional" });
    }
    Decimal::from_scientific(&format!("{mantissa}e{exponent}"))
        .map_err(|_| SbeDecodeError::InvalidValue { field: "notional" })
}

fn decode_notional_market_flag(cursor: &mut SbeCursor<'_>) -> Result<bool, SbeDecodeError> {
    match cursor.read_u8()? {
        value if value == BoolEnum::False as u8 => Ok(false),
        value if value == BoolEnum::True as u8 => Ok(true),
        _ => Err(SbeDecodeError::InvalidValue {
            field: "notional market flag",
        }),
    }
}

#[cfg(test)]
mod tests {
    use rstest::rstest;

    use super::*;
    use crate::spot::sbe::spot::{
        SBE_SCHEMA_VERSION, WriteBuf,
        cancel_order_response_codec::CancelOrderResponseEncoder,
        expiry_reason::ExpiryReason,
        floor::Floor,
        match_type::MatchType,
        new_order_full_response_codec::{
            NewOrderFullResponseEncoder,
            encoder::{FillsEncoder, PreventedMatchesEncoder},
        },
        order_capacity::OrderCapacity,
        order_response_codec::OrderResponseEncoder,
        order_side::OrderSide,
        order_status::OrderStatus,
        order_type::OrderType,
        orders_response_codec::{OrdersResponseEncoder, encoder::OrdersEncoder},
        self_trade_prevention_mode::SelfTradePreventionMode,
        time_in_force::TimeInForce,
    };

    fn create_header(block_length: u16, template_id: u16, schema_id: u16, version: u16) -> [u8; 8] {
        let mut buf = [0u8; 8];
        buf[0..2].copy_from_slice(&block_length.to_le_bytes());
        buf[2..4].copy_from_slice(&template_id.to_le_bytes());
        buf[4..6].copy_from_slice(&schema_id.to_le_bytes());
        buf[6..8].copy_from_slice(&version.to_le_bytes());
        buf
    }

    #[rstest]
    fn test_decode_ping_valid() {
        // Ping: block_length=0, template_id=101, schema_id=3, version=1
        let buf = create_header(0, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);
        decode_ping(&buf).unwrap();
    }

    #[rstest]
    fn test_decode_ping_buffer_too_short() {
        let buf = [0u8; 4];
        let err = decode_ping(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::BufferTooShort { .. }));
    }

    #[rstest]
    fn test_decode_ping_schema_mismatch() {
        let buf = create_header(0, PING_TEMPLATE_ID, 99, SBE_SCHEMA_VERSION);
        let err = decode_ping(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::SchemaMismatch { .. }));
    }

    #[rstest]
    fn test_decode_ping_wrong_template() {
        let buf = create_header(0, 999, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);
        let err = decode_ping(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::UnknownTemplateId(999)));
    }

    #[rstest]
    fn test_decode_server_time_valid() {
        // ServerTime: block_length=8, template_id=102, schema_id=3, version=1
        let header = create_header(
            8,
            SERVER_TIME_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );
        let timestamp: i64 = 1734300000000; // Example timestamp

        let mut buf = Vec::with_capacity(16);
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&timestamp.to_le_bytes());

        let result = decode_server_time(&buf).unwrap();
        assert_eq!(result, timestamp);
    }

    #[rstest]
    fn test_decode_server_time_buffer_too_short() {
        // Header only, missing body
        let buf = create_header(
            8,
            SERVER_TIME_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );
        let err = decode_server_time(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::BufferTooShort { .. }));
    }

    #[rstest]
    fn test_decode_server_time_wrong_template() {
        let header = create_header(8, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);
        let mut buf = Vec::with_capacity(16);
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&0i64.to_le_bytes());

        let err = decode_server_time(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::UnknownTemplateId(101)));
    }

    // Any version within the schema ID must decode. During a rollout one client sees
    // both the older version (un-migrated server) and the newer version; future
    // additive bumps must keep decoding too.
    #[rstest]
    #[case(SBE_SCHEMA_VERSION - 1)]
    #[case(SBE_SCHEMA_VERSION)]
    #[case(SBE_SCHEMA_VERSION + 1)]
    #[case(99)]
    fn test_decode_server_time_accepts_any_version(#[case] version: u16) {
        let header = create_header(8, SERVER_TIME_TEMPLATE_ID, SBE_SCHEMA_ID, version);
        let mut buf = Vec::with_capacity(16);
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&1_700_000_000_000i64.to_le_bytes());

        let result = decode_server_time(&buf).unwrap();
        assert_eq!(result, 1_700_000_000_000);
    }

    fn create_group_header(block_length: u16, count: u32) -> [u8; 6] {
        let mut buf = [0u8; 6];
        buf[0..2].copy_from_slice(&block_length.to_le_bytes());
        buf[2..6].copy_from_slice(&count.to_le_bytes());
        buf
    }

    #[rstest]
    fn test_decode_depth_valid() {
        // Depth: block_length=10, template_id=200
        let header = create_header(10, DEPTH_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Block: last_update_id (8) + price_exponent (1) + qty_exponent (1)
        let last_update_id: i64 = 123456789;
        let price_exponent: i8 = -8;
        let qty_exponent: i8 = -8;
        buf.extend_from_slice(&last_update_id.to_le_bytes());
        buf.push(price_exponent as u8);
        buf.push(qty_exponent as u8);

        // Bids group: 2 levels
        buf.extend_from_slice(&create_group_header(16, 2));
        // Bid 1: price=100000000000, qty=50000000
        buf.extend_from_slice(&100_000_000_000i64.to_le_bytes());
        buf.extend_from_slice(&50_000_000i64.to_le_bytes());
        // Bid 2: price=99900000000, qty=30000000
        buf.extend_from_slice(&99_900_000_000i64.to_le_bytes());
        buf.extend_from_slice(&30_000_000i64.to_le_bytes());

        // Asks group: 1 level
        buf.extend_from_slice(&create_group_header(16, 1));
        // Ask 1: price=100100000000, qty=25000000
        buf.extend_from_slice(&100_100_000_000i64.to_le_bytes());
        buf.extend_from_slice(&25_000_000i64.to_le_bytes());

        let depth = decode_depth(&buf).unwrap();

        assert_eq!(depth.last_update_id, 123456789);
        assert_eq!(depth.price_exponent, -8);
        assert_eq!(depth.qty_exponent, -8);
        assert_eq!(depth.bids.len(), 2);
        assert_eq!(depth.asks.len(), 1);
        assert_eq!(depth.bids[0].price_mantissa, 100_000_000_000);
        assert_eq!(depth.bids[0].qty_mantissa, 50_000_000);
        assert_eq!(depth.asks[0].price_mantissa, 100_100_000_000);
    }

    #[rstest]
    fn test_decode_depth_empty_book() {
        let header = create_header(10, DEPTH_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&0i64.to_le_bytes()); // last_update_id
        buf.push(0); // price_exponent
        buf.push(0); // qty_exponent

        // Empty bids
        buf.extend_from_slice(&create_group_header(16, 0));
        // Empty asks
        buf.extend_from_slice(&create_group_header(16, 0));

        let depth = decode_depth(&buf).unwrap();

        assert!(depth.bids.is_empty());
        assert!(depth.asks.is_empty());
    }

    #[rstest]
    fn test_decode_trades_valid() {
        // Trades: block_length=2, template_id=201
        let header = create_header(2, TRADES_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Block: price_exponent (1) + qty_exponent (1)
        let price_exponent: i8 = -8;
        let qty_exponent: i8 = -8;
        buf.push(price_exponent as u8);
        buf.push(qty_exponent as u8);

        // Trades group: 1 trade (42 bytes each)
        buf.extend_from_slice(&create_group_header(42, 1));

        // Trade: id(8) + price(8) + qty(8) + quoteQty(8) + time(8) + isBuyerMaker(1) + isBestMatch(1)
        let trade_id: i64 = 999;
        let price: i64 = 100_000_000_000;
        let qty: i64 = 10_000_000;
        let quote_qty: i64 = 1_000_000_000_000;
        let time: i64 = 1734300000000;
        let is_buyer_maker: u8 = 1; // true
        let is_best_match: u8 = 1; // true

        buf.extend_from_slice(&trade_id.to_le_bytes());
        buf.extend_from_slice(&price.to_le_bytes());
        buf.extend_from_slice(&qty.to_le_bytes());
        buf.extend_from_slice(&quote_qty.to_le_bytes());
        buf.extend_from_slice(&time.to_le_bytes());
        buf.push(is_buyer_maker);
        buf.push(is_best_match);

        let trades = decode_trades(&buf).unwrap();

        assert_eq!(trades.price_exponent, -8);
        assert_eq!(trades.qty_exponent, -8);
        assert_eq!(trades.trades.len(), 1);
        assert_eq!(trades.trades[0].id, 999);
        assert_eq!(trades.trades[0].price_mantissa, 100_000_000_000);
        assert!(trades.trades[0].is_buyer_maker);
        assert!(trades.trades[0].is_best_match);
    }

    #[rstest]
    fn test_decode_trades_empty() {
        let header = create_header(2, TRADES_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.push(0); // price_exponent
        buf.push(0); // qty_exponent

        // Empty trades group
        buf.extend_from_slice(&create_group_header(42, 0));

        let trades = decode_trades(&buf).unwrap();

        assert!(trades.trades.is_empty());
    }

    #[rstest]
    fn test_decode_agg_trades_preserves_all_fields() {
        let header = create_header(2, AGG_TRADES_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);
        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.push((-7_i8) as u8);
        buf.push((-5_i8) as u8);
        buf.extend_from_slice(&create_group_header(50, 1));
        buf.extend_from_slice(&101_i64.to_le_bytes());
        buf.extend_from_slice(&123_456_789_i64.to_le_bytes());
        buf.extend_from_slice(&765_432_i64.to_le_bytes());
        buf.extend_from_slice(&201_i64.to_le_bytes());
        buf.extend_from_slice(&207_i64.to_le_bytes());
        buf.extend_from_slice(&1_700_000_000_123_i64.to_le_bytes());
        buf.push(1);
        buf.push(0);

        let trades = decode_agg_trades(&buf).unwrap();

        assert_eq!(trades.price_exponent, -7);
        assert_eq!(trades.qty_exponent, -5);
        assert_eq!(trades.trades.len(), 1);
        assert_eq!(trades.trades[0].id, 101);
        assert_eq!(trades.trades[0].price_mantissa, 123_456_789);
        assert_eq!(trades.trades[0].qty_mantissa, 765_432);
        assert_eq!(trades.trades[0].first_trade_id, 201);
        assert_eq!(trades.trades[0].last_trade_id, 207);
        assert_eq!(trades.trades[0].time, 1_700_000_000_123);
        assert!(trades.trades[0].is_buyer_maker);
        assert!(!trades.trades[0].is_best_match);
    }

    #[rstest]
    fn test_decode_agg_trades_rejects_wrong_template() {
        let header = create_header(2, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);
        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&[0_u8; 2]);

        let error = decode_agg_trades(&buf).unwrap_err();

        assert!(matches!(error, SbeDecodeError::UnknownTemplateId(101)));
    }

    #[rstest]
    fn test_decode_depth_wrong_template() {
        let header = create_header(10, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&[0u8; 10]); // dummy block

        let err = decode_depth(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::UnknownTemplateId(101)));
    }

    #[rstest]
    fn test_decode_trades_wrong_template() {
        let header = create_header(2, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&[0u8; 2]); // dummy block

        let err = decode_trades(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::UnknownTemplateId(101)));
    }

    fn write_var_string(buf: &mut Vec<u8>, s: &str) {
        buf.push(s.len() as u8);
        buf.extend_from_slice(s.as_bytes());
    }

    fn resize_fixed_block(buf: &mut Vec<u8>, block_length: usize) {
        let current = usize::from(u16::from_le_bytes([buf[0], buf[1]]));
        let block_end = HEADER_LENGTH + current;
        let new_end = HEADER_LENGTH + block_length;

        if new_end < block_end {
            buf.drain(new_end..block_end);
        } else {
            buf.splice(block_end..block_end, vec![0u8; new_end - block_end]);
        }

        buf[0..2].copy_from_slice(&(block_length as u16).to_le_bytes());
    }

    fn build_order_response_buffer(expiry_reason: ExpiryReason) -> Vec<u8> {
        let mut bytes = vec![0u8; 256];
        let enc = OrderResponseEncoder::default().wrap(WriteBuf::new(&mut bytes), HEADER_LENGTH);
        let mut header = enc.header(0);
        let mut enc = header.parent().unwrap();
        enc.price_exponent(-2);
        enc.qty_exponent(-4);
        enc.order_id(12345);
        enc.order_list_id(99);
        enc.price(12_345);
        enc.orig_qty(25_000);
        enc.executed_qty(10_000);
        enc.cummulative_quote_qty(123_450_000);
        enc.status(OrderStatus::PartiallyFilled);
        enc.time_in_force(TimeInForce::Gtc);
        enc.order_type(OrderType::StopLossLimit);
        enc.side(OrderSide::Sell);
        enc.stop_price(12_000);
        enc.trailing_delta(100);
        enc.trailing_time(1_700_000_000_000_100);
        enc.iceberg_qty(5_000);
        enc.time(1_700_000_000_000_000);
        enc.update_time(1_700_000_000_000_200);
        enc.is_working(BoolEnum::True);
        enc.working_time(1_700_000_000_000_300);
        enc.orig_quote_order_qty(7_000);
        enc.strategy_id(42);
        enc.strategy_type(7);
        enc.order_capacity(OrderCapacity::Principal);
        enc.working_floor(Floor::Sor);
        enc.self_trade_prevention_mode(SelfTradePreventionMode::ExpireMaker);
        enc.prevented_match_id(77);
        enc.prevented_quantity(3);
        enc.used_sor(BoolEnum::True);
        enc.expiry_reason(expiry_reason);
        enc.symbol("BTCUSDT");
        enc.client_order_id("my-order-123");
        let len = HEADER_LENGTH + enc.encoded_length();
        bytes.truncate(len);
        bytes
    }

    fn expected_order_response(expiry_reason: Option<u8>) -> BinanceOrderResponse {
        BinanceOrderResponse {
            price_exponent: -2,
            qty_exponent: -4,
            order_id: 12345,
            order_list_id: Some(99),
            price_mantissa: 12_345,
            orig_qty_mantissa: 25_000,
            executed_qty_mantissa: 10_000,
            cummulative_quote_qty_mantissa: 123_450_000,
            status: OrderStatus::PartiallyFilled,
            time_in_force: TimeInForce::Gtc,
            order_type: OrderType::StopLossLimit,
            side: OrderSide::Sell,
            stop_price_mantissa: Some(12_000),
            iceberg_qty_mantissa: Some(5_000),
            time: 1_700_000_000_000_000,
            update_time: 1_700_000_000_000_200,
            is_working: true,
            working_time: Some(1_700_000_000_000_300),
            orig_quote_order_qty_mantissa: 7_000,
            self_trade_prevention_mode: SelfTradePreventionMode::ExpireMaker,
            client_order_id: "my-order-123".to_string(),
            symbol: "BTCUSDT".to_string(),
            expiry_reason,
        }
    }

    #[rstest]
    #[case::pre_v4_no_expiry_reason(162, ExpiryReason::NullVal, None)]
    #[case::v4_null_sentinel(163, ExpiryReason::NullVal, None)]
    #[case::v4_captures_value(163, ExpiryReason::UnfilledIocQuantityExpired, Some(0x05))]
    #[case::future_block_length(167, ExpiryReason::UnfilledIocQuantityExpired, Some(0x05))]
    fn test_decode_order_matches_codec(
        #[case] block_length: usize,
        #[case] expiry_reason: ExpiryReason,
        #[case] expected: Option<u8>,
    ) {
        let mut buf = build_order_response_buffer(expiry_reason);
        resize_fixed_block(&mut buf, block_length);

        let order = decode_order(&buf).unwrap();

        assert_eq!(order, expected_order_response(expected));
    }

    #[rstest]
    fn test_decode_order_rejects_short_block() {
        let mut buf = build_order_response_buffer(ExpiryReason::NullVal);
        resize_fixed_block(&mut buf, 161);

        let error = decode_order(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 162,
                actual: 161,
            }
        );
    }

    fn build_orders_response_buffer(orders: &[(i64, &str)]) -> Vec<u8> {
        let mut bytes = vec![0u8; 512];
        let enc = OrdersResponseEncoder::default().wrap(WriteBuf::new(&mut bytes), HEADER_LENGTH);
        let mut header = enc.header(0);
        let enc = header.parent().unwrap();
        let mut group = enc.orders_encoder(orders.len() as u32, OrdersEncoder::default());

        for (order_id, client_order_id) in orders {
            group.advance().unwrap();
            group.order_id(*order_id);
            group.iceberg_qty(5_000);
            group.time(order_id * 10);
            group.update_time(order_id * 10 + 1);
            group.is_working(BoolEnum::True);
            group.working_time(order_id * 10 + 2);
            group.self_trade_prevention_mode(SelfTradePreventionMode::ExpireTaker);
            group.expiry_reason(ExpiryReason::NullVal);
            group.symbol("BTCUSDT");
            group.client_order_id(client_order_id);
        }

        let enc = group.parent().unwrap();
        let len = HEADER_LENGTH + enc.encoded_length();
        bytes.truncate(len);
        bytes
    }

    #[rstest]
    fn test_decode_orders_matches_codec() {
        let expected = [(111, "order-1"), (222, "order-2")];
        let buf = build_orders_response_buffer(&expected);

        let orders = decode_orders(&buf).unwrap();

        assert_eq!(orders.len(), 2);

        for (order, (order_id, client_order_id)) in orders.iter().zip(expected) {
            assert_eq!(order.order_id, order_id);
            assert_eq!(order.iceberg_qty_mantissa, Some(5_000));
            assert_eq!(order.time, order_id * 10);
            assert_eq!(order.update_time, order_id * 10 + 1);
            assert!(order.is_working);
            assert_eq!(order.working_time, Some(order_id * 10 + 2));
            assert_eq!(
                order.self_trade_prevention_mode,
                SelfTradePreventionMode::ExpireTaker
            );
            assert_eq!(order.expiry_reason, None);
            assert_eq!(order.symbol, "BTCUSDT");
            assert_eq!(order.client_order_id, client_order_id);
        }
    }

    #[rstest]
    fn test_decode_orders_multiple() {
        // This test verifies cursor advances correctly through multiple orders
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Group header: block_length=162, count=2
        buf.extend_from_slice(&create_group_header(ORDER_MIN_BLOCK_LENGTH, 2));

        // Order 1
        let order1_start = buf.len();
        buf.push((-8i8) as u8); // price_exponent
        buf.push((-8i8) as u8); // qty_exponent
        buf.extend_from_slice(&1001i64.to_le_bytes()); // order_id
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // order_list_id (None)
        buf.extend_from_slice(&100_000_000_000i64.to_le_bytes()); // price_mantissa
        buf.extend_from_slice(&10_000_000i64.to_le_bytes()); // orig_qty
        buf.extend_from_slice(&0i64.to_le_bytes()); // executed_qty
        buf.extend_from_slice(&0i64.to_le_bytes()); // cummulative_quote_qty
        buf.push(1); // status
        buf.push(1); // time_in_force
        buf.push(1); // order_type
        buf.push(1); // side
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // stop_price (None)
        buf.extend_from_slice(&[0u8; 16]); // trailing_delta + trailing_time
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // iceberg_qty (None)
        buf.extend_from_slice(&1734300000000i64.to_le_bytes()); // time
        buf.extend_from_slice(&1734300000000i64.to_le_bytes()); // update_time
        buf.push(1); // is_working
        buf.extend_from_slice(&1734300000000i64.to_le_bytes()); // working_time
        buf.extend_from_slice(&0i64.to_le_bytes()); // orig_quote_order_qty

        // Pad to 162 bytes from order start
        while buf.len() - order1_start < ORDER_MIN_BLOCK_LENGTH as usize {
            buf.push(0);
        }
        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "order-1");

        // Order 2
        let order2_start = buf.len();
        buf.push((-8i8) as u8); // price_exponent
        buf.push((-8i8) as u8); // qty_exponent
        buf.extend_from_slice(&2002i64.to_le_bytes()); // order_id
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // order_list_id (None)
        buf.extend_from_slice(&200_000_000_000i64.to_le_bytes()); // price_mantissa
        buf.extend_from_slice(&20_000_000i64.to_le_bytes()); // orig_qty
        buf.extend_from_slice(&0i64.to_le_bytes()); // executed_qty
        buf.extend_from_slice(&0i64.to_le_bytes()); // cummulative_quote_qty
        buf.push(1); // status
        buf.push(1); // time_in_force
        buf.push(1); // order_type
        buf.push(2); // side (SELL)
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // stop_price (None)
        buf.extend_from_slice(&[0u8; 16]); // trailing_delta + trailing_time
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // iceberg_qty (None)
        buf.extend_from_slice(&1734300001000i64.to_le_bytes()); // time
        buf.extend_from_slice(&1734300001000i64.to_le_bytes()); // update_time
        buf.push(1); // is_working
        buf.extend_from_slice(&1734300001000i64.to_le_bytes()); // working_time
        buf.extend_from_slice(&0i64.to_le_bytes()); // orig_quote_order_qty

        while buf.len() - order2_start < ORDER_MIN_BLOCK_LENGTH as usize {
            buf.push(0);
        }
        write_var_string(&mut buf, "ETHUSDT");
        write_var_string(&mut buf, "order-2");

        let orders = decode_orders(&buf).unwrap();

        assert_eq!(orders.len(), 2);
        assert_eq!(orders[0].order_id, 1001);
        assert_eq!(orders[0].symbol, "BTCUSDT");
        assert_eq!(orders[0].client_order_id, "order-1");
        assert_eq!(orders[0].price_mantissa, 100_000_000_000);

        assert_eq!(orders[1].order_id, 2002);
        assert_eq!(orders[1].symbol, "ETHUSDT");
        assert_eq!(orders[1].client_order_id, "order-2");
        assert_eq!(orders[1].price_mantissa, 200_000_000_000);
    }

    #[rstest]
    fn test_decode_orders_v4_trailing_expiry_reason() {
        // Schema 3:4 appends a 1-byte expiryReason to the orders group fixed block,
        // bumping its length 162 -> 163. The decoder must read it via the runtime
        // group block_length so the symbol var-string starts at the right offset.
        const V4_BLOCK_LENGTH: u16 = 163;
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(V4_BLOCK_LENGTH, 1));

        let order_start = buf.len();
        buf.extend_from_slice(&[0u8; ORDER_MIN_BLOCK_LENGTH as usize]);
        buf.push(0xFF); // Sentinel for the new expiryReason byte (null/absent)
        assert_eq!(buf.len() - order_start, V4_BLOCK_LENGTH as usize);

        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "v4-order");

        let orders = decode_orders(&buf).unwrap();

        assert_eq!(orders.len(), 1);
        assert_eq!(orders[0].symbol, "BTCUSDT");
        assert_eq!(orders[0].client_order_id, "v4-order");
        assert!(orders[0].expiry_reason.is_none());
    }

    #[rstest]
    fn test_decode_orders_pre_v4_block_returns_no_expiry_reason() {
        // Schema 3:3 block_length is 162 (no expiryReason byte). The decoder
        // must surface `expiry_reason = None` regardless of the trailing
        // padding bytes inside the fixed block.
        const PRE_V4_BLOCK_LENGTH: u16 = ORDER_MIN_BLOCK_LENGTH;
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(PRE_V4_BLOCK_LENGTH, 1));

        // Fill the fixed block with non-zero, non-0xff padding so the previous
        // bug (returning that last byte as expiry_reason) would surface.
        buf.extend_from_slice(&[0xAAu8; PRE_V4_BLOCK_LENGTH as usize]);

        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "pre-v4-order");

        let orders = decode_orders(&buf).unwrap();
        assert!(orders[0].expiry_reason.is_none());
    }

    #[rstest]
    fn test_decode_orders_v4_captures_expiry_reason_value() {
        // Same layout as the null case, but the trailing byte carries a real
        // expiryReason value (0x05 = UnfilledIocQuantityExpired). The decoder
        // must surface it on the parsed `BinanceOrderResponse`.
        const V4_BLOCK_LENGTH: u16 = 163;
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(V4_BLOCK_LENGTH, 1));

        buf.extend_from_slice(&[0u8; ORDER_MIN_BLOCK_LENGTH as usize]);
        buf.push(0x05);

        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "v4-expired");

        let orders = decode_orders(&buf).unwrap();
        assert_eq!(orders[0].expiry_reason, Some(0x05));
    }

    #[rstest]
    fn test_decode_orders_empty() {
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(ORDER_MIN_BLOCK_LENGTH, 0));

        let orders = decode_orders(&buf).unwrap();
        assert!(orders.is_empty());
    }

    #[rstest]
    fn test_decode_orders_truncated_var_string() {
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(ORDER_MIN_BLOCK_LENGTH, 1));

        // Pad fixed block to 162 bytes
        buf.extend_from_slice(&[0u8; ORDER_MIN_BLOCK_LENGTH as usize]);

        // Symbol length says 7 bytes but we only provide 3
        buf.push(7); // Length prefix claims "BTCUSDT" (7 chars)
        buf.extend_from_slice(b"BTC"); // Only 3 bytes - truncated

        let err = decode_orders(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::BufferTooShort { .. }));
    }

    #[rstest]
    fn test_decode_orders_invalid_utf8() {
        let header = create_header(0, ORDERS_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(ORDER_MIN_BLOCK_LENGTH, 1));

        buf.extend_from_slice(&[0u8; ORDER_MIN_BLOCK_LENGTH as usize]);

        // Invalid UTF-8 sequence
        buf.push(4);
        buf.extend_from_slice(&[0xFF, 0xFE, 0x00, 0x01]);

        let err = decode_orders(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::InvalidUtf8));
    }

    #[rstest]
    #[case::current(137)]
    #[case::future_block_length(141)]
    fn test_decode_cancel_order_matches_codec(#[case] block_length: usize) {
        let mut buf = create_cancel_order_response_buffer(99999, "BTCUSDT", "orig-id", "new-id");
        resize_fixed_block(&mut buf, block_length);

        let cancel = decode_cancel_order(&buf).unwrap();

        assert_eq!(cancel.order_id, 99999);
        assert!(cancel.order_list_id.is_none());
        assert_eq!(cancel.transact_time, 1_700_000_000_000_000);
        assert_eq!(cancel.status, OrderStatus::Canceled);
        assert_eq!(
            cancel.self_trade_prevention_mode,
            SelfTradePreventionMode::ExpireTaker
        );
        assert_eq!(cancel.symbol, "BTCUSDT");
        assert_eq!(cancel.orig_client_order_id, "orig-id");
        assert_eq!(cancel.client_order_id, "new-id");
    }

    #[rstest]
    fn test_decode_account_with_balances() {
        let header = create_header(
            ACCOUNT_BLOCK_LENGTH as u16,
            ACCOUNT_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Fixed block (64 bytes)
        buf.push((-8i8) as u8); // commission_exponent
        buf.extend_from_slice(&100_000i64.to_le_bytes()); // maker_commission
        buf.extend_from_slice(&100_000i64.to_le_bytes()); // taker_commission
        buf.extend_from_slice(&0i64.to_le_bytes()); // buyer_commission
        buf.extend_from_slice(&0i64.to_le_bytes()); // seller_commission
        buf.push(1); // can_trade
        buf.push(1); // can_withdraw
        buf.push(1); // can_deposit
        buf.push(0); // brokered
        buf.push(0); // require_self_trade_prevention
        buf.push(0); // prevent_sor
        buf.extend_from_slice(&1734300000000i64.to_le_bytes()); // update_time
        buf.push(1); // account_type (SPOT)

        // Pad to 64 bytes
        while buf.len() < 8 + ACCOUNT_BLOCK_LENGTH {
            buf.push(0);
        }

        // Balances group: 2 balances
        buf.extend_from_slice(&create_group_header(BALANCE_BLOCK_LENGTH, 2));

        // Balance 1: BTC
        buf.push((-8i8) as u8); // exponent
        buf.extend_from_slice(&100_000_000i64.to_le_bytes()); // free (1.0 BTC)
        buf.extend_from_slice(&50_000_000i64.to_le_bytes()); // locked (0.5 BTC)
        write_var_string(&mut buf, "BTC");

        // Balance 2: USDT
        buf.push((-8i8) as u8); // exponent
        buf.extend_from_slice(&1_000_000_000_000i64.to_le_bytes()); // free (10000 USDT)
        buf.extend_from_slice(&0i64.to_le_bytes()); // locked
        write_var_string(&mut buf, "USDT");

        let account = decode_account(&buf).unwrap();

        assert!(account.can_trade);
        assert!(account.can_withdraw);
        assert!(account.can_deposit);
        assert_eq!(account.balances.len(), 2);
        assert_eq!(account.balances[0].asset, "BTC");
        assert_eq!(account.balances[0].free_mantissa, 100_000_000);
        assert_eq!(account.balances[0].locked_mantissa, 50_000_000);
        assert_eq!(account.balances[1].asset, "USDT");
        assert_eq!(account.balances[1].free_mantissa, 1_000_000_000_000);
    }

    #[rstest]
    fn test_decode_account_empty_balances() {
        let header = create_header(
            ACCOUNT_BLOCK_LENGTH as u16,
            ACCOUNT_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Minimal fixed block
        buf.push((-8i8) as u8);
        buf.extend_from_slice(&[0u8; 63]); // Rest of fixed block

        // Empty balances group
        buf.extend_from_slice(&create_group_header(BALANCE_BLOCK_LENGTH, 0));

        let account = decode_account(&buf).unwrap();
        assert!(account.balances.is_empty());
    }

    #[rstest]
    fn test_decode_account_trades_multiple() {
        let header = create_header(
            0,
            ACCOUNT_TRADES_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Group header: 2 trades
        buf.extend_from_slice(&create_group_header(ACCOUNT_TRADE_BLOCK_LENGTH, 2));

        // Trade 1
        buf.push((-8i8) as u8); // price_exponent
        buf.push((-8i8) as u8); // qty_exponent
        buf.push((-8i8) as u8); // commission_exponent
        buf.extend_from_slice(&1001i64.to_le_bytes()); // id
        buf.extend_from_slice(&5001i64.to_le_bytes()); // order_id
        buf.extend_from_slice(&i64::MIN.to_le_bytes()); // order_list_id (None)
        buf.extend_from_slice(&100_000_000_000i64.to_le_bytes()); // price
        buf.extend_from_slice(&10_000_000i64.to_le_bytes()); // qty
        buf.extend_from_slice(&1_000_000_000_000i64.to_le_bytes()); // quote_qty
        buf.extend_from_slice(&100_000i64.to_le_bytes()); // commission
        buf.extend_from_slice(&1734300000000i64.to_le_bytes()); // time
        buf.push(1); // is_buyer
        buf.push(0); // is_maker
        buf.push(1); // is_best_match
        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "BNB");

        // Trade 2
        buf.push((-8i8) as u8);
        buf.push((-8i8) as u8);
        buf.push((-8i8) as u8);
        buf.extend_from_slice(&1002i64.to_le_bytes());
        buf.extend_from_slice(&5002i64.to_le_bytes());
        buf.extend_from_slice(&i64::MIN.to_le_bytes());
        buf.extend_from_slice(&200_000_000_000i64.to_le_bytes());
        buf.extend_from_slice(&5_000_000i64.to_le_bytes());
        buf.extend_from_slice(&1_000_000_000_000i64.to_le_bytes());
        buf.extend_from_slice(&50_000i64.to_le_bytes());
        buf.extend_from_slice(&1734300001000i64.to_le_bytes());
        buf.push(0); // is_buyer (false = seller)
        buf.push(1); // is_maker
        buf.push(1); // is_best_match
        write_var_string(&mut buf, "ETHUSDT");
        write_var_string(&mut buf, "USDT");

        let trades = decode_account_trades(&buf).unwrap();

        assert_eq!(trades.len(), 2);
        assert_eq!(trades[0].id, 1001);
        assert_eq!(trades[0].order_id, 5001);
        assert!(trades[0].order_list_id.is_none());
        assert_eq!(trades[0].symbol, "BTCUSDT");
        assert_eq!(trades[0].commission_asset, "BNB");
        assert!(trades[0].is_buyer);
        assert!(!trades[0].is_maker);

        assert_eq!(trades[1].id, 1002);
        assert_eq!(trades[1].symbol, "ETHUSDT");
        assert_eq!(trades[1].commission_asset, "USDT");
        assert!(!trades[1].is_buyer);
        assert!(trades[1].is_maker);
    }

    #[rstest]
    fn test_decode_account_trades_empty() {
        let header = create_header(
            0,
            ACCOUNT_TRADES_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.extend_from_slice(&create_group_header(ACCOUNT_TRADE_BLOCK_LENGTH, 0));

        let trades = decode_account_trades(&buf).unwrap();
        assert!(trades.is_empty());
    }

    #[rstest]
    fn test_decode_exchange_info_single_symbol() {
        let header = create_header(
            0,
            EXCHANGE_INFO_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Empty rate_limits group
        buf.extend_from_slice(&create_group_header(11, 0));

        // Empty exchange_filters group
        buf.extend_from_slice(&create_group_header(0, 0));

        // Symbols group: 1 symbol with block_length=19
        buf.extend_from_slice(&create_group_header(SYMBOL_BLOCK_LENGTH as u16, 1));

        // Fixed block (19 bytes)
        buf.push(0); // status (Trading)
        buf.push(8); // base_asset_precision
        buf.push(8); // quote_asset_precision
        buf.push(8); // base_commission_precision
        buf.push(8); // quote_commission_precision
        buf.extend_from_slice(&0b0000_0111u16.to_le_bytes()); // order_types (MARKET|LIMIT|STOP_LOSS)
        buf.push(1); // iceberg_allowed (True)
        buf.push(1); // oco_allowed (True)
        buf.push(0); // oto_allowed (False)
        buf.push(1); // quote_order_qty_market_allowed (True)
        buf.push(1); // allow_trailing_stop (True)
        buf.push(1); // cancel_replace_allowed (True)
        buf.push(0); // amend_allowed (False)
        buf.push(1); // is_spot_trading_allowed (True)
        buf.push(0); // is_margin_trading_allowed (False)
        buf.push(0); // default_self_trade_prevention_mode
        buf.push(0); // allowed_self_trade_prevention_modes
        buf.push(0); // peg_instructions_allowed

        // Filters nested group: 0 filters (SBE binary filters are skipped)
        buf.extend_from_slice(&create_group_header(0, 0));

        // Permission sets nested group: 1 set with 1 permission
        buf.extend_from_slice(&create_group_header(0, 1));
        buf.extend_from_slice(&create_group_header(0, 1));
        write_var_string(&mut buf, "SPOT");

        // Variable-length strings
        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "BTC");
        write_var_string(&mut buf, "USDT");

        let info = decode_exchange_info(&buf).unwrap();

        assert_eq!(info.symbols.len(), 1);
        let symbol = &info.symbols[0];
        assert_eq!(symbol.symbol, "BTCUSDT");
        assert_eq!(symbol.base_asset, "BTC");
        assert_eq!(symbol.quote_asset, "USDT");
        assert_eq!(symbol.base_asset_precision, 8);
        assert_eq!(symbol.quote_asset_precision, 8);
        assert_eq!(symbol.status, 0); // Trading
        assert_eq!(symbol.order_types, 0b0000_0111);
        assert!(symbol.iceberg_allowed);
        assert!(symbol.oco_allowed);
        assert!(!symbol.oto_allowed);
        assert!(symbol.quote_order_qty_market_allowed);
        assert!(symbol.allow_trailing_stop);
        assert!(symbol.cancel_replace_allowed);
        assert!(!symbol.amend_allowed);
        assert!(symbol.is_spot_trading_allowed);
        assert!(!symbol.is_margin_trading_allowed);
        assert!(symbol.filters.price_filter.is_none()); // No filters in test data
        assert!(symbol.filters.lot_size_filter.is_none());
        assert_eq!(symbol.permissions.len(), 1);
        assert_eq!(symbol.permissions[0], vec!["SPOT"]);
    }

    #[rstest]
    #[case::exponent(0, 128, "notional")]
    #[case::minimum(8, 255, "notional")]
    #[case::min_flag(9, 255, "notional market flag")]
    #[case::maximum(17, 255, "notional")]
    #[case::max_flag(18, 255, "notional market flag")]
    #[case::average(22, 255, "avgPriceMins")]
    fn test_spot_notional_sbe_invalid_fields(
        #[case] offset: usize,
        #[case] value: u8,
        #[case] field: &'static str,
    ) {
        let mut wire =
            include_bytes!("../../../test_data/spot/http_sbe/notional_range.sbe").to_vec();
        let header = [23, 0, 6, 0, 3, 0, 5, 0];
        let start = wire
            .windows(header.len())
            .position(|bytes| bytes == header)
            .unwrap();
        wire[start + header.len() + offset] = value;
        assert!(
            matches!(decode_exchange_info(&wire), Err(SbeDecodeError::InvalidValue { field: actual }) if actual == field)
        );
    }

    #[rstest]
    fn test_spot_notional_sbe_truncated_filter() {
        let mut wire =
            include_bytes!("../../../test_data/spot/http_sbe/notional_range.sbe").to_vec();
        let header = [23, 0, 6, 0, 3, 0, 5, 0];
        let start = wire
            .windows(header.len())
            .position(|bytes| bytes == header)
            .unwrap();
        wire[start - 1] -= 1;
        assert!(matches!(
            decode_exchange_info(&wire),
            Err(SbeDecodeError::BufferTooShort {
                expected: 23,
                actual: 22
            })
        ));
    }

    #[rstest]
    fn test_decode_exchange_info_empty() {
        let header = create_header(
            0,
            EXCHANGE_INFO_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Empty rate_limits group
        buf.extend_from_slice(&create_group_header(11, 0));

        // Empty exchange_filters group
        buf.extend_from_slice(&create_group_header(0, 0));

        // Empty symbols group
        buf.extend_from_slice(&create_group_header(SYMBOL_BLOCK_LENGTH as u16, 0));

        let info = decode_exchange_info(&buf).unwrap();
        assert!(info.symbols.is_empty());
    }

    #[rstest]
    fn test_decode_exchange_info_wrong_template() {
        let header = create_header(0, PING_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        let err = decode_exchange_info(&buf).unwrap_err();
        assert!(matches!(err, SbeDecodeError::UnknownTemplateId(101)));
    }

    #[rstest]
    fn test_decode_exchange_info_multiple_symbols() {
        let header = create_header(
            0,
            EXCHANGE_INFO_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        );

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);

        // Empty rate_limits group
        buf.extend_from_slice(&create_group_header(11, 0));

        // Empty exchange_filters group
        buf.extend_from_slice(&create_group_header(0, 0));

        // Symbols group: 2 symbols
        buf.extend_from_slice(&create_group_header(SYMBOL_BLOCK_LENGTH as u16, 2));

        // Symbol 1: BTCUSDT
        buf.push(0); // status
        buf.push(8); // base_asset_precision
        buf.push(8); // quote_asset_precision
        buf.push(8); // base_commission_precision
        buf.push(8); // quote_commission_precision
        buf.extend_from_slice(&0b0000_0011u16.to_le_bytes()); // order_types
        buf.push(1); // iceberg_allowed
        buf.push(1); // oco_allowed
        buf.push(0); // oto_allowed
        buf.push(1); // quote_order_qty_market_allowed
        buf.push(1); // allow_trailing_stop
        buf.push(1); // cancel_replace_allowed
        buf.push(0); // amend_allowed
        buf.push(1); // is_spot_trading_allowed
        buf.push(0); // is_margin_trading_allowed
        buf.push(0); // default_self_trade_prevention_mode
        buf.push(0); // allowed_self_trade_prevention_modes
        buf.push(0); // peg_instructions_allowed
        buf.extend_from_slice(&create_group_header(0, 0)); // No filters
        buf.extend_from_slice(&create_group_header(0, 0)); // No permission sets
        write_var_string(&mut buf, "BTCUSDT");
        write_var_string(&mut buf, "BTC");
        write_var_string(&mut buf, "USDT");

        // Symbol 2: ETHUSDT
        buf.push(0); // status
        buf.push(8); // base_asset_precision
        buf.push(8); // quote_asset_precision
        buf.push(8); // base_commission_precision
        buf.push(8); // quote_commission_precision
        buf.extend_from_slice(&0b0000_0011u16.to_le_bytes()); // order_types
        buf.push(1); // iceberg_allowed
        buf.push(1); // oco_allowed
        buf.push(0); // oto_allowed
        buf.push(1); // quote_order_qty_market_allowed
        buf.push(1); // allow_trailing_stop
        buf.push(1); // cancel_replace_allowed
        buf.push(0); // amend_allowed
        buf.push(1); // is_spot_trading_allowed
        buf.push(1); // is_margin_trading_allowed
        buf.push(0); // default_self_trade_prevention_mode
        buf.push(0); // allowed_self_trade_prevention_modes
        buf.push(0); // peg_instructions_allowed
        buf.extend_from_slice(&create_group_header(0, 0)); // No filters
        buf.extend_from_slice(&create_group_header(0, 0)); // No permission sets
        write_var_string(&mut buf, "ETHUSDT");
        write_var_string(&mut buf, "ETH");
        write_var_string(&mut buf, "USDT");

        let info = decode_exchange_info(&buf).unwrap();

        assert_eq!(info.symbols.len(), 2);
        assert_eq!(info.symbols[0].symbol, "BTCUSDT");
        assert_eq!(info.symbols[0].base_asset, "BTC");
        assert!(!info.symbols[0].is_margin_trading_allowed);

        assert_eq!(info.symbols[1].symbol, "ETHUSDT");
        assert_eq!(info.symbols[1].base_asset, "ETH");
        assert!(info.symbols[1].is_margin_trading_allowed);
    }

    #[rstest]
    fn test_decode_klines_valid() {
        let header = create_header(2, KLINES_TEMPLATE_ID, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION);

        let mut buf = Vec::new();
        buf.extend_from_slice(&header);
        buf.push((-2i8) as u8); // price_exponent
        buf.push((-4i8) as u8); // qty_exponent
        buf.extend_from_slice(&create_group_header(KLINES_BLOCK_LENGTH, 1));
        buf.extend_from_slice(&1_700_000_000_000_000i64.to_le_bytes()); // open_time (micros)
        buf.extend_from_slice(&12_000i64.to_le_bytes()); // open_price
        buf.extend_from_slice(&12_500i64.to_le_bytes()); // high_price
        buf.extend_from_slice(&11_900i64.to_le_bytes()); // low_price
        buf.extend_from_slice(&12_345i64.to_le_bytes()); // close_price
        buf.extend_from_slice(&1_234_500i128.to_le_bytes()); // volume
        buf.extend_from_slice(&1_700_000_059_999_000i64.to_le_bytes()); // close_time (micros)
        buf.extend_from_slice(&2_345_600i128.to_le_bytes()); // quote_volume
        buf.extend_from_slice(&100i64.to_le_bytes()); // num_trades
        buf.extend_from_slice(&600_000i128.to_le_bytes()); // taker_buy_base_volume
        buf.extend_from_slice(&1_200_000i128.to_le_bytes()); // taker_buy_quote_volume

        let klines = decode_klines(&buf).unwrap();

        assert_eq!(klines.price_exponent, -2);
        assert_eq!(klines.qty_exponent, -4);
        assert_eq!(klines.klines.len(), 1);
        assert_eq!(klines.klines[0].open_time, 1_700_000_000_000_000);
        assert_eq!(klines.klines[0].close_price, 12_345);
        assert_eq!(i128::from_le_bytes(klines.klines[0].volume), 1_234_500);
        assert_eq!(klines.klines[0].num_trades, 100);
    }

    fn build_new_order_full_buffer(expiry_reason: ExpiryReason) -> Vec<u8> {
        let mut bytes = vec![0u8; 512];
        let enc =
            NewOrderFullResponseEncoder::default().wrap(WriteBuf::new(&mut bytes), HEADER_LENGTH);
        let mut header = enc.header(0);
        let mut enc = header.parent().unwrap();
        enc.price_exponent(-2);
        enc.qty_exponent(-4);
        enc.order_id(12345);
        enc.order_list_id(99);
        enc.transact_time(1_700_000_000_000_000);
        enc.price(12_345);
        enc.orig_qty(25_000);
        enc.executed_qty(10_000);
        enc.cummulative_quote_qty(123_450_000);
        enc.status(OrderStatus::PartiallyFilled);
        enc.time_in_force(TimeInForce::Gtc);
        enc.order_type(OrderType::Limit);
        enc.side(OrderSide::Buy);
        enc.stop_price(12_000);
        enc.working_time(1_700_000_000_000_500);
        enc.iceberg_qty(5_000);
        enc.order_capacity(OrderCapacity::Principal);
        enc.working_floor(Floor::Sor);
        enc.self_trade_prevention_mode(SelfTradePreventionMode::ExpireMaker);
        enc.trade_group_id(1);
        enc.used_sor(BoolEnum::True);
        enc.expiry_reason(expiry_reason);
        let mut fills = enc.fills_encoder(1, FillsEncoder::default());
        fills.advance().unwrap();
        fills.commission_exponent(-8);
        fills.match_type(MatchType::AutoMatch);
        fills.price(12_345);
        fills.qty(10_000);
        fills.commission(10_000);
        fills.trade_id(555);
        fills.alloc_id(i64::MIN);
        fills.commission_asset("USDT");
        let enc = fills.parent().unwrap();
        let mut prevented = enc.prevented_matches_encoder(0, PreventedMatchesEncoder::default());
        let mut enc = prevented.parent().unwrap();
        enc.symbol("ETHUSDT");
        enc.client_order_id("client-456");
        let len = HEADER_LENGTH + enc.encoded_length();
        bytes.truncate(len);
        bytes
    }

    #[rstest]
    #[case::pre_v4_no_expiry_reason(153, ExpiryReason::NullVal, None)]
    #[case::v4_null_sentinel(154, ExpiryReason::NullVal, None)]
    #[case::v4_captures_value(154, ExpiryReason::UnfilledIocQuantityExpired, Some(0x05))]
    #[case::future_block_length(158, ExpiryReason::UnfilledIocQuantityExpired, Some(0x05))]
    fn test_decode_new_order_full_matches_codec(
        #[case] block_length: usize,
        #[case] expiry_reason: ExpiryReason,
        #[case] expected: Option<u8>,
    ) {
        let mut buf = build_new_order_full_buffer(expiry_reason);
        resize_fixed_block(&mut buf, block_length);

        let response = decode_new_order_full(&buf).unwrap();

        assert_eq!(response.order_id, 12345);
        assert_eq!(response.order_list_id, Some(99));
        assert_eq!(response.transact_time, 1_700_000_000_000_000);
        assert_eq!(response.price_mantissa, 12_345);
        assert_eq!(response.orig_qty_mantissa, 25_000);
        assert_eq!(response.executed_qty_mantissa, 10_000);
        assert_eq!(response.status, OrderStatus::PartiallyFilled);
        assert_eq!(response.stop_price_mantissa, Some(12_000));
        assert_eq!(response.working_time, Some(1_700_000_000_000_500));
        assert_eq!(
            response.self_trade_prevention_mode,
            SelfTradePreventionMode::ExpireMaker
        );
        assert_eq!(response.expiry_reason, expected);
        assert_eq!(response.symbol, "ETHUSDT");
        assert_eq!(response.client_order_id, "client-456");
        assert_eq!(response.fills.len(), 1);
        assert_eq!(response.fills[0].price_mantissa, 12_345);
        assert_eq!(response.fills[0].qty_mantissa, 10_000);
        assert_eq!(response.fills[0].trade_id, Some(555));
        assert_eq!(response.fills[0].commission_asset, "USDT");
    }

    #[rstest]
    fn test_decode_new_order_full_rejects_short_block() {
        let mut buf = build_new_order_full_buffer(ExpiryReason::NullVal);
        resize_fixed_block(&mut buf, 116);

        let error = decode_new_order_full(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 117,
                actual: 116,
            }
        );
    }

    #[rstest]
    #[case::current(2)]
    #[case::extended(5)]
    fn test_decode_cancel_replace_nested_order(#[case] block_length: u16) {
        let nested = build_new_order_full_buffer(ExpiryReason::NullVal);
        let mut buf = create_header(
            block_length,
            CANCEL_REPLACE_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        )
        .to_vec();
        buf.resize(HEADER_LENGTH + usize::from(block_length), 0);
        buf.extend_from_slice(&3_u16.to_le_bytes());
        buf.extend_from_slice(&[11, 22, 33]);
        buf.extend_from_slice(&(nested.len() as u32).to_le_bytes());
        buf.extend_from_slice(&nested);

        let response = decode_cancel_replace(&buf).unwrap();
        let expected = decode_new_order_full(&nested).unwrap();
        assert_eq!(response, expected);

        for end in 0..buf.len() {
            assert!(
                decode_cancel_replace(&buf[..end]).is_err(),
                "Accepted truncated response at {end}"
            );
        }
        buf[HEADER_LENGTH + 1] = CancelReplaceStatus::Failure as u8;
        assert!(matches!(
            decode_cancel_replace(&buf),
            Err(SbeDecodeError::InvalidValue {
                field: "cancel-replace result"
            })
        ));
    }

    #[rstest]
    fn test_decode_cancel_open_orders_valid() {
        let response_one = create_cancel_order_response_buffer(111, "ETHUSDT", "orig-1", "new-1");
        let response_two = create_cancel_order_response_buffer(222, "BTCUSDT", "orig-2", "new-2");
        let buf = create_cancel_open_orders_buffer(&[response_one, response_two]);
        let responses = decode_cancel_open_orders(&buf).unwrap();

        assert_eq!(responses.len(), 2);
        let BinanceCancelOpenOrdersResponse::Order(first) = &responses[0] else {
            panic!("Expected ordinary cancel response");
        };
        assert_eq!(first.order_id, 111);
        assert_eq!(first.symbol, "ETHUSDT");
        assert_eq!(first.orig_client_order_id, "orig-1");
        assert_eq!(first.client_order_id, "new-1");
        let BinanceCancelOpenOrdersResponse::Order(second) = &responses[1] else {
            panic!("Expected ordinary cancel response");
        };
        assert_eq!(second.order_id, 222);
        assert_eq!(second.symbol, "BTCUSDT");
        assert_eq!(second.orig_client_order_id, "orig-2");
        assert_eq!(second.client_order_id, "new-2");
    }

    #[rstest]
    fn test_decode_cancel_open_orders_empty() {
        let buf = create_cancel_open_orders_buffer(&[]);

        let responses = decode_cancel_open_orders(&buf).unwrap();

        assert!(responses.is_empty());
    }

    #[rstest]
    fn test_decode_cancel_open_orders_order_list() {
        let order_list = create_cancel_order_list_response_buffer();
        let buf = create_cancel_open_orders_buffer(&[order_list]);

        let responses = decode_cancel_open_orders(&buf).unwrap();

        let BinanceCancelOpenOrdersResponse::OrderList(response) = &responses[0] else {
            panic!("Expected order-list cancel response");
        };
        assert_eq!(response.order_list_id, 44);
        assert_eq!(response.symbol, "BTCUSDT");
        assert_eq!(response.list_client_order_id, "list-44");
        assert_eq!(response.orders.len(), 2);
        assert_eq!(response.orders[0].order_id, 111);
        assert_eq!(response.orders[0].client_order_id, "orig-1");
        assert_eq!(response.orders[1].order_id, 222);
        assert_eq!(response.orders[1].client_order_id, "orig-2");
        assert_eq!(response.order_reports.len(), 2);
        assert_eq!(response.order_reports[0].order_id, 111);
        assert_eq!(response.order_reports[0].order_list_id, Some(44));
        assert_eq!(response.order_reports[0].orig_client_order_id, "orig-1");
        assert_eq!(response.order_reports[1].order_id, 222);
        assert_eq!(response.order_reports[1].orig_client_order_id, "orig-2");
    }

    #[rstest]
    fn test_decode_cancel_open_orders_mixed() {
        let order = create_cancel_order_response_buffer(333, "BTCUSDT", "orig-3", "new-3");
        let order_list = create_cancel_order_list_response_buffer();
        let buf = create_cancel_open_orders_buffer(&[order, order_list]);

        let responses = decode_cancel_open_orders(&buf).unwrap();

        assert!(matches!(
            responses[0],
            BinanceCancelOpenOrdersResponse::Order(_)
        ));
        assert!(matches!(
            responses[1],
            BinanceCancelOpenOrdersResponse::OrderList(_)
        ));
    }

    #[rstest]
    fn test_decode_cancel_open_orders_unknown_embedded_template() {
        let unknown = create_header(0, 999, SBE_SCHEMA_ID, SBE_SCHEMA_VERSION).to_vec();
        let buf = create_cancel_open_orders_buffer(&[unknown]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(error, SbeDecodeError::UnknownTemplateId(999));
    }

    #[rstest]
    fn test_decode_cancel_open_orders_truncated_item() {
        let mut order_list = create_cancel_order_list_response_buffer();
        order_list.pop();
        let buf = create_cancel_open_orders_buffer(&[order_list]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert!(matches!(error, SbeDecodeError::BufferTooShort { .. }));
    }

    #[rstest]
    fn test_decode_cancel_open_orders_rejects_group_item_block() {
        let mut buf = create_cancel_open_orders_buffer(&[]);
        buf[8..10].copy_from_slice(&1u16.to_le_bytes());

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 0,
                actual: 1,
            }
        );
    }

    #[rstest]
    fn test_decode_cancel_open_orders_rejects_short_order_list_block() {
        let mut order_list = create_cancel_order_list_response_buffer();
        order_list[0..2].copy_from_slice(&20u16.to_le_bytes());
        let buf = create_cancel_open_orders_buffer(&[order_list]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 21,
                actual: 20,
            }
        );
    }

    #[rstest]
    fn test_decode_cancel_open_orders_rejects_short_order_block() {
        let mut order = create_cancel_order_response_buffer(111, "BTCUSDT", "orig-1", "new-1");
        order[0..2].copy_from_slice(&108u16.to_le_bytes());
        let buf = create_cancel_open_orders_buffer(&[order]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 109,
                actual: 108,
            }
        );
    }

    #[rstest]
    fn test_decode_cancel_open_orders_rejects_short_order_report_block() {
        let mut order_list = create_cancel_order_list_response_buffer();
        let report_header = order_list
            .windows(4)
            .position(|window| window == [135, 0, 2, 0])
            .unwrap();
        order_list[report_header..report_header + 2].copy_from_slice(&134u16.to_le_bytes());
        let buf = create_cancel_open_orders_buffer(&[order_list]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(
            error,
            SbeDecodeError::InvalidBlockLength {
                expected: 135,
                actual: 134,
            }
        );
    }

    #[rstest]
    fn test_decode_cancel_open_orders_rejects_invalid_utf8() {
        let mut order_list = create_cancel_order_list_response_buffer();
        let symbol_start = order_list
            .windows(b"BTCUSDT".len())
            .position(|window| window == b"BTCUSDT")
            .unwrap();
        order_list[symbol_start] = 0xff;
        let buf = create_cancel_open_orders_buffer(&[order_list]);

        let error = decode_cancel_open_orders(&buf).unwrap_err();

        assert_eq!(error, SbeDecodeError::InvalidUtf8);
    }

    fn create_cancel_order_response_buffer(
        order_id: i64,
        symbol: &str,
        orig_client_order_id: &str,
        client_order_id: &str,
    ) -> Vec<u8> {
        let mut bytes = vec![0u8; 256];
        let enc =
            CancelOrderResponseEncoder::default().wrap(WriteBuf::new(&mut bytes), HEADER_LENGTH);
        let mut header = enc.header(0);
        let mut enc = header.parent().unwrap();
        enc.price_exponent(-8);
        enc.qty_exponent(-8);
        enc.order_id(order_id);
        enc.order_list_id(i64::MIN);
        enc.transact_time(1_700_000_000_000_000);
        enc.price(100_000_000_000);
        enc.orig_qty(10_000_000);
        enc.executed_qty(10_000_000);
        enc.cummulative_quote_qty(1_000_000_000);
        enc.status(OrderStatus::Canceled);
        enc.time_in_force(TimeInForce::Gtc);
        enc.order_type(OrderType::Limit);
        enc.side(OrderSide::Buy);
        enc.stop_price(3);
        enc.self_trade_prevention_mode(SelfTradePreventionMode::ExpireTaker);
        enc.symbol(symbol);
        enc.orig_client_order_id(orig_client_order_id);
        enc.client_order_id(client_order_id);
        let len = HEADER_LENGTH + enc.encoded_length();
        bytes.truncate(len);
        bytes
    }

    fn create_cancel_order_list_response_buffer() -> Vec<u8> {
        const REPORT_BLOCK_LENGTH: usize = 135;

        let mut buf = Vec::new();
        buf.extend_from_slice(&create_header(
            CANCEL_ORDER_LIST_FIELDS_END as u16,
            CANCEL_ORDER_LIST_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        ));
        buf.extend_from_slice(&44i64.to_le_bytes());
        buf.push(1); // contingency_type (OCO)
        buf.push(2); // list_status_type (ALL_DONE)
        buf.push(2); // list_order_status (ALL_DONE)
        buf.extend_from_slice(&1_700_000_000_000_000i64.to_le_bytes());
        buf.push((-8i8) as u8);
        buf.push((-8i8) as u8);

        buf.extend_from_slice(&8u16.to_le_bytes());
        buf.extend_from_slice(&2u16.to_le_bytes());
        for (order_id, client_order_id) in [(111i64, "orig-1"), (222, "orig-2")] {
            buf.extend_from_slice(&order_id.to_le_bytes());
            write_var_string(&mut buf, "BTCUSDT");
            write_var_string(&mut buf, client_order_id);
        }

        buf.extend_from_slice(&(REPORT_BLOCK_LENGTH as u16).to_le_bytes());
        buf.extend_from_slice(&2u16.to_le_bytes());
        for (order_id, orig_client_order_id) in [(111i64, "orig-1"), (222, "orig-2")] {
            let report_start = buf.len();
            buf.extend_from_slice(&order_id.to_le_bytes());
            buf.extend_from_slice(&44i64.to_le_bytes());
            buf.extend_from_slice(&1_700_000_000_000_000i64.to_le_bytes());
            buf.extend_from_slice(&100_000_000_000i64.to_le_bytes());
            buf.extend_from_slice(&10_000_000i64.to_le_bytes());
            buf.extend_from_slice(&0i64.to_le_bytes());
            buf.extend_from_slice(&0i64.to_le_bytes());
            buf.push(3); // status (CANCELED)
            buf.push(0); // time_in_force (GTC)
            buf.push(1); // order_type (LIMIT)
            buf.push(1); // side (SELL)
            while buf.len() - report_start < REPORT_BLOCK_LENGTH {
                buf.push(0);
            }
            write_var_string(&mut buf, "BTCUSDT");
            write_var_string(&mut buf, orig_client_order_id);
            write_var_string(&mut buf, "cancel-44");
        }

        write_var_string(&mut buf, "list-44");
        write_var_string(&mut buf, "BTCUSDT");
        buf
    }

    fn create_cancel_open_orders_buffer(responses: &[Vec<u8>]) -> Vec<u8> {
        let mut buf = Vec::new();
        buf.extend_from_slice(&create_header(
            0,
            CANCEL_OPEN_ORDERS_TEMPLATE_ID,
            SBE_SCHEMA_ID,
            SBE_SCHEMA_VERSION,
        ));
        buf.extend_from_slice(&create_group_header(0, responses.len() as u32));
        for response in responses {
            buf.extend_from_slice(&(response.len() as u16).to_le_bytes());
            buf.extend_from_slice(response);
        }
        buf
    }
}