lifetimes bump

Author: rakita

crates/context/src/journal/inner.rs

@@ -566,13 +566,13 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
 
     /// Loads account into memory. return if it is cold or warm accessed
     #[inline]
-    pub fn load_account<'a, 'b, DB: Database>(
+    pub fn load_account<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'b mut DB,
+        db: &'db mut DB,
         address: Address,
     ) -> Result<StateLoad<&'a Account>, DB::Error>
     where
-        'b: 'a,
+        'db: 'a,
     {
         self.load_account_optional(db, address, false, false)
             .map_err(JournalLoadError::unwrap_db_error)
@@ -625,29 +625,29 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
     /// In case of EIP-7702 delegated account will not be loaded,
     /// [`Self::load_account_delegated`] should be used instead.
     #[inline]
-    pub fn load_code<'a, 'b, DB: Database>(
+    pub fn load_code<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'a mut DB,
+        db: &'db mut DB,
         address: Address,
     ) -> Result<StateLoad<&'a Account>, DB::Error>
     where
-        'b: 'a,
+        'db: 'a,
     {
         self.load_account_optional(db, address, true, false)
             .map_err(JournalLoadError::unwrap_db_error)
     }
 
     /// Loads account into memory. If account is already loaded it will be marked as warm.
     #[inline]
-    pub fn load_account_optional<'a, 'b, DB: Database>(
+    pub fn load_account_optional<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'a mut DB,
+        db: &'db mut DB,
         address: Address,
         load_code: bool,
         skip_cold_load: bool,
     ) -> Result<StateLoad<&'a Account>, JournalLoadError<DB::Error>>
     where
-        'b: 'a,
+        'db: 'a,
     {
         let mut load = self.load_account_mut_optional(db, address, skip_cold_load)?;
         if load_code {
@@ -658,29 +658,29 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
 
     /// Loads account into memory. If account is already loaded it will be marked as warm.
     #[inline]
-    pub fn load_account_mut<'a, 'b, DB: Database>(
+    pub fn load_account_mut<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'b mut DB,
+        db: &'db mut DB,
         address: Address,
     ) -> Result<StateLoad<JournaledAccount<'a, DB, ENTRY>>, DB::Error>
     where
-        'b: 'a,
+        'db: 'a,
     {
         self.load_account_mut_optional(db, address, false)
             .map_err(JournalLoadError::unwrap_db_error)
     }
 
     /// Loads account. If account is already loaded it will be marked as warm.
     #[inline]
-    pub fn load_account_mut_optional_code<'a, 'b, DB: Database>(
+    pub fn load_account_mut_optional_code<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'b mut DB,
+        db: &'db mut DB,
         address: Address,
         load_code: bool,
         skip_cold_load: bool,
     ) -> Result<StateLoad<JournaledAccount<'a, DB, ENTRY>>, JournalLoadError<DB::Error>>
     where
-        'b: 'a,
+        'db: 'a,
     {
         let mut load = self.load_account_mut_optional(db, address, skip_cold_load)?;
         if load_code {
@@ -697,13 +697,13 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
     /// It will not bump transition_id or return if it is cold or warm loaded. This function is useful
     /// when we know account is warm, touched and already loaded.
     #[inline]
-    pub fn load_account_mut_unsafe<'a, 'b, DB: Database>(
+    pub fn load_account_mut_unsafe<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'b mut DB,
+        db: &'db mut DB,
         address: Address,
     ) -> Option<JournaledAccount<'a, DB, ENTRY>>
     where
-        'b: 'a,
+        'db: 'a,
     {
         let account = self.state.get_mut(&address)?;
         Some(JournaledAccount::new(
@@ -717,14 +717,14 @@ impl<ENTRY: JournalEntryTr> JournalInner<ENTRY> {
     }
     /// Loads account. If account is already loaded it will be marked as warm.
     #[inline(never)]
-    pub fn load_account_mut_optional<'a, 'b, DB: Database>(
+    pub fn load_account_mut_optional<'a, 'db, DB: Database>(
         &'a mut self,
-        db: &'b mut DB,
+        db: &'db mut DB,
         address: Address,
         skip_cold_load: bool,
     ) -> Result<StateLoad<JournaledAccount<'a, DB, ENTRY>>, JournalLoadError<DB::Error>>
     where
-        'b: 'a,
+        'db: 'a,
     {
         let (account, is_cold) = match self.state.entry(address) {
             Entry::Occupied(entry) => {