dcex 0.26.2__tar.gz → 0.26.3__tar.gz

{dcex-0.26.2 → dcex-0.26.3}/Cargo.lock

@@ -225,7 +225,7 @@ checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
 
 [[package]]
 name = "dcex"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "base64",
  "ed25519-dalek",

{dcex-0.26.2 → dcex-0.26.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcex
-Version: 0.26.2
+Version: 0.26.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Financial and Insurance Industry

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.4.4 (2026-07-02)
+
+### Fix
+
+- harden live private cleanup and throttling
+- harden live stateful cleanup
+
 ## 0.4.3 (2026-06-29)
 
 ### Fix

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/Cargo.toml

@@ -6,7 +6,7 @@ edition.workspace = true
 license.workspace = true
 readme = "README.md"
 repository.workspace = true
-version = "0.4.3"
+version = "0.4.4"
 keywords = ["crypto", "trading", "exchange", "http"]
 categories = ["api-bindings", "web-programming::http-client"]
 

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_http_parity/binance.rs

@@ -4,14 +4,14 @@ use dcex::exchange::ValidatedResponse;
 use dcex::exchanges::binance::BinanceClient;
 
 use super::common::{
-    require_env, run_cases, run_private_cases, Case, BTC_USDT_SPOT, BTC_USDT_SWAP,
+    require_env, run_cases_with_delay, run_private_cases, Case, BTC_USDT_SPOT, BTC_USDT_SWAP,
 };
 
 #[tokio::test]
 #[ignore = "requires live exchange API access"]
 async fn binance_public_live_parity() -> dcex::Result<()> {
     let client = BinanceClient::public(Duration::from_secs(20))?;
-    run_cases(
+    run_cases_with_delay(
         vec![
             Case::new(
                 "get_spot_exchange_info",
@@ -95,6 +95,7 @@ async fn binance_public_live_parity() -> dcex::Result<()> {
                 ],
             ),
         ],
+        Duration::from_secs(2),
         |case| {
             let client = client.clone();
             async move { binance_public_case(&client, case).await }

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_http_parity/common.rs

@@ -1,8 +1,9 @@
 use std::collections::HashMap;
 use std::sync::OnceLock;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use dcex::exchange::ValidatedResponse;
+use tokio::time::sleep;
 
 pub(crate) const BTC_USDT_SPOT: &str = "BTC-USDT-SPOT";
 pub(crate) const BTC_USDT_SWAP: &str = "BTC-USDT-SWAP";
@@ -51,7 +52,14 @@ pub(crate) fn require_env(names: &[&str]) -> Option<Vec<String>> {
     if missing.is_empty() {
         Some(values)
     } else {
-        eprintln!("skipping live private test; missing {}", missing.join(", "));
+        let message = format!(
+            "missing required live private environment variables: {}",
+            missing.join(", ")
+        );
+        if live_http_enabled() {
+            panic!("{message}");
+        }
+        eprintln!("skipping live private test; {message}");
         None
     }
 }
@@ -95,7 +103,19 @@ fn assert_success(response: &ValidatedResponse) {
     assert!(!response.data.is_null(), "{response:?}");
 }
 
-pub(crate) async fn run_cases<F, Fut>(cases: Vec<Case>, mut request: F) -> dcex::Result<()>
+pub(crate) async fn run_cases<F, Fut>(cases: Vec<Case>, request: F) -> dcex::Result<()>
+where
+    F: FnMut(Case) -> Fut,
+    Fut: std::future::Future<Output = dcex::Result<ValidatedResponse>>,
+{
+    run_cases_with_delay(cases, Duration::ZERO, request).await
+}
+
+pub(crate) async fn run_cases_with_delay<F, Fut>(
+    cases: Vec<Case>,
+    delay: Duration,
+    mut request: F,
+) -> dcex::Result<()>
 where
     F: FnMut(Case) -> Fut,
     Fut: std::future::Future<Output = dcex::Result<ValidatedResponse>>,
@@ -110,6 +130,9 @@ where
         let response = request(case).await?;
         assert_success(&response);
         eprintln!("ok {method}");
+        if !delay.is_zero() {
+            sleep(delay).await;
+        }
     }
     Ok(())
 }

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_stateful/aster.rs

@@ -4,8 +4,8 @@ use dcex::exchange::Exchange;
 use dcex::exchanges::aster::AsterClient;
 
 use super::common::{
-    assert_success, fetch_trading_details, minimum_order_quantity, params, post_only_buy_price,
-    require_env, require_live_trading, require_order_id, BTC_USDT_SWAP,
+    assert_success, fetch_trading_details, live_test_error, minimum_order_quantity, params,
+    post_only_buy_price, require_env, require_live_trading, require_order_id, BTC_USDT_SWAP,
 };
 
 #[tokio::test]
@@ -39,8 +39,28 @@ async fn aster_futures_direct_live_stateful_order() -> dcex::Result<()> {
         .as_array()
         .is_some_and(|orders| !orders.is_empty())
     {
-        eprintln!("skipping Aster futures live stateful order; open BTC-USDT swap orders exist");
-        return Ok(());
+        let cancel = super::common::exchange_method_request(
+            &client,
+            "cancel_all_futures_open_orders",
+            params(&[("product_symbol", BTC_USDT_SWAP)]),
+        )
+        .await?;
+        assert_success(&cancel);
+        let remaining = super::common::exchange_method_request(
+            &client,
+            "get_futures_open_orders",
+            params(&[("product_symbol", BTC_USDT_SWAP)]),
+        )
+        .await?;
+        if remaining
+            .data
+            .as_array()
+            .is_some_and(|orders| !orders.is_empty())
+        {
+            return Err(live_test_error(
+                "Aster futures still has open BTC-USDT swap orders after cleanup",
+            ));
+        }
     }
 
     let orderbook = client.get_futures_orderbook(BTC_USDT_SWAP).limit(5).await?;

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_stateful/backpack.rs

@@ -4,8 +4,8 @@ use dcex::exchange::Exchange;
 use dcex::exchanges::backpack::BackpackClient;
 
 use super::common::{
-    assert_success, fetch_trading_details, minimum_order_quantity, params, post_only_buy_price,
-    require_env, require_live_trading, require_order_id,
+    assert_success, fetch_trading_details, live_test_error, minimum_order_quantity, params,
+    post_only_buy_price, require_env, require_live_trading, require_order_id,
 };
 
 const BTC_USDC_SPOT: &str = "BTC-USDC-SPOT";
@@ -37,8 +37,28 @@ async fn backpack_direct_live_stateful_order() -> dcex::Result<()> {
         .as_array()
         .is_some_and(|orders| !orders.is_empty())
     {
-        eprintln!("skipping Backpack live stateful order; open BTC-USDC spot orders exist");
-        return Ok(());
+        let cancel = super::common::exchange_method_request(
+            &client,
+            "cancel_open_orders",
+            params(&[("product_symbol", BTC_USDC_SPOT)]),
+        )
+        .await?;
+        assert_success(&cancel);
+        let remaining = super::common::exchange_method_request(
+            &client,
+            "get_open_orders",
+            params(&[("product_symbol", BTC_USDC_SPOT)]),
+        )
+        .await?;
+        if remaining
+            .data
+            .as_array()
+            .is_some_and(|orders| !orders.is_empty())
+        {
+            return Err(live_test_error(
+                "Backpack still has open BTC-USDC spot orders after cleanup",
+            ));
+        }
     }
 
     let orderbook = super::common::exchange_method_request(

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_stateful/binance.rs

@@ -7,10 +7,10 @@ use tokio::time::sleep;
 use super::common::{
     assert_success, asset_amount, contains_non_empty_array, fetch_trading_details, find_f64,
     first_bid_price, format_transfer_amount, format_transfer_amount_floor,
-    leveraged_margin_required, margin_target, minimum_order_quantity, parse_positive,
-    post_only_buy_price_from_bid, price_below_market, require_env, require_live_trading,
-    require_order_id, sum_abs_values, wait_for_flat_position, wait_for_positive_position,
-    BTC_USDT_SPOT, BTC_USDT_SWAP,
+    insufficient_funds_error, leveraged_margin_required, live_test_error, margin_target,
+    minimum_order_quantity, parse_positive, post_only_buy_price_from_bid, price_below_market,
+    require_env, require_live_trading, require_order_id, wait_for_flat_position,
+    wait_for_positive_position, BTC_USDT_SPOT, BTC_USDT_SWAP,
 };
 
 struct TransferBack {
@@ -47,7 +47,11 @@ async fn binance_direct_live_stateful_order() -> dcex::Result<()> {
             amount: "0".to_string(),
             transfer_type: "",
         },
-        None => return Ok(()),
+        None => {
+            return Err(live_test_error(
+                "Binance spot has insufficient transferable USDT for live stateful order",
+            ));
+        }
     };
 
     let order_result = client
@@ -87,14 +91,7 @@ async fn binance_futures_direct_live_stateful_order() -> dcex::Result<()> {
         Some(keys[1].clone()),
         Duration::from_secs(20),
     )?;
-    if binance_open_swap_orders(&client).await? {
-        eprintln!("skipping Binance futures live stateful order; open BTC-USDT swap orders exist");
-        return Ok(());
-    }
-    if futures_position_abs(&client).await? > 0.0 {
-        eprintln!("skipping Binance futures live stateful order; BTC-USDT swap position exists");
-        return Ok(());
-    }
+    cleanup_binance_futures_state(&client).await?;
 
     let ticker = client
         .get_futures_ticker()
@@ -114,7 +111,11 @@ async fn binance_futures_direct_live_stateful_order() -> dcex::Result<()> {
         leveraged_margin_required(bid, &quantity, &details, BINANCE_FUTURES_LEVERAGE_VALUE)?;
     let transfer = match ensure_futures_usdt(&client, margin_target(required_usdt)).await? {
         Some(transfer) => transfer,
-        None => return Ok(()),
+        None => {
+            return Err(live_test_error(
+                "Binance futures has insufficient transferable USDT for live stateful order",
+            ));
+        }
     };
 
     let order_result = client
@@ -147,6 +148,12 @@ async fn binance_futures_direct_live_stateful_order() -> dcex::Result<()> {
         .await;
     let opened = match open_result {
         Ok(opened) => opened,
+        Err(error) if insufficient_funds_error(&error) => {
+            return_binance_transfer(&client, &transfer).await?;
+            return Err(live_test_error(format!(
+                "Binance futures insufficient margin for market open: {error}"
+            )));
+        }
         Err(error) => {
             return_binance_transfer(&client, &transfer).await?;
             return Err(error);
@@ -202,9 +209,6 @@ async fn ensure_spot_usdt(
             }));
         }
     }
-    eprintln!(
-        "skipping Binance live stateful order; insufficient transferable USDT, required={required:.8}"
-    );
     Ok(None)
 }
 
@@ -242,12 +246,64 @@ async fn ensure_futures_usdt(
             }));
         }
     }
-    eprintln!(
-        "skipping Binance futures live stateful order; insufficient transferable USDT, required={required:.8}"
-    );
     Ok(None)
 }
 
+async fn cleanup_binance_futures_state(client: &BinanceClient) -> dcex::Result<()> {
+    if binance_open_swap_orders(client).await? {
+        let cancel = client.cancel_all_open_orders(BTC_USDT_SWAP).await?;
+        assert_success(&cancel);
+        sleep(Duration::from_secs(1)).await;
+    }
+    let open_algo = client
+        .get_all_open_futures_algo_orders()
+        .param("product_symbol", BTC_USDT_SWAP)
+        .await?;
+    if contains_non_empty_array(&open_algo.data, &["orders", "data"]) {
+        let cancel = client
+            .cancel_all_open_futures_algo_orders(BTC_USDT_SWAP)
+            .await?;
+        assert_success(&cancel);
+        sleep(Duration::from_secs(1)).await;
+    }
+
+    let amount = futures_position_amt(client).await?;
+    if amount != 0.0 {
+        let quantity = format_transfer_amount_floor(amount.abs(), 8);
+        let close = client
+            .place_market_order(
+                BTC_USDT_SWAP,
+                if amount > 0.0 { "SELL" } else { "BUY" },
+                quantity.as_str(),
+            )
+            .param("reduceOnly", "true")
+            .await?;
+        assert_success(&close);
+        sleep(Duration::from_secs(1)).await;
+    }
+
+    if binance_open_swap_orders(client).await? {
+        return Err(live_test_error(
+            "Binance futures still has open BTC-USDT swap orders after cleanup",
+        ));
+    }
+    let open_algo = client
+        .get_all_open_futures_algo_orders()
+        .param("product_symbol", BTC_USDT_SWAP)
+        .await?;
+    if contains_non_empty_array(&open_algo.data, &["orders", "data"]) {
+        return Err(live_test_error(
+            "Binance futures still has open BTC-USDT algo orders after cleanup",
+        ));
+    }
+    if wait_for_flat_position(|| futures_position_abs(client)).await? != 0.0 {
+        return Err(live_test_error(
+            "Binance futures BTC-USDT swap position still exists after cleanup",
+        ));
+    }
+    Ok(())
+}
+
 async fn return_binance_transfer(
     client: &BinanceClient,
     transfer: &TransferBack,
@@ -298,8 +354,12 @@ async fn futures_usdt(client: &BinanceClient) -> dcex::Result<f64> {
 }
 
 async fn futures_position_abs(client: &BinanceClient) -> dcex::Result<f64> {
+    Ok(futures_position_amt(client).await?.abs())
+}
+
+async fn futures_position_amt(client: &BinanceClient) -> dcex::Result<f64> {
     let response = client.get_future_position(BTC_USDT_SWAP).await?;
-    Ok(sum_abs_values(&response.data, &["positionAmt"]))
+    Ok(find_f64(&response.data, &["positionAmt"]).unwrap_or(0.0))
 }
 
 async fn binance_open_swap_orders(client: &BinanceClient) -> dcex::Result<bool> {

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_stateful/bingx.rs

@@ -6,8 +6,8 @@ use dcex::exchanges::bingx::BingxClient;
 use super::common::{
     assert_success, asset_amount, contains_non_empty_array, fetch_trading_details, find_f64,
     first_bid_price, format_transfer_amount_floor, insufficient_funds_error,
-    leveraged_margin_required, margin_target, minimum_order_quantity, params, post_only_buy_price,
-    price_below_market, require_env, require_live_trading, require_order_id,
+    leveraged_margin_required, live_test_error, margin_target, minimum_order_quantity, params,
+    post_only_buy_price, price_below_market, require_env, require_live_trading, require_order_id,
     sum_abs_values_for_symbols, unique_client_id, wait_for_flat_position,
     wait_for_positive_position, BTC_USDT_SPOT, BTC_USDT_SWAP,
 };
@@ -40,10 +40,7 @@ async fn bingx_spot_direct_live_stateful_order() -> dcex::Result<()> {
         Duration::from_secs(20),
     )?;
 
-    if bingx_spot_open_orders(&client).await? {
-        eprintln!("skipping BingX spot live stateful order; open BTC-USDT spot orders exist");
-        return Ok(());
-    }
+    cleanup_bingx_spot_orders(&client).await?;
 
     let orderbook = super::common::exchange_method_request(
         &client,
@@ -62,10 +59,9 @@ async fn bingx_spot_direct_live_stateful_order() -> dcex::Result<()> {
     let transfers = match ensure_bingx_usdt(&client, BINGX_SPOT_ACCOUNT, required_usdt).await? {
         Some(transfers) => transfers,
         None => {
-            eprintln!(
-                "skipping BingX spot live stateful order; insufficient transferable USDT, required={required_usdt:.8}"
-            );
-            return Ok(());
+            return Err(live_test_error(
+                "BingX spot has insufficient transferable USDT for live stateful order",
+            ));
         }
     };
 
@@ -120,14 +116,7 @@ async fn bingx_swap_direct_live_stateful_order() -> dcex::Result<()> {
         Duration::from_secs(20),
     )?;
 
-    if bingx_swap_open_orders(&client).await? {
-        eprintln!("skipping BingX swap live stateful order; open BTC-USDT swap orders exist");
-        return Ok(());
-    }
-    if bingx_swap_position_abs(&client).await? > 0.0 {
-        eprintln!("skipping BingX swap live stateful order; BTC-USDT swap position exists");
-        return Ok(());
-    }
+    cleanup_bingx_swap_state(&client).await?;
 
     let orderbook = super::common::exchange_method_request(
         &client,
@@ -141,21 +130,15 @@ async fn bingx_swap_direct_live_stateful_order() -> dcex::Result<()> {
     let market_price = bingx_swap_market_price(&client).await?;
     let required_usdt =
         leveraged_margin_required(market_price, &quantity, &details, BINGX_LEVERAGE_VALUE)?;
-    let transfers = match ensure_bingx_usdt(
-        &client,
-        BINGX_SWAP_ACCOUNT,
-        margin_target(required_usdt),
-    )
-    .await?
-    {
-        Some(transfers) => transfers,
-        None => {
-            eprintln!(
-                    "skipping BingX swap live stateful order; insufficient transferable USDT, required={required_usdt:.8}"
-                );
-            return Ok(());
-        }
-    };
+    let transfers =
+        match ensure_bingx_usdt(&client, BINGX_SWAP_ACCOUNT, margin_target(required_usdt)).await? {
+            Some(transfers) => transfers,
+            None => {
+                return Err(live_test_error(
+                    "BingX swap has insufficient transferable USDT for live stateful order",
+                ));
+            }
+        };
 
     let order_result = super::common::exchange_method_request(
         &client,
@@ -173,10 +156,9 @@ async fn bingx_swap_direct_live_stateful_order() -> dcex::Result<()> {
         Ok(order) => order,
         Err(error) if insufficient_funds_error(&error) => {
             return_bingx_transfers(&client, &transfers).await?;
-            eprintln!(
-                "skipping BingX swap live stateful order; insufficient margin for post-only order: {error}"
-            );
-            return Ok(());
+            return Err(live_test_error(format!(
+                "BingX swap insufficient margin for post-only order: {error}"
+            )));
         }
         Err(error) => {
             return_bingx_transfers(&client, &transfers).await?;
@@ -219,10 +201,9 @@ async fn bingx_swap_direct_live_stateful_order() -> dcex::Result<()> {
         Ok(market_order) => market_order,
         Err(error) if insufficient_funds_error(&error) => {
             return_bingx_transfers(&client, &transfers).await?;
-            eprintln!(
-                "skipping BingX swap live stateful order; insufficient margin for market open: {error}"
-            );
-            return Ok(());
+            return Err(live_test_error(format!(
+                "BingX swap insufficient margin for market open: {error}"
+            )));
         }
         Err(error) => {
             return_bingx_transfers(&client, &transfers).await?;
@@ -257,6 +238,25 @@ async fn bingx_spot_open_orders(client: &BingxClient) -> dcex::Result<bool> {
     Ok(contains_non_empty_array(&response.data, &["orders"]))
 }
 
+async fn cleanup_bingx_spot_orders(client: &BingxClient) -> dcex::Result<()> {
+    if bingx_spot_open_orders(client).await? {
+        let cancel = super::common::exchange_method_request(
+            client,
+            "cancel_spot_open_orders",
+            params(&[("product_symbol", BTC_USDT_SPOT)]),
+        )
+        .await?;
+        assert_success(&cancel);
+        sleep(Duration::from_secs(1)).await;
+    }
+    if bingx_spot_open_orders(client).await? {
+        return Err(live_test_error(
+            "BingX spot still has open BTC-USDT orders after cleanup",
+        ));
+    }
+    Ok(())
+}
+
 async fn bingx_swap_open_orders(client: &BingxClient) -> dcex::Result<bool> {
     let response = super::common::exchange_method_request(
         &client,
@@ -267,6 +267,40 @@ async fn bingx_swap_open_orders(client: &BingxClient) -> dcex::Result<bool> {
     Ok(contains_non_empty_array(&response.data, &["orders"]))
 }
 
+async fn cleanup_bingx_swap_state(client: &BingxClient) -> dcex::Result<()> {
+    if bingx_swap_open_orders(client).await? {
+        let cancel = super::common::exchange_method_request(
+            client,
+            "cancel_swap_all_orders",
+            params(&[("product_symbol", BTC_USDT_SWAP)]),
+        )
+        .await?;
+        assert_success(&cancel);
+        sleep(Duration::from_secs(1)).await;
+    }
+    if bingx_swap_position_abs(client).await? != 0.0 {
+        let close = super::common::exchange_method_request(
+            client,
+            "close_swap_all_positions",
+            params(&[("product_symbol", BTC_USDT_SWAP)]),
+        )
+        .await?;
+        assert_success(&close);
+        sleep(Duration::from_secs(2)).await;
+    }
+    if bingx_swap_open_orders(client).await? {
+        return Err(live_test_error(
+            "BingX swap still has open BTC-USDT orders after cleanup",
+        ));
+    }
+    if wait_for_flat_position(|| bingx_swap_position_abs(client)).await? != 0.0 {
+        return Err(live_test_error(
+            "BingX BTC-USDT swap position still exists after cleanup",
+        ));
+    }
+    Ok(())
+}
+
 async fn bingx_swap_position_abs(client: &BingxClient) -> dcex::Result<f64> {
     let response = super::common::exchange_method_request(
         &client,
@@ -329,9 +363,7 @@ async fn ensure_bingx_usdt(
         let source_available = match bingx_account_usdt(client, source_account).await {
             Ok(value) => value,
             Err(error) => {
-                eprintln!(
-                    "skipping BingX transfer source {source_account}; balance unavailable: {error}"
-                );
+                eprintln!("BingX transfer source {source_account} balance unavailable: {error}");
                 continue;
             }
         };
@@ -341,7 +373,7 @@ async fn ensure_bingx_usdt(
             Ok(value) => value,
             Err(error) => {
                 eprintln!(
-                    "skipping BingX transfer route {source_account}->{target_account}; transferable amount unavailable: {error}"
+                    "BingX transfer route {source_account}->{target_account} transferable amount unavailable: {error}"
                 );
                 continue;
             }
@@ -366,7 +398,7 @@ async fn ensure_bingx_usdt(
             }
             Err(error) => {
                 eprintln!(
-                    "skipping BingX transfer route {source_account}->{target_account}; transfer failed: {error}"
+                    "BingX transfer route {source_account}->{target_account} transfer failed: {error}"
                 );
             }
         }

{dcex-0.26.2 → dcex-0.26.3}/crates/dcex/tests/live_stateful/bitget.rs

@@ -8,10 +8,10 @@ use tokio::time::sleep;
 use super::common::{
     account_restriction, assert_success, asset_amount, bitget_unified_account_error,
     contains_non_empty_array, fetch_trading_details, first_bid_price, format_transfer_amount,
-    format_transfer_amount_floor, leveraged_margin_required, margin_target, minimum_order_quantity,
-    params, post_only_buy_price, price_below_market, push, require_env, require_live_trading,
-    require_order_id, sum_abs_values_for_symbols, unique_client_id, wait_for_flat_position,
-    wait_for_positive_position, BTC_USDT_SPOT, BTC_USDT_SWAP,
+    format_transfer_amount_floor, leveraged_margin_required, live_test_error, margin_target,
+    minimum_order_quantity, params, post_only_buy_price, price_below_market, push, require_env,
+    require_live_trading, require_order_id, sum_abs_values_for_symbols, unique_client_id,
+    wait_for_flat_position, wait_for_positive_position, BTC_USDT_SPOT, BTC_USDT_SWAP,
 };
 
 const BITGET_FUTURES_PRODUCT_TYPE: &str = "USDT-FUTURES";
@@ -71,8 +71,9 @@ async fn bitget_direct_live_stateful_order() -> dcex::Result<()> {
     let order = match order_result {
         Ok(response) => response,
         Err(error) if bitget_unified_account_error(&error) => {
-            eprintln!("skipping Bitget classic stateful order on unified account: {error}");
-            return Ok(());
+            return Err(live_test_error(format!(
+                "Bitget classic stateful order is unsupported on unified account: {error}"
+            )));
         }
         Err(error) => return Err(error),
     };
@@ -126,14 +127,7 @@ async fn bitget_swap_direct_live_stateful_order() -> dcex::Result<()> {
     )?;
     let uta = is_uta(&client).await;
 
-    if bitget_open_swap_orders(&client, uta).await? {
-        eprintln!("skipping Bitget swap live stateful order; open BTC-USDT swap orders exist");
-        return Ok(());
-    }
-    if bitget_swap_position_abs(&client, uta).await? > 0.0 {
-        eprintln!("skipping Bitget swap live stateful order; BTC-USDT swap position exists");
-        return Ok(());
-    }
+    cleanup_bitget_swap_state(&client, uta).await?;
 
     let orderbook = super::common::exchange_method_request(
         &client,
@@ -159,7 +153,11 @@ async fn bitget_swap_direct_live_stateful_order() -> dcex::Result<()> {
     let transferred =
         match ensure_bitget_futures_margin(&client, uta, margin_target(required_usdt)).await? {
             Some(amount) => amount,
-            None => return Ok(()),
+            None => {
+                return Err(live_test_error(
+                    "Bitget swap has insufficient transferable USDT for live stateful order",
+                ));
+            }
         };
 
     let order_result = bitget_place_swap_post_only_buy(&client, uta, &quantity, &price).await;
@@ -305,6 +303,27 @@ async fn bitget_swap_position_abs(client: &BitgetClient, uta: bool) -> dcex::Res
     ))
 }
 
+async fn cleanup_bitget_swap_state(client: &BitgetClient, uta: bool) -> dcex::Result<()> {
+    if bitget_open_swap_orders(client, uta).await? {
+        return Err(live_test_error(
+            "Bitget swap has open BTC-USDT orders before live stateful order",
+        ));
+    }
+    let position = bitget_swap_position_abs(client, uta).await?;
+    if position > 0.0 {
+        let quantity = format_transfer_amount_floor(position, 8);
+        let close = bitget_place_swap_market_sell_reduce_only(client, uta, &quantity).await?;
+        assert_success(&close);
+        sleep(Duration::from_secs(2)).await;
+    }
+    if wait_for_flat_position(|| bitget_swap_position_abs(client, uta)).await? != 0.0 {
+        return Err(live_test_error(
+            "Bitget BTC-USDT swap position still exists after cleanup",
+        ));
+    }
+    Ok(())
+}
+
 async fn ensure_bitget_futures_margin(
     client: &BitgetClient,
     uta: bool,
@@ -316,16 +335,10 @@ async fn ensure_bitget_futures_margin(
     }
     let needed = required - futures;
     if uta {
-        eprintln!(
-            "skipping Bitget UTA swap live stateful order; insufficient USDT, required={required:.8}, futures={futures:.8}"
-        );
         return Ok(None);
     }
     let spot = bitget_spot_usdt(client).await?;
     if spot < needed {
-        eprintln!(
-            "skipping Bitget swap live stateful order; insufficient transferable USDT, required={required:.8}, futures={futures:.8}, spot={spot:.8}"
-        );
         return Ok(None);
     }
     let amount = format_transfer_amount(needed);