feat(sdk): get_first_nonce_in_queue

Author: MarcosNicolau

batcher/aligned-sdk/src/core/errors.rs

@@ -248,6 +248,16 @@ pub enum GetNonceError {
     ProtocolMismatch { current: u16, expected: u16 },
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum GetFirstNonceFromQueueError {
+    ConnectionFailed(String),
+    SerializationError(String),
+    UnexpectedResponse(String),
+    InvalidRequest(String),
+    ProtocolMismatch { current: u16, expected: u16 },
+    NoProofsInQueue,
+}
+
 #[derive(Debug)]
 pub enum ChainIdError {
     EthereumProviderError(String),

batcher/aligned-sdk/src/sdk.rs

@@ -10,10 +10,10 @@ use crate::{
             ADDITIONAL_SUBMISSION_GAS_COST_PER_PROOF, CONSTANT_GAS_COST,
             MAX_FEE_BATCH_PROOF_NUMBER, MAX_FEE_DEFAULT_PROOF_NUMBER,
         },
-        errors::{self, GetNonceError},
+        errors::{self, GetFirstNonceFromQueueError, GetNonceError},
         types::{
-            AlignedVerificationData, ClientMessage, GetNonceResponseMessage, Network,
-            PriceEstimate, ProvingSystemId, VerificationData,
+            AlignedVerificationData, ClientMessage, GetFirstNonceInQueueResponseMessage,
+            GetNonceResponseMessage, Network, PriceEstimate, ProvingSystemId, VerificationData,
         },
     },
     eth::{
@@ -653,6 +653,79 @@ pub async fn get_nonce_from_ethereum(
     }
 }
 
+/// Returns the nonce of the proof with the lowest nonce inside the batcher queue for a given address.
+/// This might be useful when you proofs are stuck in the batcher due to a low fee and you need to bump them
+/// # Arguments
+/// * `batcher_url` - The batcher websocket url.
+/// * `address` - The user address for which the nonce will be retrieved.
+/// # Returns
+/// * The nonce of the oldest proof inside the batcher queue.
+/// # Errors
+/// * `NoProofsInQueue` if the address did not have proofs in the batcher queue.
+pub async fn get_first_nonce_in_queue_from_batcher(
+    batcher_ws_url: &str,
+    address: Address,
+) -> Result<U256, GetFirstNonceFromQueueError> {
+    let (ws_stream, _) = connect_async(batcher_ws_url).await.map_err(|_| {
+        GetFirstNonceFromQueueError::ConnectionFailed("Ws connection to batcher failed".to_string())
+    })?;
+
+    debug!("WebSocket handshake has been successfully completed");
+    let (mut ws_write, mut ws_read) = ws_stream.split();
+    check_protocol_version(&mut ws_read)
+        .map_err(|e| match e {
+            errors::SubmitError::ProtocolVersionMismatch { current, expected } => {
+                GetFirstNonceFromQueueError::ProtocolMismatch { current, expected }
+            }
+            _ => GetFirstNonceFromQueueError::UnexpectedResponse(
+                "Unexpected response, expected protocol version".to_string(),
+            ),
+        })
+        .await?;
+
+    let msg = ClientMessage::GetNonceForAddress(address);
+
+    let msg_bin = cbor_serialize(&msg).map_err(|_| {
+        GetFirstNonceFromQueueError::SerializationError("Failed to serialize msg".to_string())
+    })?;
+    ws_write
+        .send(Message::Binary(msg_bin.clone()))
+        .await
+        .map_err(|_| {
+            GetFirstNonceFromQueueError::ConnectionFailed(
+                "Ws connection failed to send message to batcher".to_string(),
+            )
+        })?;
+
+    let mut response_stream: ResponseStream =
+        ws_read.try_filter(|msg| futures_util::future::ready(msg.is_binary()));
+
+    let msg = match response_stream.next().await {
+        Some(Ok(msg)) => msg,
+        _ => {
+            return Err(GetFirstNonceFromQueueError::ConnectionFailed(
+                "Connection was closed without close message before receiving all messages"
+                    .to_string(),
+            ));
+        }
+    };
+
+    let _ = ws_write.close().await;
+
+    match cbor_deserialize(msg.into_data().as_slice()) {
+        Ok(GetFirstNonceInQueueResponseMessage::Nonce(nonce)) => Ok(nonce),
+        Ok(GetFirstNonceInQueueResponseMessage::InvalidRequest(e)) => {
+            Err(GetFirstNonceFromQueueError::InvalidRequest(e))
+        }
+        Ok(GetFirstNonceInQueueResponseMessage::NoProofsInQueue) => {
+            Err(GetFirstNonceFromQueueError::NoProofsInQueue)
+        }
+        Err(_) => Err(GetFirstNonceFromQueueError::SerializationError(
+            "Failed to deserialize batcher message".to_string(),
+        )),
+    }
+}
+
 /// Returns the chain ID of the Ethereum network.
 /// # Arguments
 /// * `eth_rpc_url` - The URL of the Ethereum RPC node.