pub struct ScrollBuilderConfig {
 /// Gas limit.
 pub gas_limit: u64,
 /// Time limit for payload building.
 pub time_limit: Duration,
 /// Maximum total data availability size for a block.
 pub max_da_block_size: Option<u64>,
}

 let desired_gas_limit = self
 .attributes()
 .gas_limit
 .unwrap_or_else(|| builder_config.gas_limit.unwrap_or_default());

pub struct PayloadBuildingBreaker {
 start: Instant,
 time_limit: Duration,
 gas_limit: u64,
 max_da_block_size: Option<u64>,
}

 /// Returns the gas limit for the new block.
 fn gas_limit(&self, builder_gas_limit: u64) -> u64 {
 let parent_gas_limit = self.parent().gas_limit();
 let target_gas_limit = self.attributes().gas_limit.unwrap_or(builder_gas_limit);
 calculate_block_gas_limit(parent_gas_limit, target_gas_limit)
 }

 /// Prepares a [`BlockBuilder`] for the next block.
 pub fn block_builder_with_breaker<'a, DB: Database>(
 &'a self,
 db: &'a mut State<DB>,
 builder_config: &ScrollBuilderConfig,
 ) -> Result<
 (impl BlockBuilder<Primitives = Evm::Primitives> + 'a, PayloadBuildingBreaker),
 PayloadBuilderError,
 > {
 // get the base fee for the attributes.
 let base_fee_provider = ScrollBaseFeeProvider::new(self.chain_spec.clone());
 let base_fee: u64 = base_fee_provider
 .next_block_base_fee(db, self.parent().header(), self.attributes().timestamp())
 .map_err(|err| PayloadBuilderError::Other(Box::new(err)))?;
 let gas_limit = self.gas_limit(builder_config.gas_limit);
 let block_builder = self
 .evm_config
 .builder_for_next_block(
 db,
 self.parent(),
 ScrollNextBlockEnvAttributes {
 timestamp: self.attributes().timestamp(),
 suggested_fee_recipient: self.attributes().suggested_fee_recipient(),
 gas_limit,
 base_fee,
 },
 )
 .map_err(PayloadBuilderError::other)?;
 let breaker = PayloadBuildingBreaker::new(
 builder_config.time_limit,
 gas_limit,
 builder_config.max_da_block_size,
 );
 Ok((block_builder, breaker))
 }

let (mut builder, breaker) = ctx.block_builder_with_breaker(&mut db, builder_config)?;