nautechsystems/nautilus_trader · warning · anyhow::Error

Ambiguous order-list submit failure, awaiting reconciliation

Error message

Ambiguous order-list submit failure, awaiting reconciliation: {e}

What it means

This warning is logged when an order-list submit to Binance Futures fails with an error that cannot be classified as a definitive venue rejection or a definitive local failure (per is_ambiguous_submit_error). Because the adapter cannot know whether the order list actually reached Binance, it treats the outcome as unknown and waits for exchange reconciliation (order status updates) to determine final state instead of emitting a local reject, which avoids double-cancelling or misreporting live orders.

Source

Thrown at crates/adapters/binance/src/futures/execution.rs:3220

                                    account_id,
                                    format!(
                                        "submit-order-list-error: code={}, msg={}",
                                        error.code, error.msg
                                    )
                                    .into(),
                                    UUID4::new(),
                                    ts_now,
                                    ts_now,
                                    false,
                                    false,
                                );
                                emitter.send_order_event(OrderEventAny::Rejected(rejected));
                            }
                        }
                    }
                }
                Err(e) => {
                    let e = anyhow::Error::new(e);

                    if is_ambiguous_submit_error(&e) {
                        log::warn!(
                            "Ambiguous order-list submit failure, awaiting reconciliation: {e}"
                        );
                    } else if is_structured_venue_rejection(&e) {
                        let ts_now = clock.get_time_ns();
                        let due_post_only = classify_submit_order_error(&e);

                        for order in &orders {
                            let rejected = OrderRejected::new(
                                trader_id,
                                order.strategy_id(),
                                order.instrument_id(),
                                order.client_order_id(),
                                account_id,
                                format!("submit-order-list-error: {e}").into(),
                                UUID4::new(),

View on GitHub (pinned to 18893faf8b)

Solutions

1. Wait for the reconciliation pass to report the actual order state before taking action; do not resubmit immediately to avoid duplicate orders
2. Check network connectivity and latency to Binance endpoints (and any proxy) that caused the ambiguous failure
3. Verify the adapter and Binance API schema versions match; update nautilus_binance if Binance added new error codes
4. Enable debug logging around is_ambiguous_submit_error to capture the raw error and classify it explicitly
5. Retry the submit only after confirming via reconciliation or order query that the original list was not accepted

Example fix

// before: blindly resubmitting on any submit error
match client.submit_order_list(list).await {
    Err(e) => client.submit_order_list(list).await?, // may duplicate orders
    ok => ok?,
}
// after: wait for reconciliation on ambiguous errors
match client.submit_order_list(list).await {
    Err(e) if is_ambiguous_submit_error(&anyhow::Error::new(e)) => {
        log::warn!("Ambiguous submit, awaiting reconciliation");
        // reconcile: query open orders / listen for order-update events
    }
    other => other?,
}

// Check connectivity/classifiability before submitting orders
if !client.is_connected() {
    log::warn!("Binance Futures client not connected; deferring order-list submit");
    return;
}

fn is_definitive_failure(e: &anyhow::Error) -> bool {
    is_structured_venue_rejection(e) || !is_ambiguous_submit_error(e)
}

match client.submit_order_list(list).await {
    Err(e) => {
        let e = anyhow::Error::new(e);
        if is_ambiguous_submit_error(&e) {
            log::warn!("Ambiguous submit; awaiting reconciliation: {e}");
            // do NOT resubmit; rely on order-status reconciliation
        } else {
            return Err(e);
        }
    }
    Ok(v) => Ok(v),
}

When it happens

Trigger: Calling submit order-list on the Binance Futures execution client when the HTTP/WebSocket submit returns a timeout, connection reset, or an unrecognized error payload that is neither a structured venue rejection nor a known local failure.

Common situations: Network instability or Binance API latency causing request timeouts during volatile markets; rate-limit disconnects mid-submit; Binance returning an unexpected error body after a schema/API version change; proxy or VPN dropping the connection between request send and response read.

Related errors

• {failure_prefix}; outcome is unknown after possible transmis
• Unsupported `OrderSide` for Binance: {value:?}
• Binance Futures position has unresolved instrument {instrume
• WS submit order failed: {e}
• Binance Futures open order request has unresolved instrument

AI-assisted analysis of nautechsystems/nautilus_trader@18893faf8b (2026-09-08). Data as JSON: /api/errors/5887cb45a58bba7c. Report an issue: GitHub.