feat: add registry market statistics

Author: findolor

Cargo.lock

@@ -48,7 +48,7 @@ derive_builder = "0.20.0"
 thirtyfour = "0.31.0"
 test-context = "0.3.0"
 portpicker = "0.1.1"
-rain-erc = "0.1.1"
+rain-erc = "0.1.5"
 rain-math-float = "0.1.7"
 rain-error-decoding = "0.1.2"
 # Direct dep required: the #[wasm_bindgen] macro emits `::wasm_bindgen` paths, and

Cargo.toml

@@ -38,7 +38,9 @@ require its `COMMIT_SHA` env var.
   prepare batch withdraw calldata; expose WASM‑friendly structs. The `local_db/`
   subtree is split into `state.rs` (runtime state, query routing via
   `LocalDbState`/`QuerySource`/`SyncReadiness`) and `status.rs` (UI
-  status‑reporting types).
+  status‑reporting types). The `markets/` subtree discovers registry-listed
+  base/quote pairs and assembles normalized order books, trades, and rolling
+  statistics without application-specific token semantics.
 - `dotrain_order` — Parse and validate a DOTRAIN config; compose
   scenarios/deployments to Rainlang; fetch authoring metadata and pragma words;
   merge additional settings.

crates/common/ARCHITECTURE.md

@@ -43,6 +43,7 @@ csv = { workspace = true }
 chrono = { workspace = true }
 futures = { workspace = true }
 rain-error-decoding = { workspace = true }
+rain-erc = { workspace = true }
 rain-interpreter-eval = { workspace = true }
 wasm-bindgen = { workspace = true }
 wasm-bindgen-utils = { workspace = true }

crates/common/Cargo.toml

@@ -0,0 +1,267 @@
+use super::*;
+
+pub(super) fn discover_markets(
+    client: &RaindexClient,
+    options: &MarketListOptions,
+) -> Result<Vec<RaindexMarket>, RaindexError> {
+    let selected_chains = options
+        .chain_ids
+        .as_ref()
+        .map(|ids| ids.iter().copied().collect::<HashSet<_>>());
+    let tokens = client.get_all_tokens()?.into_values().collect::<Vec<_>>();
+    let raindexes = client
+        .get_all_raindexes()?
+        .into_values()
+        .collect::<Vec<_>>();
+    let mut bases = BTreeMap::<(u32, Address), TokenCfg>::new();
+
+    tokens
+        .iter()
+        .filter(|token| {
+            selected_chains
+                .as_ref()
+                .is_none_or(|chains| chains.contains(&token.network.chain_id))
+                && extension_bool(token, MARKET_LISTED_EXTENSION)
+                && !extension_bool(token, MARKET_QUOTE_EXTENSION)
+        })
+        .for_each(|token| {
+            bases.insert((token.network.chain_id, token.address), token.clone());
+        });
+
+    let mut markets = bases
+        .into_values()
+        .map(|base| {
+            let quote = unique_quote_token(&tokens, base.network.chain_id)?;
+            let base = market_token(&base);
+            let quote = market_token(&quote);
+            let mut raindex_addresses = raindexes
+                .iter()
+                .filter(|raindex| raindex.network.chain_id == base.chain_id)
+                .map(|raindex| raindex.address)
+                .collect::<Vec<_>>();
+            raindex_addresses.sort_unstable();
+            raindex_addresses.dedup();
+            let id = format!("{}:{:#x}:{:#x}", base.chain_id, base.address, quote.address);
+            let ticker_id = format!("{:#x}_{:#x}", base.address, quote.address);
+            Ok(RaindexMarket {
+                id,
+                ticker_id,
+                chain_id: base.chain_id,
+                base,
+                quote,
+                raindex_addresses,
+            })
+        })
+        .collect::<Result<Vec<_>, RaindexError>>()?;
+    markets.sort_by(|a, b| {
+        (a.chain_id, a.base.symbol.as_str(), a.base.address).cmp(&(
+            b.chain_id,
+            b.base.symbol.as_str(),
+            b.base.address,
+        ))
+    });
+    Ok(markets)
+}
+
+fn unique_quote_token(tokens: &[TokenCfg], chain_id: u32) -> Result<TokenCfg, RaindexError> {
+    let quotes = tokens
+        .iter()
+        .filter(|token| {
+            token.network.chain_id == chain_id && extension_bool(token, MARKET_QUOTE_EXTENSION)
+        })
+        .fold(BTreeMap::<Address, TokenCfg>::new(), |mut quotes, token| {
+            quotes.entry(token.address).or_insert_with(|| token.clone());
+            quotes
+        });
+
+    match quotes.into_values().collect::<Vec<_>>().as_slice() {
+        [quote] => Ok(quote.clone()),
+        [] => Err(RaindexError::PreflightError(format!(
+            "no token with {MARKET_QUOTE_EXTENSION}=true is configured for chain {chain_id}"
+        ))),
+        _ => Err(RaindexError::PreflightError(format!(
+            "multiple tokens with {MARKET_QUOTE_EXTENSION}=true are configured for chain {chain_id}"
+        ))),
+    }
+}
+
+fn market_token(token: &TokenCfg) -> RaindexMarketToken {
+    let unwrapped_address = extension_address(token, "unwrappedAddress");
+    let legacy_address = extension_address(token, "legacyAddress");
+    let receipt_address = extension_address(token, "receiptAddress");
+    let mut variants = [Some(token.address), unwrapped_address, legacy_address]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>();
+    variants.sort_unstable();
+    variants.dedup();
+
+    RaindexMarketToken {
+        chain_id: token.network.chain_id,
+        address: token.address,
+        name: token.label.clone().unwrap_or_else(|| token.key.clone()),
+        symbol: token.symbol.clone().unwrap_or_else(|| token.key.clone()),
+        decimals: token.decimals,
+        logo_uri: token.logo_uri.as_ref().map(ToString::to_string),
+        extensions: token.extensions.clone(),
+        unwrapped_address,
+        legacy_address,
+        receipt_address,
+        variants,
+    }
+}
+
+fn extension_string<'a>(token: &'a TokenCfg, key: &str) -> Option<&'a str> {
+    token
+        .extensions
+        .as_ref()
+        .and_then(|extensions| extensions.get(key))
+        .and_then(Value::as_str)
+}
+
+fn extension_bool(token: &TokenCfg, key: &str) -> bool {
+    token
+        .extensions
+        .as_ref()
+        .and_then(|extensions| extensions.get(key))
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+}
+
+fn extension_address(token: &TokenCfg, key: &str) -> Option<Address> {
+    extension_string(token, key).and_then(|address| address.parse().ok())
+}
+
+#[cfg(all(test, not(target_family = "wasm")))]
+mod tests {
+    use super::*;
+    use httpmock::MockServer;
+
+    const USDC: &str = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+    const STOCK: &str = "0xfb5b41acdba20a3230f84be995173cfb98b8d6e7";
+    const UNWRAPPED: &str = "0x7271a3c91bb6070ed09333b84a815949d4f16d14";
+
+    async fn client_with_tokens(tokens: Value) -> RaindexClient {
+        let server = MockServer::start_async().await;
+        server
+            .mock_async(|when, then| {
+                when.method("GET").path("/tokens");
+                then.status(200).json_body(serde_json::json!({
+                    "name": "Markets",
+                    "timestamp": "2026-01-01T00:00:00Z",
+                    "version": { "major": 1, "minor": 0, "patch": 0 },
+                    "tokens": tokens
+                }));
+            })
+            .await;
+        let yaml = format!(
+            r#"
+version: 6
+networks:
+  base:
+    rpcs:
+      - http://localhost:8545
+    chain-id: 8453
+subgraphs:
+  base: http://localhost:8080/subgraph
+raindexes:
+  base:
+    address: 0xe522cb4a5fcb2eb31a52ff41a4653d85a4fd7c9d
+    network: base
+    subgraph: base
+    deployment-block: 1
+using-tokens-from:
+  - {}/tokens
+"#,
+            server.base_url()
+        );
+        RaindexClient::new(vec![yaml], None, None).await.unwrap()
+    }
+
+    fn token(address: &str, symbol: &str, extensions: Value) -> Value {
+        serde_json::json!({
+            "chainId": 8453,
+            "address": address,
+            "name": symbol,
+            "symbol": symbol,
+            "decimals": 18,
+            "extensions": extensions
+        })
+    }
+
+    #[tokio::test]
+    async fn discovery_uses_only_registry_market_flags_and_preserves_opaque_extensions() {
+        let client = client_with_tokens(serde_json::json!([
+            token(
+                USDC,
+                "USDC",
+                serde_json::json!({ "marketListed": true, "marketQuote": true })
+            ),
+            token(
+                STOCK,
+                "wtNVDA",
+                serde_json::json!({
+                    "marketListed": true,
+                    "marketQuote": false,
+                    "unwrappedAddress": UNWRAPPED,
+                    "isin": "US67066G1040",
+                    "tradingViewSymbol": "NASDAQ:NVDA"
+                })
+            ),
+            token(
+                "0x1111111111111111111111111111111111111111",
+                "IGNORED",
+                serde_json::json!({ "marketQuote": false })
+            )
+        ]))
+        .await;
+
+        let markets = client.get_markets(None).unwrap();
+
+        assert_eq!(markets.len(), 1);
+        assert_eq!(markets[0].base.address.to_string().to_lowercase(), STOCK);
+        assert_eq!(markets[0].quote.address.to_string().to_lowercase(), USDC);
+        assert_eq!(markets[0].base.variants.len(), 2);
+        assert_eq!(
+            markets[0]
+                .base
+                .extensions
+                .as_ref()
+                .and_then(|extensions| extensions.get("isin"))
+                .and_then(Value::as_str),
+            Some("US67066G1040")
+        );
+    }
+
+    #[tokio::test]
+    async fn discovery_requires_one_quote_token_for_each_listed_market_chain() {
+        let client = client_with_tokens(serde_json::json!([token(
+            STOCK,
+            "wtNVDA",
+            serde_json::json!({ "marketListed": true })
+        )]))
+        .await;
+
+        let error = client.get_markets(None).unwrap_err().to_string();
+
+        assert!(error.contains("no token with marketQuote=true"));
+    }
+
+    #[tokio::test]
+    async fn discovery_rejects_ambiguous_quote_tokens() {
+        let client = client_with_tokens(serde_json::json!([
+            token(STOCK, "wtNVDA", serde_json::json!({ "marketListed": true })),
+            token(USDC, "USDC", serde_json::json!({ "marketQuote": true })),
+            token(
+                "0x2222222222222222222222222222222222222222",
+                "USDT",
+                serde_json::json!({ "marketQuote": true })
+            )
+        ]))
+        .await;
+
+        let error = client.get_markets(None).unwrap_err().to_string();
+
+        assert!(error.contains("multiple tokens with marketQuote=true"));
+    }
+}