migrate to timed-map entirely

Signed-off-by: onur-ozkan <work@onurozkan.dev>

mm2src/coins/Cargo.toml

@@ -125,6 +125,7 @@ mm2_db = { path = "../mm2_db" }
 mm2_metamask = { path = "../mm2_metamask" }
 mm2_test_helpers = { path = "../mm2_test_helpers" }
 time = { version = "0.3.20", features = ["wasm-bindgen"] }
+timed-map = { version = "1.2", features = ["rustc-hash", "wasm"] }
 tonic = { version = "0.10", default-features = false, features = ["prost", "codegen", "gzip"] }
 tower-service = "0.3"
 wasm-bindgen = "0.2.86"
@@ -148,6 +149,7 @@ lightning-net-tokio = "0.0.113"
 rust-ini = { version = "0.13" }
 rustls = { version = "0.21", features = ["dangerous_configuration"] }
 secp256k1v24 = { version = "0.24", package = "secp256k1" }
+timed-map = { version = "1.2", features = ["rustc-hash"] }
 tokio = { version = "1.20" }
 tokio-rustls = { version = "0.24" }
 tonic = { version = "0.10", features = ["tls", "tls-webpki-roots", "gzip"] }

mm2src/coins/eth/web3_transport/websocket_transport.rs

@@ -11,7 +11,6 @@ use crate::eth::web3_transport::Web3SendOut;
 use crate::eth::{EthCoin, RpcTransportEventHandlerShared};
 use crate::{MmCoin, RpcTransportEventHandler};
 use common::executor::{AbortSettings, SpawnAbortable, Timer};
-use common::expirable_map::ExpirableMap;
 use common::log;
 use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures::channel::oneshot;
@@ -25,6 +24,7 @@ use proxy_signature::{ProxySign, RawMessage};
 use std::sync::atomic::AtomicBool;
 use std::sync::{atomic::{AtomicUsize, Ordering},
                 Arc};
+use timed_map::{StdClock, TimedMap};
 use tokio_tungstenite_wasm::WebSocketStream;
 use web3::error::{Error, TransportError};
 use web3::helpers::to_string;
@@ -136,15 +136,15 @@ impl WebsocketTransport {
         &self,
         request: Option<ControllerMessage>,
         wsocket: &mut WebSocketStream,
-        response_notifiers: &mut ExpirableMap<usize, oneshot::Sender<Vec<u8>>>,
+        response_notifiers: &mut TimedMap<StdClock, usize, oneshot::Sender<Vec<u8>>>,
     ) -> OuterAction {
         match request {
             Some(ControllerMessage::Request(WsRequest {
                 request_id,
                 serialized_request,
                 response_notifier,
             })) => {
-                response_notifiers.insert(
+                response_notifiers.insert_expirable_unchecked(
                     request_id,
                     response_notifier,
                     // Since request will be cancelled when timeout occurs, we are free to drop its state.
@@ -187,7 +187,7 @@ impl WebsocketTransport {
     async fn handle_response(
         &self,
         message: Option<Result<tokio_tungstenite_wasm::Message, tokio_tungstenite_wasm::Error>>,
-        response_notifiers: &mut ExpirableMap<usize, oneshot::Sender<Vec<u8>>>,
+        response_notifiers: &mut TimedMap<StdClock, usize, oneshot::Sender<Vec<u8>>>,
     ) -> OuterAction {
         match message {
             Some(Ok(tokio_tungstenite_wasm::Message::Text(inc_event))) => {
@@ -248,7 +248,7 @@ impl WebsocketTransport {
         let _guard = self.connection_guard.lock().await;
 
         // List of awaiting requests
-        let mut response_notifiers: ExpirableMap<RequestId, oneshot::Sender<Vec<u8>>> = ExpirableMap::default();
+        let mut response_notifiers: TimedMap<StdClock, RequestId, oneshot::Sender<Vec<u8>>> = TimedMap::default();
 
         let mut wsocket = match self
             .attempt_to_establish_socket_connection(MAX_ATTEMPTS, SLEEP_DURATION)

mm2src/coins/utxo/rpc_clients/electrum_rpc/connection.rs

@@ -6,12 +6,12 @@ use crate::{RpcTransportEventHandler, SharableRpcTransportEventHandler};
 use common::custom_futures::timeout::FutureTimerExt;
 use common::executor::{abortable_queue::AbortableQueue, abortable_queue::WeakSpawner, AbortableSystem, SpawnFuture,
                        Timer};
-use common::expirable_map::ExpirableMap;
 use common::jsonrpc_client::{JsonRpcBatchResponse, JsonRpcErrorType, JsonRpcId, JsonRpcRequest, JsonRpcResponse,
                              JsonRpcResponseEnum};
 use common::log::{error, info};
 use common::{now_float, now_ms};
 use mm2_rpc::data::legacy::ElectrumProtocol;
+use timed_map::{MapKind, StdClock, TimedMap};
 
 use std::io;
 use std::sync::atomic::{AtomicU64, Ordering as AtomicOrdering};
@@ -48,7 +48,7 @@ cfg_wasm32! {
     use std::sync::atomic::AtomicUsize;
 }
 
-pub type JsonRpcPendingRequests = ExpirableMap<JsonRpcId, async_oneshot::Sender<JsonRpcResponseEnum>>;
+pub type JsonRpcPendingRequests = TimedMap<StdClock, JsonRpcId, async_oneshot::Sender<JsonRpcResponseEnum>>;
 
 macro_rules! disconnect_and_return {
     ($typ:tt, $err:expr, $conn:expr, $handlers:expr) => {{
@@ -177,7 +177,7 @@ impl ElectrumConnection {
             settings,
             tx: Mutex::new(None),
             establishing_connection: AsyncMutex::new(()),
-            responses: Mutex::new(JsonRpcPendingRequests::new()),
+            responses: Mutex::new(JsonRpcPendingRequests::new_with_map_kind(MapKind::BTreeMap)),
             protocol_version: Mutex::new(None),
             last_error: Mutex::new(None),
             abortable_system,
@@ -251,7 +251,7 @@ impl ElectrumConnection {
         self.responses
             .lock()
             .unwrap()
-            .insert(rpc_id, req_tx, Duration::from_secs_f64(timeout));
+            .insert_expirable_unchecked(rpc_id, req_tx, Duration::from_secs_f64(timeout));
         let tx = self
             .tx
             .lock()

mm2src/common/common.rs

@@ -128,12 +128,10 @@ pub mod crash_reports;
 pub mod custom_futures;
 pub mod custom_iter;
 #[path = "executor/mod.rs"] pub mod executor;
-pub mod expirable_map;
 pub mod notifier;
 pub mod number_type_casting;
 pub mod password_policy;
 pub mod seri;
-pub mod time_cache;
 
 #[cfg(not(target_arch = "wasm32"))]
 #[path = "wio.rs"]