removed first_block variable

crates/rpc/src/method/subscribe_transaction_status.rs

@@ -12,7 +12,6 @@ use tokio::time::MissedTickBehavior;
 
 use super::REORG_SUBSCRIPTION_NAME;
 use crate::context::RpcContext;
-use crate::error::ApplicationError;
 use crate::jsonrpc::{RpcError, RpcSubscriptionFlow, SubscriptionMessage};
 use crate::Reorg;
 
@@ -143,52 +142,43 @@ impl RpcSubscriptionFlow for SubscribeTransactionStatus {
             let storage = state.storage.clone();
             // Check if we have the transaction in our database, and if so, send the
             // relevant transaction status updates.
-            let (first_block, l1_state, tx_with_receipt) =
+            let (l1_state, tx_with_receipt) =
                 util::task::spawn_blocking(move |_| -> Result<_, RpcError> {
                     let mut conn = storage.connection().map_err(RpcError::InternalError)?;
                     let db = conn.transaction().map_err(RpcError::InternalError)?;
-                    let first_block = db
-                        .block_number(pathfinder_storage::BlockId::Latest)
-                        .map_err(RpcError::InternalError)?;
                     let l1_block_number = db.latest_l1_state().map_err(RpcError::InternalError)?;
                     let tx_with_receipt = db
                         .transaction_with_receipt(tx_hash)
                         .map_err(RpcError::InternalError)?;
-                    Ok((first_block, l1_block_number, tx_with_receipt))
+                    Ok((l1_block_number, tx_with_receipt))
                 })
                 .await
                 .map_err(|e| RpcError::InternalError(e.into()))??;
-            let first_block = first_block
-                .ok_or_else(|| RpcError::ApplicationError(ApplicationError::BlockNotFound))?;
             if let Some((_, receipt, _, block_number)) = tx_with_receipt {
                 // We already have the transaction in the database.
                 if let Some(parent) = block_number.parent() {
                     // This transaction was pending in the parent block.
-                    if first_block <= parent {
-                        if sender
-                            .send(parent, FinalityStatus::Received, None)
-                            .await
-                            .is_err()
-                        {
-                            // Subscription closing.
-                            break;
-                        }
-                    }
-                }
-                if first_block <= block_number {
                     if sender
-                        .send(
-                            block_number,
-                            FinalityStatus::AcceptedOnL2,
-                            Some(receipt.execution_status.clone()),
-                        )
+                        .send(parent, FinalityStatus::Received, None)
                         .await
                         .is_err()
                     {
                         // Subscription closing.
                         break;
                     }
                 }
+                if sender
+                    .send(
+                        block_number,
+                        FinalityStatus::AcceptedOnL2,
+                        Some(receipt.execution_status.clone()),
+                    )
+                    .await
+                    .is_err()
+                {
+                    // Subscription closing.
+                    break;
+                }
                 if let Some(l1_state) = l1_state {
                     if l1_state.block_number >= block_number {
                         if sender