From 3d92e0d23ccc4ab2d8f5ca1861e58c3a02f2f29a Mon Sep 17 00:00:00 2001
From: 2pk03 <alo.alt@me.com>
Date: Tue, 15 Sep 2026 17:06:22 +0200
Subject: [PATCH] Use Kraken and Coinbase market data

---
 .env.example                       |   9 +-
 README.md                          |  16 +-
 com.novatechflow.polydisplay.plist |   2 +-
 index.html                         |   6 +-
 install.sh                         |  30 +--
 server.go                          | 362 +++++++++++++++++------------
 server_test.go                     | 154 ++++++++++--
 7 files changed, 380 insertions(+), 199 deletions(-)

diff --git a/.env.example b/.env.example
index 9b66996..dc69019 100644
--- a/.env.example
+++ b/.env.example
@@ -5,12 +5,11 @@
 #
 # These four are the Polymarket-traded names. Format:
 #   SYM:Name:coingecko-id[,SYM:Name:id…]
-# Optional 4th field: Binance symbol if it is not SYM+USDT.
+# A legacy fourth field is accepted and reduced to its base symbol.
 #
 # install.sh then asks for extra tickers to chart. It looks each one up on
-# CoinGecko (id + name) and checks Binance for a USDT pair. No pair is fine:
-# the server already serves those from CoinGecko. You can also add tokens later
-# in ⚙ search.
+# CoinGecko (id + name). Runtime prices and candles come from Kraken with
+# Coinbase fallback. You can also add tokens later in ⚙ search.
 
 POLYDISPLAY_ASSETS="BTC:Bitcoin:bitcoin,ETH:Ethereum:ethereum,SOL:Solana:solana,XRP:XRP:ripple"
 
@@ -23,5 +22,5 @@ POLYDISPLAY_ASSETS="BTC:Bitcoin:bitcoin,ETH:Ethereum:ethereum,SOL:Solana:solana,
 # POLYDISPLAY_PIN=000000
 # POLYDISPLAY_TOKEN_SECRET=
 
-# Optional: free CoinGecko demo key for higher rate limits
+# Optional: free CoinGecko demo key used only by asset search
 # CG_DEMO_KEY=
diff --git a/README.md b/README.md
index 196cc55..4692154 100644
--- a/README.md
+++ b/README.md
@@ -11,13 +11,14 @@ a P/L card (the day's profit as polymarket.com reports it, over a 30-day
 sparkline, with the 7d, 30d, and all-time figures), then the open positions
 and recent activity. Right column is charts for a mix of trading and
 monitoring assets. A Go process on the host serves the page and talks to Polymarket,
-Binance, and CoinGecko. Browsers only talk to that process.
+Kraken, and Coinbase. CoinGecko is used only for asset search. Browsers only talk
+to that process.
 
 ```
  ┌────────────┐   http        ┌─────────────────────────────┐   https
  │  pad /     │ ────────────► │  polydisplayd (Go)          │ ──► Polymarket
- │  browser   │  /api/state   │   polls + caches            │ ──► Binance
- │            │ ◄──────────── │   serves the page           │ ──► CoinGecko
+ │  browser   │  /api/state   │   polls + caches            │ ──► Kraken
+ │            │ ◄──────────── │   serves the page           │ ──► Coinbase
  └────────────┘               │   /api/config, /api/search  │
                               └─────────────────────────────┘
 ```
@@ -36,8 +37,8 @@ Default listen port is 8080 (`POLYDISPLAY_PORT`). Dark/light follows the device.
 Downloads Go if needed, asks for a Polymarket public address (`0x...`), writes
 `config.json`, builds `polydisplayd`, and installs a login service: LaunchAgent
 on macOS, systemd user unit on Linux. At the prompt you can add extra tickers;
-those are looked up on CoinGecko. Binance is used at runtime when a USDT pair
-exists, otherwise CoinGecko.
+those are looked up on CoinGecko. Kraken supplies runtime prices and candles,
+with Coinbase as the fallback.
 
 ```bash
 POLYMARKET_WALLET=0x... POLYDISPLAY_EXTRA_ASSETS=FLR,HBAR ./install.sh
@@ -118,7 +119,7 @@ search, or run `./install.sh` again and add them at the prompt.
 
 Port: `POLYDISPLAY_PORT` in `.env`, else `config.json` `port`, else 8080.
 Wallet and candle range: ⚙ or `config.json`. Pad PIN: `POLYDISPLAY_PIN` in
-`.env`. Optional `CG_DEMO_KEY` in `.env` for a higher CoinGecko rate limit.
+`.env`. Optional `CG_DEMO_KEY` in `.env` applies only to asset search.
 
 If ⚙ has saved a `coins` list into `config.json`, that list wins until you
 delete the `coins` key. `config.json` and `.env` are gitignored.
@@ -128,7 +129,8 @@ Logs: `polydisplay.log` in the working directory. Rolled at local midnight to
 
 ## Data
 
-Candles and prices: Binance when a USDT pair exists, otherwise CoinGecko.
+Candles and prices: Kraken, with Coinbase fallback. Kraken ticker prices are
+fetched in one request; OHLC requests are paced to its public API guidance.
 Positions and activity: Polymarket data-api, polled every 30s. Account P/L:
 Polymarket user-pnl-api, 720 hourly points over 30 days, polled every 2 min
 and thinned to 120 points for the sparkline. Gamma market metadata supplies
diff --git a/com.novatechflow.polydisplay.plist b/com.novatechflow.polydisplay.plist
index 7b8bc33..5230e34 100644
--- a/com.novatechflow.polydisplay.plist
+++ b/com.novatechflow.polydisplay.plist
@@ -39,7 +39,7 @@
   <string>/dev/null</string>
   <key>EnvironmentVariables</key>
   <dict>
-    <!-- optional: paste a free CoinGecko demo key for higher rate limits -->
+    <!-- optional: CoinGecko key used only by asset search -->
     <key>CG_DEMO_KEY</key>
     <string></string>
   </dict>
diff --git a/index.html b/index.html
index fa9b06d..cc7083b 100644
--- a/index.html
+++ b/index.html
@@ -20,7 +20,7 @@
 
   polyDisplay - LAN web app: Polymarket positions + crypto watchlist.
   The browser talks ONLY to the local Go server (/api/*): it aggregates
-  Polymarket + crypto (Binance-first, CoinGecko fallback) so the display
+  Polymarket + crypto (Kraken-first, Coinbase fallback) so the display
   never hits an external API, rate limit, or geoblock.
 -->
 <style>
@@ -196,7 +196,7 @@ <h3>Settings</h3>
       <button class="btn primary" id="saveBtn">Save &amp; reload</button>
     </div>
     <button class="btn" id="reloadBtn" style="width:100%;margin-top:10px">Reload app &middot; clear cache</button>
-    <div class="muted" style="margin-top:10px">Saved on the server (config.json). Data source: Binance &rarr; CoinGecko fallback.</div>
+    <div class="muted" style="margin-top:10px">Saved on the server (config.json). Data source: Kraken &rarr; Coinbase fallback.</div>
   </div>
 </div>
 
@@ -564,7 +564,7 @@ <h3>Unlock pad</h3>
   if(!coins.length){ cl='<div class="empty">No assets. Tap &#9881; to add.</div>'; }
   for(var k=0;k<coins.length;k++){
     var c=coins[k];
-    var tag=c.source?('<span class="srctag">'+(c.source==="binance"?"Binance":"CoinGecko")+'</span>'):"";
+    var tag=c.source?('<span class="srctag">'+(c.source==="kraken"?"Kraken":"Coinbase")+'</span>'):"";
     cl+='<div class="coin'+(c.active?' active':'')+'"><div class="top">'+
       '<div><span class="sym">'+esc(c.sym)+'</span><span class="name">'+esc(c.name)+'</span></div>'+
       '<div><span class="val">'+fmtUsd(c.price)+'</span>'+
diff --git a/install.sh b/install.sh
index 0a1b538..278c2a8 100755
--- a/install.sh
+++ b/install.sh
@@ -180,11 +180,11 @@ ensure_auth() {
   echo "Clearing site data on the pad means typing the PIN again."
 }
 
-# CoinGecko search for id+name; Binance ticker tells us if SYM+USDT exists.
-# Prints "SYM:Name:id<TAB>binance|coingecko" or exits non-zero.
+# CoinGecko search supplies a stable id and display name. Runtime market data
+# comes from Kraken with Coinbase fallback.
 resolve_asset() {
   py - "$1" <<'PY'
-import json, sys, urllib.error, urllib.parse, urllib.request
+import json, sys, urllib.parse, urllib.request
 
 q = sys.argv[1].strip()
 if not q:
@@ -217,30 +217,16 @@ name = pick.get("name") or sym
 cid = pick.get("id") or ""
 if not cid:
     sys.exit(4)
-src = "coingecko"
-try:
-    urllib.request.urlopen(
-        urllib.request.Request(
-            "https://api.binance.com/api/v3/ticker/24hr?symbol=" + urllib.parse.quote(sym + "USDT"),
-            headers=ua,
-        ),
-        timeout=10,
-    )
-    src = "binance"
-except urllib.error.HTTPError:
-    pass
-except Exception:
-    pass
-print("%s:%s:%s\t%s" % (sym, name, cid, src))
+print("%s:%s:%s" % (sym, name, cid))
 PY
 }
 
 ask_assets() {
-  local extra raw spec src line
+  local extra raw spec line
   extra="${POLYDISPLAY_EXTRA_ASSETS:-}"
   if [ -z "$extra" ] && [ -t 0 ]; then
     echo "Watchlist starts with BTC, ETH, SOL, XRP (Polymarket)."
-    echo "Extra names are looked up on CoinGecko; Binance is used when a USDT pair exists."
+    echo "Extra names are looked up on CoinGecko; charts use Kraken then Coinbase."
     read -r -p "Additional assets to chart (tickers or names, comma-separated, empty to skip): " extra
   fi
   [ -n "$extra" ] || return 0
@@ -251,9 +237,7 @@ ask_assets() {
     line="$(echo "$line" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
     [ -n "$line" ] || continue
     if spec="$(resolve_asset "$line")"; then
-      src="${spec##*$'\t'}"
-      spec="${spec%%$'\t'*}"
-      echo "   $spec  ($src)"
+      echo "   $spec"
       specs+=("$spec")
     else
       echo "   skip $line (not found on CoinGecko)"
diff --git a/server.go b/server.go
index 0a19f0d..a416f09 100644
--- a/server.go
+++ b/server.go
@@ -3,7 +3,7 @@
 //
 // polyDisplay aggregator server.
 //
-// Polls Polymarket + (Binance-first, CoinGecko-fallback) on its own schedule,
+// Polls Polymarket + (Kraken-first, Coinbase-fallback) on its own schedule,
 // caches the result, and serves ONE cheap endpoint (/api/state) plus the static
 // web app. The browser therefore makes a single LAN request and never
 // touches an external API, cert, rate limit, or geoblock.
@@ -36,7 +36,7 @@ type Coin struct {
 	Sym  string `json:"sym"`
 	Name string `json:"name"`
 	ID   string `json:"id"`           // CoinGecko id
-	Bn   string `json:"bn,omitempty"` // Binance symbol override; default SYM+USDT
+	Bn   string `json:"bn,omitempty"` // legacy market-symbol override
 }
 
 type Config struct {
@@ -83,7 +83,8 @@ func loadEnvFile(path string) {
 }
 
 // POLYDISPLAY_ASSETS=SYM:Name:id,SYM:id,...  Name may contain spaces.
-// Two fields → name defaults to SYM. Fourth field is an optional Binance symbol.
+// Two fields → name defaults to SYM. A legacy fourth-field market override is
+// reduced to its base symbol for Kraken and Coinbase.
 func parseAssets(s string) []Coin {
 	var out []Coin
 	for _, item := range strings.Split(s, ",") {
@@ -212,7 +213,7 @@ type CoinState struct {
 	ID      string   `json:"id"`
 	Price   float64  `json:"price"`
 	Chg24h  float64  `json:"chg24h"`
-	Source  string   `json:"source"` // "binance" | "coingecko" | ""
+	Source  string   `json:"source"` // "kraken" | "coinbase" | ""
 	Active  bool     `json:"active"` // referenced by a current Polymarket position
 	Candles []Candle `json:"candles"`
 	Cand24  []Candle `json:"cand24"` // last 24h, whatever the display period
@@ -269,15 +270,14 @@ type State struct {
 }
 
 var (
-	mu      sync.RWMutex
-	cfg     Config
-	state   State
-	candles = map[string][]Candle{}   // id -> candles (refreshed slowly)
-	cand24  = map[string][]Candle{}   // id -> last 24h, for the trend read
-	csource = map[string]string{}     // id -> source
-	bnHas   = map[string]bool{}       // id -> has a working Binance pair (absent = unknown)
-	bnProbe = map[string]time.Time{}  // id -> when to re-probe a pair Binance doesn't list
-	cgPrice = map[string][2]float64{} // id -> {price, chg} cached CoinGecko price (non-Binance coins)
+	mu          sync.RWMutex
+	cfg         Config
+	state       State
+	candles     = map[string][]Candle{} // id -> candles (refreshed slowly)
+	cand24      = map[string][]Candle{} // id -> last 24h, for the trend read
+	csource     = map[string]string{}   // id -> candle source
+	marketPrice = map[string]float64{}  // id -> last good spot price
+	slowMu      sync.Mutex
 	// Fresh connection per request: a VPN's short idle timeout was dropping the
 	// pooled keep-alive connections during the 20s gap between cycles, so the
 	// first couple of requests each cycle failed (BTC/ETH showed price 0).
@@ -385,9 +385,8 @@ func shortURL(raw string) string {
 	return strings.TrimPrefix(strings.TrimPrefix(raw, "https://"), "http://")
 }
 
-// Log upstream failures, but collapse repeats: the Binance pair probe 400s once
-// per slow cycle for every non-Binance token (FLR etc), which would otherwise
-// bury the 429s this logging exists to catch.
+// Log upstream failures, but collapse repeats so a temporary provider outage
+// does not bury the first useful error in repeated refresh attempts.
 const upstreamLogEvery = 10 * time.Minute
 
 var (
@@ -454,101 +453,209 @@ func cgHeaders() map[string]string {
 
 /* ------------------------- data fetchers ------------------------- */
 
-func bnSymbol(c Coin) string {
-	if c.Bn != "" {
-		return c.Bn
+var (
+	krakenBase   = "https://api.kraken.com"
+	coinbaseBase = "https://api.exchange.coinbase.com"
+)
+
+func marketSymbol(c Coin) string {
+	s := strings.ToUpper(strings.TrimSpace(c.Sym))
+	if c.Bn != "" { // accept old fourth-field values such as WIFUSDT
+		s = strings.ToUpper(strings.TrimSpace(c.Bn))
+		for _, suffix := range []string{"USDT", "USD"} {
+			s = strings.TrimSuffix(s, suffix)
+		}
+		s = strings.TrimRight(s, "-/")
+	}
+	return s
+}
+
+func krakenPair(c Coin) string {
+	s := marketSymbol(c)
+	if s == "BTC" {
+		s = "XBT"
 	}
-	return c.Sym + "USDT"
+	return s + "USD"
 }
 
-func bnParams(days int) (string, int) {
+func coinbaseProduct(c Coin) string { return marketSymbol(c) + "-USD" }
+
+func candleParams(days int, provider string) (interval, limit int) {
+	if provider == "kraken" {
+		switch {
+		case days <= 1:
+			return 30, 48
+		case days <= 7:
+			return 240, 42
+		case days <= 14:
+			return 240, 84
+		default:
+			return 240, 180
+		}
+	}
 	switch {
 	case days <= 1:
-		return "30m", 48
+		return 900, 96
 	case days <= 7:
-		return "4h", 42
+		return 3600, 168
 	case days <= 14:
-		return "8h", 42
+		return 21600, 56
 	default:
-		return "12h", 60
+		return 21600, 120
 	}
 }
 
-func fetchBinanceCandles(c Coin, days int) ([]Candle, error) {
-	iv, lim := bnParams(days)
-	url := fmt.Sprintf("https://api.binance.com/api/v3/klines?symbol=%s&interval=%s&limit=%d", bnSymbol(c), iv, lim)
-	var raw [][]interface{}
-	if err := getJSON(url, &raw, nil); err != nil {
+func trimCandles(in []Candle, limit int) []Candle {
+	sort.Slice(in, func(i, j int) bool { return in[i][0] < in[j][0] })
+	if len(in) > limit {
+		return in[len(in)-limit:]
+	}
+	return in
+}
+
+func fetchKrakenCandles(c Coin, days int) ([]Candle, error) {
+	interval, limit := candleParams(days, "kraken")
+	q := url.Values{}
+	q.Set("pair", krakenPair(c))
+	q.Set("interval", strconv.Itoa(interval))
+	q.Set("assetVersion", "1")
+	q.Set("since", strconv.FormatInt(time.Now().Add(-time.Duration(days)*24*time.Hour).Unix(), 10))
+	u := krakenBase + "/0/public/OHLC?" + q.Encode()
+	var raw struct {
+		Error  []string                   `json:"error"`
+		Result map[string]json.RawMessage `json:"result"`
+	}
+	if err := getJSON(u, &raw, nil); err != nil {
 		return nil, err
 	}
-	if len(raw) == 0 {
-		return nil, fmt.Errorf("empty")
+	if len(raw.Error) > 0 {
+		return nil, fmt.Errorf("%s", strings.Join(raw.Error, ", "))
 	}
-	out := make([]Candle, 0, len(raw))
-	for _, k := range raw {
+	var rows [][]interface{}
+	for key, value := range raw.Result {
+		if key != "last" && json.Unmarshal(value, &rows) == nil {
+			break
+		}
+	}
+	out := make([]Candle, 0, len(rows))
+	for _, k := range rows {
 		if len(k) < 5 {
 			continue
 		}
-		t, _ := k[0].(float64)
+		t, _ := strconv.ParseFloat(fmt.Sprint(k[0]), 64)
 		o, _ := strconv.ParseFloat(fmt.Sprint(k[1]), 64)
 		h, _ := strconv.ParseFloat(fmt.Sprint(k[2]), 64)
 		l, _ := strconv.ParseFloat(fmt.Sprint(k[3]), 64)
 		cl, _ := strconv.ParseFloat(fmt.Sprint(k[4]), 64)
-		out = append(out, Candle{t, o, h, l, cl})
+		out = append(out, Candle{t * 1000, o, h, l, cl})
 	}
-	return out, nil
+	if len(out) == 0 {
+		return nil, fmt.Errorf("empty")
+	}
+	return trimCandles(out, limit), nil
 }
 
-func fetchCgCandles(c Coin, days int) ([]Candle, error) {
-	url := fmt.Sprintf("https://api.coingecko.com/api/v3/coins/%s/ohlc?vs_currency=usd&days=%d", c.ID, days)
+func fetchCoinbaseCandles(c Coin, days int) ([]Candle, error) {
+	granularity, limit := candleParams(days, "coinbase")
+	end := time.Now().UTC()
+	q := url.Values{}
+	q.Set("granularity", strconv.Itoa(granularity))
+	q.Set("start", end.Add(-time.Duration(days)*24*time.Hour).Format(time.RFC3339))
+	q.Set("end", end.Format(time.RFC3339))
+	u := coinbaseBase + "/products/" + url.PathEscape(coinbaseProduct(c)) + "/candles?" + q.Encode()
 	var raw [][]float64
-	if err := getJSON(url, &raw, cgHeaders()); err != nil {
+	if err := getJSON(u, &raw, nil); err != nil {
 		return nil, err
 	}
-	if len(raw) == 0 {
-		return nil, fmt.Errorf("empty")
-	}
 	out := make([]Candle, 0, len(raw))
 	for _, k := range raw {
 		if len(k) >= 5 {
-			out = append(out, Candle{k[0], k[1], k[2], k[3], k[4]})
+			out = append(out, Candle{k[0] * 1000, k[3], k[2], k[1], k[4]})
 		}
 	}
-	return out, nil
+	if len(out) == 0 {
+		return nil, fmt.Errorf("empty")
+	}
+	return trimCandles(out, limit), nil
 }
 
-// live price + 24h change from Binance (primary source)
-func fetchBinanceTicker(sym string) (float64, float64, error) {
-	var t struct {
-		LastPrice string `json:"lastPrice"`
-		Pct       string `json:"priceChangePercent"`
+func fetchMarketCandles(c Coin, days int) ([]Candle, string, error) {
+	cs, kerr := fetchKrakenCandles(c, days)
+	if kerr == nil {
+		return cs, "kraken", nil
 	}
-	if err := getJSON("https://api.binance.com/api/v3/ticker/24hr?symbol="+sym, &t, nil); err != nil {
-		return 0, 0, err
+	cs, cerr := fetchCoinbaseCandles(c, days)
+	if cerr == nil {
+		return cs, "coinbase", nil
 	}
-	if t.LastPrice == "" {
-		return 0, 0, fmt.Errorf("no price")
+	return nil, "", fmt.Errorf("kraken: %v; coinbase: %v", kerr, cerr)
+}
+
+func pairKey(s string) string {
+	s = strings.NewReplacer("/", "", "-", "").Replace(strings.ToUpper(s))
+	if strings.HasPrefix(s, "XBT") {
+		s = "BTC" + strings.TrimPrefix(s, "XBT")
 	}
-	p, _ := strconv.ParseFloat(t.LastPrice, 64)
-	c, _ := strconv.ParseFloat(t.Pct, 64)
-	return p, c, nil
+	return s
 }
 
-// CoinGecko price fallback (only for tokens with no Binance pair, e.g. FLR)
-func fetchCgPrice(id string) (float64, float64, error) {
-	var m map[string]struct {
-		USD float64 `json:"usd"`
-		Chg float64 `json:"usd_24h_change"`
+func fetchKrakenPrices(coins []Coin) (map[string]float64, error) {
+	if len(coins) == 0 {
+		return map[string]float64{}, nil
+	}
+	pairs := make([]string, 0, len(coins))
+	ids := map[string]string{}
+	for _, c := range coins {
+		pair := krakenPair(c)
+		pairs = append(pairs, pair)
+		ids[pairKey(pair)] = c.ID
 	}
-	url := "https://api.coingecko.com/api/v3/simple/price?ids=" + id + "&vs_currencies=usd&include_24hr_change=true"
-	if err := getJSON(url, &m, cgHeaders()); err != nil {
-		return 0, 0, err
+	u := krakenBase + "/0/public/Ticker?pair=" + url.QueryEscape(strings.Join(pairs, ",")) + "&assetVersion=1"
+	var raw struct {
+		Error  []string `json:"error"`
+		Result map[string]struct {
+			Close []string `json:"c"`
+		} `json:"result"`
 	}
-	v, ok := m[id]
-	if !ok {
-		return 0, 0, fmt.Errorf("no price")
+	if err := getJSON(u, &raw, nil); err != nil {
+		return nil, err
 	}
-	return v.USD, v.Chg, nil
+	if len(raw.Error) > 0 {
+		return nil, fmt.Errorf("%s", strings.Join(raw.Error, ", "))
+	}
+	out := map[string]float64{}
+	for pair, ticker := range raw.Result {
+		id, ok := ids[pairKey(pair)]
+		if !ok || len(ticker.Close) == 0 {
+			continue
+		}
+		if p, err := strconv.ParseFloat(ticker.Close[0], 64); err == nil && p > 0 {
+			out[id] = p
+		}
+	}
+	return out, nil
+}
+
+func fetchCoinbasePrice(c Coin) (float64, error) {
+	var raw struct {
+		Price string `json:"price"`
+	}
+	u := coinbaseBase + "/products/" + url.PathEscape(coinbaseProduct(c)) + "/ticker"
+	if err := getJSON(u, &raw, nil); err != nil {
+		return 0, err
+	}
+	p, err := strconv.ParseFloat(raw.Price, 64)
+	if err != nil || p <= 0 {
+		return 0, fmt.Errorf("no price")
+	}
+	return p, nil
+}
+
+func candleChange24(price float64, data []Candle) float64 {
+	if price <= 0 || len(data) == 0 || data[0][1] <= 0 {
+		return 0
+	}
+	return (price/data[0][1] - 1) * 100
 }
 
 func fetchPositions(wallet string) ([]Position, error) {
@@ -807,44 +914,42 @@ func refreshFast() {
 		refreshPnl(wallet)
 	}
 
-	// Binance-only hot path. Tokens with no Binance pair (e.g. FLR) use the
-	// CoinGecko price cached by the slow loop, so CoinGecko is never called at
-	// 20s cadence (that was the source of the 429s).
-	type pr struct{ price, chg float64 }
-	prices := map[string]pr{}
+	// Kraken returns all requested tickers in one call. Only missing pairs fall
+	// back to Coinbase, and the last good price survives a provider outage.
+	prices, _ := fetchKrakenPrices(c.Coins)
+	if prices == nil {
+		prices = map[string]float64{}
+	}
+	var priceMu sync.Mutex
+	var priceWG sync.WaitGroup
 	for _, cn := range c.Coins {
-		mu.RLock()
-		known, seen := bnHas[cn.ID]
-		cached, hasCache := cgPrice[cn.ID]
-		mu.RUnlock()
-
-		if !seen || known { // unknown or known-on-Binance -> try Binance
-			if p, ch, e := fetchBinanceTicker(bnSymbol(cn)); e == nil {
-				prices[cn.ID] = pr{p, ch}
-				mu.Lock()
-				bnHas[cn.ID] = true
-				mu.Unlock()
-				continue
-			}
-			mu.Lock()
-			bnHas[cn.ID] = false
-			mu.Unlock()
-		}
-		if hasCache { // non-Binance token -> use cached CoinGecko price
-			prices[cn.ID] = pr{cached[0], cached[1]}
+		if prices[cn.ID] == 0 {
+			cn := cn
+			priceWG.Add(1)
+			go func() {
+				defer priceWG.Done()
+				if p, err := fetchCoinbasePrice(cn); err == nil {
+					priceMu.Lock()
+					prices[cn.ID] = p
+					priceMu.Unlock()
+				}
+			}()
 		}
-		// else: not yet cached (first few seconds after start) -> shows blank, not an error
 	}
+	priceWG.Wait()
 
 	active := activeCoins(positions, c.Coins)
 
 	mu.Lock()
+	for id, price := range prices {
+		marketPrice[id] = price
+	}
 	coinStates := make([]CoinState, 0, len(c.Coins))
 	for _, cn := range sortedCoins(c.Coins, c.Sort, active) {
-		p := prices[cn.ID]
+		p := marketPrice[cn.ID]
 		coinStates = append(coinStates, CoinState{
 			Sym: cn.Sym, Name: cn.Name, ID: cn.ID,
-			Price: p.price, Chg24h: p.chg,
+			Price: p, Chg24h: candleChange24(p, cand24[cn.ID]),
 			Source: csource[cn.ID], Active: active[cn.ID], Candles: candles[cn.ID],
 			Cand24: cand24[cn.ID],
 		})
@@ -862,77 +967,42 @@ func refreshFast() {
 	mu.Unlock()
 }
 
-// How often to re-check a token Binance doesn't list. Every slow cycle was a
-// guaranteed 400 per such token; hourly still catches a new listing same-day.
-const bnProbeEvery = time.Hour
-
-func binanceDue(id string) bool {
-	mu.RLock()
-	defer mu.RUnlock()
-	return time.Now().After(bnProbe[id])
-}
-
 // slow: candles + polymarket history (every 5 min), spaced out
 func refreshSlow() {
+	slowMu.Lock()
+	defer slowMu.Unlock()
+
 	mu.RLock()
 	c := cfg
 	mu.RUnlock()
 
 	for _, cn := range c.Coins {
-		var cs []Candle
-		var src string
-		probed := binanceDue(cn.ID)
-		if probed {
-			if bc, err := fetchBinanceCandles(cn, c.CandleDays); err == nil {
-				cs, src = bc, "binance"
-			}
-		}
-		if cs == nil {
-			if gc, err := fetchCgCandles(cn, c.CandleDays); err == nil {
-				cs, src = gc, "coingecko"
-			}
+		cs, src, err := fetchMarketCandles(cn, c.CandleDays)
+		if err != nil {
+			log.Printf("market candles %s: %v", cn.Sym, err)
 		}
 		// the trend read always wants 24h; a 7d/4h window only spans 6 candles
 		var c24 []Candle
 		if cs != nil && c.CandleDays == 1 {
 			c24 = cs
-		} else if src == "binance" {
-			if bc, err := fetchBinanceCandles(cn, 1); err == nil {
-				c24 = bc
-			}
-		} else if src == "coingecko" {
-			if gc, err := fetchCgCandles(cn, 1); err == nil {
-				c24 = gc
+		} else {
+			time.Sleep(1100 * time.Millisecond)
+			if trend, _, trendErr := fetchMarketCandles(cn, 1); trendErr == nil {
+				c24 = trend
+			} else {
+				log.Printf("market trend %s: %v", cn.Sym, trendErr)
 			}
 		}
 		mu.Lock()
 		if cs != nil {
 			candles[cn.ID] = cs
 			csource[cn.ID] = src
-			bnHas[cn.ID] = src == "binance"
 		}
 		if c24 != nil {
 			cand24[cn.ID] = c24
 		}
-		if probed {
-			if src == "binance" {
-				delete(bnProbe, cn.ID)
-			} else {
-				bnProbe[cn.ID] = time.Now().Add(bnProbeEvery)
-			}
-		}
 		mu.Unlock()
-		// non-Binance token: cache a CoinGecko price so the hot path never calls CG
-		if src == "coingecko" {
-			if p, ch, e := fetchCgPrice(cn.ID); e == nil {
-				mu.Lock()
-				cgPrice[cn.ID] = [2]float64{p, ch}
-				mu.Unlock()
-			}
-			time.Sleep(1500 * time.Millisecond) // gentle on CoinGecko free tier
-		} else {
-			time.Sleep(200 * time.Millisecond) // Binance handles bursts fine -> snappy refresh
-		}
+		time.Sleep(1100 * time.Millisecond) // Kraken public REST guidance: at most 1 request/s
 	}
 }
 
@@ -988,9 +1058,7 @@ func handleConfig(w http.ResponseWriter, r *http.Request) {
 		candles = map[string][]Candle{}
 		cand24 = map[string][]Candle{}
 		csource = map[string]string{}
-		bnHas = map[string]bool{}
-		bnProbe = map[string]time.Time{}
-		cgPrice = map[string][2]float64{}
+		marketPrice = map[string]float64{}
 		mu.Unlock()
 		saveConfig(saved)
 		select {
diff --git a/server_test.go b/server_test.go
index ffc4033..ac6570d 100644
--- a/server_test.go
+++ b/server_test.go
@@ -106,7 +106,7 @@ func TestRefreshFastBacksOffAndKeepsLastPositions(t *testing.T) {
 
 	origBase := polyBase
 	polyBase = srv.URL
-	cfg = Config{Wallet: "0xtest", CandleDays: 1, Sort: "az"} // no coins -> no Binance calls
+	cfg = Config{Wallet: "0xtest", CandleDays: 1, Sort: "az"} // no coins -> no market-data calls
 	polyNextAt, polyBackoff, polyWallet = time.Time{}, 0, ""
 	lastPositions, lastActivity = nil, nil
 	t.Cleanup(func() {
@@ -297,20 +297,144 @@ func TestFetchPositionsAddsBTCPriceToBeat(t *testing.T) {
 	}
 }
 
-func TestBinanceDue(t *testing.T) {
-	bnProbe = map[string]time.Time{}
-	t.Cleanup(func() { bnProbe = map[string]time.Time{} })
+func TestMarketPairsPreserveLegacyOverride(t *testing.T) {
+	if got := krakenPair(Coin{Sym: "BTC"}); got != "XBTUSD" {
+		t.Errorf("kraken BTC pair = %q, want XBTUSD", got)
+	}
+	c := Coin{Sym: "OLD", Bn: "WIFUSDT"}
+	if got := krakenPair(c); got != "WIFUSD" {
+		t.Errorf("legacy Kraken pair = %q, want WIFUSD", got)
+	}
+	if got := coinbaseProduct(c); got != "WIF-USD" {
+		t.Errorf("legacy Coinbase product = %q, want WIF-USD", got)
+	}
+}
 
-	if !binanceDue("never-probed") {
-		t.Error("unknown token: want a probe")
+func TestFetchMarketCandlesFallsBackToCoinbase(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/0/public/OHLC":
+			w.WriteHeader(http.StatusUnavailableForLegalReasons)
+		case r.URL.Path == "/products/BTC-USD/candles":
+			// Coinbase is newest-first: [time, low, high, open, close, volume].
+			w.Write([]byte(`[[200,2,4,3,3.5,10],[100,1,3,2,2.5,8]]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	origKraken, origCoinbase := krakenBase, coinbaseBase
+	krakenBase, coinbaseBase = srv.URL, srv.URL
+	t.Cleanup(func() { krakenBase, coinbaseBase = origKraken, origCoinbase })
+
+	got, source, err := fetchMarketCandles(Coin{Sym: "BTC", ID: "bitcoin"}, 1)
+	if err != nil {
+		t.Fatal(err)
 	}
-	bnProbe["flare-networks"] = time.Now().Add(bnProbeEvery)
-	if binanceDue("flare-networks") {
-		t.Error("recently 400'd: want the probe skipped")
+	if source != "coinbase" {
+		t.Errorf("source = %q, want coinbase", source)
 	}
-	bnProbe["flare-networks"] = time.Now().Add(-time.Minute)
-	if !binanceDue("flare-networks") {
-		t.Error("probe window elapsed: want a re-probe")
+	if len(got) != 2 || got[0] != (Candle{100000, 2, 3, 1, 2.5}) || got[1][0] != 200000 {
+		t.Errorf("normalized Coinbase candles = %#v", got)
+	}
+}
+
+func TestFetchKrakenCandlesNormalizesAndSorts(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(`{"error":[],"result":{"BTC/USD":[[200,"3","4","2","3.5","0",1,1],[100,"2","3","1","2.5","0",1,1]],"last":200}}`))
+	}))
+	defer srv.Close()
+	orig := krakenBase
+	krakenBase = srv.URL
+	t.Cleanup(func() { krakenBase = orig })
+
+	got, err := fetchKrakenCandles(Coin{Sym: "BTC"}, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 || got[0] != (Candle{100000, 2, 3, 1, 2.5}) || got[1][0] != 200000 {
+		t.Errorf("normalized Kraken candles = %#v", got)
+	}
+}
+
+func TestFetchKrakenPricesBatchesPairs(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		pairs := r.URL.Query().Get("pair")
+		if !strings.Contains(pairs, "XBTUSD") || !strings.Contains(pairs, "ETHUSD") {
+			t.Errorf("pair query = %q", pairs)
+		}
+		w.Write([]byte(`{"error":[],"result":{"BTC/USD":{"c":["100.5","1"]},"ETH/USD":{"c":["20.25","1"]}}}`))
+	}))
+	defer srv.Close()
+	orig := krakenBase
+	krakenBase = srv.URL
+	t.Cleanup(func() { krakenBase = orig })
+
+	got, err := fetchKrakenPrices([]Coin{{Sym: "BTC", ID: "bitcoin"}, {Sym: "ETH", ID: "ethereum"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got["bitcoin"] != 100.5 || got["ethereum"] != 20.25 {
+		t.Errorf("prices = %#v", got)
+	}
+}
+
+func TestRefreshFastUsesCoinbaseAndKeepsLastPrice(t *testing.T) {
+	var krakenOK, coinbaseOK atomic.Bool
+	krakenOK.Store(true)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/0/public/Ticker":
+			if !krakenOK.Load() {
+				w.WriteHeader(http.StatusUnavailableForLegalReasons)
+				return
+			}
+			w.Write([]byte(`{"error":[],"result":{"BTC/USD":{"c":["100","1"]}}}`))
+		case "/products/BTC-USD/ticker":
+			if !coinbaseOK.Load() {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				return
+			}
+			w.Write([]byte(`{"price":"101"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+
+	origKraken, origCoinbase := krakenBase, coinbaseBase
+	krakenBase, coinbaseBase = srv.URL, srv.URL
+	cfg = Config{CandleDays: 1, Sort: "az", Coins: []Coin{{Sym: "BTC", ID: "bitcoin"}}}
+	marketPrice = map[string]float64{}
+	t.Cleanup(func() {
+		krakenBase, coinbaseBase = origKraken, origCoinbase
+		cfg, state = Config{}, State{}
+		marketPrice = map[string]float64{}
+	})
+
+	refreshFast()
+	if got := state.Coins[0].Price; got != 100 {
+		t.Fatalf("Kraken price = %v, want 100", got)
+	}
+
+	krakenOK.Store(false)
+	coinbaseOK.Store(true)
+	refreshFast()
+	if got := state.Coins[0].Price; got != 101 {
+		t.Fatalf("Coinbase fallback price = %v, want 101", got)
+	}
+
+	coinbaseOK.Store(false)
+	refreshFast()
+	if got := state.Coins[0].Price; got != 101 {
+		t.Fatalf("price after both providers fail = %v, want last good 101", got)
+	}
+}
+
+func TestCandleChange24(t *testing.T) {
+	got := candleChange24(110, []Candle{{0, 100, 0, 0, 0}})
+	if got < 9.999 || got > 10.001 {
+		t.Errorf("change = %v, want 10%%", got)
 	}
 }
 
@@ -520,7 +644,8 @@ func TestInstallScriptSyntax(t *testing.T) {
 		"POLYDISPLAY_TOKEN_SECRET",
 		"POLYDISPLAY_EXTRA_ASSETS",
 		"api.coingecko.com/api/v3/search",
-		"api.binance.com/api/v3/ticker/24hr",
+		"Kraken",
+		"Coinbase",
 	} {
 		if !strings.Contains(s, want) {
 			t.Errorf("install.sh missing %q", want)
@@ -529,6 +654,9 @@ func TestInstallScriptSyntax(t *testing.T) {
 	if strings.Contains(s, "install_windows") {
 		t.Error("install.sh should not install a Windows service")
 	}
+	if strings.Contains(s, "api.binance.com") {
+		t.Error("install.sh must not probe the geo-blocked Binance API")
+	}
 }
 
 func TestLiveConfigIsGitignored(t *testing.T) {