prefer non-blocking async api

zerosnacks · zerosnacks · commit ef21e1ece1f5 · 2025-11-03T18:50:05.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/wallets/Cargo.toml b/crates/wallets/Cargo.toml
@@ -31,7 +31,6 @@ axum.workspace = true
 foundry-common.workspace = true
 serde_json.workspace = true
 tokio = { workspace = true, features = ["macros"] }
-parking_lot.workspace = true
 uuid.workspace = true
 webbrowser = "1.0.6"
 
diff --git a/crates/wallets/src/wallet_browser/handlers.rs b/crates/wallets/src/wallet_browser/handlers.rs
@@ -84,7 +84,7 @@ pub(crate) async fn serve_logo_png() -> impl axum::response::IntoResponse {
 pub(crate) async fn get_next_transaction_request(
     State(state): State<Arc<BrowserWalletState>>,
 ) -> Json<BrowserApiResponse<BrowserTransactionRequest>> {
-    match state.read_next_transaction_request() {
+    match state.read_next_transaction_request().await {
         Some(tx) => Json(BrowserApiResponse::with_data(tx)),
         None => Json(BrowserApiResponse::error("No pending transaction request")),
     }
@@ -97,7 +97,7 @@ pub(crate) async fn post_transaction_response(
     Json(body): Json<BrowserTransactionResponse>,
 ) -> Json<BrowserApiResponse> {
     // Ensure that the transaction request exists.
-    if !state.has_transaction_request(&body.id) {
+    if !state.has_transaction_request(&body.id).await {
         return Json(BrowserApiResponse::error("Unknown transaction id"));
     }
 
@@ -127,7 +127,7 @@ pub(crate) async fn post_transaction_response(
         }
     }
 
-    state.add_transaction_response(body);
+    state.add_transaction_response(body).await;
 
     Json(BrowserApiResponse::ok())
 }
@@ -137,7 +137,7 @@ pub(crate) async fn post_transaction_response(
 pub(crate) async fn get_next_signing_request(
     State(state): State<Arc<BrowserWalletState>>,
 ) -> Json<BrowserApiResponse<BrowserSignRequest>> {
-    match state.read_next_signing_request() {
+    match state.read_next_signing_request().await {
         Some(req) => Json(BrowserApiResponse::with_data(req)),
         None => Json(BrowserApiResponse::error("No pending signing request")),
     }
@@ -150,7 +150,7 @@ pub(crate) async fn post_signing_response(
     Json(body): Json<BrowserSignResponse>,
 ) -> Json<BrowserApiResponse> {
     // Ensure that the signing request exists.
-    if !state.has_signing_request(&body.id) {
+    if !state.has_signing_request(&body.id).await {
         return Json(BrowserApiResponse::error("Unknown signing request id"));
     }
 
@@ -167,7 +167,7 @@ pub(crate) async fn post_signing_response(
         _ => {}
     }
 
-    state.add_signing_response(body);
+    state.add_signing_response(body).await;
 
     Json(BrowserApiResponse::ok())
 }
@@ -177,7 +177,7 @@ pub(crate) async fn post_signing_response(
 pub(crate) async fn get_connection_info(
     State(state): State<Arc<BrowserWalletState>>,
 ) -> Json<BrowserApiResponse<Option<Connection>>> {
-    let connection = state.get_connection();
+    let connection = state.get_connection().await;
 
     Json(BrowserApiResponse::with_data(connection))
 }
@@ -188,7 +188,7 @@ pub(crate) async fn post_connection_update(
     State(state): State<Arc<BrowserWalletState>>,
     Json(body): Json<Option<Connection>>,
 ) -> Json<BrowserApiResponse> {
-    state.set_connection(body);
+    state.set_connection(body).await;
 
     Json(BrowserApiResponse::ok())
 }
diff --git a/crates/wallets/src/wallet_browser/mod.rs b/crates/wallets/src/wallet_browser/mod.rs
@@ -40,7 +40,7 @@ mod tests {
         let client = client_with_token(&server);
 
         // Check initial state
-        assert!(!server.is_connected());
+        assert!(!server.is_connected().await);
         assert!(!server.open_browser());
         assert!(server.timeout() == DEFAULT_TIMEOUT);
 
@@ -68,22 +68,22 @@ mod tests {
 
         // Check connection state
         let Connection { address, chain_id } =
-            server.get_connection().expect("expected an active wallet connection");
+            server.get_connection().await.expect("expected an active wallet connection");
         assert_eq!(address, ALICE);
         assert_eq!(chain_id, 1);
 
         // Disconnect wallet
         disconnect_wallet(&client, &server).await;
 
         // Check disconnected state
-        assert!(!server.is_connected());
+        assert!(!server.is_connected().await);
 
         // Connect Bob's wallet
         connect_wallet(&client, &server, Connection::new(BOB, 42)).await;
 
         // Check connection state
         let Connection { address, chain_id } =
-            server.get_connection().expect("expected an active wallet connection");
+            server.get_connection().await.expect("expected an active wallet connection");
         assert_eq!(address, BOB);
         assert_eq!(chain_id, 42);
 
@@ -100,14 +100,14 @@ mod tests {
         // Connect Alice, assert connected
         connect_wallet(&client, &server, Connection::new(ALICE, 1)).await;
         let Connection { address, chain_id } =
-            server.get_connection().expect("expected an active wallet connection");
+            server.get_connection().await.expect("expected an active wallet connection");
         assert_eq!(address, ALICE);
         assert_eq!(chain_id, 1);
 
         // Connect Bob, assert switched
         connect_wallet(&client, &server, Connection::new(BOB, 42)).await;
         let Connection { address, chain_id } =
-            server.get_connection().expect("expected an active wallet connection");
+            server.get_connection().await.expect("expected an active wallet connection");
         assert_eq!(address, BOB);
         assert_eq!(chain_id, 42);
 
diff --git a/crates/wallets/src/wallet_browser/server.rs b/crates/wallets/src/wallet_browser/server.rs
@@ -106,32 +106,32 @@ impl BrowserWalletServer {
     }
 
     /// Check if a wallet is connected.
-    pub fn is_connected(&self) -> bool {
-        self.state.is_connected()
+    pub async fn is_connected(&self) -> bool {
+        self.state.is_connected().await
     }
 
     /// Get current wallet connection.
-    pub fn get_connection(&self) -> Option<Connection> {
-        self.state.get_connection()
+    pub async fn get_connection(&self) -> Option<Connection> {
+        self.state.get_connection().await
     }
 
     /// Request a transaction to be signed and sent via the browser wallet.
     pub async fn request_transaction(
         &self,
         request: BrowserTransactionRequest,
     ) -> Result<TxHash, BrowserWalletError> {
-        if !self.is_connected() {
+        if !self.is_connected().await {
             return Err(BrowserWalletError::NotConnected);
         }
 
         let tx_id = request.id;
 
-        self.state.add_transaction_request(request);
+        self.state.add_transaction_request(request).await;
 
         let start = Instant::now();
 
         loop {
-            if let Some(response) = self.state.get_transaction_response(&tx_id) {
+            if let Some(response) = self.state.get_transaction_response(&tx_id).await {
                 if let Some(hash) = response.hash {
                     return Ok(hash);
                 } else if let Some(error) = response.error {
@@ -147,7 +147,7 @@ impl BrowserWalletServer {
             }
 
             if start.elapsed() > self.timeout {
-                self.state.remove_transaction_request(&tx_id);
+                self.state.remove_transaction_request(&tx_id).await;
                 return Err(BrowserWalletError::Timeout { operation: "Transaction" });
             }
 
@@ -160,18 +160,18 @@ impl BrowserWalletServer {
         &self,
         request: BrowserSignRequest,
     ) -> Result<Bytes, BrowserWalletError> {
-        if !self.is_connected() {
+        if !self.is_connected().await {
             return Err(BrowserWalletError::NotConnected);
         }
 
         let tx_id = request.id;
 
-        self.state.add_signing_request(request);
+        self.state.add_signing_request(request).await;
 
         let start = Instant::now();
 
         loop {
-            if let Some(response) = self.state.get_signing_response(&tx_id) {
+            if let Some(response) = self.state.get_signing_response(&tx_id).await {
                 if let Some(signature) = response.signature {
                     return Ok(signature);
                 } else if let Some(error) = response.error {
@@ -187,7 +187,7 @@ impl BrowserWalletServer {
             }
 
             if start.elapsed() > self.timeout {
-                self.state.remove_signing_request(&tx_id);
+                self.state.remove_signing_request(&tx_id).await;
                 return Err(BrowserWalletError::Timeout { operation: "Signing" });
             }
 
diff --git a/crates/wallets/src/wallet_browser/signer.rs b/crates/wallets/src/wallet_browser/signer.rs
@@ -44,7 +44,7 @@ impl BrowserSigner {
         let start = Instant::now();
 
         loop {
-            if let Some(Connection { address, chain_id }) = server.get_connection() {
+            if let Some(Connection { address, chain_id }) = server.get_connection().await {
                 let _ = sh_println!("Wallet connected: {}", address);
                 let _ = sh_println!("Chain ID: {}", chain_id);
 
diff --git a/crates/wallets/src/wallet_browser/state.rs b/crates/wallets/src/wallet_browser/state.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use parking_lot::Mutex;
+use tokio::sync::{Mutex, RwLock};
 use uuid::Uuid;
 
 use crate::wallet_browser::{
@@ -14,7 +14,7 @@ use crate::wallet_browser::{
 #[derive(Debug, Clone)]
 pub(crate) struct BrowserWalletState {
     /// Current information about the wallet connection.
-    connection: Arc<Mutex<Option<Connection>>>,
+    connection: Arc<RwLock<Option<Connection>>>,
     /// Request/response queue for transactions.
     transactions: Arc<Mutex<RequestQueue<BrowserTransactionRequest, BrowserTransactionResponse>>>,
     /// Request/response queue for signings.
@@ -33,7 +33,7 @@ impl BrowserWalletState {
     /// Create a new browser wallet state.
     pub fn new(session_token: String, development: bool) -> Self {
         Self {
-            connection: Arc::new(Mutex::new(None)),
+            connection: Arc::new(RwLock::new(None)),
             transactions: Arc::new(Mutex::new(RequestQueue::new())),
             signings: Arc::new(Mutex::new(RequestQueue::new())),
             session_token,
@@ -55,83 +55,83 @@ impl BrowserWalletState {
     }
 
     /// Check if wallet is connected.
-    pub fn is_connected(&self) -> bool {
-        self.connection.lock().is_some()
+    pub async fn is_connected(&self) -> bool {
+        self.connection.read().await.is_some()
     }
 
     /// Get current connection information.
-    pub fn get_connection(&self) -> Option<Connection> {
-        *self.connection.lock()
+    pub async fn get_connection(&self) -> Option<Connection> {
+        *self.connection.read().await
     }
 
     /// Set connection information.
-    pub fn set_connection(&self, connection: Option<Connection>) {
-        *self.connection.lock() = connection;
+    pub async fn set_connection(&self, connection: Option<Connection>) {
+        *self.connection.write().await = connection;
     }
 
     /// Add a transaction request.
-    pub fn add_transaction_request(&self, request: BrowserTransactionRequest) {
-        self.transactions.lock().add_request(request);
+    pub async fn add_transaction_request(&self, request: BrowserTransactionRequest) {
+        self.transactions.lock().await.add_request(request);
     }
 
     /// Check if a transaction request exists.
-    pub fn has_transaction_request(&self, id: &Uuid) -> bool {
-        self.transactions.lock().has_request(id)
+    pub async fn has_transaction_request(&self, id: &Uuid) -> bool {
+        self.transactions.lock().await.has_request(id)
     }
 
     /// Read the next transaction request.
-    pub fn read_next_transaction_request(&self) -> Option<BrowserTransactionRequest> {
-        self.transactions.lock().read_request().cloned()
+    pub async fn read_next_transaction_request(&self) -> Option<BrowserTransactionRequest> {
+        self.transactions.lock().await.read_request().cloned()
     }
 
     // Remove a transaction request.
-    pub fn remove_transaction_request(&self, id: &Uuid) {
-        self.transactions.lock().remove_request(id);
+    pub async fn remove_transaction_request(&self, id: &Uuid) {
+        self.transactions.lock().await.remove_request(id);
     }
 
     /// Add transaction response.
-    pub fn add_transaction_response(&self, response: BrowserTransactionResponse) {
+    pub async fn add_transaction_response(&self, response: BrowserTransactionResponse) {
         let id = response.id;
-        let mut transactions = self.transactions.lock();
+        let mut transactions = self.transactions.lock().await;
         transactions.add_response(id, response);
         transactions.remove_request(&id);
     }
 
     /// Get transaction response, removing it from the queue.
-    pub fn get_transaction_response(&self, id: &Uuid) -> Option<BrowserTransactionResponse> {
-        self.transactions.lock().get_response(id)
+    pub async fn get_transaction_response(&self, id: &Uuid) -> Option<BrowserTransactionResponse> {
+        self.transactions.lock().await.get_response(id)
     }
 
     /// Add a signing request.
-    pub fn add_signing_request(&self, request: BrowserSignRequest) {
-        self.signings.lock().add_request(request);
+    pub async fn add_signing_request(&self, request: BrowserSignRequest) {
+        self.signings.lock().await.add_request(request);
     }
 
     /// Check if a signing request exists.
-    pub fn has_signing_request(&self, id: &Uuid) -> bool {
-        self.signings.lock().has_request(id)
+    pub async fn has_signing_request(&self, id: &Uuid) -> bool {
+        self.signings.lock().await.has_request(id)
     }
 
     /// Read the next signing request.
-    pub fn read_next_signing_request(&self) -> Option<BrowserSignRequest> {
-        self.signings.lock().read_request().cloned()
+    pub async fn read_next_signing_request(&self) -> Option<BrowserSignRequest> {
+        self.signings.lock().await.read_request().cloned()
     }
 
     /// Remove a signing request.
-    pub fn remove_signing_request(&self, id: &Uuid) {
-        self.signings.lock().remove_request(id);
+    pub async fn remove_signing_request(&self, id: &Uuid) {
+        self.signings.lock().await.remove_request(id);
     }
 
     /// Add signing response.
-    pub fn add_signing_response(&self, response: BrowserSignResponse) {
+    pub async fn add_signing_response(&self, response: BrowserSignResponse) {
         let id = response.id;
-        let mut signings = self.signings.lock();
+        let mut signings = self.signings.lock().await;
         signings.add_response(id, response);
         signings.remove_request(&id);
     }
 
     /// Get signing response, removing it from the queue.
-    pub fn get_signing_response(&self, id: &Uuid) -> Option<BrowserSignResponse> {
-        self.signings.lock().get_response(id)
+    pub async fn get_signing_response(&self, id: &Uuid) -> Option<BrowserSignResponse> {
+        self.signings.lock().await.get_response(id)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ pub(crate) async fn serve_logo_png() -> impl axum::response::IntoResponse {`
`84`	`84`	`pub(crate) async fn get_next_transaction_request(`
`85`	`85`	`State(state): State<Arc<BrowserWalletState>>,`
`86`	`86`	`) -> Json<BrowserApiResponse<BrowserTransactionRequest>> {`
`87`		`- match state.read_next_transaction_request() {`
	`87`	`+ match state.read_next_transaction_request().await {`
`88`	`88`	`Some(tx) => Json(BrowserApiResponse::with_data(tx)),`
`89`	`89`	`None => Json(BrowserApiResponse::error("No pending transaction request")),`
`90`	`90`	`}`
`@@ -97,7 +97,7 @@ pub(crate) async fn post_transaction_response(`
`97`	`97`	`Json(body): Json<BrowserTransactionResponse>,`
`98`	`98`	`) -> Json<BrowserApiResponse> {`
`99`	`99`	`// Ensure that the transaction request exists.`
`100`		`- if !state.has_transaction_request(&body.id) {`
	`100`	`+ if !state.has_transaction_request(&body.id).await {`
`101`	`101`	`return Json(BrowserApiResponse::error("Unknown transaction id"));`
`102`	`102`	`}`
`103`	`103`
`@@ -127,7 +127,7 @@ pub(crate) async fn post_transaction_response(`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
`130`		`- state.add_transaction_response(body);`
	`130`	`+ state.add_transaction_response(body).await;`
`131`	`131`
`132`	`132`	`Json(BrowserApiResponse::ok())`
`133`	`133`	`}`
`@@ -137,7 +137,7 @@ pub(crate) async fn post_transaction_response(`
`137`	`137`	`pub(crate) async fn get_next_signing_request(`
`138`	`138`	`State(state): State<Arc<BrowserWalletState>>,`
`139`	`139`	`) -> Json<BrowserApiResponse<BrowserSignRequest>> {`
`140`		`- match state.read_next_signing_request() {`
	`140`	`+ match state.read_next_signing_request().await {`
`141`	`141`	`Some(req) => Json(BrowserApiResponse::with_data(req)),`
`142`	`142`	`None => Json(BrowserApiResponse::error("No pending signing request")),`
`143`	`143`	`}`
`@@ -150,7 +150,7 @@ pub(crate) async fn post_signing_response(`
`150`	`150`	`Json(body): Json<BrowserSignResponse>,`
`151`	`151`	`) -> Json<BrowserApiResponse> {`
`152`	`152`	`// Ensure that the signing request exists.`
`153`		`- if !state.has_signing_request(&body.id) {`
	`153`	`+ if !state.has_signing_request(&body.id).await {`
`154`	`154`	`return Json(BrowserApiResponse::error("Unknown signing request id"));`
`155`	`155`	`}`
`156`	`156`
`@@ -167,7 +167,7 @@ pub(crate) async fn post_signing_response(`
`167`	`167`	`_ => {}`
`168`	`168`	`}`
`169`	`169`
`170`		`- state.add_signing_response(body);`
	`170`	`+ state.add_signing_response(body).await;`
`171`	`171`
`172`	`172`	`Json(BrowserApiResponse::ok())`
`173`	`173`	`}`
`@@ -177,7 +177,7 @@ pub(crate) async fn post_signing_response(`
`177`	`177`	`pub(crate) async fn get_connection_info(`
`178`	`178`	`State(state): State<Arc<BrowserWalletState>>,`
`179`	`179`	`) -> Json<BrowserApiResponse<Option<Connection>>> {`
`180`		`- let connection = state.get_connection();`
	`180`	`+ let connection = state.get_connection().await;`
`181`	`181`
`182`	`182`	`Json(BrowserApiResponse::with_data(connection))`
`183`	`183`	`}`
`@@ -188,7 +188,7 @@ pub(crate) async fn post_connection_update(`
`188`	`188`	`State(state): State<Arc<BrowserWalletState>>,`
`189`	`189`	`Json(body): Json<Option<Connection>>,`
`190`	`190`	`) -> Json<BrowserApiResponse> {`
`191`		`- state.set_connection(body);`
	`191`	`+ state.set_connection(body).await;`
`192`	`192`
`193`	`193`	`Json(BrowserApiResponse::ok())`
`194`	`194`	`}`