dcex 0.26.0__tar.gz → 0.26.2__tar.gz

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

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

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

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

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

@@ -1,3 +1,21 @@
+## 0.4.3 (2026-06-29)
+
+### Fix
+
+- require API key for listen key requests
+- require BitMEX credentials for signed requests
+
+## 0.4.2 (2026-06-29)
+
+### Fix
+
+- satisfy product table lint checks
+- align native params and timeout validation
+
+### Perf
+
+- reduce product table lookup allocations
+
 ## 0.4.1 (2026-06-28)
 
 ### Fix

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

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

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/aster/wrappers.rs

@@ -15,7 +15,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         set_futures_multi_assets_mode(multi_assets_margin => "multiAssetsMargin"),
         get_futures_balance(),
         get_futures_account(),
-        modify_futures_position_margin(product_symbol => "product_symbol", amount => "amount", type_ => "type_"),
+        modify_futures_position_margin(product_symbol => "product_symbol", amount => "amount", type_ => "type"),
         get_futures_position_margin_history(product_symbol => "product_symbol"),
         get_futures_position_risk(),
         get_futures_user_trades(product_symbol => "product_symbol"),
@@ -35,7 +35,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         create_futures_listen_key(),
         keep_alive_futures_listen_key(),
         close_futures_listen_key(),
-        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type_"),
+        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type"),
         cancel_spot_order(product_symbol => "product_symbol"),
         get_spot_order(product_symbol => "product_symbol"),
         get_spot_open_order(product_symbol => "product_symbol"),
@@ -43,7 +43,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         cancel_all_spot_open_orders(product_symbol => "product_symbol"),
         get_spot_all_orders(product_symbol => "product_symbol"),
         get_spot_user_trades(),
-        place_futures_order(product_symbol => "product_symbol", side => "side", type_ => "type_"),
+        place_futures_order(product_symbol => "product_symbol", side => "side", type_ => "type"),
         modify_futures_order(product_symbol => "product_symbol", quantity => "quantity", price => "price"),
         place_futures_chase_order(product_symbol => "product_symbol", side => "side", quantity_unit => "quantityUnit", quantity => "quantity", chase_offset => "chaseOffset", chase_offset_type => "chaseOffsetType"),
         place_futures_batch_orders(batch_orders => "batchOrders"),

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/bingx/client.rs

@@ -6,7 +6,7 @@ use serde_json::Value;
 use crate::exchange::{ExchangeHttpClient, ValidatedResponse};
 use crate::http::{block_on, HttpMethod, HttpRequest, HttpResponse};
 use crate::product_table::ProductTable;
-use crate::Result;
+use crate::{DcexError, Result};
 
 use super::endpoints::BASE_URL;
 use super::params::{exchange_symbol_fallback, is_canonical_product_symbol};
@@ -157,11 +157,10 @@ impl BingxClient {
         path: &str,
         params: Vec<(String, String)>,
     ) -> Result<ValidatedResponse> {
-        let headers = self
-            .api_key
-            .as_ref()
-            .map(|api_key| vec![("X-BX-APIKEY".to_string(), api_key.to_string())])
-            .unwrap_or_default();
+        let api_key = self.api_key.as_deref().ok_or_else(|| {
+            DcexError::InvalidInput("BingX API key is required for this request.".to_string())
+        })?;
+        let headers = vec![("X-BX-APIKEY".to_string(), api_key.to_string())];
         self.request(HttpMethod::Post, path, params, false, headers, None)
             .await
     }

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/bingx/tests.rs

@@ -1,6 +1,8 @@
 use crate::exchange::RequestSigner;
-use crate::http::{HttpMethod, HttpRequest};
+use crate::http::{block_on, HttpMethod, HttpRequest};
+use std::time::Duration;
 
+use super::client::BingxClient;
 use super::endpoints::BASE_URL;
 use super::signing::BingxSigner;
 
@@ -37,3 +39,14 @@ fn signer_uses_unescaped_sorted_payload() {
         Some("api-key")
     );
 }
+
+#[test]
+fn listen_key_requires_api_key() {
+    let client = BingxClient::public(Duration::from_secs(1)).expect("client");
+    let error = block_on(async move { client.private_request("get_listen_key", Vec::new()).await })
+        .expect_err("missing API key should fail before sending");
+    assert_eq!(
+        error.to_string(),
+        "BingX API key is required for this request."
+    );
+}

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/bitmex/client.rs

@@ -157,24 +157,32 @@ impl BitmexClient {
             request.body = body.clone().map(RequestBody::Raw).unwrap_or_default();
         }
         if signed {
-            if let (Some(api_key), Some(api_secret)) = (&self.api_key, &self.api_secret) {
-                let body = String::from_utf8_lossy(body.as_deref().unwrap_or_default());
-                let payload = format!("{}{full_path}{expires}{body}", http_method_name(method));
-                let signature = hmac_sha256_hex(api_secret.as_bytes(), payload.as_bytes())?;
-                request
-                    .headers
-                    .insert("api-key".to_string(), api_key.clone());
-                request
-                    .headers
-                    .insert("api-signature".to_string(), signature);
-                request
-                    .headers
-                    .insert("api-expires".to_string(), expires.to_string());
-            }
+            let (api_key, api_secret) = self.credentials()?;
+            let body = String::from_utf8_lossy(body.as_deref().unwrap_or_default());
+            let payload = format!("{}{full_path}{expires}{body}", http_method_name(method));
+            let signature = hmac_sha256_hex(api_secret.as_bytes(), payload.as_bytes())?;
+            request
+                .headers
+                .insert("api-key".to_string(), api_key.to_string());
+            request
+                .headers
+                .insert("api-signature".to_string(), signature);
+            request
+                .headers
+                .insert("api-expires".to_string(), expires.to_string());
         }
         Ok(request)
     }
 
+    fn credentials(&self) -> Result<(&str, &str)> {
+        match (&self.api_key, &self.api_secret) {
+            (Some(api_key), Some(api_secret)) => Ok((api_key, api_secret)),
+            _ => Err(DcexError::InvalidInput(
+                "Signed BitMEX requests require api_key and api_secret.".to_string(),
+            )),
+        }
+    }
+
     pub(super) fn exchange_symbol(&self, product_symbol: &str) -> Result<String> {
         if is_canonical_product_symbol(product_symbol) {
             if let Some(table) = &self.product_table {

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/bitmex/tests.rs

@@ -31,6 +31,26 @@ fn signature_includes_encoded_query_path() {
     );
 }
 
+#[test]
+fn signed_request_requires_credentials() {
+    let client = BitmexClient::public(Duration::from_secs(1)).expect("client");
+    let error = client
+        .build_request(
+            HttpMethod::Get,
+            "/api/v1/order",
+            Vec::new(),
+            None,
+            true,
+            1_700_000_005,
+        )
+        .expect_err("missing credentials should fail before sending");
+
+    assert_eq!(
+        error.to_string(),
+        "Signed BitMEX requests require api_key and api_secret."
+    );
+}
+
 #[test]
 fn limit_buy_shortcut_builds_order_body_without_side_param() {
     let client = BitmexClient::public(Duration::from_secs(1)).expect("client");

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/kucoin/wrappers.rs

@@ -47,7 +47,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         place_futures_market_buy_order(product_symbol => "product_symbol", size => "size"),
         place_futures_market_order(product_symbol => "product_symbol", side => "side", size => "size"),
         place_futures_market_sell_order(product_symbol => "product_symbol", size => "size"),
-        place_futures_order(product_symbol => "product_symbol", side => "side", type_ => "type_", size => "size"),
+        place_futures_order(product_symbol => "product_symbol", side => "side", type_ => "type", size => "size"),
         place_futures_post_only_limit_buy_order(product_symbol => "product_symbol", size => "size", price => "price"),
         place_futures_post_only_limit_order(product_symbol => "product_symbol", side => "side", size => "size", price => "price"),
         place_futures_post_only_limit_sell_order(product_symbol => "product_symbol", size => "size", price => "price"),
@@ -60,7 +60,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         place_spot_market_buy_order(product_symbol => "product_symbol"),
         place_spot_market_order(product_symbol => "product_symbol", side => "side"),
         place_spot_market_sell_order(product_symbol => "product_symbol"),
-        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type_"),
+        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type"),
         place_spot_post_only_limit_buy_order(product_symbol => "product_symbol", size => "size", price => "price"),
         place_spot_post_only_limit_order(product_symbol => "product_symbol", side => "side", size => "size", price => "price"),
         place_spot_post_only_limit_sell_order(product_symbol => "product_symbol", size => "size", price => "price"),

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/mexc/wrappers.rs

@@ -39,7 +39,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         cancel_spot_open_orders(product_symbol => "product_symbol"),
         cancel_spot_order(product_symbol => "product_symbol"),
         change_contract_leverage(leverage => "leverage"),
-        change_contract_margin(position_id => "positionId", amount => "amount", type_ => "type_"),
+        change_contract_margin(position_id => "positionId", amount => "amount", type_ => "type"),
         change_contract_position_mode(position_mode => "positionMode"),
         get_contract_asset(currency => "currency"),
         get_contract_assets(),
@@ -82,7 +82,7 @@ crate::exchanges::impl_exchange_method_wrappers! {
         place_contract_market_buy_order(product_symbol => "product_symbol", vol => "vol"),
         place_contract_market_order(product_symbol => "product_symbol", side => "side", vol => "vol"),
         place_contract_market_sell_order(product_symbol => "product_symbol", vol => "vol"),
-        place_contract_order(product_symbol => "product_symbol", side => "side", type_ => "type_", open_type => "openType", vol => "vol"),
+        place_contract_order(product_symbol => "product_symbol", side => "side", type_ => "type", open_type => "openType", vol => "vol"),
         place_contract_post_only_buy_order(product_symbol => "product_symbol", price => "price", vol => "vol"),
         place_contract_post_only_order(product_symbol => "product_symbol", side => "side", price => "price", vol => "vol"),
         place_contract_post_only_sell_order(product_symbol => "product_symbol", price => "price", vol => "vol"),
@@ -93,12 +93,12 @@ crate::exchanges::impl_exchange_method_wrappers! {
         place_spot_market_buy_order(product_symbol => "product_symbol", quote_order_qty => "quoteOrderQty"),
         place_spot_market_order(product_symbol => "product_symbol", side => "side"),
         place_spot_market_sell_order(product_symbol => "product_symbol", quantity => "quantity"),
-        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type_"),
+        place_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type"),
         place_spot_post_only_limit_buy_order(product_symbol => "product_symbol", quantity => "quantity", price => "price"),
         place_spot_post_only_limit_order(product_symbol => "product_symbol", side => "side", quantity => "quantity", price => "price"),
         place_spot_post_only_limit_sell_order(product_symbol => "product_symbol", quantity => "quantity", price => "price"),
         set_spot_mx_deduct(mx_deduct_enable => "mxDeductEnable"),
-        test_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type_"),
+        test_spot_order(product_symbol => "product_symbol", side => "side", type_ => "type"),
         user_universal_transfer(from_account_type => "fromAccountType", to_account_type => "toAccountType", asset => "asset", amount => "amount"),
     ];
 }

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/exchanges/mod.rs

@@ -546,7 +546,7 @@ impl<'a, C: ExchangeMethodRequestClient> ExchangeMethodRequest<'a, C> {
     }
 
     pub fn from_(self, value: impl ToString) -> Self {
-        self.param("from_", value)
+        self.param("from", value)
     }
 
     pub fn from_account(self, value: impl ToString) -> Self {
@@ -1646,16 +1646,113 @@ mod tests {
         let client = DummyClient;
         let request = ExchangeMethodRequest::private(&client, "wallet_transfer", Vec::new())
             .currency_pair("BTC_USDT")
+            .from_("spot")
             .settle("usdt");
 
         assert_eq!(
             request.params,
             vec![
                 ("currency_pair".to_string(), "BTC_USDT".to_string()),
+                ("from".to_string(), "spot".to_string()),
                 ("settle".to_string(), "usdt".to_string())
             ]
         );
     }
+
+    #[test]
+    fn type_keyword_builders_use_native_type_parameter_name() {
+        let client =
+            crate::exchanges::aster::AsterClient::public(std::time::Duration::from_secs(1))
+                .expect("client");
+
+        let spot = client.place_spot_order("ASTER-USDT-SPOT", "buy", "MARKET");
+        assert_eq!(
+            spot.params,
+            vec![
+                ("product_symbol".to_string(), "ASTER-USDT-SPOT".to_string()),
+                ("side".to_string(), "buy".to_string()),
+                ("type".to_string(), "MARKET".to_string())
+            ]
+        );
+
+        let futures = client.place_futures_order("ASTER-USDT-SWAP", "sell", "LIMIT");
+        assert_eq!(
+            futures.params,
+            vec![
+                ("product_symbol".to_string(), "ASTER-USDT-SWAP".to_string()),
+                ("side".to_string(), "sell".to_string()),
+                ("type".to_string(), "LIMIT".to_string())
+            ]
+        );
+
+        let margin = client.modify_futures_position_margin("ASTER-USDT-SWAP", "10", "ADD");
+        assert_eq!(
+            margin.params,
+            vec![
+                ("product_symbol".to_string(), "ASTER-USDT-SWAP".to_string()),
+                ("amount".to_string(), "10".to_string()),
+                ("type".to_string(), "ADD".to_string())
+            ]
+        );
+
+        let client =
+            crate::exchanges::kucoin::KucoinClient::public(std::time::Duration::from_secs(1))
+                .expect("client");
+        let spot = client.place_spot_order("BTC-USDT-SPOT", "buy", "market");
+        assert_eq!(
+            spot.params,
+            vec![
+                ("product_symbol".to_string(), "BTC-USDT-SPOT".to_string()),
+                ("side".to_string(), "buy".to_string()),
+                ("type".to_string(), "market".to_string())
+            ]
+        );
+
+        let futures = client.place_futures_order("BTC-USDT-SWAP", "sell", "limit", "1");
+        assert_eq!(
+            futures.params,
+            vec![
+                ("product_symbol".to_string(), "BTC-USDT-SWAP".to_string()),
+                ("side".to_string(), "sell".to_string()),
+                ("type".to_string(), "limit".to_string()),
+                ("size".to_string(), "1".to_string())
+            ]
+        );
+
+        let client = crate::exchanges::mexc::MexcClient::public(std::time::Duration::from_secs(1))
+            .expect("client");
+        let spot = client.place_spot_order("MX-USDT-SPOT", "BUY", "MARKET");
+        assert_eq!(
+            spot.params,
+            vec![
+                ("product_symbol".to_string(), "MX-USDT-SPOT".to_string()),
+                ("side".to_string(), "BUY".to_string()),
+                ("type".to_string(), "MARKET".to_string())
+            ]
+        );
+
+        let contract = client.place_contract_order("BTC-USDT-SWAP", "1", "5", "1", "10");
+        assert_eq!(
+            contract.params,
+            vec![
+                ("product_symbol".to_string(), "BTC-USDT-SWAP".to_string()),
+                ("side".to_string(), "1".to_string()),
+                ("type".to_string(), "5".to_string()),
+                ("openType".to_string(), "1".to_string()),
+                ("vol".to_string(), "10".to_string())
+            ]
+        );
+
+        let margin = client.change_contract_margin("123", "10", "ADD");
+        assert_eq!(
+            margin.params,
+            vec![
+                ("positionId".to_string(), "123".to_string()),
+                ("amount".to_string(), "10".to_string()),
+                ("type".to_string(), "ADD".to_string())
+            ]
+        );
+    }
 }
 
 pub mod aster;

{dcex-0.26.0 → dcex-0.26.2}/crates/dcex/src/product_table.rs

@@ -7,6 +7,10 @@ use crate::{DcexError, Result};
 #[path = "product_table_fetch.rs"]
 mod fetch;
 
+type UniqueIndex = HashMap<String, HashMap<String, Option<usize>>>;
+type MultiIndex = HashMap<String, HashMap<String, Vec<usize>>>;
+type TypedUniqueIndex = HashMap<String, HashMap<String, HashMap<String, Option<usize>>>>;
+
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct MarketInfo {
     pub exchange: String,
@@ -44,10 +48,10 @@ pub struct ProductFilter<'a> {
 #[derive(Clone, Debug, Default)]
 pub struct ProductTable {
     rows: Vec<MarketInfo>,
-    by_exchange_product: HashMap<(String, String), Option<usize>>,
-    by_exchange_exchange_symbol: HashMap<(String, String), Vec<usize>>,
-    by_exchange_exchange_symbol_product_type: HashMap<(String, String, String), Option<usize>>,
-    by_exchange_exchange_symbol_exchange_type: HashMap<(String, String, String), Option<usize>>,
+    by_exchange_product: UniqueIndex,
+    by_exchange_exchange_symbol: MultiIndex,
+    by_exchange_exchange_symbol_product_type: TypedUniqueIndex,
+    by_exchange_exchange_symbol_exchange_type: TypedUniqueIndex,
 }
 
 impl ProductTable {
@@ -107,11 +111,8 @@ impl ProductTable {
     }
 
     pub fn get_exchange_symbol(&self, exchange: &str, product_symbol: &str) -> Result<String> {
-        match self
-            .by_exchange_product
-            .get(&(exchange.to_string(), product_symbol.to_string()))
-        {
-            Some(Some(index)) => Ok(self.rows[*index].exchange_symbol.clone()),
+        match lookup_unique_index(&self.by_exchange_product, exchange, product_symbol) {
+            Some(Some(index)) => Ok(self.rows[index].exchange_symbol.clone()),
             _ => self.get(
                 "exchange_symbol",
                 ProductFilter {
@@ -221,29 +222,28 @@ impl ProductTable {
         for (index, row) in self.rows.iter().enumerate() {
             insert_unique_index(
                 &mut self.by_exchange_product,
-                (row.exchange.clone(), row.product_symbol.clone()),
+                &row.exchange,
+                &row.product_symbol,
                 index,
             );
-            self.by_exchange_exchange_symbol
-                .entry((row.exchange.clone(), row.exchange_symbol.clone()))
-                .or_default()
-                .push(index);
-            insert_unique_index(
+            insert_multi_index(
+                &mut self.by_exchange_exchange_symbol,
+                &row.exchange,
+                &row.exchange_symbol,
+                index,
+            );
+            insert_typed_unique_index(
                 &mut self.by_exchange_exchange_symbol_product_type,
-                (
-                    row.exchange.clone(),
-                    row.exchange_symbol.clone(),
-                    row.product_type.clone(),
-                ),
+                &row.exchange,
+                &row.exchange_symbol,
+                &row.product_type,
                 index,
             );
-            insert_unique_index(
+            insert_typed_unique_index(
                 &mut self.by_exchange_exchange_symbol_exchange_type,
-                (
-                    row.exchange.clone(),
-                    row.exchange_symbol.clone(),
-                    row.exchange_type.clone(),
-                ),
+                &row.exchange,
+                &row.exchange_symbol,
+                &row.exchange_type,
                 index,
             );
         }
@@ -256,38 +256,31 @@ impl ProductTable {
         product_type: Option<&str>,
         exchange_type: Option<&str>,
     ) -> Option<usize> {
-        let index = match (product_type, exchange_type) {
-            (Some(product_type), None) => self
-                .by_exchange_exchange_symbol_product_type
-                .get(&(
-                    exchange.to_string(),
-                    exchange_symbol.to_string(),
-                    product_type.to_string(),
-                ))
-                .copied()
-                .flatten(),
-            (None, Some(exchange_type)) => self
-                .by_exchange_exchange_symbol_exchange_type
-                .get(&(
-                    exchange.to_string(),
-                    exchange_symbol.to_string(),
-                    exchange_type.to_string(),
-                ))
-                .copied()
-                .flatten(),
-            (Some(product_type), Some(exchange_type)) => self
-                .by_exchange_exchange_symbol_product_type
-                .get(&(
-                    exchange.to_string(),
-                    exchange_symbol.to_string(),
-                    product_type.to_string(),
-                ))
-                .copied()
-                .flatten()
-                .filter(|index| self.rows[*index].exchange_type == exchange_type),
+        match (product_type, exchange_type) {
+            (Some(product_type), None) => lookup_typed_unique_index(
+                &self.by_exchange_exchange_symbol_product_type,
+                exchange,
+                exchange_symbol,
+                product_type,
+            )
+            .flatten(),
+            (None, Some(exchange_type)) => lookup_typed_unique_index(
+                &self.by_exchange_exchange_symbol_exchange_type,
+                exchange,
+                exchange_symbol,
+                exchange_type,
+            )
+            .flatten(),
+            (Some(product_type), Some(exchange_type)) => lookup_typed_unique_index(
+                &self.by_exchange_exchange_symbol_product_type,
+                exchange,
+                exchange_symbol,
+                product_type,
+            )
+            .flatten()
+            .filter(|index| self.rows[*index].exchange_type == exchange_type),
             (None, None) => None,
-        };
-        index
+        }
     }
 
     fn get_product_field(
@@ -301,9 +294,8 @@ impl ProductTable {
             return self.get_product_value(key, exchange, product_symbol);
         }
         if let Some(exchange_symbol) = exchange_symbol {
-            if let Some(indexes) = self
-                .by_exchange_exchange_symbol
-                .get(&(exchange.to_string(), exchange_symbol.to_string()))
+            if let Some(indexes) =
+                lookup_multi_index(&self.by_exchange_exchange_symbol, exchange, exchange_symbol)
             {
                 if indexes.len() == 1 {
                     return row_value(&self.rows[indexes[0]], key)
@@ -333,11 +325,8 @@ impl ProductTable {
     }
 
     fn unique_product(&self, exchange: &str, product_symbol: &str) -> Result<&MarketInfo> {
-        match self
-            .by_exchange_product
-            .get(&(exchange.to_string(), product_symbol.to_string()))
-        {
-            Some(Some(index)) => Ok(&self.rows[*index]),
+        match lookup_unique_index(&self.by_exchange_product, exchange, product_symbol) {
+            Some(Some(index)) => Ok(&self.rows[index]),
             _ => {
                 let matches = self
                     .rows
@@ -378,17 +367,62 @@ impl ProductTable {
     }
 }
 
-fn insert_unique_index<K: std::hash::Hash + Eq>(
-    index: &mut HashMap<K, Option<usize>>,
-    key: K,
+fn insert_unique_index(index: &mut UniqueIndex, exchange: &str, symbol: &str, row_index: usize) {
+    index
+        .entry(exchange.to_string())
+        .or_default()
+        .entry(symbol.to_string())
+        .and_modify(|value| *value = None)
+        .or_insert(Some(row_index));
+}
+
+fn lookup_unique_index(index: &UniqueIndex, exchange: &str, symbol: &str) -> Option<Option<usize>> {
+    index.get(exchange)?.get(symbol).copied()
+}
+
+fn insert_multi_index(index: &mut MultiIndex, exchange: &str, symbol: &str, row_index: usize) {
+    index
+        .entry(exchange.to_string())
+        .or_default()
+        .entry(symbol.to_string())
+        .or_default()
+        .push(row_index);
+}
+
+fn lookup_multi_index<'a>(
+    index: &'a MultiIndex,
+    exchange: &str,
+    symbol: &str,
+) -> Option<&'a [usize]> {
+    index.get(exchange)?.get(symbol).map(Vec::as_slice)
+}
+
+fn insert_typed_unique_index(
+    index: &mut TypedUniqueIndex,
+    exchange: &str,
+    symbol: &str,
+    kind: &str,
     row_index: usize,
 ) {
     index
-        .entry(key)
+        .entry(exchange.to_string())
+        .or_default()
+        .entry(symbol.to_string())
+        .or_default()
+        .entry(kind.to_string())
         .and_modify(|value| *value = None)
         .or_insert(Some(row_index));
 }
 
+fn lookup_typed_unique_index(
+    index: &TypedUniqueIndex,
+    exchange: &str,
+    symbol: &str,
+    kind: &str,
+) -> Option<Option<usize>> {
+    index.get(exchange)?.get(symbol)?.get(kind).copied()
+}
+
 fn row_matches(row: &MarketInfo, filter: ProductFilter<'_>) -> bool {
     filter
         .product_symbol