Add Rust regression test suite and safe accessor implementations

- Add comprehensive regression test suite (56 tests) in rust/tests/regression.rs
  covering safe accessor methods, Value helpers, describe() shape validation,
  fixture-based comparison, and live network tests
- Add manually-maintained safe accessor implementations to Exchange trait:
  safe_string, safe_integer, safe_float, safe_value, safe_bool, safe_dict,
  safe_list, safe_number, parse_number, safe_timestamp and all _2/_n variants
- Add free helper functions: safe_get, value_to_string_opt, value_to_i64_opt,
  value_to_f64_opt
- Update rustTranspiler.ts with MANUALLY_IMPLEMENTED_METHODS set to skip
  generating stubs for methods already implemented in the Exchange trait
- Add test fixtures in rust/tests/fixtures/ for JS-parity validation
- Regenerate all exchange .rs files (safe accessor stubs removed)

https://claude.ai/code/session_01KE37uEYUSbY3Ug9yFSjpzZ

Author: claude

build/rustTranspiler.ts

@@ -25,6 +25,25 @@ const __dirname = path.dirname(fileURLToPath(metaFileUrl));
 const FUNCTION_INFO: Record<string, Record<string, { paramsCount: number; async: boolean }>> = {};
 const RUST_STUB_MODE = true;
 
+// Methods that are manually implemented in the Exchange trait (in exchange.rs)
+// and should NOT be auto-generated as stubs by the transpiler.
+const MANUALLY_IMPLEMENTED_METHODS = new Set([
+    'safeString', 'safeString2', 'safeStringN',
+    'safeStringLower', 'safeStringLower2', 'safeStringLowerN',
+    'safeStringUpper', 'safeStringUpper2', 'safeStringUpperN',
+    'safeInteger', 'safeInteger2', 'safeIntegerN',
+    'safeIntegerProduct', 'safeIntegerProduct2', 'safeIntegerProductN',
+    'safeTimestamp', 'safeTimestamp2', 'safeTimestampN',
+    'safeFloat', 'safeFloat2', 'safeFloatN',
+    'safeValue', 'safeValue2', 'safeValueN',
+    'parseNumber', 'parseToInt', 'parseToNumeric',
+    'safeNumber', 'safeNumber2', 'safeNumberN', 'safeNumberOmitZero',
+    'safeIntegerOmitZero',
+    'safeBool', 'safeBool2', 'safeBoolN',
+    'safeDict', 'safeDict2', 'safeDictN',
+    'safeList', 'safeList2', 'safeListN',
+]);
+
 function isUpperCase(x: string) {
     return x && x.length > 0 && x[0] === x.toUpperCase()[0];
 }
@@ -342,6 +361,10 @@ function transpileMethodToRust(opts: {
             return '';
         }
         const fname = fnNode.id?.name || 'unknown';
+        // Skip methods that are manually implemented above the auto-generated delimiter.
+        if (MANUALLY_IMPLEMENTED_METHODS.has(fname)) {
+            return '';
+        }
         let isSelfImmutable = false;
         if (
             fname.startsWith('safe') ||

examples/rust/benchmark.rs

@@ -0,0 +1,7 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/benchmark.ts
+
+#[tokio::main]
+async fn main() {
+    println!("No exchange constructor detected in benchmark.ts; generated placeholder.");
+}

examples/rust/build_ohlcv_bars.rs

@@ -0,0 +1,22 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/build-ohlcv-bars.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::pro::binance::{Binance, BinanceImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = BinanceImpl::new(Value::Json(json!({})));
+    let symbol: Value = "OGN/USDT".into();
+
+    let rv = Binance::build_ohlcvc(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined);
+    println!("buildOHLCVC: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::fetch_trades(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("fetchTrades: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::filter_by_since_limit(&mut exchange, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined);
+    println!("filterBySinceLimit: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    // skipped: milliseconds (not found in transpiled trait)
+    let rv = Binance::watch_trades(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("watchTrades: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/compare_two_exchanges_capabilities.rs

@@ -0,0 +1,12 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/compare-two-exchanges-capabilities.ts
+
+use ccxt::exchanges::okx::{OkxImpl};
+use ccxt::exchange::Value;
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let _exchange = OkxImpl::new(Value::Json(json!({})));
+    println!("No exchange method calls detected in compare-two-exchanges-capabilities.ts; generated placeholder.");
+}

examples/rust/create_order_position_with_takeprofit_stoploss.rs

@@ -0,0 +1,26 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/create-order-position-with-takeprofit-stoploss.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::exchanges::okx::{Okx, OkxImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = OkxImpl::new(Value::Json(json!({})));
+    let symbol: Value = "DOGE/USDT:USDT".into();
+
+    // skipped: cancel_order (not found in transpiled trait)
+    let rv = Okx::create_order(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createOrder: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Okx::fetch_open_orders(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("fetchOpenOrders: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Okx::fetch_ticker(&mut exchange, symbol.clone(), Value::Undefined).await;
+    println!("fetchTicker: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Okx::load_markets(&mut exchange, Value::Undefined, Value::Undefined).await;
+    println!("loadMarkets: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Okx::market(&mut exchange, Value::Undefined);
+    println!("market: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Okx::price_to_precision(&mut exchange, Value::Undefined, Value::Undefined);
+    println!("priceToPrecision: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/create_order_ws_example.rs

@@ -0,0 +1,19 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/create-order-ws-example.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::pro::binance::{Binance, BinanceImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = BinanceImpl::new(Value::Json(json!({})));
+    let symbol: Value = "ETH/USDT".into();
+
+    let rv = Binance::create_order_ws(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createOrderWs: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::load_markets(&mut exchange, Value::Undefined, Value::Undefined).await;
+    println!("loadMarkets: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::set_sandbox_mode(&mut exchange, Value::Undefined);
+    println!("setSandboxMode: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/create_orders_example.rs

@@ -0,0 +1,19 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/create-orders-example.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::exchanges::binance::{Binance, BinanceImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = BinanceImpl::new(Value::Json(json!({})));
+    let symbol: Value = "BTC/USDT".into();
+
+    let rv = Binance::create_orders(&mut exchange, symbol.clone(), Value::Undefined).await;
+    println!("createOrders: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::load_markets(&mut exchange, Value::Undefined, Value::Undefined).await;
+    println!("loadMarkets: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Binance::set_sandbox_mode(&mut exchange, Value::Undefined);
+    println!("setSandboxMode: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/create_trailing_amount_order.rs

@@ -0,0 +1,21 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/create-trailing-amount-order.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::exchanges::bingx::{Bingx, BingxImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = BingxImpl::new(Value::Json(json!({})));
+    let symbol: Value = "BTC/USDT:USDT".into();
+
+    let rv = Bingx::create_order(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createOrder: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::create_trailing_amount_order(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createTrailingAmountOrder: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::load_markets(&mut exchange, Value::Undefined, Value::Undefined).await;
+    println!("loadMarkets: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::set_sandbox_mode(&mut exchange, Value::Undefined);
+    println!("setSandboxMode: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/create_trailing_percent_order.rs

@@ -0,0 +1,21 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/create-trailing-percent-order.ts
+
+use ccxt::exchange::{normalize, Value};
+use ccxt::exchanges::bingx::{Bingx, BingxImpl};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let mut exchange = BingxImpl::new(Value::Json(json!({})));
+    let symbol: Value = "BTC/USDT:USDT".into();
+
+    let rv = Bingx::create_order(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createOrder: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::create_trailing_percent_order(&mut exchange, symbol.clone(), Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined, Value::Undefined).await;
+    println!("createTrailingPercentOrder: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::load_markets(&mut exchange, Value::Undefined, Value::Undefined).await;
+    println!("loadMarkets: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+    let rv = Bingx::set_sandbox_mode(&mut exchange, Value::Undefined);
+    println!("setSandboxMode: {}", normalize(&rv).map(|v| v.to_string()).unwrap_or_else(|| "undefined".into()));
+}

examples/rust/custom_proxy_agent_for_js.rs

@@ -0,0 +1,12 @@
+// AUTO-GENERATED: transpiled from TypeScript examples/
+// Source: examples/ts/custom-proxy-agent-for-js.ts
+
+use ccxt::exchanges::kraken::{KrakenImpl};
+use ccxt::exchange::Value;
+use serde_json::json;
+
+#[tokio::main]
+async fn main() {
+    let _exchange = KrakenImpl::new(Value::Json(json!({})));
+    println!("No exchange method calls detected in custom-proxy-agent-for-js.ts; generated placeholder.");
+}