diff --git a/crates/agglayer-config/src/settlement_service.rs b/crates/agglayer-config/src/settlement_service.rs
index 36397be4b..c51f2e8fb 100644
--- a/crates/agglayer-config/src/settlement_service.rs
+++ b/crates/agglayer-config/src/settlement_service.rs
@@ -275,19 +275,17 @@ pub struct SettlementServiceConfig {
 /// The Agglayer settlement configuration.
 ///
 /// This configuration controls how the Agglayer settlement service interacts
-/// with the L1 blockchain for settling certificates and validium transactions.
-/// It provides separate transaction configurations for certificate settlements
-/// and validium settlements, allowing fine-grained control over gas prices,
-/// retries, and confirmation requirements.
+/// with the L1 blockchain for settling certificates.
+/// It provides transaction configuration for certificate settlements, allowing
+/// fine-grained control over gas prices, retries, and confirmation
+/// requirements.
 ///
 /// # Configuration Structure
 ///
-/// The settlement configuration is organized into three main components:
+/// The settlement configuration is organized into two main components:
 ///
 /// - **Certificate Transaction Config**: Controls settlement transactions for
 ///   certificates with pessimistic proofs (proofs of state transitions).
-/// - **Validium Transaction Config**: Controls settlement transactions for
-///   validium data (off-chain data availability).
 /// - **Settlement Service Config**: General settlement service configuration.
 ///
 /// # Gas Price Configuration
@@ -327,14 +325,6 @@ pub struct SettlementConfig {
     #[serde(default)]
     pub pessimistic_proof_tx_config: SettlementTransactionConfig,
 
-    /// Configuration for validium settlement transactions.
-    ///
-    /// This controls how validium data (off-chain data availability proofs)
-    /// are submitted to the L1 settlement layer. Validium transactions may
-    /// have different gas and retry requirements than certificate transactions.
-    #[serde(default)]
-    pub validium_tx_config: SettlementTransactionConfig,
-
     /// General settlement service configuration.
     ///
     /// Contains service-wide settings that apply to the overall settlement
diff --git a/crates/agglayer-config/tests/fixtures/settlement/full_settlement_config.toml b/crates/agglayer-config/tests/fixtures/settlement/full_settlement_config.toml
index 954d38f74..83959d181 100644
--- a/crates/agglayer-config/tests/fixtures/settlement/full_settlement_config.toml
+++ b/crates/agglayer-config/tests/fixtures/settlement/full_settlement_config.toml
@@ -1,4 +1,4 @@
-# Full settlement configuration with both certificate and validium configs
+# Full settlement configuration for pessimistic-proof settlement
 [pessimistic-proof-tx-config]
 max-expected-retries = 2048
 retry-on-transient-failure.initial-interval = "15s"
@@ -12,16 +12,6 @@ gas-limit-multiplier-factor = 1.1
 max-fee-per-gas-multiplier-factor = 1.2
 max-fee-per-gas-ceiling = "200gwei"
 
-[validium-tx-config]
-max-expected-retries = 512
-retry-on-transient-failure.initial-interval = "5s"
-confirmations = 16
-settlement-policy = "LatestBlock"
-gas-limit-ceiling = "0x1c9c380"
-gas-limit-multiplier-factor = 1.05
-max-fee-per-gas-floor = "2gwei"
-max-fee-per-gas-ceiling = "50gwei"
-
 [settlement-service-config]
 # Currently no service-specific fields
 
diff --git a/crates/agglayer-config/tests/settlement_service.rs b/crates/agglayer-config/tests/settlement_service.rs
index dcd496cea..86cc8512b 100644
--- a/crates/agglayer-config/tests/settlement_service.rs
+++ b/crates/agglayer-config/tests/settlement_service.rs
@@ -62,7 +62,7 @@ fn deserialize_custom_config_2() {
     let content = std::fs::read_to_string(input).unwrap();
     let config: SettlementTransactionConfig = toml::from_str(&content).unwrap();
 
-    // Assert custom validium values
+    // Assert custom latest-block values
     assert_eq!(
         config.retry_on_transient_failure.initial_interval,
         Duration::from_secs(5)
@@ -124,41 +124,6 @@ fn deserialize_full_settlement_config() {
         1.2
     );
 
-    // Assert validium config
-    assert_eq!(
-        config
-            .validium_tx_config
-            .retry_on_transient_failure
-            .initial_interval,
-        Duration::from_secs(5)
-    );
-    assert_eq!(config.validium_tx_config.confirmations, 16);
-    assert_eq!(
-        config.validium_tx_config.settlement_policy,
-        SettlementPolicy::LatestBlock
-    );
-    assert_eq!(
-        config.validium_tx_config.gas_limit_ceiling,
-        U256::from(30_000_000_u64)
-    );
-    assert_eq!(
-        config.validium_tx_config.max_fee_per_gas_floor,
-        2_000_000_000_u128
-    );
-    assert_eq!(
-        config.validium_tx_config.max_fee_per_gas_ceiling,
-        50_000_000_000_u128
-    );
-
-    // Assert validium multipliers
-    assert_eq!(
-        config
-            .validium_tx_config
-            .gas_limit_multiplier_factor
-            .as_f64(),
-        1.05
-    );
-
     assert_toml_snapshot!(config);
 }
 
diff --git a/crates/agglayer-config/tests/snapshots/settlement_service__deserialize_full_settlement_config.snap b/crates/agglayer-config/tests/snapshots/settlement_service__deserialize_full_settlement_config.snap
index 00f79acca..602c44fb4 100644
--- a/crates/agglayer-config/tests/snapshots/settlement_service__deserialize_full_settlement_config.snap
+++ b/crates/agglayer-config/tests/snapshots/settlement_service__deserialize_full_settlement_config.snap
@@ -23,25 +23,4 @@ interval-multiplier-factor = 2.0
 max-interval = "10m"
 jitter = "10s"
 
-[validium-tx-config]
-confirmations = 16
-settlement-policy = "LatestBlock"
-gas-limit-multiplier-factor = 1.05
-gas-limit-ceiling = "0x1c9c380"
-max-fee-per-gas-floor = "2gwei"
-max-fee-per-gas-ceiling = "50gwei"
-max-priority-fee-per-gas-ceiling = "100gwei"
-
-[validium-tx-config.retry-on-transient-failure]
-initial-interval = "5s"
-interval-multiplier-factor = 1.5
-max-interval = "2m"
-jitter = "1s"
-
-[validium-tx-config.retry-on-not-included-on-l1]
-initial-interval = "1m"
-interval-multiplier-factor = 2.0
-max-interval = "10m"
-jitter = "10s"
-
 [settlement-service-config]
diff --git a/crates/agglayer-settlement-service/src/settlement_service.rs b/crates/agglayer-settlement-service/src/settlement_service.rs
index a88342198..6c02b68b7 100644
--- a/crates/agglayer-settlement-service/src/settlement_service.rs
+++ b/crates/agglayer-settlement-service/src/settlement_service.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashMap, future::Future, pin::Pin, sync::Arc};
 
-use agglayer_config::settlement_service::SettlementServiceConfig;
+use agglayer_config::settlement_service::{SettlementServiceConfig, SettlementTransactionConfig};
 use agglayer_storage::stores::{SettlementReader, SettlementWriter};
 use agglayer_types::{SettlementJob, SettlementJobId, SettlementJobResult};
 use alloy::providers::Provider;
@@ -21,6 +21,7 @@ const ADMIN_CHANNEL_BUFFER_SIZE: usize = 10;
 #[derive(Educe)]
 #[educe(Clone)]
 pub struct SettlementService<L1Provider, SettlementStore> {
+    tx_config: Arc<SettlementTransactionConfig>,
     provider: Arc<L1Provider>,
     store: Arc<SettlementStore>,
     cancellation_token: CancellationToken,
@@ -56,11 +57,13 @@ impl<
 {
     pub async fn start(
         _config: SettlementServiceConfig,
+        tx_config: Arc<SettlementTransactionConfig>,
         provider: Arc<L1Provider>,
         store: Arc<SettlementStore>,
         cancellation_token: CancellationToken,
     ) -> eyre::Result<Self> {
         let this = Self {
+            tx_config,
             provider,
             store,
             cancellation_token,
@@ -119,9 +122,14 @@ impl<
         let (result_sender, result_receiver) = watch::channel(None);
         let (task_control_handle, task_control) =
             TaskControlHandle::new(&self.cancellation_token, admin_sender, admin_receiver);
-        let (job_id, mut task) =
-            SettlementTask::create(job, self.provider.clone(), self.store.clone(), task_control)
-                .await?;
+        let (job_id, mut task) = SettlementTask::create(
+            job,
+            self.tx_config.clone(),
+            self.provider.clone(),
+            self.store.clone(),
+            task_control,
+        )
+        .await?;
         self.task_controls
             .lock()
             .await
diff --git a/crates/agglayer-settlement-service/src/settlement_task.rs b/crates/agglayer-settlement-service/src/settlement_task.rs
index 9449f4f46..aa37c169b 100644
--- a/crates/agglayer-settlement-service/src/settlement_task.rs
+++ b/crates/agglayer-settlement-service/src/settlement_task.rs
@@ -4,7 +4,7 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-use agglayer_config::settlement_service::TxRetryPolicy;
+use agglayer_config::settlement_service::{SettlementPolicy, SettlementTransactionConfig};
 use agglayer_storage::stores::{SettlementReader, SettlementWriter};
 use agglayer_types::{
     ClientError, ClientErrorType, ContractCallOutcome, ContractCallResult, Digest, Nonce,
@@ -12,19 +12,55 @@ use agglayer_types::{
     SettlementJobId, SettlementJobResult, SettlementTxHash,
 };
 use alloy::{
-    consensus::{EthereumTxEnvelope, TxEip4844Variant},
-    primitives::Address,
+    consensus::{BlockHeader as _, EthereumTxEnvelope, TxEip4844Variant},
+    eips::BlockNumberOrTag,
+    network::{BlockResponse as _, ReceiptResponse as _},
+    primitives::{Address, TxHash},
     providers::Provider,
     transports::TransportError,
 };
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
-use tracing::{error, warn};
+use tracing::{debug, error, warn};
 
 use crate::utils::RetryCallbackError;
 
 type TxEnvelope = EthereumTxEnvelope<TxEip4844Variant>;
 
+/// Returns the minimum selected settlement-head block number required for a
+/// transaction receipt to be considered settled.
+///
+/// `receipt_block_number` is the block that included the transaction.
+/// `confirmations` is inclusive of that block, so 0 or 1 confirmations settle
+/// at `receipt_block_number`, while 2 confirmations require the selected head
+/// (`latest`, `safe`, or `finalized`) to be at least one block later.
+fn required_settlement_head_number(receipt_block_number: u64, confirmations: usize) -> u64 {
+    let confirmation_offset = confirmations.saturating_sub(1);
+    let confirmation_offset = confirmation_offset.try_into().unwrap_or(u64::MAX);
+
+    receipt_block_number.saturating_add(confirmation_offset)
+}
+
+#[derive(Debug)]
+enum WaitForSettlementError {
+    NotSettledYet,
+    Transport(TransportError),
+}
+
+impl WaitForSettlementError {
+    fn is_transient(&self) -> bool {
+        match self {
+            Self::NotSettledYet => true,
+            Self::Transport(error) => crate::utils::is_transient_alloy_error(error),
+        }
+    }
+}
+
+impl From<TransportError> for WaitForSettlementError {
+    fn from(error: TransportError) -> Self {
+        Self::Transport(error)
+    }
+}
 #[derive(Debug, thiserror::Error)]
 #[error(
     "assumed non-recoverable in settlement task {settlement_task_id} at {file}:{line}: \
@@ -106,6 +142,7 @@ struct ActiveSettlementAttempt {
 pub struct SettlementTask<L1Provider, SettlementStore> {
     id: SettlementJobId,
     job: SettlementJob,
+    tx_config: Arc<SettlementTransactionConfig>,
     provider: Arc<L1Provider>,
     store: Arc<SettlementStore>,
     control: TaskControl,
@@ -120,6 +157,7 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
 {
     pub async fn create(
         job: SettlementJob,
+        tx_config: Arc<SettlementTransactionConfig>,
         provider: Arc<L1Provider>,
         store: Arc<SettlementStore>,
         control: TaskControl,
@@ -138,6 +176,7 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
         let this = Self {
             id,
             job,
+            tx_config,
             provider,
             store,
             control,
@@ -149,6 +188,7 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
 
     pub async fn load(
         id: SettlementJobId,
+        tx_config: Arc<SettlementTransactionConfig>,
         provider: Arc<L1Provider>,
         store: Arc<SettlementStore>,
         control: TaskControl,
@@ -160,6 +200,7 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
             let mut this = SettlementTask {
                 id,
                 job,
+                tx_config,
                 provider,
                 store,
                 control,
@@ -235,7 +276,11 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
                         reverts.insert((wallet, nonce), (attempt_number, tx_hash, tx_result));
                         continue 'nonces;
                     }
-                    let Some(settled_result) = self.wait_for_settlement_of(tx_hash).await else {
+                    let settlement_result = retry!(
+                        self.wait_for_settlement_of(tx_hash).await,
+                        "waiting for settlement of tx {tx_hash}",
+                    );
+                    let Some(settled_result) = settlement_result else {
                         continue 'start; // reorg
                     };
                     if settled_result != tx_result {
@@ -300,7 +345,11 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
                     .clone();
                 for (wallet, nonce) in self.all_used_nonces() {
                     if let Some(tx_hash) = nonces_used_externally.remove(&(wallet, nonce)) {
-                        if self.wait_for_settlement_of(tx_hash).await.is_none() {
+                        let settlement_result = retry!(
+                            self.wait_for_settlement_of(tx_hash).await,
+                            "waiting for settlement of externally-used tx {tx_hash}",
+                        );
+                        if settlement_result.is_none() {
                             continue 'start; // reorg
                         }
                         self.write_nonce_used_externally_to_db(wallet, nonce, tx_hash)
@@ -308,8 +357,11 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
                     } else if let Some((attempt_number, tx_hash, result)) =
                         reverts.remove(&(wallet, nonce))
                     {
-                        let Some(settled_result) = self.wait_for_settlement_of(tx_hash).await
-                        else {
+                        let settlement_result = retry!(
+                            self.wait_for_settlement_of(tx_hash).await,
+                            "waiting for settlement of reverting tx {tx_hash}",
+                        );
+                        let Some(settled_result) = settlement_result else {
                             continue 'start; // reorg
                         };
                         if settled_result != result {
@@ -474,9 +526,8 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
         wallet: Address,
         nonce: Nonce,
     ) -> Result<Option<SettlementTxHash>, RetryCallbackError<TransportError>> {
-        let retry_policy = TxRetryPolicy::default_on_transient_failure();
         crate::utils::retry_alloy_callback_until_success(
-            &retry_policy,
+            &self.tx_config.retry_on_transient_failure,
             &self.control.cancellation_token,
             || crate::utils::tx_hash_on_l1_for_nonce(self.provider.as_ref(), wallet, nonce),
         )
@@ -495,12 +546,145 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
 
     async fn wait_for_settlement_of(
         &self,
-        _tx_hash: SettlementTxHash,
-    ) -> Option<ContractCallResult> {
-        // TODO: Wait for the settlement of tx_hash, and then return its result on L1.
-        // If a reorg is detected during the waiting, return None.
-        // XREF: https://github.com/agglayer/agglayer/issues/1316
-        todo!()
+        tx_hash: SettlementTxHash,
+    ) -> Result<Option<ContractCallResult>, RetryCallbackError<TransportError>> {
+        // Let the shared retry helper own polling; this callback only distinguishes
+        // "not settled yet" from terminal reorg and RPC outcomes.
+        let result = crate::utils::retry_callback_until_success(
+            &self.tx_config.retry_on_not_included_on_l1,
+            &self.control.cancellation_token,
+            || self.check_settlement_once(tx_hash),
+            WaitForSettlementError::is_transient,
+        )
+        .await;
+
+        result.map_err(|error| match error {
+            RetryCallbackError::Cancelled => RetryCallbackError::Cancelled,
+            RetryCallbackError::Error(WaitForSettlementError::Transport(error)) => {
+                RetryCallbackError::Error(error)
+            }
+            RetryCallbackError::Error(WaitForSettlementError::NotSettledYet) => {
+                unreachable!("not-settled-yet errors are always transient")
+            }
+        })
+    }
+
+    #[tracing::instrument(
+        level = "debug",
+        skip_all,
+        fields(
+            task_id = ?self.id,
+            ?tx_hash,
+            settlement_policy = ?self.tx_config.settlement_policy,
+        )
+    )]
+    async fn check_settlement_once(
+        &self,
+        tx_hash: SettlementTxHash,
+    ) -> Result<Option<ContractCallResult>, WaitForSettlementError> {
+        // Read the settlement head first so any later receipt lookup is checked
+        // against a head that was already acceptable for the configured policy.
+        let settlement_head_number = self.settlement_head_number().await?;
+        let Some(settlement_head_number) = settlement_head_number else {
+            debug!("Waiting for selected settlement head before checking settlement transaction");
+            return Err(WaitForSettlementError::NotSettledYet);
+        };
+
+        let provider_tx_hash: TxHash = tx_hash.into();
+        let receipt = self
+            .provider
+            .get_transaction_receipt(provider_tx_hash)
+            .await?;
+        let Some(receipt) = receipt else {
+            // The caller only waits after observing this transaction on L1, so
+            // a missing receipt is a reorg/drop signal.
+            debug!(
+                settlement_head_number,
+                "Settlement transaction receipt missing after inclusion; treating as reorg or drop"
+            );
+            return Ok(None);
+        };
+
+        let Some(block_hash) = receipt.block_hash() else {
+            debug!(
+                settlement_head_number,
+                "Waiting for settlement transaction receipt block hash"
+            );
+            return Err(WaitForSettlementError::NotSettledYet);
+        };
+        let Some(block_number) = receipt.block_number() else {
+            debug!(
+                ?block_hash,
+                settlement_head_number, "Waiting for settlement transaction receipt block number"
+            );
+            return Err(WaitForSettlementError::NotSettledYet);
+        };
+
+        let required_head_number =
+            required_settlement_head_number(block_number, self.tx_config.confirmations);
+        if settlement_head_number < required_head_number {
+            debug!(
+                block_number,
+                settlement_head_number,
+                required_head_number,
+                "Waiting for settlement transaction finality"
+            );
+            return Err(WaitForSettlementError::NotSettledYet);
+        }
+
+        let canonical_block = self
+            .provider
+            .get_block_by_number(BlockNumberOrTag::Number(block_number))
+            .await?;
+        let Some(canonical_block) = canonical_block else {
+            debug!(
+                block_number,
+                ?block_hash,
+                settlement_head_number,
+                "Waiting for settlement transaction block to be available"
+            );
+            return Err(WaitForSettlementError::NotSettledYet);
+        };
+
+        // A receipt whose block number no longer resolves to the same canonical
+        // block hash is a reorg signal, not a transient "wait longer" condition.
+        let canonical_block_hash = canonical_block.header().hash;
+        if canonical_block_hash != block_hash {
+            debug!(
+                block_number,
+                ?block_hash,
+                ?canonical_block_hash,
+                settlement_head_number,
+                "Settlement transaction receipt block hash differs from canonical block; treating \
+                 as reorg"
+            );
+            return Ok(None);
+        }
+
+        Ok(self.current_result_on_l1_for(tx_hash).await)
+    }
+
+    async fn settlement_head_number(&self) -> Result<Option<u64>, WaitForSettlementError> {
+        match self.tx_config.settlement_policy {
+            SettlementPolicy::LatestBlock => self
+                .provider
+                .get_block_number()
+                .await
+                .map(Some)
+                .map_err(WaitForSettlementError::Transport),
+            SettlementPolicy::SafeBlock => self
+                .provider
+                .get_block_by_number(BlockNumberOrTag::Safe)
+                .await
+                .map(|block| block.map(|block| block.header().number()))
+                .map_err(WaitForSettlementError::Transport),
+            SettlementPolicy::FinalizedBlock => self
+                .provider
+                .get_block_by_number(BlockNumberOrTag::Finalized)
+                .await
+                .map(|block| block.map(|block| block.header().number()))
+                .map_err(WaitForSettlementError::Transport),
+        }
     }
 
     fn build_next_attempt_with_nonce(
@@ -619,3 +803,25 @@ impl<L1Provider: Provider + 'static, SettlementStore: SettlementReader + Settlem
         todo!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn required_settlement_head_number_is_inclusive_of_receipt_block() {
+        // Confirmations count the receipt block itself, and saturate rather than
+        // overflow.
+        for (receipt_block, confirmations, required_head) in [
+            (10, 0, 10),
+            (10, 1, 10),
+            (10, 12, 21),
+            (10, usize::MAX, u64::MAX),
+        ] {
+            assert_eq!(
+                required_settlement_head_number(receipt_block, confirmations),
+                required_head
+            );
+        }
+    }
+}
diff --git a/crates/agglayer-settlement-service/src/utils.rs b/crates/agglayer-settlement-service/src/utils.rs
index 2b6d34d99..f8b700489 100644
--- a/crates/agglayer-settlement-service/src/utils.rs
+++ b/crates/agglayer-settlement-service/src/utils.rs
@@ -94,7 +94,7 @@ where
     .await
 }
 
-fn is_transient_alloy_error(error: &TransportError) -> bool {
+pub(crate) fn is_transient_alloy_error(error: &TransportError) -> bool {
     RateLimitRetryPolicy::default().should_retry(error)
 }
 
diff --git a/crates/agglayer-storage/src/columns/settlement_attempts/tests.rs b/crates/agglayer-storage/src/columns/settlement_attempts/tests.rs
index efa7c49bf..a7d41bd21 100644
--- a/crates/agglayer-storage/src/columns/settlement_attempts/tests.rs
+++ b/crates/agglayer-storage/src/columns/settlement_attempts/tests.rs
@@ -7,7 +7,7 @@ use crate::{
     stores::state::StateStore,
     tests::TempDBDir,
     types::{
-        generated::agglayer::storage::v0::{Address, Nonce, SettlementAttempt, TxHash, Uint128},
+        generated::agglayer::storage::v0::{Address, Nonce, SettlementAttempt, TxHash},
         settlement::attempt::{Key, Value},
     },
 };
@@ -76,12 +76,6 @@ fn mk_settlement_attempt(seed: u64) -> SettlementAttempt {
             address: vec![0x22; 20].into(),
         }),
         nonce: Some(Nonce { nonce: seed }),
-        max_fee_per_gas: Some(Uint128 {
-            value: vec![0x07; 16].into(),
-        }),
-        max_priority_fee_per_gas: Some(Uint128 {
-            value: vec![0x08; 16].into(),
-        }),
         tx_hash: Some(TxHash {
             hash: vec![0x66; 32].into(),
         }),
diff --git a/crates/agglayer-storage/src/columns/settlement_jobs/tests.rs b/crates/agglayer-storage/src/columns/settlement_jobs/tests.rs
index 2b9f6c6cc..e511e85d6 100644
--- a/crates/agglayer-storage/src/columns/settlement_jobs/tests.rs
+++ b/crates/agglayer-storage/src/columns/settlement_jobs/tests.rs
@@ -43,19 +43,5 @@ fn mk_settlement_job() -> SettlementJob {
         gas_limit: Some(Uint128 {
             value: vec![0x02; 16].into(),
         }),
-        max_fee_per_gas_ceiling: Some(Uint128 {
-            value: vec![0x03; 16].into(),
-        }),
-        max_fee_per_gas_floor: Some(Uint128 {
-            value: vec![0x04; 16].into(),
-        }),
-        max_fee_per_gas_increase_percents: 10,
-        max_priority_fee_per_gas_ceiling: Some(Uint128 {
-            value: vec![0x05; 16].into(),
-        }),
-        max_priority_fee_per_gas_floor: Some(Uint128 {
-            value: vec![0x06; 16].into(),
-        }),
-        max_priority_fee_per_gas_increase_percents: 20,
     }
 }
diff --git a/crates/agglayer-storage/src/storage/iterators.rs b/crates/agglayer-storage/src/storage/iterators.rs
index 93eae859b..45b55d307 100644
--- a/crates/agglayer-storage/src/storage/iterators.rs
+++ b/crates/agglayer-storage/src/storage/iterators.rs
@@ -86,15 +86,6 @@ impl<'a, C: ColumnSchema> ColumnIterator<'a, C> {
         }
     }
 
-    /// Seeks to the first entry whose key is greater than or equal to `key`.
-    pub fn seek(&mut self, key: &C::Key) -> Result<(), DBError> {
-        let encoded = C::Key::encode(key)?;
-        self.iter.seek(&encoded);
-        self.status = IteratorStatus::Initialized;
-
-        Ok(())
-    }
-
     fn parse_key_value(&self) -> KeyValueResult<C::Key, C::Value> {
         let key = self.iter.key().map(C::Key::decode).transpose()?;
         let value = self.iter.value().map(C::Value::decode).transpose()?;
diff --git a/crates/agglayer-storage/src/storage/mod.rs b/crates/agglayer-storage/src/storage/mod.rs
index d0e96d2de..fb4f7e4e9 100644
--- a/crates/agglayer-storage/src/storage/mod.rs
+++ b/crates/agglayer-storage/src/storage/mod.rs
@@ -232,6 +232,17 @@ impl DB {
         Ok(ColumnIterator::new(iterator, direction))
     }
 
+    pub(crate) fn prefix_iterator<C: ColumnSchema, P: Codec>(
+        &self,
+        prefix: &P,
+    ) -> Result<ColumnIterator<'_, C>, DBError> {
+        let cf = self.cf::<C>()?;
+        let prefix = prefix.encode()?;
+        let iterator = self.rocksdb.prefix_iterator_cf(&cf, prefix).into();
+
+        Ok(ColumnIterator::new(iterator, Direction::Forward))
+    }
+
     pub(crate) fn delete<C: ColumnSchema>(&self, key: &C::Key) -> Result<(), DBError> {
         let cf = self.cf::<C>()?;
         let key = key.encode()?;
diff --git a/crates/agglayer-storage/src/stores/state/settlement/mod.rs b/crates/agglayer-storage/src/stores/state/settlement/mod.rs
index b81c89946..3a962a6ab 100644
--- a/crates/agglayer-storage/src/stores/state/settlement/mod.rs
+++ b/crates/agglayer-storage/src/stores/state/settlement/mod.rs
@@ -1,7 +1,7 @@
 use agglayer_types::{
     SettlementAttempt, SettlementAttemptResult, SettlementJob, SettlementJobId, SettlementJobResult,
 };
-use rocksdb::{Direction, ReadOptions, WriteBatch};
+use rocksdb::WriteBatch;
 
 use super::StateStore;
 use crate::{
@@ -73,28 +73,16 @@ impl SettlementReader for StateStore {
         &self,
         settlement_job_id: &SettlementJobId,
     ) -> Result<Vec<(u64, SettlementAttempt)>, Error> {
-        let mut iterator = self.db.iter_with_direction::<SettlementAttemptsColumn>(
-            ReadOptions::default(),
-            Direction::Forward,
-        )?;
-        iterator.seek(&SettlementAttemptKey {
-            settlement_job_id: *settlement_job_id,
-            attempt_sequence_number: 0,
-        })?;
-
-        iterator
-            .map(|entry| -> Result<Option<(u64, SettlementAttempt)>, Error> {
+        self.db
+            .prefix_iterator::<SettlementAttemptsColumn, _>(settlement_job_id)?
+            .map(|entry| -> Result<(u64, SettlementAttempt), Error> {
                 let (key, attempt) = entry?;
-                if key.settlement_job_id != *settlement_job_id {
-                    return Ok(None);
-                }
 
-                Ok(Some((
+                Ok((
                     key.attempt_sequence_number,
                     SettlementAttempt::try_from(attempt)?,
-                )))
+                ))
             })
-            .map_while(|entry| entry.transpose())
             .collect::<Result<Vec<_>, _>>()
     }
 
@@ -102,32 +90,16 @@ impl SettlementReader for StateStore {
         &self,
         settlement_job_id: &SettlementJobId,
     ) -> Result<Vec<(u64, SettlementAttemptResult)>, Error> {
-        let mut iterator = self
-            .db
-            .iter_with_direction::<SettlementAttemptResultsColumn>(
-                ReadOptions::default(),
-                Direction::Forward,
-            )?;
-        iterator.seek(&SettlementAttemptKey {
-            settlement_job_id: *settlement_job_id,
-            attempt_sequence_number: 0,
-        })?;
+        self.db
+            .prefix_iterator::<SettlementAttemptResultsColumn, _>(settlement_job_id)?
+            .map(|entry| -> Result<(u64, SettlementAttemptResult), Error> {
+                let (key, result) = entry?;
 
-        iterator
-            .map(
-                |entry| -> Result<Option<(u64, SettlementAttemptResult)>, Error> {
-                    let (key, result) = entry?;
-                    if key.settlement_job_id != *settlement_job_id {
-                        return Ok(None);
-                    }
-
-                    Ok(Some((
-                        key.attempt_sequence_number,
-                        SettlementAttemptResult::try_from(result)?,
-                    )))
-                },
-            )
-            .map_while(|entry| entry.transpose())
+                Ok((
+                    key.attempt_sequence_number,
+                    SettlementAttemptResult::try_from(result)?,
+                ))
+            })
             .collect::<Result<Vec<_>, _>>()
     }
 }
diff --git a/crates/agglayer-storage/src/stores/state/tests/settlement.rs b/crates/agglayer-storage/src/stores/state/tests/settlement.rs
index 8537f73e5..d31d64935 100644
--- a/crates/agglayer-storage/src/stores/state/tests/settlement.rs
+++ b/crates/agglayer-storage/src/stores/state/tests/settlement.rs
@@ -40,12 +40,6 @@ fn mk_settlement_job(seed: u8) -> SettlementJob {
         calldata: vec![seed, seed.wrapping_add(1)].into(),
         eth_value: U256::from_be_bytes([seed; 32]),
         gas_limit: u128::from_be_bytes([seed; 16]),
-        max_fee_per_gas_ceiling: u128::from_be_bytes([seed.wrapping_add(1); 16]),
-        max_fee_per_gas_floor: u128::from_be_bytes([seed.wrapping_add(2); 16]),
-        max_fee_per_gas_increase_percents: 10,
-        max_priority_fee_per_gas_ceiling: u128::from_be_bytes([seed.wrapping_add(3); 16]),
-        max_priority_fee_per_gas_floor: u128::from_be_bytes([seed.wrapping_add(4); 16]),
-        max_priority_fee_per_gas_increase_percents: 20,
     }
 }
 
@@ -53,8 +47,6 @@ fn mk_settlement_attempt(seed: u64) -> SettlementAttempt {
     SettlementAttempt {
         sender_wallet: Address::from([(seed as u8).wrapping_add(1); 20]),
         nonce: Nonce(seed),
-        max_fee_per_gas: u128::from_be_bytes([(seed as u8).wrapping_add(2); 16]),
-        max_priority_fee_per_gas: u128::from_be_bytes([(seed as u8).wrapping_add(3); 16]),
         hash: SettlementTxHash::new(Digest::from([(seed as u8).wrapping_add(4); 32])),
         submission_time: SystemTime::UNIX_EPOCH + Duration::from_secs(seed),
     }
diff --git a/crates/agglayer-storage/src/types/generated/agglayer.storage.v0.rs b/crates/agglayer-storage/src/types/generated/agglayer.storage.v0.rs
index 7bdc0589c..4da108ebe 100644
--- a/crates/agglayer-storage/src/types/generated/agglayer.storage.v0.rs
+++ b/crates/agglayer-storage/src/types/generated/agglayer.storage.v0.rs
@@ -818,24 +818,6 @@ pub struct SettlementJob {
     /// Gas limit for each settlement attempt.
     #[prost(message, optional, tag="4")]
     pub gas_limit: ::core::option::Option<Uint128>,
-    /// Ceiling for max fee per gas.
-    #[prost(message, optional, tag="5")]
-    pub max_fee_per_gas_ceiling: ::core::option::Option<Uint128>,
-    /// Floor for max fee per gas.
-    #[prost(message, optional, tag="6")]
-    pub max_fee_per_gas_floor: ::core::option::Option<Uint128>,
-    /// Percent increase for max fee per gas: each retry will multiply max fee per gas by N / 100.
-    #[prost(uint32, tag="7")]
-    pub max_fee_per_gas_increase_percents: u32,
-    /// Ceiling for max priority fee per gas.
-    #[prost(message, optional, tag="8")]
-    pub max_priority_fee_per_gas_ceiling: ::core::option::Option<Uint128>,
-    /// Floor for max priority fee per gas.
-    #[prost(message, optional, tag="9")]
-    pub max_priority_fee_per_gas_floor: ::core::option::Option<Uint128>,
-    /// Percent increase for max priority fee per gas: each retry will multiply max priority fee per gas by N / 100.
-    #[prost(uint32, tag="10")]
-    pub max_priority_fee_per_gas_increase_percents: u32,
 }
 /// Result of one settlement attempt.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -925,12 +907,6 @@ pub struct SettlementAttempt {
     /// Nonce reserved for the transaction.
     #[prost(message, optional, tag="2")]
     pub nonce: ::core::option::Option<Nonce>,
-    /// Gas price parameters used for this attempt.
-    #[prost(message, optional, tag="3")]
-    pub max_fee_per_gas: ::core::option::Option<Uint128>,
-    /// Gas price parameters used for this attempt.
-    #[prost(message, optional, tag="4")]
-    pub max_priority_fee_per_gas: ::core::option::Option<Uint128>,
     /// Hash of the submitted transaction.
     #[prost(message, optional, tag="5")]
     pub tx_hash: ::core::option::Option<TxHash>,
diff --git a/crates/agglayer-storage/src/types/settlement/compat/settlement_attempt.rs b/crates/agglayer-storage/src/types/settlement/compat/settlement_attempt.rs
index 00f2e6224..022bbd638 100644
--- a/crates/agglayer-storage/src/types/settlement/compat/settlement_attempt.rs
+++ b/crates/agglayer-storage/src/types/settlement/compat/settlement_attempt.rs
@@ -32,8 +32,6 @@ impl From<&SettlementAttempt> for v0::SettlementAttempt {
         Self {
             sender_wallet: Some(value.sender_wallet.into()),
             nonce: Some(value.nonce.into()),
-            max_fee_per_gas: Some(value.max_fee_per_gas.into()),
-            max_priority_fee_per_gas: Some(value.max_priority_fee_per_gas.into()),
             tx_hash: Some(value.hash.into()),
             submission_time: Some(prost_types::Timestamp::from(value.submission_time)),
         }
@@ -49,10 +47,6 @@ impl TryFrom<v0::SettlementAttempt> for SettlementAttempt {
                 try_into::<agglayer_types::Address>
             ),
             nonce: required_field!(value, nonce => into::<Nonce>),
-            max_fee_per_gas: required_field!(value, max_fee_per_gas => try_into::<u128>),
-            max_priority_fee_per_gas: required_field!(value, max_priority_fee_per_gas =>
-                try_into::<u128>
-            ),
             hash: required_field!(value, tx_hash => try_into::<agglayer_types::SettlementTxHash>),
             submission_time: required_field!(value, submission_time =>
                 try_into::<std::time::SystemTime>
@@ -74,8 +68,6 @@ mod tests {
         let attempt = SettlementAttempt {
             sender_wallet: Address::from([1_u8; 20]),
             nonce: Nonce(7),
-            max_fee_per_gas: 10,
-            max_priority_fee_per_gas: 20,
             hash: SettlementTxHash::new(Digest::from([2_u8; 32])),
             submission_time: SystemTime::UNIX_EPOCH,
         };
@@ -85,11 +77,6 @@ mod tests {
 
         assert_eq!(decoded.sender_wallet, attempt.sender_wallet);
         assert_eq!(decoded.nonce, attempt.nonce);
-        assert_eq!(decoded.max_fee_per_gas, attempt.max_fee_per_gas);
-        assert_eq!(
-            decoded.max_priority_fee_per_gas,
-            attempt.max_priority_fee_per_gas
-        );
         assert_eq!(decoded.hash, attempt.hash);
         assert_eq!(decoded.submission_time, attempt.submission_time);
     }
diff --git a/crates/agglayer-storage/src/types/settlement/compat/settlement_job.rs b/crates/agglayer-storage/src/types/settlement/compat/settlement_job.rs
index e2dcdd879..c858aba5c 100644
--- a/crates/agglayer-storage/src/types/settlement/compat/settlement_job.rs
+++ b/crates/agglayer-storage/src/types/settlement/compat/settlement_job.rs
@@ -14,23 +14,6 @@ impl TryFrom<v0::SettlementJob> for SettlementJob {
             calldata: required_field!(value, calldata => into::<Vec<u8>>).into(),
             eth_value: required_field!(value, eth_value => try_into::<agglayer_types::U256>),
             gas_limit: required_field!(value, gas_limit => try_into::<u128>),
-            max_fee_per_gas_ceiling: required_field!(value, max_fee_per_gas_ceiling =>
-                try_into::<u128>
-            ),
-            max_fee_per_gas_floor: required_field!(value, max_fee_per_gas_floor =>
-                try_into::<u128>
-            ),
-            max_fee_per_gas_increase_percents: value.max_fee_per_gas_increase_percents,
-            max_priority_fee_per_gas_ceiling: required_field!(
-                value,
-                max_priority_fee_per_gas_ceiling => try_into::<u128>
-            ),
-            max_priority_fee_per_gas_floor: required_field!(
-                value,
-                max_priority_fee_per_gas_floor => try_into::<u128>
-            ),
-            max_priority_fee_per_gas_increase_percents: value
-                .max_priority_fee_per_gas_increase_percents,
         })
     }
 }
@@ -44,13 +27,6 @@ impl From<&SettlementJob> for v0::SettlementJob {
             }),
             eth_value: Some(value.eth_value.into()),
             gas_limit: Some(value.gas_limit.into()),
-            max_fee_per_gas_ceiling: Some(value.max_fee_per_gas_ceiling.into()),
-            max_fee_per_gas_floor: Some(value.max_fee_per_gas_floor.into()),
-            max_fee_per_gas_increase_percents: value.max_fee_per_gas_increase_percents,
-            max_priority_fee_per_gas_ceiling: Some(value.max_priority_fee_per_gas_ceiling.into()),
-            max_priority_fee_per_gas_floor: Some(value.max_priority_fee_per_gas_floor.into()),
-            max_priority_fee_per_gas_increase_percents: value
-                .max_priority_fee_per_gas_increase_percents,
         }
     }
 }
@@ -74,12 +50,6 @@ mod tests {
             calldata: Bytes::from(vec![1, 2, 3]),
             eth_value: agglayer_types::U256::from(3_u64),
             gas_limit: 10,
-            max_fee_per_gas_ceiling: 20,
-            max_fee_per_gas_floor: 30,
-            max_fee_per_gas_increase_percents: 125,
-            max_priority_fee_per_gas_ceiling: 40,
-            max_priority_fee_per_gas_floor: 50,
-            max_priority_fee_per_gas_increase_percents: 125,
         }
     }
 
diff --git a/crates/agglayer-types/src/settlement.rs b/crates/agglayer-types/src/settlement.rs
index d61162d8f..7f6704921 100644
--- a/crates/agglayer-types/src/settlement.rs
+++ b/crates/agglayer-types/src/settlement.rs
@@ -79,12 +79,6 @@ pub struct SettlementJob {
     pub calldata: Bytes,
     pub eth_value: U256,
     pub gas_limit: u128,
-    pub max_fee_per_gas_ceiling: u128,
-    pub max_fee_per_gas_floor: u128,
-    pub max_fee_per_gas_increase_percents: u32,
-    pub max_priority_fee_per_gas_ceiling: u128,
-    pub max_priority_fee_per_gas_floor: u128,
-    pub max_priority_fee_per_gas_increase_percents: u32,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -147,8 +141,6 @@ pub enum ContractCallOutcome {
 pub struct SettlementAttempt {
     pub sender_wallet: Address,
     pub nonce: Nonce,
-    pub max_fee_per_gas: u128,
-    pub max_priority_fee_per_gas: u128,
     pub hash: SettlementTxHash,
     pub submission_time: SystemTime,
 }
diff --git a/proto/agglayer/storage/v0/settlement.proto b/proto/agglayer/storage/v0/settlement.proto
index fe91f703f..1a5714eba 100644
--- a/proto/agglayer/storage/v0/settlement.proto
+++ b/proto/agglayer/storage/v0/settlement.proto
@@ -20,24 +20,6 @@ message SettlementJob {
 
   // Gas limit for each settlement attempt.
   Uint128 gas_limit = 4;
-
-  // Ceiling for max fee per gas.
-  Uint128 max_fee_per_gas_ceiling = 5;
-
-  // Floor for max fee per gas.
-  Uint128 max_fee_per_gas_floor = 6;
-
-  // Percent increase for max fee per gas: each retry will multiply max fee per gas by N / 100.
-  uint32 max_fee_per_gas_increase_percents = 7;
-
-  // Ceiling for max priority fee per gas.
-  Uint128 max_priority_fee_per_gas_ceiling = 8;
-
-  // Floor for max priority fee per gas.
-  Uint128 max_priority_fee_per_gas_floor = 9;
-
-  // Percent increase for max priority fee per gas: each retry will multiply max priority fee per gas by N / 100.
-  uint32 max_priority_fee_per_gas_increase_percents = 10;
 }
 
 // Result of one settlement attempt.
@@ -135,12 +117,6 @@ message SettlementAttempt {
   // Nonce reserved for the transaction.
   Nonce nonce = 2;
 
-  // Gas price parameters used for this attempt.
-  Uint128 max_fee_per_gas = 3;
-
-  // Gas price parameters used for this attempt.
-  Uint128 max_priority_fee_per_gas = 4;
-
   // Hash of the submitted transaction.
   TxHash tx_hash = 5;