diff --git a/crates/katana/storage/db/src/abstraction/transaction.rs b/crates/katana/storage/db/src/abstraction/transaction.rs
index 3db3e7d012..9f62a7a572 100644
--- a/crates/katana/storage/db/src/abstraction/transaction.rs
+++ b/crates/katana/storage/db/src/abstraction/transaction.rs
@@ -1,15 +1,24 @@
 use super::cursor::{DbCursor, DbCursorMut};
+use super::{DbDupSortCursor, DbDupSortCursorMut};
 use crate::error::DatabaseError;
-use crate::tables::Table;
+use crate::tables::{DupSort, Table};
 
 /// Trait for read-only transaction type.
 pub trait DbTx {
     /// The cursor type.
     type Cursor<T: Table>: DbCursor<T>;
 
+    /// The cursor type for dupsort table.
+    // TODO: ideally we should only define the cursor type once,
+    // find a way to not have to define both cursor types in both traits
+    type DupCursor<T: DupSort>: DbDupSortCursor<T>;
+
     /// Creates a cursor to iterate over a table items.
     fn cursor<T: Table>(&self) -> Result<Self::Cursor<T>, DatabaseError>;
 
+    /// Creates a cursor to iterate over a dupsort table items.
+    fn cursor_dup<T: DupSort>(&self) -> Result<Self::DupCursor<T>, DatabaseError>;
+
     /// Gets a value from a table using the given key.
     fn get<T: Table>(&self, key: T::Key) -> Result<Option<T::Value>, DatabaseError>;
 
@@ -28,9 +37,16 @@ pub trait DbTxMut: DbTx {
     /// The mutable cursor type.
     type Cursor<T: Table>: DbCursorMut<T>;
 
+    /// The mutable cursor type for dupsort table.
+    // TODO: find a way to not have to define both cursor types in both traits
+    type DupCursor<T: DupSort>: DbDupSortCursorMut<T>;
+
     /// Creates a cursor to mutably iterate over a table items.
     fn cursor_mut<T: Table>(&self) -> Result<<Self as DbTxMut>::Cursor<T>, DatabaseError>;
 
+    /// Creates a cursor to iterate over a dupsort table items.
+    fn cursor_dup_mut<T: DupSort>(&self) -> Result<<Self as DbTxMut>::DupCursor<T>, DatabaseError>;
+
     /// Inserts an item into a database.
     ///
     /// This function stores key/data pairs in the database. The default behavior is to enter the
diff --git a/crates/katana/storage/db/src/mdbx/tx.rs b/crates/katana/storage/db/src/mdbx/tx.rs
index bc2d0b3c35..700004422b 100644
--- a/crates/katana/storage/db/src/mdbx/tx.rs
+++ b/crates/katana/storage/db/src/mdbx/tx.rs
@@ -10,7 +10,7 @@ use super::cursor::Cursor;
 use crate::abstraction::{DbTx, DbTxMut};
 use crate::codecs::{Compress, Encode};
 use crate::error::DatabaseError;
-use crate::tables::{Table, Tables, NUM_TABLES};
+use crate::tables::{DupSort, Table, Tables, NUM_TABLES};
 use crate::utils::decode_one;
 
 /// Alias for read-only transaction.
@@ -51,6 +51,7 @@ impl<K: TransactionKind> Tx<K> {
 
 impl<K: TransactionKind> DbTx for Tx<K> {
     type Cursor<T: Table> = Cursor<K, T>;
+    type DupCursor<T: DupSort> = Self::Cursor<T>;
 
     fn cursor<T: Table>(&self) -> Result<Cursor<K, T>, DatabaseError> {
         self.inner
@@ -59,6 +60,13 @@ impl<K: TransactionKind> DbTx for Tx<K> {
             .map_err(DatabaseError::CreateCursor)
     }
 
+    fn cursor_dup<T: DupSort>(&self) -> Result<Cursor<K, T>, DatabaseError> {
+        self.inner
+            .cursor_with_dbi(self.get_dbi::<T>()?)
+            .map(Cursor::new)
+            .map_err(DatabaseError::CreateCursor)
+    }
+
     fn get<T: Table>(&self, key: T::Key) -> Result<Option<<T as Table>::Value>, DatabaseError> {
         let key = Encode::encode(key);
         self.inner
@@ -86,11 +94,19 @@ impl<K: TransactionKind> DbTx for Tx<K> {
 
 impl DbTxMut for Tx<RW> {
     type Cursor<T: Table> = Cursor<RW, T>;
+    type DupCursor<T: DupSort> = <Self as DbTxMut>::Cursor<T>;
 
     fn cursor_mut<T: Table>(&self) -> Result<<Self as DbTxMut>::Cursor<T>, DatabaseError> {
         DbTx::cursor(self)
     }
 
+    fn cursor_dup_mut<T: DupSort>(&self) -> Result<<Self as DbTxMut>::DupCursor<T>, DatabaseError> {
+        self.inner
+            .cursor_with_dbi(self.get_dbi::<T>()?)
+            .map(Cursor::new)
+            .map_err(DatabaseError::CreateCursor)
+    }
+
     fn put<T: Table>(&self, key: T::Key, value: T::Value) -> Result<(), DatabaseError> {
         let key = key.encode();
         let value = value.compress();