feat(data): native Binance REST kline fetcher in 9 languages (#315)

Adds `BinanceRest::fetch_klines` to `wickra-data`: a blocking historical kline
downloader (`GET /api/v3/klines`) and the historical counterpart to the F4 live
`BinanceFeed`. It is the last native data-layer primitive needed to drop
third-party HTTP/JSON download helpers (`jackson`, `jsonlite`, `urllib`, …) from
the examples.

## What

- **Core** (`wickra-data`): `fetch_klines(symbol, interval, limit, start?, end?)`
  built on `ureq` with native-tls — sharing the exact same TLS backend
  (native-tls 0.2 / SChannel) as the existing tokio-tungstenite live feed, so the
  two pull one TLS stack, not two. Parses Binance's 12-element array rows via the
  existing serde infrastructure into validated `Candle`s. Blocking by design (a
  one-shot request needs no async runtime; the FFI boundary is synchronous
  anyway). Nine mock-HTTP-server tests cover parse / empty / limit / transport /
  JSON / invariant-violation paths.
- **C ABI**: `wickra_binance_fetch_klines(...)` (blocking drain into a caller
  buffer, `-1` on error) + regenerated cbindgen header and its vendored Go copy.
- **Bindings**: native Node `fetchBinanceKlines` / Python `fetch_binance_klines`;
  generated Go `FetchBinanceKlines` / C# `BinanceFeed.FetchKlines` / Java
  `BinanceFeed.fetchKlines` / R `fetch_binance_klines`. C / C++ call the C ABI
  directly. **WASM is excluded** (browsers use the host `fetch`).

The four C-ABI bindings are regenerated from the ScriptHelpers generators (not
hand-edited); the regen diff is exactly the new wrapper in each.

## Verification

All ten toolchains green locally: Rust (`cargo test`/`clippy`/`fmt`), Node, Python,
Go, C#, Java, R (`R CMD INSTALL` + smoke), WASM (`cargo check`, confirmed `ureq`
is not pulled). Each binding has an error-path smoke test; the parse/HTTP success
path is covered by the Rust mock-server tests.

No release in this PR — ships with the data-layer + numpy bundle later.

bindings/r/NAMESPACE

@@ -530,6 +530,7 @@ export(Zlema)
 export(batch)
 export(binance_close)
 export(binance_next)
+export(fetch_binance_klines)
 export(is_ready)
 export(name)
 export(push)

bindings/r/R/indicators.R

@@ -4180,3 +4180,24 @@ binance_close <- function(feed) {
   invisible(NULL)
 }
 
+#' Fetch historical Binance klines over REST
+#'
+#' Downloads up to `limit` (`1:1000`) historical klines for `symbol` at the given
+#' `interval` code (an integer `0:15`, the same order as the other bindings).
+#' `start_ms`/`end_ms` are optional inclusive Unix-millisecond bounds (a negative
+#' value means unset); `base_url` overrides the host (`NULL` = production). Returns
+#' an `n x 6` numeric matrix with columns `open`, `high`, `low`, `close`,
+#' `volume`, `timestamp`. Blocks until the response arrives. Not available in the
+#' wasm (r-universe/webR) build, which has no raw sockets.
+#'
+#' @keywords internal
+#' @export
+fetch_binance_klines <- function(symbol, interval, limit, start_ms = -1,
+                                 end_ms = -1, base_url = NULL) {
+  m <- .Call("wk_binance_fetch_klines", symbol, as.integer(interval),
+             as.integer(limit), as.numeric(start_ms), as.numeric(end_ms),
+             base_url, PACKAGE = "wickra")
+  colnames(m) <- c("open", "high", "low", "close", "volume", "timestamp")
+  m
+}
+

bindings/r/src/wickra.c

@@ -22707,6 +22707,31 @@ SEXP wk_binance_close(SEXP e) {
   wickra_binance_close(h);
   return R_NilValue;
 }
+SEXP wk_binance_fetch_klines(SEXP symbol, SEXP interval, SEXP limit,
+                             SEXP start_ms, SEXP end_ms, SEXP base_url) {
+  const char *url = (base_url == R_NilValue || Rf_xlength(base_url) == 0)
+    ? NULL : CHAR(STRING_ELT(base_url, 0));
+  uint32_t lim = (uint32_t)Rf_asInteger(limit);
+  if (lim == 0) Rf_error("limit must be in 1..=1000");
+  struct WickraCandle *buf =
+    (struct WickraCandle *)R_alloc(lim, sizeof(struct WickraCandle));
+  intptr_t n = wickra_binance_fetch_klines(
+    CHAR(STRING_ELT(symbol, 0)), (uint8_t)Rf_asInteger(interval), lim,
+    (int64_t)Rf_asReal(start_ms), (int64_t)Rf_asReal(end_ms), url, buf,
+    (uintptr_t)lim);
+  if (n < 0) Rf_error("invalid fetch_binance_klines parameters or transport error");
+  SEXP r = PROTECT(Rf_allocMatrix(REALSXP, (int)n, 6));
+  for (intptr_t i = 0; i < n; i++) {
+    REAL(r)[i + n * 0] = buf[i].open;
+    REAL(r)[i + n * 1] = buf[i].high;
+    REAL(r)[i + n * 2] = buf[i].low;
+    REAL(r)[i + n * 3] = buf[i].close;
+    REAL(r)[i + n * 4] = buf[i].volume;
+    REAL(r)[i + n * 5] = (double)buf[i].timestamp;
+  }
+  UNPROTECT(1);
+  return r;
+}
 #endif
 
 static const R_CallMethodDef CallEntries[] = {
@@ -26141,6 +26166,7 @@ static const R_CallMethodDef CallEntries[] = {
   {"wk_binance_connect", (DL_FUNC)&wk_binance_connect, 3},
   {"wk_binance_next", (DL_FUNC)&wk_binance_next, 2},
   {"wk_binance_close", (DL_FUNC)&wk_binance_close, 1},
+  {"wk_binance_fetch_klines", (DL_FUNC)&wk_binance_fetch_klines, 6},
 #endif
   {NULL, NULL, 0}
 };

bindings/r/tests/testthat/test-binance.R

@@ -6,3 +6,13 @@ test_that("binance feed rejects bad parameters", {
   expect_error(BinanceFeed("", 1L), "BinanceFeed")
   expect_error(BinanceFeed("BTCUSDT", 1L, "ws://127.0.0.1:1"), "BinanceFeed")
 })
+
+# The REST fetcher's parse/HTTP success path is covered by the Rust
+# mock-HTTP-server tests; here we only assert the binding's error paths.
+test_that("fetch_binance_klines rejects bad parameters", {
+  expect_error(fetch_binance_klines("BTCUSDT", 6L, 0L), "limit")
+  expect_error(
+    fetch_binance_klines("BTCUSDT", 6L, 1L, base_url = "http://127.0.0.1:1"),
+    "fetch_binance_klines"
+  )
+})